Add files using upload-large-folder tool

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/fsspec-2026.4.0.dist-info/METADATA

@@ -0,0 +1,257 @@
+Metadata-Version: 2.4
+Name: fsspec
+Version: 2026.4.0
+Summary: File-system specification
+Project-URL: Changelog, https://filesystem-spec.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://filesystem-spec.readthedocs.io/en/latest/
+Project-URL: Homepage, https://github.com/fsspec/filesystem_spec
+Maintainer-email: Martin Durant <mdurant@anaconda.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Provides-Extra: abfs
+Requires-Dist: adlfs; extra == 'abfs'
+Provides-Extra: adl
+Requires-Dist: adlfs; extra == 'adl'
+Provides-Extra: arrow
+Requires-Dist: pyarrow>=1; extra == 'arrow'
+Provides-Extra: dask
+Requires-Dist: dask; extra == 'dask'
+Requires-Dist: distributed; extra == 'dask'
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: numpydoc; extra == 'doc'
+Requires-Dist: sphinx; extra == 'doc'
+Requires-Dist: sphinx-design; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme; extra == 'doc'
+Requires-Dist: yarl; extra == 'doc'
+Provides-Extra: dropbox
+Requires-Dist: dropbox; extra == 'dropbox'
+Requires-Dist: dropboxdrivefs; extra == 'dropbox'
+Requires-Dist: requests; extra == 'dropbox'
+Provides-Extra: entrypoints
+Provides-Extra: full
+Requires-Dist: adlfs; extra == 'full'
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'full'
+Requires-Dist: dask; extra == 'full'
+Requires-Dist: distributed; extra == 'full'
+Requires-Dist: dropbox; extra == 'full'
+Requires-Dist: dropboxdrivefs; extra == 'full'
+Requires-Dist: fusepy; extra == 'full'
+Requires-Dist: gcsfs>2024.2.0; extra == 'full'
+Requires-Dist: libarchive-c; extra == 'full'
+Requires-Dist: ocifs; extra == 'full'
+Requires-Dist: panel; extra == 'full'
+Requires-Dist: paramiko; extra == 'full'
+Requires-Dist: pyarrow>=1; extra == 'full'
+Requires-Dist: pygit2; extra == 'full'
+Requires-Dist: requests; extra == 'full'
+Requires-Dist: s3fs>2024.2.0; extra == 'full'
+Requires-Dist: smbprotocol; extra == 'full'
+Requires-Dist: tqdm; extra == 'full'
+Provides-Extra: fuse
+Requires-Dist: fusepy; extra == 'fuse'
+Provides-Extra: gcs
+Requires-Dist: gcsfs>2024.2.0; extra == 'gcs'
+Provides-Extra: git
+Requires-Dist: pygit2; extra == 'git'
+Provides-Extra: github
+Requires-Dist: requests; extra == 'github'
+Provides-Extra: gs
+Requires-Dist: gcsfs; extra == 'gs'
+Provides-Extra: gui
+Requires-Dist: panel; extra == 'gui'
+Provides-Extra: hdfs
+Requires-Dist: pyarrow>=1; extra == 'hdfs'
+Provides-Extra: http
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'http'
+Provides-Extra: libarchive
+Requires-Dist: libarchive-c; extra == 'libarchive'
+Provides-Extra: oci
+Requires-Dist: ocifs; extra == 'oci'
+Provides-Extra: s3
+Requires-Dist: s3fs>2024.2.0; extra == 's3'
+Provides-Extra: sftp
+Requires-Dist: paramiko; extra == 'sftp'
+Provides-Extra: smb
+Requires-Dist: smbprotocol; extra == 'smb'
+Provides-Extra: ssh
+Requires-Dist: paramiko; extra == 'ssh'
+Provides-Extra: test
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'test'
+Requires-Dist: numpy; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio!=0.22.0; extra == 'test'
+Requires-Dist: pytest-benchmark; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Requires-Dist: pytest-recording; extra == 'test'
+Requires-Dist: pytest-rerunfailures; extra == 'test'
+Requires-Dist: requests; extra == 'test'
+Provides-Extra: test-downstream
+Requires-Dist: aiobotocore<3.0.0,>=2.5.4; extra == 'test-downstream'
+Requires-Dist: dask[dataframe,test]; extra == 'test-downstream'
+Requires-Dist: moto[server]<5,>4; extra == 'test-downstream'
+Requires-Dist: pytest-timeout; extra == 'test-downstream'
+Requires-Dist: xarray; extra == 'test-downstream'
+Provides-Extra: test-full
+Requires-Dist: adlfs; extra == 'test-full'
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'test-full'
+Requires-Dist: backports-zstd; (python_version < '3.14') and extra == 'test-full'
+Requires-Dist: cloudpickle; extra == 'test-full'
+Requires-Dist: dask; extra == 'test-full'
+Requires-Dist: distributed; extra == 'test-full'
+Requires-Dist: dropbox; extra == 'test-full'
+Requires-Dist: dropboxdrivefs; extra == 'test-full'
+Requires-Dist: fastparquet; extra == 'test-full'
+Requires-Dist: fusepy; extra == 'test-full'
+Requires-Dist: gcsfs; extra == 'test-full'
+Requires-Dist: jinja2; extra == 'test-full'
+Requires-Dist: kerchunk; extra == 'test-full'
+Requires-Dist: libarchive-c; extra == 'test-full'
+Requires-Dist: lz4; extra == 'test-full'
+Requires-Dist: notebook; extra == 'test-full'
+Requires-Dist: numpy; extra == 'test-full'
+Requires-Dist: ocifs; extra == 'test-full'
+Requires-Dist: pandas<3.0.0; extra == 'test-full'
+Requires-Dist: panel; extra == 'test-full'
+Requires-Dist: paramiko; extra == 'test-full'
+Requires-Dist: pyarrow; extra == 'test-full'
+Requires-Dist: pyarrow>=1; extra == 'test-full'
+Requires-Dist: pyftpdlib; extra == 'test-full'
+Requires-Dist: pygit2; extra == 'test-full'
+Requires-Dist: pytest; extra == 'test-full'
+Requires-Dist: pytest-asyncio!=0.22.0; extra == 'test-full'
+Requires-Dist: pytest-benchmark; extra == 'test-full'
+Requires-Dist: pytest-cov; extra == 'test-full'
+Requires-Dist: pytest-mock; extra == 'test-full'
+Requires-Dist: pytest-recording; extra == 'test-full'
+Requires-Dist: pytest-rerunfailures; extra == 'test-full'
+Requires-Dist: python-snappy; extra == 'test-full'
+Requires-Dist: requests; extra == 'test-full'
+Requires-Dist: smbprotocol; extra == 'test-full'
+Requires-Dist: tqdm; extra == 'test-full'
+Requires-Dist: urllib3; extra == 'test-full'
+Requires-Dist: zarr; extra == 'test-full'
+Requires-Dist: zstandard; (python_version < '3.14') and extra == 'test-full'
+Provides-Extra: tqdm
+Requires-Dist: tqdm; extra == 'tqdm'
+Description-Content-Type: text/markdown
+
+# filesystem_spec
+
+[![PyPI version](https://badge.fury.io/py/fsspec.svg)](https://pypi.python.org/pypi/fsspec/)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/fsspec/badges/version.svg)](https://anaconda.org/conda-forge/fsspec)
+![Build](https://github.com/fsspec/filesystem_spec/workflows/CI/badge.svg)
+[![Docs](https://readthedocs.org/projects/filesystem-spec/badge/?version=latest)](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+
+A specification for pythonic filesystems.
+
+## Install
+
+```bash
+pip install fsspec
+```
+
+would install the base fsspec. Various optionally supported features might require specification of custom
+extra require, e.g. `pip install fsspec[ssh]` will install dependencies for `ssh` backends support.
+Use `pip install fsspec[full]` for installation of all known extra dependencies.
+
+Up-to-date package also provided through conda-forge distribution:
+
+```bash
+conda install -c conda-forge fsspec
+```
+
+
+## Purpose
+
+To produce a template or specification for a file-system interface, that specific implementations should follow,
+so that applications making use of them can rely on a common behaviour and not have to worry about the specific
+internal implementation decisions with any given backend. Many such implementations are included in this package,
+or in sister projects such as `s3fs` and `gcsfs`.
+
+In addition, if this is well-designed, then additional functionality, such as a key-value store or FUSE
+mounting of the file-system implementation may be available for all implementations "for free".
+
+## Documentation
+
+Please refer to [RTD](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+
+## Develop
+
+fsspec uses GitHub Actions for CI. Environment files can be found
+in the "ci/" directory. Note that the main environment is called "py38",
+but it is expected that the version of python installed be adjustable at
+CI runtime. For local use, pick a version suitable for you.
+
+```bash
+# For a new environment (mamba / conda).
+mamba create -n fsspec -c conda-forge  python=3.10 -y
+conda activate fsspec
+
+# Standard dev install with docs and tests.
+pip install -e ".[dev,doc,test]"
+
+# Full tests except for downstream
+pip install s3fs
+pip uninstall s3fs
+pip install -e .[dev,doc,test_full]
+pip install s3fs --no-deps
+pytest -v
+
+# Downstream tests.
+sh install_s3fs.sh
+# Windows powershell.
+install_s3fs.sh
+```
+
+### Testing
+
+Tests can be run in the dev environment, if activated, via ``pytest fsspec``.
+
+The full fsspec suite requires a system-level docker, docker-compose, and fuse
+installation. If only making changes to one backend implementation, it is
+not generally necessary to run all tests locally.
+
+It is expected that contributors ensure that any change to fsspec does not
+cause issues or regressions for either other fsspec-related packages such
+as gcsfs and s3fs, nor for downstream users of fsspec. The "downstream" CI
+run and corresponding environment file run a set of tests from the dask
+test suite, and very minimal tests against pandas and zarr from the
+test_downstream.py module in this repo.
+
+### Code Formatting
+
+fsspec uses [Black](https://black.readthedocs.io/en/stable) to ensure
+a consistent code format throughout the project.
+Run ``black fsspec`` from the root of the filesystem_spec repository to
+auto-format your code. Additionally, many editors have plugins that will apply
+``black`` as you edit files. ``black`` is included in the ``tox`` environments.
+
+Optionally, you may wish to setup [pre-commit hooks](https://pre-commit.com) to
+automatically run ``black`` when you make a git commit.
+Run ``pre-commit install --install-hooks`` from the root of the
+filesystem_spec repository to setup pre-commit hooks. ``black`` will now be run
+before you commit, reformatting any changed files. You can format without
+committing via ``pre-commit run`` or skip these checks with ``git commit
+--no-verify``.
+
+## Support
+
+Work on this repository is supported in part by:
+
+"Anaconda, Inc. - Advancing AI through open source."
+
+<a href="https://anaconda.com/"><img src="https://camo.githubusercontent.com/b8555ef2222598ed37ce38ac86955febbd25de7619931bb7dd3c58432181d3b6/68747470733a2f2f626565776172652e6f72672f636f6d6d756e6974792f6d656d626572732f616e61636f6e64612f616e61636f6e64612d6c617267652e706e67" alt="anaconda logo" width="40%"/></a>

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/bart/__init__.py

@@ -0,0 +1,28 @@
+# 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.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from ..roberta.tokenization_roberta import RobertaTokenizer as BartTokenizer
+    from .configuration_bart import *
+    from .modeling_bart import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/bart/configuration_bart.py

@@ -0,0 +1,86 @@
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. 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.
+"""BART model configuration"""
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="facebook/bart-large")
+@strict
+class BartConfig(PreTrainedConfig):
+    r"""
+    Example:
+
+    ```python
+    >>> from transformers import BartConfig, BartModel
+
+    >>> # Initializing a BART facebook/bart-large style configuration
+    >>> configuration = BartConfig()
+
+    >>> # Initializing a model (with random weights) from the facebook/bart-large style configuration
+    >>> model = BartModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```"""
+
+    model_type = "bart"
+    keys_to_ignore_at_inference = ["past_key_values"]
+    attribute_map = {
+        "num_attention_heads": "encoder_attention_heads",
+        "hidden_size": "d_model",
+        "num_hidden_layers": "encoder_layers",
+    }
+
+    vocab_size: int = 50265
+    max_position_embeddings: int = 1024
+    encoder_layers: int | None = 12
+    encoder_ffn_dim: int | None = 4096
+    encoder_attention_heads: int | None = 16
+    decoder_layers: int | None = 12
+    decoder_ffn_dim: int | None = 4096
+    decoder_attention_heads: int | None = 16
+    encoder_layerdrop: float | None = 0.0
+    decoder_layerdrop: float | None = 0.0
+    activation_function: str | None = "gelu"
+    d_model: int | None = 1024
+    dropout: float | int | None = 0.1
+    attention_dropout: float | int | None = 0.0
+    activation_dropout: float | int | None = 0.0
+    init_std: float | None = 0.02
+    classifier_dropout: float | int | None = 0.0
+    scale_embedding: bool | None = False
+    use_cache: bool = True
+    pad_token_id: int | None = 1
+    bos_token_id: int | None = 0
+    eos_token_id: int | list[int] | None = 2
+    is_encoder_decoder: bool | None = True
+    decoder_start_token_id: int | None = 2
+    forced_eos_token_id: int | list[int] | None = 2
+    is_decoder: bool | None = False
+    tie_word_embeddings: bool = True
+
+    def __post_init__(self, **kwargs):
+        # Set the default `num_labels` only if `id2label` is not
+        # yet set, i.e. user didn't pass `id2label/lable2id` in kwargs
+        if self.id2label is None:
+            self.num_labels = kwargs.pop("num_labels", 3)
+
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["BartConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/bart/modeling_bart.py

@@ -0,0 +1,1321 @@
+# Copyright 2021 The Fairseq Authors and The HuggingFace Inc. 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.
+"""PyTorch BART model."""
+
+import math
+import warnings
+from collections.abc import Callable
+
+import torch
+from torch import nn
+from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
+
+from ... import initialization as init
+from ...activations import ACT2FN
+from ...cache_utils import Cache, DynamicCache, EncoderDecoderCache
+from ...generation import GenerationMixin
+from ...masking_utils import create_bidirectional_mask, create_causal_mask
+from ...modeling_flash_attention_utils import FlashAttentionKwargs
+from ...modeling_layers import GradientCheckpointingLayer
+from ...modeling_outputs import (
+    BaseModelOutput,
+    BaseModelOutputWithPastAndCrossAttentions,
+    CausalLMOutputWithCrossAttentions,
+    Seq2SeqLMOutput,
+    Seq2SeqModelOutput,
+    Seq2SeqQuestionAnsweringModelOutput,
+    Seq2SeqSequenceClassifierOutput,
+)
+from ...modeling_utils import ALL_ATTENTION_FUNCTIONS, PreTrainedModel
+from ...processing_utils import Unpack
+from ...utils import (
+    TransformersKwargs,
+    auto_docstring,
+    can_return_tuple,
+    is_torchdynamo_compiling,
+    logging,
+    torch_compilable_check,
+)
+from ...utils.generic import merge_with_config_defaults
+from ...utils.output_capturing import OutputRecorder, capture_outputs
+from .configuration_bart import BartConfig
+
+
+logger = logging.get_logger(__name__)
+
+
+def shift_tokens_right(input_ids: torch.Tensor, pad_token_id: int, decoder_start_token_id: int):
+    """
+    Shift input ids one token to the right.
+    """
+    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
+
+
+class BartLearnedPositionalEmbedding(nn.Embedding):
+    """
+    This module learns positional embeddings up to a fixed maximum size.
+    """
+
+    def __init__(self, num_embeddings: int, embedding_dim: int):
+        # Bart is set up so that if padding_idx is specified then offset the embedding ids by 2
+        # and adjust num_embeddings appropriately. Other models don't have this hack
+        self.offset = 2
+        super().__init__(num_embeddings + self.offset, embedding_dim)
+
+    def forward(
+        self, input_ids: torch.Tensor, past_key_values_length: int = 0, position_ids: torch.Tensor | None = None
+    ):
+        """`input_ids' shape is expected to be [bsz x seqlen]."""
+
+        if position_ids is None:
+            bsz, seq_len = input_ids.shape[:2]
+            position_ids = torch.arange(
+                past_key_values_length, past_key_values_length + seq_len, dtype=torch.long, device=self.weight.device
+            ).expand(bsz, -1)
+        else:
+            position_ids = position_ids.unsqueeze(0)
+
+        return super().forward(position_ids + self.offset)
+
+
+class BartScaledWordEmbedding(nn.Embedding):
+    """
+    This module overrides nn.Embeddings' forward by multiplying with embeddings scale.
+    """
+
+    def __init__(self, num_embeddings: int, embedding_dim: int, padding_idx: int, embed_scale: float | None = 1.0):
+        super().__init__(num_embeddings, embedding_dim, padding_idx)
+        self.embed_scale = embed_scale
+
+    def forward(self, input_ids: torch.Tensor):
+        return super().forward(input_ids) * self.embed_scale
+
+
+# Copied from transformers.models.bert.modeling_bert.eager_attention_forward
+def eager_attention_forward(
+    module: nn.Module,
+    query: torch.Tensor,
+    key: torch.Tensor,
+    value: torch.Tensor,
+    attention_mask: torch.Tensor | None,
+    scaling: float | None = None,
+    dropout: float = 0.0,
+    **kwargs: Unpack[TransformersKwargs],
+):
+    if scaling is None:
+        scaling = query.size(-1) ** -0.5
+
+    # Take the dot product between "query" and "key" to get the raw attention scores.
+    attn_weights = torch.matmul(query, key.transpose(2, 3)) * scaling
+
+    if attention_mask is not None:
+        attn_weights = attn_weights + attention_mask
+
+    attn_weights = nn.functional.softmax(attn_weights, dim=-1)
+    attn_weights = nn.functional.dropout(attn_weights, p=dropout, training=module.training)
+
+    attn_output = torch.matmul(attn_weights, value)
+    attn_output = attn_output.transpose(1, 2).contiguous()
+
+    return attn_output, attn_weights
+
+
+class BartAttention(nn.Module):
+    """Multi-headed attention from 'Attention Is All You Need' paper"""
+
+    def __init__(
+        self,
+        embed_dim: int,
+        num_heads: int,
+        dropout: float = 0.0,
+        is_decoder: bool = False,
+        bias: bool = True,
+        is_causal: bool = False,
+        config: BartConfig | None = None,
+        layer_idx: int | None = None,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.num_heads = num_heads
+        self.dropout = dropout
+        self.head_dim = embed_dim // num_heads
+        self.config = config
+
+        if (self.head_dim * num_heads) != self.embed_dim:
+            raise ValueError(
+                f"embed_dim must be divisible by num_heads (got `embed_dim`: {self.embed_dim}"
+                f" and `num_heads`: {num_heads})."
+            )
+        self.scaling = self.head_dim**-0.5
+        self.is_decoder = is_decoder
+        self.is_causal = is_causal
+        self.layer_idx = layer_idx
+        if layer_idx is None and self.is_decoder:
+            logger.warning_once(
+                f"Instantiating a decoder {self.__class__.__name__} without passing `layer_idx` is not recommended and "
+                "will lead to errors during the forward call, if caching is used. Please make sure to provide a `layer_idx` "
+                "when creating this class."
+            )
+
+        self.k_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.v_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.q_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.out_proj = nn.Linear(embed_dim, embed_dim, bias=bias)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        key_value_states: torch.Tensor | None = None,
+        past_key_values: Cache | None = None,
+        attention_mask: torch.Tensor | None = None,
+        # TODO: we need a refactor so that the different attention modules can get their specific kwargs
+        # ATM, we have mixed things encoder, decoder, and encoder-decoder attn
+        **kwargs: Unpack[FlashAttentionKwargs],
+    ) -> tuple[torch.Tensor, torch.Tensor | None]:
+        """Input shape: Batch x Time x Channel"""
+
+        # if key_value_states are provided this layer is used as a cross-attention layer
+        # for the decoder
+        is_cross_attention = key_value_states is not None
+
+        # determine input shapes
+        input_shape = hidden_states.shape[:-1]
+
+        hidden_shape = (*input_shape, -1, self.head_dim)
+
+        # get query proj
+        query_states = self.q_proj(hidden_states).view(hidden_shape).transpose(1, 2)
+
+        is_updated = False
+        if past_key_values is not None:
+            if isinstance(past_key_values, EncoderDecoderCache):
+                is_updated = past_key_values.is_updated.get(self.layer_idx)
+                if is_cross_attention:
+                    # after the first generated id, we can subsequently re-use all key/value_states from cache
+                    curr_past_key_values = past_key_values.cross_attention_cache
+                else:
+                    curr_past_key_values = past_key_values.self_attention_cache
+            else:
+                curr_past_key_values = past_key_values
+
+        current_states = key_value_states if is_cross_attention else hidden_states
+        if is_cross_attention and past_key_values is not None and is_updated:
+            # reuse k,v, cross_attentions
+            key_states = curr_past_key_values.layers[self.layer_idx].keys
+            value_states = curr_past_key_values.layers[self.layer_idx].values
+        else:
+            key_states = self.k_proj(current_states)
+            value_states = self.v_proj(current_states)
+            kv_shape = (*current_states.shape[:-1], -1, self.head_dim)
+            key_states = key_states.view(kv_shape).transpose(1, 2)
+            value_states = value_states.view(kv_shape).transpose(1, 2)
+
+            if past_key_values is not None:
+                key_states, value_states = curr_past_key_values.update(key_states, value_states, self.layer_idx)
+                # set flag that curr layer for cross-attn is already updated so we can re-use in subsequent calls
+                if is_cross_attention and isinstance(past_key_values, EncoderDecoderCache):
+                    past_key_values.is_updated[self.layer_idx] = True
+
+        attention_interface: Callable = ALL_ATTENTION_FUNCTIONS.get_interface(
+            self.config._attn_implementation, eager_attention_forward
+        )
+
+        attn_output, attn_weights = attention_interface(
+            self,
+            query_states,
+            key_states,
+            value_states,
+            attention_mask,
+            dropout=0.0 if not self.training else self.dropout,
+            scaling=self.scaling,
+            **kwargs,
+        )
+
+        attn_output = attn_output.reshape(*input_shape, -1).contiguous()
+        attn_output = self.out_proj(attn_output)
+
+        return attn_output, attn_weights
+
+
+class BartEncoderLayer(GradientCheckpointingLayer):
+    def __init__(self, config: BartConfig, layer_idx: int | None = None):
+        super().__init__()
+        self.embed_dim = config.d_model
+
+        self.self_attn = BartAttention(
+            embed_dim=self.embed_dim,
+            num_heads=config.encoder_attention_heads,
+            dropout=config.attention_dropout,
+            config=config,
+            layer_idx=layer_idx,
+        )
+        self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+        self.dropout = config.dropout
+        self.activation_fn = ACT2FN[config.activation_function]
+        self.activation_dropout = config.activation_dropout
+        self.fc1 = nn.Linear(self.embed_dim, config.encoder_ffn_dim)
+        self.fc2 = nn.Linear(config.encoder_ffn_dim, self.embed_dim)
+        self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+    def forward(
+        self,
+        hidden_states: torch.FloatTensor,
+        attention_mask: torch.FloatTensor,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> torch.Tensor:
+        residual = hidden_states
+        hidden_states, _ = self.self_attn(
+            hidden_states,
+            attention_mask=attention_mask,
+            **kwargs,
+        )
+        hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.self_attn_layer_norm(hidden_states)
+
+        residual = hidden_states
+        hidden_states = self.activation_fn(self.fc1(hidden_states))
+        hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+        hidden_states = self.fc2(hidden_states)
+        hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.final_layer_norm(hidden_states)
+
+        if hidden_states.dtype == torch.float16 and not torch.isfinite(hidden_states).all():
+            clamp_value = torch.finfo(hidden_states.dtype).max - 1000
+            hidden_states = torch.clamp(hidden_states, min=-clamp_value, max=clamp_value)
+
+        return hidden_states
+
+
+class BartDecoderLayer(GradientCheckpointingLayer):
+    def __init__(self, config: BartConfig, layer_idx: int | None = None):
+        super().__init__()
+        self.embed_dim = config.d_model
+
+        self.self_attn = BartAttention(
+            embed_dim=self.embed_dim,
+            num_heads=config.decoder_attention_heads,
+            dropout=config.attention_dropout,
+            is_decoder=True,
+            is_causal=True,
+            config=config,
+            layer_idx=layer_idx,
+        )
+        self.dropout = config.dropout
+        self.activation_fn = ACT2FN[config.activation_function]
+        self.activation_dropout = config.activation_dropout
+
+        self.self_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+        self.encoder_attn = BartAttention(
+            self.embed_dim,
+            config.decoder_attention_heads,
+            dropout=config.attention_dropout,
+            is_decoder=True,
+            config=config,
+            layer_idx=layer_idx,
+        )
+        self.encoder_attn_layer_norm = nn.LayerNorm(self.embed_dim)
+        self.fc1 = nn.Linear(self.embed_dim, config.decoder_ffn_dim)
+        self.fc2 = nn.Linear(config.decoder_ffn_dim, self.embed_dim)
+        self.final_layer_norm = nn.LayerNorm(self.embed_dim)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        attention_mask: torch.Tensor | None = None,
+        encoder_hidden_states: torch.Tensor | None = None,
+        encoder_attention_mask: torch.Tensor | None = None,
+        past_key_values: Cache | None = None,
+        use_cache: bool | None = True,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> torch.Tensor:
+        residual = hidden_states
+
+        # Self Attention
+        hidden_states, _ = self.self_attn(
+            hidden_states,
+            past_key_values=past_key_values,
+            attention_mask=attention_mask,
+            **kwargs,
+        )
+        hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.self_attn_layer_norm(hidden_states)
+
+        # Cross-Attention Block
+        if encoder_hidden_states is not None:
+            residual = hidden_states
+
+            hidden_states, _ = self.encoder_attn(
+                hidden_states,
+                key_value_states=encoder_hidden_states,
+                attention_mask=encoder_attention_mask,
+                past_key_values=past_key_values,
+                **kwargs,
+            )
+            hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+            hidden_states = residual + hidden_states
+            hidden_states = self.encoder_attn_layer_norm(hidden_states)
+
+        # Fully Connected
+        residual = hidden_states
+        hidden_states = self.activation_fn(self.fc1(hidden_states))
+        hidden_states = nn.functional.dropout(hidden_states, p=self.activation_dropout, training=self.training)
+        hidden_states = self.fc2(hidden_states)
+        hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+        hidden_states = residual + hidden_states
+        hidden_states = self.final_layer_norm(hidden_states)
+
+        return hidden_states
+
+
+class BartClassificationHead(nn.Module):
+    """Head for sentence-level classification tasks."""
+
+    def __init__(
+        self,
+        input_dim: int,
+        inner_dim: int,
+        num_classes: int,
+        pooler_dropout: float,
+    ):
+        super().__init__()
+        self.dense = nn.Linear(input_dim, inner_dim)
+        self.dropout = nn.Dropout(p=pooler_dropout)
+        self.out_proj = nn.Linear(inner_dim, num_classes)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.dense(hidden_states)
+        hidden_states = torch.tanh(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.out_proj(hidden_states)
+        return hidden_states
+
+
+@auto_docstring
+class BartPreTrainedModel(PreTrainedModel):
+    config: BartConfig
+    base_model_prefix = "model"
+    supports_gradient_checkpointing = True
+    _keys_to_ignore_on_load_unexpected = ["encoder.version", "decoder.version"]
+    _no_split_modules = [r"BartEncoderLayer", r"BartDecoderLayer"]
+    _skip_keys_device_placement = ["past_key_values"]
+    _supports_flash_attn = True
+    _supports_sdpa = True
+    _supports_flex_attn = True
+
+    _can_compile_fullgraph = True
+
+    def _init_weights(self, module):
+        super()._init_weights(module)
+        if isinstance(module, BartForConditionalGeneration):
+            init.zeros_(module.final_logits_bias)
+
+    @property
+    def dummy_inputs(self):
+        pad_token = self.config.pad_token_id
+        input_ids = torch.tensor([[0, 6, 10, 4, 2], [0, 8, 12, 2, pad_token]], device=self.device)
+        dummy_inputs = {
+            "attention_mask": input_ids.ne(pad_token),
+            "input_ids": input_ids,
+        }
+        return dummy_inputs
+
+
+class PretrainedBartModel(BartPreTrainedModel):
+    def __init_subclass__(self):
+        warnings.warn(
+            "The class `PretrainedBartModel` has been depreciated, please use `BartPreTrainedModel` instead.",
+            FutureWarning,
+        )
+
+
+class BartPretrainedModel(BartPreTrainedModel):
+    def __init_subclass__(self):
+        warnings.warn(
+            "The class `PretrainedBartModel` has been depreciated, please use `BartPreTrainedModel` instead.",
+            FutureWarning,
+        )
+
+
+class BartEncoder(BartPreTrainedModel):
+    """
+    Transformer encoder consisting of *config.encoder_layers* self attention layers. Each layer is a
+    [`BartEncoderLayer`].
+
+    Args:
+        config: BartConfig
+        embed_tokens (nn.Embedding): output embedding
+    """
+
+    _can_record_outputs = {
+        "hidden_states": BartEncoderLayer,
+        "attentions": BartAttention,
+    }
+
+    def __init__(self, config: BartConfig):
+        super().__init__(config)
+
+        self.dropout = config.dropout
+        self.layerdrop = config.encoder_layerdrop
+
+        embed_dim = config.d_model
+        self.padding_idx = config.pad_token_id
+        self.max_source_positions = config.max_position_embeddings
+        embed_scale = math.sqrt(embed_dim) if config.scale_embedding else 1.0
+
+        self.embed_tokens = BartScaledWordEmbedding(
+            config.vocab_size, embed_dim, self.padding_idx, embed_scale=embed_scale
+        )
+
+        self.embed_positions = BartLearnedPositionalEmbedding(
+            config.max_position_embeddings,
+            embed_dim,
+        )
+        self.layers = nn.ModuleList([BartEncoderLayer(config, layer_idx=i) for i in range(config.encoder_layers)])
+        self.layernorm_embedding = nn.LayerNorm(embed_dim)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @merge_with_config_defaults
+    @capture_outputs
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> BaseModelOutput:
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError("You must specify exactly one of input_ids or inputs_embeds")
+
+        if inputs_embeds is None:
+            inputs_embeds = self.embed_tokens(input_ids)
+
+        embed_pos = self.embed_positions(inputs_embeds[:, :, -1])  # needed for the shape only
+        embed_pos = embed_pos.to(inputs_embeds.device)
+
+        hidden_states = inputs_embeds + embed_pos
+        hidden_states = self.layernorm_embedding(hidden_states)
+        hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+        attention_mask = create_bidirectional_mask(
+            config=self.config,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+        )
+        for idx, encoder_layer in enumerate(self.layers):
+            # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+            to_drop = False
+            if self.training:
+                dropout_probability = torch.rand([])
+                if dropout_probability < self.layerdrop:  # skip the layer
+                    to_drop = True
+
+            if not to_drop:
+                hidden_states = encoder_layer(
+                    hidden_states,
+                    attention_mask,
+                    **kwargs,
+                )
+
+        return BaseModelOutput(
+            last_hidden_state=hidden_states,
+        )
+
+
+class BartDecoder(BartPreTrainedModel):
+    """
+    Transformer decoder consisting of *config.decoder_layers* layers. Each layer is a [`BartDecoderLayer`]
+
+    Args:
+        config: BartConfig
+        embed_tokens (nn.Embedding): output embedding
+    """
+
+    _can_record_outputs = {
+        "hidden_states": BartDecoderLayer,
+        "attentions": OutputRecorder(BartAttention, index=1, layer_name="self_attn"),
+        "cross_attentions": OutputRecorder(BartAttention, index=1, layer_name="encoder_attn"),
+    }
+
+    def __init__(self, config: BartConfig):
+        super().__init__(config)
+        self.dropout = config.dropout
+        self.layerdrop = config.decoder_layerdrop
+        self.padding_idx = config.pad_token_id
+        self.max_target_positions = config.max_position_embeddings
+        embed_scale = math.sqrt(config.d_model) if config.scale_embedding else 1.0
+
+        self.embed_tokens = BartScaledWordEmbedding(
+            config.vocab_size, config.d_model, self.padding_idx, embed_scale=embed_scale
+        )
+
+        self.embed_positions = BartLearnedPositionalEmbedding(
+            config.max_position_embeddings,
+            config.d_model,
+        )
+        self.layers = nn.ModuleList([BartDecoderLayer(config, layer_idx=i) for i in range(config.decoder_layers)])
+
+        self.layernorm_embedding = nn.LayerNorm(config.d_model)
+
+        self.gradient_checkpointing = False
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @merge_with_config_defaults
+    @capture_outputs
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        encoder_hidden_states: torch.FloatTensor | None = None,
+        encoder_attention_mask: torch.LongTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        use_cache: bool | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> BaseModelOutputWithPastAndCrossAttentions:
+        if (input_ids is None) ^ (inputs_embeds is not None):
+            raise ValueError("You must specify exactly one of decoder_input_ids or decoder_inputs_embeds")
+
+        if inputs_embeds is None:
+            inputs_embeds = self.embed_tokens(input_ids)
+
+        # initialize `past_key_values`
+        if use_cache and past_key_values is None:
+            past_key_values = (
+                EncoderDecoderCache(DynamicCache(config=self.config), DynamicCache(config=self.config))
+                if encoder_hidden_states is not None or self.config.is_encoder_decoder
+                else DynamicCache(config=self.config)
+            )
+
+        batch_size, seq_length = inputs_embeds.size()[:-1]
+        past_key_values_length = past_key_values.get_seq_length() if past_key_values is not None else 0
+        position_ids = torch.arange(seq_length, device=inputs_embeds.device) + past_key_values_length
+
+        if attention_mask is None and not is_torchdynamo_compiling():
+            # required mask seq length can be calculated via length of past cache
+            mask_seq_length = past_key_values_length + seq_length
+            attention_mask = torch.ones(batch_size, mask_seq_length, device=inputs_embeds.device)
+
+        self_attn_cache = (
+            past_key_values.self_attention_cache
+            if isinstance(past_key_values, EncoderDecoderCache)
+            else past_key_values
+        )
+
+        attention_mask = create_causal_mask(
+            config=self.config,
+            inputs_embeds=inputs_embeds,
+            attention_mask=attention_mask,
+            past_key_values=self_attn_cache,
+        )
+        encoder_attention_mask = create_bidirectional_mask(
+            config=self.config,
+            inputs_embeds=inputs_embeds,
+            attention_mask=encoder_attention_mask,
+            encoder_hidden_states=encoder_hidden_states,
+        )
+
+        # embed positions
+        positions = self.embed_positions(input_ids, past_key_values_length, position_ids=position_ids)
+        positions = positions.to(inputs_embeds.device)
+
+        hidden_states = inputs_embeds + positions
+        hidden_states = self.layernorm_embedding(hidden_states)
+
+        hidden_states = nn.functional.dropout(hidden_states, p=self.dropout, training=self.training)
+
+        for idx, decoder_layer in enumerate(self.layers):
+            # add LayerDrop (see https://huggingface.co/papers/1909.11556 for description)
+            if self.training:
+                dropout_probability = torch.rand([])
+                if dropout_probability < self.layerdrop:
+                    continue
+
+            hidden_states = decoder_layer(
+                hidden_states,
+                attention_mask,
+                encoder_hidden_states,  # as a positional argument for gradient checkpointing
+                encoder_attention_mask=encoder_attention_mask,
+                past_key_values=past_key_values,
+                use_cache=use_cache,
+                **kwargs,
+            )
+
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=past_key_values,
+        )
+
+
+@auto_docstring
+class BartModel(BartPreTrainedModel):
+    _tied_weights_keys = {
+        "decoder.embed_tokens.weight": "shared.weight",
+        "encoder.embed_tokens.weight": "shared.weight",
+    }
+
+    def __init__(self, config: BartConfig):
+        super().__init__(config)
+
+        padding_idx, vocab_size = config.pad_token_id, config.vocab_size
+        embed_scale = math.sqrt(config.d_model) if config.scale_embedding else 1.0
+        self.shared = BartScaledWordEmbedding(vocab_size, config.d_model, padding_idx, embed_scale=embed_scale)
+
+        self.encoder = BartEncoder(config)
+        self.decoder = BartDecoder(config)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.shared
+
+    def set_input_embeddings(self, value):
+        self.shared = value
+        self.encoder.embed_tokens = self.shared
+        self.decoder.embed_tokens = self.shared
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        decoder_input_ids: torch.LongTensor | None = None,
+        decoder_attention_mask: torch.LongTensor | None = None,
+        encoder_outputs: list[torch.FloatTensor] | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        decoder_inputs_embeds: torch.FloatTensor | None = None,
+        use_cache: bool | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple | Seq2SeqModelOutput:
+        r"""
+        decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Indices of decoder input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+            Bart uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+            is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+            For translation and summarization training, `decoder_input_ids` should be provided. If no
+            `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right
+            for denoising pre-training following the paper.
+        decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+            be used by default.
+
+            If you want to change padding behavior, you should read [`modeling_bart._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+            information on the default strategy.
+        """
+        # different to other models, Bart automatically creates decoder_input_ids from
+        # input_ids if no decoder_input_ids are provided
+        if decoder_input_ids is None and decoder_inputs_embeds is None:
+            if input_ids is None:
+                raise ValueError(
+                    "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+                    "passed, `input_ids` cannot be `None`. Please pass either "
+                    "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+                )
+
+            decoder_input_ids = shift_tokens_right(
+                input_ids, self.config.pad_token_id, self.config.decoder_start_token_id
+            )
+
+        if encoder_outputs is None:
+            encoder_outputs: BaseModelOutput = self.encoder(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                inputs_embeds=inputs_embeds,
+                **kwargs,
+            )
+        elif not isinstance(encoder_outputs, BaseModelOutput):
+            encoder_outputs = BaseModelOutput(
+                last_hidden_state=encoder_outputs[0],
+                hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+                attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+            )
+
+        decoder_outputs: BaseModelOutputWithPastAndCrossAttentions = self.decoder(
+            input_ids=decoder_input_ids,
+            attention_mask=decoder_attention_mask,
+            encoder_hidden_states=encoder_outputs[0],
+            encoder_attention_mask=attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            **kwargs,
+        )
+
+        return Seq2SeqModelOutput(
+            last_hidden_state=decoder_outputs.last_hidden_state,
+            past_key_values=decoder_outputs.past_key_values,
+            decoder_hidden_states=decoder_outputs.hidden_states,
+            decoder_attentions=decoder_outputs.attentions,
+            cross_attentions=decoder_outputs.cross_attentions,
+            encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+            encoder_hidden_states=encoder_outputs.hidden_states,
+            encoder_attentions=encoder_outputs.attentions,
+        )
+
+
+@auto_docstring(
+    custom_intro="""
+    The BART Model with a language modeling head. Can be used for summarization.
+    """
+)
+class BartForConditionalGeneration(BartPreTrainedModel, GenerationMixin):
+    base_model_prefix = "model"
+    _tied_weights_keys = {
+        "lm_head.weight": "model.shared.weight",
+    }
+    _keys_to_ignore_on_load_missing = ["final_logits_bias"]
+
+    def __init__(self, config: BartConfig):
+        super().__init__(config)
+        self.model = BartModel(config)
+        self.register_buffer("final_logits_bias", torch.zeros((1, self.model.shared.num_embeddings)))
+        self.lm_head = nn.Linear(config.d_model, self.model.shared.num_embeddings, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def resize_token_embeddings(
+        self, new_num_tokens: int, pad_to_multiple_of: int | None = None, mean_resizing: bool = True
+    ) -> nn.Embedding:
+        new_embeddings = super().resize_token_embeddings(new_num_tokens, pad_to_multiple_of, mean_resizing)
+        self._resize_final_logits_bias(new_embeddings.weight.shape[0])
+        return new_embeddings
+
+    def _resize_final_logits_bias(self, new_num_tokens: int) -> None:
+        old_num_tokens = self.final_logits_bias.shape[-1]
+        if new_num_tokens <= old_num_tokens:
+            new_bias = self.final_logits_bias[:, :new_num_tokens]
+        else:
+            extra_bias = torch.zeros((1, new_num_tokens - old_num_tokens), device=self.final_logits_bias.device)
+            new_bias = torch.cat([self.final_logits_bias, extra_bias], dim=1)
+        self.register_buffer("final_logits_bias", new_bias)
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        decoder_input_ids: torch.LongTensor | None = None,
+        decoder_attention_mask: torch.LongTensor | None = None,
+        encoder_outputs: list[torch.FloatTensor] | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        decoder_inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple | Seq2SeqLMOutput:
+        r"""
+        decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Indices of decoder input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+            Bart uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+            is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+            For translation and summarization training, `decoder_input_ids` should be provided. If no
+            `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right
+            for denoising pre-training following the paper.
+        decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+            be used by default.
+
+            If you want to change padding behavior, you should read [`modeling_bart._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+            information on the default strategy.
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+            config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+        Example summarization:
+
+        ```python
+        >>> from transformers import AutoTokenizer, BartForConditionalGeneration
+
+        >>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-large-cnn")
+        >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-large-cnn")
+
+        >>> ARTICLE_TO_SUMMARIZE = (
+        ...     "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
+        ...     "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
+        ...     "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
+        ... )
+        >>> inputs = tokenizer([ARTICLE_TO_SUMMARIZE], max_length=1024, return_tensors="pt")
+
+        >>> # Generate Summary
+        >>> summary_ids = model.generate(inputs["input_ids"], num_beams=2, min_length=0, max_length=20)
+        >>> tokenizer.batch_decode(summary_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+        'PG&E scheduled the blackouts in response to forecasts for high winds amid dry conditions'
+        ```
+
+        Mask filling example:
+
+        ```python
+        >>> from transformers import AutoTokenizer, BartForConditionalGeneration
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base")
+        >>> model = BartForConditionalGeneration.from_pretrained("facebook/bart-base")
+
+        >>> TXT = "My friends are <mask> but they eat too many carbs."
+        >>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
+        >>> logits = model(input_ids).logits
+
+        >>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
+        >>> probs = logits[0, masked_index].softmax(dim=0)
+        >>> values, predictions = probs.topk(5)
+
+        >>> tokenizer.decode(predictions).split()
+        ['not', 'good', 'healthy', 'great', 'very']
+        ```
+        """
+        if labels is not None:
+            if use_cache:
+                logger.warning("The `use_cache` argument is changed to `False` since `labels` is provided.")
+            use_cache = False
+            if decoder_input_ids is None and decoder_inputs_embeds is None:
+                decoder_input_ids = shift_tokens_right(
+                    labels, self.config.pad_token_id, self.config.decoder_start_token_id
+                )
+
+        outputs: Seq2SeqModelOutput = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            encoder_outputs=encoder_outputs,
+            decoder_attention_mask=decoder_attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            **kwargs,
+        )
+
+        lm_logits = self.lm_head(outputs[0])
+        lm_logits = lm_logits + self.final_logits_bias.to(lm_logits.device)
+
+        masked_lm_loss = None
+        if labels is not None:
+            labels = labels.to(lm_logits.device)
+            loss_fct = CrossEntropyLoss()
+            masked_lm_loss = loss_fct(lm_logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+        return Seq2SeqLMOutput(
+            loss=masked_lm_loss,
+            logits=lm_logits,
+            past_key_values=outputs.past_key_values,
+            decoder_hidden_states=outputs.decoder_hidden_states,
+            decoder_attentions=outputs.decoder_attentions,
+            cross_attentions=outputs.cross_attentions,
+            encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+            encoder_hidden_states=outputs.encoder_hidden_states,
+            encoder_attentions=outputs.encoder_attentions,
+        )
+
+    def prepare_decoder_input_ids_from_labels(self, labels: torch.Tensor):
+        return shift_tokens_right(labels, self.config.pad_token_id, self.config.decoder_start_token_id)
+
+
+@auto_docstring(
+    custom_intro="""
+    Bart model with a sequence classification/head on top (a linear layer on top of the pooled output) e.g. for GLUE
+    tasks.
+    """
+)
+class BartForSequenceClassification(BartPreTrainedModel):
+    def __init__(self, config: BartConfig, **kwargs):
+        super().__init__(config, **kwargs)
+        self.model = BartModel(config)
+        self.classification_head = BartClassificationHead(
+            config.d_model,
+            config.d_model,
+            config.num_labels,
+            config.classifier_dropout,
+        )
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        decoder_input_ids: torch.LongTensor | None = None,
+        decoder_attention_mask: torch.LongTensor | None = None,
+        encoder_outputs: list[torch.FloatTensor] | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        decoder_inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple | Seq2SeqSequenceClassifierOutput:
+        r"""
+        decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Indices of decoder input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+            Bart uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+            is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+            For translation and summarization training, `decoder_input_ids` should be provided. If no
+            `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right
+            for denoising pre-training following the paper.
+        decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+            be used by default.
+
+            If you want to change padding behavior, you should read [`modeling_bart._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+            information on the default strategy.
+        labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
+            Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
+            config.num_labels - 1]`. If `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
+        """
+        if labels is not None:
+            use_cache = False
+
+        if input_ids is None and inputs_embeds is not None:
+            raise NotImplementedError(
+                f"Passing input embeddings is currently not supported for {self.__class__.__name__}"
+            )
+
+        outputs: Seq2SeqModelOutput = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            decoder_attention_mask=decoder_attention_mask,
+            encoder_outputs=encoder_outputs,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            **kwargs,
+        )
+        hidden_states = outputs[0]  # last hidden state
+
+        eos_mask = input_ids.eq(self.config.eos_token_id).to(hidden_states.device)
+
+        torch_compilable_check(
+            torch.unique_consecutive(eos_mask.sum(1)).numel() == 1,
+            "All examples must have the same number of <eos> tokens.",
+        )
+        sentence_representation = hidden_states[eos_mask, :].view(hidden_states.size(0), -1, hidden_states.size(-1))[
+            :, -1, :
+        ]
+        logits = self.classification_head(sentence_representation)
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+            if self.config.problem_type is None:
+                if self.config.num_labels == 1:
+                    self.config.problem_type = "regression"
+                elif self.config.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.config.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.config.num_labels), labels.view(-1))
+            elif self.config.problem_type == "multi_label_classification":
+                loss_fct = BCEWithLogitsLoss()
+                loss = loss_fct(logits, labels)
+
+        return Seq2SeqSequenceClassifierOutput(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            decoder_hidden_states=outputs.decoder_hidden_states,
+            decoder_attentions=outputs.decoder_attentions,
+            cross_attentions=outputs.cross_attentions,
+            encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+            encoder_hidden_states=outputs.encoder_hidden_states,
+            encoder_attentions=outputs.encoder_attentions,
+        )
+
+
+@auto_docstring
+class BartForQuestionAnswering(BartPreTrainedModel):
+    def __init__(self, config):
+        super().__init__(config)
+
+        config.num_labels = 2
+        self.num_labels = config.num_labels
+
+        self.model = BartModel(config)
+        self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.Tensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        decoder_input_ids: torch.LongTensor | None = None,
+        decoder_attention_mask: torch.LongTensor | None = None,
+        encoder_outputs: list[torch.FloatTensor] | None = None,
+        start_positions: torch.LongTensor | None = None,
+        end_positions: torch.LongTensor | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        decoder_inputs_embeds: torch.FloatTensor | None = None,
+        use_cache: bool | None = None,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple | Seq2SeqQuestionAnsweringModelOutput:
+        r"""
+        decoder_input_ids (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Indices of decoder input sequence tokens in the vocabulary.
+
+            Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
+            [`PreTrainedTokenizer.__call__`] for details.
+
+            [What are decoder input IDs?](../glossary#decoder-input-ids)
+
+            Bart uses the `eos_token_id` as the starting token for `decoder_input_ids` generation. If `past_key_values`
+            is used, optionally only the last `decoder_input_ids` have to be input (see `past_key_values`).
+
+            For translation and summarization training, `decoder_input_ids` should be provided. If no
+            `decoder_input_ids` is provided, the model will create this tensor by shifting the `input_ids` to the right
+            for denoising pre-training following the paper.
+        decoder_attention_mask (`torch.LongTensor` of shape `(batch_size, target_sequence_length)`, *optional*):
+            Default behavior: generate a tensor that ignores pad tokens in `decoder_input_ids`. Causal mask will also
+            be used by default.
+
+            If you want to change padding behavior, you should read [`modeling_bart._prepare_decoder_attention_mask`]
+            and modify to your needs. See diagram 1 in [the paper](https://huggingface.co/papers/1910.13461) for more
+            information on the default strategy.
+        """
+        if start_positions is not None and end_positions is not None:
+            use_cache = False
+
+        outputs: Seq2SeqModelOutput = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            decoder_attention_mask=decoder_attention_mask,
+            encoder_outputs=encoder_outputs,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            **kwargs,
+        )
+
+        sequence_output = outputs[0]
+
+        logits = self.qa_outputs(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
+
+        return Seq2SeqQuestionAnsweringModelOutput(
+            loss=total_loss,
+            start_logits=start_logits,
+            end_logits=end_logits,
+            past_key_values=outputs.past_key_values,
+            decoder_hidden_states=outputs.decoder_hidden_states,
+            decoder_attentions=outputs.decoder_attentions,
+            cross_attentions=outputs.cross_attentions,
+            encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+            encoder_hidden_states=outputs.encoder_hidden_states,
+            encoder_attentions=outputs.encoder_attentions,
+        )
+
+
+class BartDecoderWrapper(BartPreTrainedModel):
+    """
+    This wrapper class is a helper class to correctly load pretrained checkpoints when the causal language model is
+    used in combination with the [`EncoderDecoderModel`] framework.
+    """
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.decoder = BartDecoder(config)
+        self.post_init()
+
+    def forward(self, *args, **kwargs):
+        return self.decoder(*args, **kwargs)
+
+
+@auto_docstring(
+    custom_intro="""
+    BART decoder with a language modeling head on top (linear layer with weights tied to the input embeddings).
+    """
+)
+class BartForCausalLM(BartPreTrainedModel, GenerationMixin):
+    _tied_weights_keys = {
+        "lm_head.weight": "model.decoder.embed_tokens.weight",
+    }
+
+    def __init__(self, config):
+        config.is_decoder = True
+        config.is_encoder_decoder = False
+        super().__init__(config)
+        self.model = BartDecoderWrapper(config)
+
+        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        # Initialize weights and apply final processing
+        self.post_init()
+
+    def get_input_embeddings(self):
+        return self.model.decoder.embed_tokens
+
+    def set_input_embeddings(self, value):
+        self.model.decoder.embed_tokens = value
+
+    @can_return_tuple
+    @auto_docstring
+    def forward(
+        self,
+        input_ids: torch.LongTensor | None = None,
+        attention_mask: torch.Tensor | None = None,
+        encoder_hidden_states: torch.FloatTensor | None = None,
+        encoder_attention_mask: torch.FloatTensor | None = None,
+        past_key_values: Cache | None = None,
+        inputs_embeds: torch.FloatTensor | None = None,
+        labels: torch.LongTensor | None = None,
+        use_cache: bool | None = None,
+        logits_to_keep: int | torch.Tensor = 0,
+        **kwargs: Unpack[TransformersKwargs],
+    ) -> tuple | CausalLMOutputWithCrossAttentions:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+            config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+
+        Example:
+
+        ```python
+        >>> from transformers import AutoTokenizer, BartForCausalLM
+
+        >>> tokenizer = AutoTokenizer.from_pretrained("facebook/bart-base")
+        >>> model = BartForCausalLM.from_pretrained("facebook/bart-base")
+        >>> assert model.config.is_decoder, f"{model.__class__} has to be configured as a decoder."
+        >>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
+        >>> outputs = model(**inputs)
+
+        >>> logits = outputs.logits
+        >>> expected_shape = [1, inputs.input_ids.shape[-1], model.config.vocab_size]
+        >>> list(logits.shape) == expected_shape
+        True
+        ```"""
+
+        outputs: BaseModelOutputWithPastAndCrossAttentions = self.model.decoder(
+            input_ids=input_ids,
+            attention_mask=attention_mask,
+            encoder_hidden_states=encoder_hidden_states,
+            encoder_attention_mask=encoder_attention_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            use_cache=use_cache,
+            **kwargs,
+        )
+
+        hidden_states = outputs[0]
+        # Only compute necessary logits
+        slice_indices = slice(-logits_to_keep, None) if isinstance(logits_to_keep, int) else logits_to_keep
+        logits = self.lm_head(hidden_states[:, slice_indices, :])
+
+        loss = None
+        if labels is not None:
+            labels = labels.to(logits.device)
+            loss_fct = CrossEntropyLoss()
+            loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+        return CausalLMOutputWithCrossAttentions(
+            loss=loss,
+            logits=logits,
+            past_key_values=outputs.past_key_values,
+            hidden_states=outputs.hidden_states,
+            attentions=outputs.attentions,
+            cross_attentions=outputs.cross_attentions,
+        )
+
+
+__all__ = [
+    "BartForCausalLM",
+    "BartForConditionalGeneration",
+    "BartForQuestionAnswering",
+    "BartForSequenceClassification",
+    "BartModel",
+    "BartPreTrainedModel",
+    "BartPretrainedModel",
+    "PretrainedBartModel",
+]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/bart/tokenization_bart.py

@@ -0,0 +1,23 @@
+# Copyright 2024 The HuggingFace Team. All rights reserved.
+#
+# This source code is licensed under the Apache 2.0 license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Compatibility shims for BART tokenizers in v5.
+
+In v5 we consolidate on the tokenizers-library backend and remove separate
+"slow" vs "fast" implementations. BART uses the same byte-level BPE
+tokenizer as RoBERTa, so we expose `BartTokenizer` and `BartTokenizerFast`
+as aliases to `RobertaTokenizer` to preserve the public API expected by
+existing code and tests.
+"""
+
+from ..roberta.tokenization_roberta import RobertaTokenizer as _RobertaTokenizer
+
+
+# Public aliases maintained for backwards compatibility
+BartTokenizer = _RobertaTokenizer
+BartTokenizerFast = _RobertaTokenizer
+
+__all__ = ["BartTokenizer", "BartTokenizerFast"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/gptj/__init__.py

@@ -0,0 +1,27 @@
+# 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.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_gptj import *
+    from .modeling_gptj import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/mpt/__init__.py

@@ -0,0 +1,27 @@
+# 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.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_mpt import *
+    from .modeling_mpt import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/mpt/configuration_mpt.py

@@ -0,0 +1,150 @@
+# Copyright 2023 HuggingFace Inc. team and MosaicML NLP team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Mpt configuration"""
+
+from typing import Literal
+
+from huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+
+
+@auto_docstring(checkpoint="mosaicml/mpt-7b")
+@strict
+class MptAttentionConfig(PreTrainedConfig):
+    r"""
+    attn_type (`str`, *optional*, defaults to `"multihead_attention"`):
+        type of attention to use. Options: `"multihead_attention"`, `"multiquery_attention"`.
+    attn_pdrop (`float`, *optional*, defaults to `0.0`):
+        The dropout probability for the attention layers.
+    attn_impl (`str`, *optional*, defaults to `"torch"`):
+        The attention implementation to use. One of `"torch"`, `"flash"`, or `"triton"`.
+    clip_qkv (`float`, *optional*):
+        If not `None`, clip the queries, keys, and values in the attention layer to this value.
+    softmax_scale (`float`, *optional*):
+        If not `None`, scale the softmax in the attention layer by this value. If `None`, will default to
+        `1/sqrt(hidden_size)`.
+    prefix_lm (`bool`, *optional*, defaults to `False`):
+        Whether the model should operate as a Prefix LM. This requires passing an extra `prefix_mask` argument
+        which indicates which tokens belong to the prefix. Tokens in the prefix can attend to one another
+        bi-directionally. Tokens outside the prefix use causal attention.
+    qk_ln (`bool`, *optional*, defaults to `False`):
+        Whether to apply layer normalization to the queries and keys in the attention layer.
+    attn_uses_sequence_id (`bool`, *optional*, defaults to `False`):
+        Whether to restrict attention to tokens that have the same token_type_ids. When the model is in `train`
+        mode, this requires passing an extra *token_type_ids* argument which indicates which sub-sequence each
+        token belongs to. Defaults to `False` meaning any provided *token_type_ids* will be ignored.
+    alibi (`bool`, *optional*, defaults to `True`):
+        Whether or not to use the alibi bias instead of positional embedding.
+    alibi_bias_max (`int`, *optional*, defaults to 8):
+        The maximum value of the alibi bias.
+    """
+
+    base_config_key = "attn_config"
+
+    attn_type: Literal["multihead_attention", "multiquery_attention"] = "multihead_attention"
+    attn_pdrop: int = 0
+    attn_impl: str = "torch"
+    clip_qkv: float | None = None
+    softmax_scale: float | None = None
+    prefix_lm: bool = False
+    qk_ln: bool = False
+    attn_uses_sequence_id: bool = False
+    alibi: bool = True
+    alibi_bias_max: int = 8
+
+
+@auto_docstring(checkpoint="mosaicml/mpt-7b")
+@strict
+class MptConfig(PreTrainedConfig):
+    r"""
+    expansion_ratio (`int`, *optional*, defaults to 4):
+        The ratio of the up/down scale in the MLP.
+    max_seq_len (`int`, *optional*, defaults to 2048):
+        The maximum sequence length of the model.
+    layer_norm_epsilon (`float`, *optional*, defaults to 1e-05):
+        The epsilon to use in the layer normalization layers.
+    learned_pos_emb (`bool`, *optional*, defaults to `True`):
+        Whether to use learned positional embeddings.
+    attn_config (`dict`, *optional*):
+        A dictionary used to configure the model's attention module.
+    init_device (`str`, *optional*, defaults to `"cpu"`):
+        The device to use for parameter initialization. Defined for backward compatibility
+    logit_scale (`float`, *optional*):
+        If not None, scale the logits by this value.
+    no_bias (`bool`, *optional*, defaults to `True`):
+        Whether to use bias in all linear layers.
+    embedding_fraction (`float`, *optional*, defaults to 1.0):
+        The fraction to scale the gradients of the embedding layer by.
+    norm_type (`str`, *optional*, defaults to `"low_precision_layernorm"`):
+        Type of layer norm to use. All MPT models uses the same layer norm implementation. Defined for backward
+        compatibility.
+
+    Example:
+
+    ```python
+    >>> from transformers import MptConfig, MptModel
+
+    >>> # Initializing a Mpt configuration
+    >>> configuration = MptConfig()
+
+    >>> # Initializing a model (with random weights) from the configuration
+    >>> model = MptModel(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+    ```
+    """
+
+    model_type = "mpt"
+    sub_configs = {"attn_config": MptAttentionConfig}
+    attribute_map = {
+        "num_attention_heads": "n_heads",
+        "hidden_size": "d_model",
+        "num_hidden_layers": "n_layers",
+    }
+
+    d_model: int = 2048
+    n_heads: int = 16
+    n_layers: int = 24
+    expansion_ratio: int = 4
+    max_seq_len: int = 2048
+    vocab_size: int = 50368
+    resid_pdrop: float | int = 0.0
+    layer_norm_epsilon: float = 1e-5
+    emb_pdrop: float | int = 0.0
+    learned_pos_emb: bool = True
+    attn_config: dict | MptAttentionConfig | None = None
+    init_device: str = "cpu"
+    logit_scale: float | str | None = None
+    no_bias: bool = True
+    embedding_fraction: float = 1.0
+    norm_type: str = "low_precision_layernorm"
+    use_cache: bool = False
+    initializer_range: float = 0.02
+    tie_word_embeddings: bool = True
+    pad_token_id: int | None = None
+    bos_token_id: int | None = None
+    eos_token_id: int | list[int] | None = None
+
+    def __post_init__(self, **kwargs):
+        if self.attn_config is None:
+            self.attn_config = MptAttentionConfig()
+        elif isinstance(self.attn_config, dict):
+            self.attn_config = MptAttentionConfig(**self.attn_config)
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["MptConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/sam2_video/__init__.py

@@ -0,0 +1,29 @@
+# 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.
+from typing import TYPE_CHECKING
+
+from ...utils import _LazyModule
+from ...utils.import_utils import define_import_structure
+
+
+if TYPE_CHECKING:
+    from .configuration_sam2_video import *
+    from .modeling_sam2_video import *
+    from .processing_sam2_video import *
+    from .video_processing_sam2_video import *
+else:
+    import sys
+
+    _file = globals()["__file__"]
+    sys.modules[__name__] = _LazyModule(__name__, _file, define_import_structure(_file), module_spec=__spec__)

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/sam2_video/configuration_sam2_video.py

@@ -0,0 +1,274 @@
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+#           This file was automatically generated from src/transformers/models/sam2_video/modular_sam2_video.py.
+#               Do NOT edit this file manually as any edits will be overwritten by the generation of
+#             the file from the modular. If any change should be done, please apply the change to the
+#                          modular_sam2_video.py file directly. One of our CI enforces this.
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 The Meta AI Authors and 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 huggingface_hub.dataclasses import strict
+
+from ...configuration_utils import PreTrainedConfig
+from ...utils import auto_docstring
+from ..auto import CONFIG_MAPPING, AutoConfig
+
+
+@auto_docstring(checkpoint="facebook/sam2_video.1-hiera-tiny")
+@strict
+class Sam2VideoPromptEncoderConfig(PreTrainedConfig):
+    r"""
+    mask_input_channels (`int`, *optional*, defaults to 16):
+        The number of channels to be fed to the `MaskDecoder` module.
+    num_point_embeddings (`int`, *optional*, defaults to 4):
+        The number of point embeddings to be used.
+    scale (`float`, *optional*, defaults to 1):
+        The scale factor for the prompt encoder.
+    """
+
+    base_config_key = "prompt_encoder_config"
+
+    hidden_size: int = 256
+    image_size: int | list[int] | tuple[int, int] = 1024
+    patch_size: int | list[int] | tuple[int, int] = 16
+    mask_input_channels: int = 16
+    num_point_embeddings: int = 4
+    hidden_act: str = "gelu"
+    layer_norm_eps: float = 1e-6
+    scale: int = 1
+
+
+@auto_docstring(checkpoint="facebook/sam2_video.1-hiera-tiny")
+@strict
+class Sam2VideoMaskDecoderConfig(PreTrainedConfig):
+    r"""
+    mlp_dim (`int`, *optional*, defaults to 2048):
+        The dimension of the MLP in the two-way transformer.
+    attention_downsample_rate (`int`, *optional*, defaults to 2):
+        The downsample rate for the attention layers.
+    num_multimask_outputs (`int`, *optional*, defaults to 3):
+        The number of multimask outputs.
+    iou_head_depth (`int`, *optional*, defaults to 3):
+        The depth of the IoU head.
+    iou_head_hidden_dim (`int`, *optional*, defaults to 256):
+        The hidden dimension of the IoU head.
+    dynamic_multimask_via_stability (`bool`, *optional*, defaults to `True`):
+        Whether to use dynamic multimask via stability.
+    dynamic_multimask_stability_delta (`float`, *optional*, defaults to 0.05):
+        The stability delta for the dynamic multimask.
+    dynamic_multimask_stability_thresh (`float`, *optional*, defaults to 0.98):
+        The stability threshold for the dynamic multimask.
+    """
+
+    base_config_key = "mask_decoder_config"
+
+    hidden_size: int = 256
+    hidden_act: str = "gelu"
+    mlp_dim: int = 2048
+    num_hidden_layers: int = 2
+    num_attention_heads: int = 8
+    attention_downsample_rate: int = 2
+    num_multimask_outputs: int = 3
+    iou_head_depth: int = 3
+    iou_head_hidden_dim: int = 256
+    dynamic_multimask_via_stability: bool = True
+    dynamic_multimask_stability_delta: float = 0.05
+    dynamic_multimask_stability_thresh: float = 0.98
+
+
+@auto_docstring(checkpoint="facebook/sam2.1-hiera-tiny")
+@strict
+class Sam2VideoConfig(PreTrainedConfig):
+    r"""
+    prompt_encoder_config (Union[`dict`, `Sam2PromptEncoderConfig`], *optional*):
+        Dictionary of configuration options used to initialize [`Sam2PromptEncoderConfig`].
+    mask_decoder_config (Union[`dict`, `Sam2MaskDecoderConfig`], *optional*):
+        Dictionary of configuration options used to initialize [`Sam2MaskDecoderConfig`].
+    initializer_range (`float`, *optional*, defaults to 0.02):
+        Standard deviation for parameter initialization.
+    num_maskmem (`int`, *optional*, defaults to 7):
+        The number of memory slots for the mask memory.
+    sigmoid_scale_for_mem_enc (`float`, *optional*, defaults to 20.0):
+        Scale factor for the sigmoid function in the memory encoder.
+    sigmoid_bias_for_mem_enc (`float`, *optional*, defaults to -10.0):
+        Bias for the sigmoid function in the memory encoder.
+    enable_occlusion_spatial_embedding (`bool`, *optional*, defaults to `True`):
+        Whether to enable spatial embedding for occlusions.
+    multimask_output_in_sam (`bool`, *optional*, defaults to `True`):
+        Whether to output multiple masks from the SAM head.
+    multimask_min_pt_num (`int`, *optional*, defaults to 0):
+        The minimum number of points to trigger multimask output.
+    multimask_max_pt_num (`int`, *optional*, defaults to 1):
+        The maximum number of points to trigger multimask output.
+    multimask_output_for_tracking (`bool`, *optional*, defaults to `True`):
+        Whether to use multimask output for tracking.
+    max_object_pointers_in_encoder (`int`, *optional*, defaults to 16):
+        The maximum number of object pointers in the encoder.
+    max_cond_frame_num (`int`, *optional*, defaults to -1):
+        Maximum number of conditioning frames to use in memory attention. Set to -1 to use all conditioning frames.
+    enable_temporal_pos_encoding_for_object_pointers (`bool`, *optional*, defaults to `True`):
+        Whether to enable temporal positional encoding for object pointers.
+    memory_attention_hidden_size (`int`, *optional*, defaults to 256):
+        Dimensionality of the memory attention hidden states.
+    memory_attention_num_layers (`int`, *optional*, defaults to 4):
+        The number of layers in the memory attention module.
+    memory_attention_num_attention_heads (`int`, *optional*, defaults to 1):
+        Number of attention heads for each attention layer in the memory attention.
+    memory_attention_downsample_rate (`int`, *optional*, defaults to 1):
+        The downsample rate for the attention layers.
+    memory_attention_feed_forward_hidden_size (`int`, *optional*, defaults to 2048):
+        The dimension of the feedforward network in the memory attention module.
+    memory_attention_feed_forward_hidden_act (`str`, *optional*, defaults to `"relu"`):
+        The non-linear activation function in the feedforward network in the memory attention module.
+    memory_attention_dropout (`float`, *optional*, defaults to 0.1):
+        The dropout rate for the memory attention module.
+    memory_attention_rope_theta (`float`, *optional*, defaults to 10000):
+        The Rope theta parameter.
+    memory_attention_rope_feat_sizes (`list[int]`, *optional*, defaults to `[64, 64]`):
+        The feature sizes for the Rope positional encoding.
+    memory_attention_rope_dropout (`float`, *optional*, defaults to 0.1):
+        The dropout rate for the Rope positional encoding.
+    memory_encoder_hidden_size (`int`, *optional*, defaults to 256):
+        Dimensionality of the memory encoder hidden states.
+    memory_encoder_output_channels (`int`, *optional*, defaults to 64):
+        The number of output channels for the memory encoder.
+    mask_downsampler_embed_dim (`int`, *optional*, defaults to 256):
+        The dimension of the mask downsampler embedding.
+    mask_downsampler_kernel_size (`int`, *optional*, defaults to 3):
+        The kernel size for the mask downsampler.
+    mask_downsampler_stride (`int`, *optional*, defaults to 2):
+        The stride for the mask downsampler.
+    mask_downsampler_padding (`int`, *optional*, defaults to 1):
+        The padding for the mask downsampler.
+    mask_downsampler_total_stride (`int`, *optional*, defaults to 16):
+        The total stride for the mask downsampler.
+    mask_downsampler_hidden_act (`str`, *optional*, defaults to `"gelu"`):
+        The non-linear activation function in the mask downsampler.
+    memory_fuser_num_layers (`int`, *optional*, defaults to 2):
+        The number of layers in the memory fuser.
+    memory_fuser_embed_dim (`int`, *optional*, defaults to 256):
+        The dimension of the embedding layer in the memory fuser.
+    memory_fuser_intermediate_dim (`int`, *optional*, defaults to 1024):
+        The dimension of the intermediate layer in the memory fuser.
+    memory_fuser_kernel_size (`int`, *optional*, defaults to 7):
+        The kernel size for the memory fuser.
+    memory_fuser_padding (`int`, *optional*, defaults to 3):
+        The padding for the memory fuser.
+    memory_fuser_layer_scale_init_value (`float`, *optional*, defaults to 1e-06):
+        The initial value for the layer scale in the memory fuser.
+    memory_fuser_hidden_act (`str`, *optional*, defaults to `"gelu"`):
+        The non-linear activation function in the memory fuser..
+
+    Example:
+
+    ```python
+    >>> from transformers import (
+    ...     Sam2VisionConfig,
+    ...     Sam2PromptEncoderConfig,
+    ...     Sam2MaskDecoderConfig,
+    ...     Sam2Model,
+    ... )
+
+    >>> # Initializing a Sam2Config with `"facebook/sam2.1_hiera_tiny"` style configuration
+    >>> configuration = Sam2config()
+
+    >>> # Initializing a Sam2Model (with random weights) from the `"facebook/sam2.1_hiera_tiny"` style configuration
+    >>> model = Sam2Model(configuration)
+
+    >>> # Accessing the model configuration
+    >>> configuration = model.config
+
+    >>> # We can also initialize a Sam2Config from a Sam2VisionConfig, Sam2PromptEncoderConfig, and Sam2MaskDecoderConfig
+
+    >>> # Initializing SAM2 vision encoder, memory attention, and memory encoder configurations
+    >>> vision_config = Sam2VisionConfig()
+    >>> prompt_encoder_config = Sam2PromptEncoderConfig()
+    >>> mask_decoder_config = Sam2MaskDecoderConfig()
+
+    >>> config = Sam2Config(vision_config, prompt_encoder_config, mask_decoder_config)
+    ```"""
+
+    model_type = "sam2_video"
+    sub_configs = {
+        "vision_config": AutoConfig,
+        "prompt_encoder_config": Sam2VideoPromptEncoderConfig,
+        "mask_decoder_config": Sam2VideoMaskDecoderConfig,
+    }
+
+    vision_config: dict | PreTrainedConfig | None = None
+    prompt_encoder_config: dict | PreTrainedConfig | None = None
+    mask_decoder_config: dict | PreTrainedConfig | None = None
+    initializer_range: float = 0.02
+    num_maskmem: int = 7
+    image_size: int | list[int] | tuple[int, int] = 1024
+    sigmoid_scale_for_mem_enc: float = 20.0
+    sigmoid_bias_for_mem_enc: float = -10.0
+    enable_occlusion_spatial_embedding: bool = True
+    multimask_output_in_sam: bool = True
+    multimask_min_pt_num: int = 0
+    multimask_max_pt_num: int = 1
+    multimask_output_for_tracking: bool = True
+    max_object_pointers_in_encoder: int = 16
+    max_cond_frame_num: int = -1
+    enable_temporal_pos_encoding_for_object_pointers: bool = True
+    memory_attention_hidden_size: int = 256
+    memory_attention_num_layers: int = 4
+    memory_attention_num_attention_heads: int = 1
+    memory_attention_downsample_rate: int = 1
+    memory_attention_feed_forward_hidden_size: int = 2048
+    memory_attention_feed_forward_hidden_act: str = "relu"
+    memory_attention_dropout: float | int = 0.1
+    memory_attention_rope_theta: int = 10000
+    memory_attention_rope_feat_sizes: list[int] | None = None
+    memory_attention_rope_dropout: float | int = 0.1
+    memory_encoder_hidden_size: int = 256
+    memory_encoder_output_channels: int = 64
+    mask_downsampler_embed_dim: int = 256
+    mask_downsampler_kernel_size: int = 3
+    mask_downsampler_stride: int = 2
+    mask_downsampler_padding: int = 1
+    mask_downsampler_total_stride: int = 16
+    mask_downsampler_hidden_act: str = "gelu"
+    memory_fuser_num_layers: int = 2
+    memory_fuser_embed_dim: int = 256
+    memory_fuser_intermediate_dim: int = 1024
+    memory_fuser_kernel_size: int = 7
+    memory_fuser_padding: int = 3
+    memory_fuser_layer_scale_init_value: float = 1e-6
+    memory_fuser_hidden_act: str = "gelu"
+
+    def __post_init__(self, **kwargs):
+        self.memory_attention_rope_feat_sizes = (
+            [64, 64] if self.memory_attention_rope_feat_sizes is None else self.memory_attention_rope_feat_sizes
+        )
+
+        if isinstance(self.vision_config, dict):
+            self.vision_config["model_type"] = self.vision_config.get("model_type", "sam2_vision_model")
+            self.vision_config = CONFIG_MAPPING[self.vision_config["model_type"]](**self.vision_config)
+        elif self.vision_config is None:
+            self.vision_config = CONFIG_MAPPING["sam2_vision_model"]()
+
+        if isinstance(self.prompt_encoder_config, dict):
+            self.prompt_encoder_config = Sam2VideoPromptEncoderConfig(**self.prompt_encoder_config)
+        elif self.prompt_encoder_config is None:
+            self.prompt_encoder_config = Sam2VideoPromptEncoderConfig()
+
+        if isinstance(self.mask_decoder_config, dict):
+            self.mask_decoder_config = Sam2VideoPromptEncoderConfig(**self.mask_decoder_config)
+        elif self.mask_decoder_config is None:
+            self.mask_decoder_config = Sam2VideoMaskDecoderConfig()
+
+        super().__post_init__(**kwargs)
+
+
+__all__ = ["Sam2VideoMaskDecoderConfig", "Sam2VideoPromptEncoderConfig", "Sam2VideoConfig"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/sam2_video/processing_sam2_video.py

@@ -0,0 +1,801 @@
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+#           This file was automatically generated from src/transformers/models/sam2_video/modular_sam2_video.py.
+#               Do NOT edit this file manually as any edits will be overwritten by the generation of
+#             the file from the modular. If any change should be done, please apply the change to the
+#                          modular_sam2_video.py file directly. One of our CI enforces this.
+#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
+# Copyright 2025 The Meta AI Authors and 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 copy import deepcopy
+from typing import Union
+
+import numpy as np
+import torch
+
+from ...image_utils import ImageInput
+from ...processing_utils import ProcessorMixin
+from ...tokenization_utils_base import BatchEncoding
+from ...utils import TensorType, auto_docstring
+from ...utils.import_utils import requires
+from ...video_utils import VideoInput
+from .modeling_sam2_video import Sam2VideoInferenceSession
+
+
+@requires(backends=("torch",))
+@auto_docstring
+class Sam2VideoProcessor(ProcessorMixin):
+    def __init__(
+        self, image_processor, video_processor, target_size: int | None = None, point_pad_value: int = -10, **kwargs
+    ):
+        r"""
+        target_size (`int`, *optional*):
+            The target size (in pixels) for normalizing input points and bounding boxes. If not provided, defaults
+            to the image processor's size configuration. All input coordinates (points and boxes) are normalized
+            to this size before being passed to the model. This ensures consistent coordinate representation
+            regardless of the original image dimensions.
+        point_pad_value (`int`, *optional*, defaults to -10):
+            The value used for padding input points when batching sequences of different lengths. This value is
+            used to mark padded positions and is preserved during coordinate normalization.
+        """
+        super().__init__(image_processor, video_processor, **kwargs)
+        self.point_pad_value = point_pad_value
+        self.target_size = target_size if target_size is not None else self.image_processor.size["height"]
+
+    @auto_docstring
+    def __call__(
+        self,
+        images: ImageInput | None = None,
+        segmentation_maps: ImageInput | None = None,
+        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
+        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
+        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
+        original_sizes: list[list[float]] | torch.Tensor | None = None,
+        return_tensors: str | TensorType | None = None,
+        **kwargs,
+    ) -> BatchEncoding:
+        r"""
+        segmentation_maps (`ImageInput`, *optional*):
+            The segmentation maps to process.
+        input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *optional*):
+            The points to add to the frame.
+        input_labels (`list[list[list[int]]]`, `torch.Tensor`, *optional*):
+            The labels for the points.
+        input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *optional*):
+            The bounding boxes to add to the frame.
+        original_sizes (`list[list[float]]`, `torch.Tensor`, *optional*):
+            The original sizes of the images.
+
+        Returns:
+            A [`BatchEncoding`] with the following fields:
+            - `pixel_values` (`torch.Tensor`): The processed image(s).
+            - `original_sizes` (`list[list[float]]`): The original sizes of the images.
+            - `labels` (`torch.Tensor`): The processed segmentation maps (if provided).
+            - `input_points` (`torch.Tensor`): The processed points.
+            - `input_labels` (`torch.Tensor`): The processed labels.
+            - `input_boxes` (`torch.Tensor`): The processed bounding boxes.
+        """
+        if images is not None:
+            encoding_image_processor = self.image_processor(
+                images,
+                segmentation_maps=segmentation_maps,
+                return_tensors=return_tensors,
+                **kwargs,
+            )
+        elif original_sizes is not None:
+            if isinstance(original_sizes, torch.Tensor):
+                original_sizes = original_sizes.cpu().tolist()
+            encoding_image_processor = BatchEncoding({"original_sizes": original_sizes}, tensor_type=return_tensors)
+        else:
+            raise ValueError("Either images or original_sizes must be provided")
+
+        # pop arguments that are not used in the forward but used nevertheless
+        original_sizes = encoding_image_processor["original_sizes"]
+        # Check original_sizes is of length 1 or len(images)
+        if images is not None and len(original_sizes) != 1 and len(original_sizes) != len(images):
+            raise ValueError(
+                "original_sizes must be of length 1 or len(images). If you are passing a single image, you must pass a single original_size."
+            )
+
+        # Process input points, labels, and boxes if provided
+        if input_points is not None or input_labels is not None or input_boxes is not None:
+            # Validate and convert inputs to standardized format
+            processed_points = self._validate_single_input(
+                input_points,
+                expected_depth=4,
+                input_name="points",
+                expected_format="[image level, object level, point level, point coordinates]",
+                expected_coord_size=2,
+            )
+            processed_labels = self._validate_single_input(
+                input_labels,
+                expected_depth=3,
+                input_name="labels",
+                expected_format="[image level, object level, point level]",
+            )
+            processed_boxes = self._validate_single_input(
+                input_boxes,
+                expected_depth=3,
+                input_name="boxes",
+                expected_format="[image level, box level, box coordinates]",
+                expected_coord_size=4,
+            )
+
+            # Get padding requirements for all inputs
+            if processed_points is not None:
+                points_max_dims = self._get_nested_dimensions(processed_points)[:3]
+            if processed_labels is not None:
+                labels_max_dims = self._get_nested_dimensions(processed_labels)[:3]
+            if processed_boxes is not None:
+                boxes_max_dims = self._get_nested_dimensions(processed_boxes)[:2]
+
+            # Ensure points and labels have consistent dimensions
+            if processed_points is not None and processed_labels is not None:
+                if points_max_dims != labels_max_dims:
+                    raise ValueError(
+                        "Input points and labels have inconsistent dimensions. Please ensure they have the same dimensions."
+                    )
+
+            # Check that boxes don't need padding (model limitation)
+            if processed_boxes is not None and len(processed_boxes) >= 2:
+                if any(len(img_boxes) < boxes_max_dims[1] for img_boxes in processed_boxes):
+                    raise ValueError(
+                        "Input boxes have inconsistent dimensions that would require padding, "
+                        "but boxes cannot be padded due to model limitations. "
+                        "Please ensure all images have the same number of boxes."
+                    )
+
+            # Pad and normalize all inputs to final tensor format
+            if processed_points is not None:
+                padded_points = self._pad_nested_list(processed_points, points_max_dims + [2])
+                final_points = torch.tensor(padded_points, dtype=torch.float32)
+                self._normalize_tensor_coordinates(final_points, original_sizes, preserve_padding=True)
+                encoding_image_processor.update({"input_points": final_points})
+
+            if processed_labels is not None:
+                padded_labels = self._pad_nested_list(processed_labels, labels_max_dims)
+                final_labels = torch.tensor(padded_labels, dtype=torch.int64)
+                encoding_image_processor.update({"input_labels": final_labels})
+
+            if processed_boxes is not None:
+                final_boxes = torch.tensor(processed_boxes, dtype=torch.float32)
+                self._normalize_tensor_coordinates(final_boxes, original_sizes, is_bounding_box=True)
+                encoding_image_processor.update({"input_boxes": final_boxes})
+
+        return encoding_image_processor
+
+    def _normalize_coordinates(
+        self, target_size: int, coords: "torch.Tensor", original_size, is_bounding_box=False
+    ) -> "torch.Tensor":
+        """
+        Expects a numpy array of length 2 in the final dimension. Requires the original image size in (H, W) format.
+
+        Args:
+            target_size (`int`):
+                The target size of the image.
+            coords (`torch.Tensor`):
+                The coordinates to be normalized.
+            original_size (`tuple`):
+                The original size of the image.
+            is_bounding_box (`bool`, *optional*, defaults to `False`):
+                Whether the coordinates are bounding boxes.
+        """
+        old_h, old_w = original_size
+        new_h, new_w = target_size, target_size
+        coords = deepcopy(coords).float()
+
+        if is_bounding_box:
+            coords = coords.reshape(-1, 2, 2)
+        coords[..., 0] = coords[..., 0] * (new_w / old_w)
+        coords[..., 1] = coords[..., 1] * (new_h / old_h)
+
+        if is_bounding_box:
+            coords = coords.reshape(-1, 4)
+
+        return coords
+
+    def _convert_to_nested_list(self, data, expected_depth, current_depth=0):
+        """
+        Recursively convert various input formats (tensors, numpy arrays, lists) to nested lists.
+
+        Args:
+            data: Input data in any format
+            expected_depth: Expected nesting depth
+            current_depth: Current depth in recursion
+
+        Returns:
+            Nested list representation of the data
+        """
+        if data is None:
+            return None
+
+        # Convert tensor/numpy to list if we're at a leaf level or if it's a multi-dimensional array
+        if isinstance(data, torch.Tensor):  # PyTorch tensor
+            if current_depth == expected_depth - 2 or len(data.shape) <= 2:  # At coordinate level or small tensor
+                return data.numpy().tolist()
+            else:
+                return [self._convert_to_nested_list(item, expected_depth, current_depth + 1) for item in data]
+        elif isinstance(data, np.ndarray):  # NumPy array
+            if current_depth == expected_depth - 2 or len(data.shape) <= 2:  # At coordinate level or small array
+                return data.tolist()
+            else:
+                return [self._convert_to_nested_list(item, expected_depth, current_depth + 1) for item in data]
+        elif isinstance(data, list):
+            if current_depth == expected_depth:
+                # We've reached the expected depth, return as is
+                return data
+            else:
+                # Continue recursion
+                return [self._convert_to_nested_list(item, expected_depth, current_depth + 1) for item in data]
+        elif isinstance(data, (int, float)):
+            return data
+        else:
+            raise TypeError(f"Unsupported data type: {type(data)}")
+
+    def _get_nested_dimensions(self, nested_list, max_dims=None):
+        """
+        Get the maximum dimensions at each level of nesting.
+
+        Args:
+            nested_list (`list`):
+                Nested list structure.
+            max_dims (`list`, *optional*):
+                Current maximum dimensions (for recursion).
+
+        Returns:
+            `list`: A list of maximum dimensions for each nesting level.
+        """
+        if max_dims is None:
+            max_dims = []
+
+        if not isinstance(nested_list, list):
+            return max_dims
+
+        if len(max_dims) == 0:
+            max_dims.append(len(nested_list))
+        else:
+            max_dims[0] = max(max_dims[0], len(nested_list))
+
+        if len(nested_list) > 0:
+            for item in nested_list:
+                if isinstance(item, list):
+                    sub_dims = self._get_nested_dimensions(item)
+                    # Merge sub_dims into max_dims
+                    for i, dim in enumerate(sub_dims):
+                        if i + 1 >= len(max_dims):
+                            max_dims.append(dim)
+                        else:
+                            max_dims[i + 1] = max(max_dims[i + 1], dim)
+
+        return max_dims
+
+    def _pad_nested_list(self, nested_list, target_dims, current_level=0, pad_value=None):
+        """
+        Recursively pad a nested list to match target dimensions.
+
+        Args:
+            nested_list (`list`):
+                Nested list to pad.
+            target_dims (`list`):
+                Target dimensions for each level.
+            current_level (`int`, *optional*, defaults to 0):
+                Current nesting level.
+            pad_value (`int`, *optional*):
+                Value to use for padding.
+
+        Returns:
+            `list`: The padded nested list.
+        """
+        if pad_value is None:
+            pad_value = self.point_pad_value
+
+        if current_level >= len(target_dims):
+            return nested_list
+
+        # Ensure we have a list
+        if not isinstance(nested_list, list):
+            nested_list = [nested_list]
+
+        # Pad current level
+        current_size = len(nested_list)
+        target_size = target_dims[current_level]
+
+        # Pad with appropriate values
+        if current_level == len(target_dims) - 1:
+            # At the coordinate level, pad with pad_value
+            nested_list.extend([pad_value] * (target_size - current_size))
+        else:
+            # At higher levels, pad with nested structures
+            if current_size > 0:
+                # Create appropriately sized template
+                if current_level < len(target_dims) - 2:
+                    # For non-coordinate levels, create empty nested structure
+                    template_dims = target_dims[current_level + 1 :]
+                    template = self._create_empty_nested_structure(template_dims, pad_value)
+                else:
+                    # For coordinate level, create list of pad_values
+                    template = [pad_value] * target_dims[current_level + 1]
+
+                nested_list.extend([deepcopy(template) for _ in range(target_size - current_size)])
+            else:
+                # Create from scratch
+                template_dims = target_dims[current_level + 1 :]
+                template = self._create_empty_nested_structure(template_dims, pad_value)
+                nested_list.extend([deepcopy(template) for _ in range(target_size)])
+
+        # Recursively pad sublists
+        if current_level < len(target_dims) - 1:
+            for i in range(len(nested_list)):
+                if isinstance(nested_list[i], list):
+                    nested_list[i] = self._pad_nested_list(nested_list[i], target_dims, current_level + 1, pad_value)
+
+        return nested_list
+
+    def _create_empty_nested_structure(self, dims, pad_value):
+        """
+        Create an empty nested structure with given dimensions filled with pad_value.
+
+        Args:
+            dims (`list`):
+                The dimensions of the nested structure.
+            pad_value (`int`):
+                The value to fill the structure with.
+        """
+        if len(dims) == 1:
+            return [pad_value] * dims[0]
+        else:
+            return [self._create_empty_nested_structure(dims[1:], pad_value) for _ in range(dims[0])]
+
+    def _get_nesting_level(self, input_list):
+        """
+        Get the nesting level of a list structure.
+
+        Args:
+            input_list (`list`):
+                The list to get the nesting level of.
+        """
+        if isinstance(input_list, list):
+            if len(input_list) == 0:
+                return 1
+            return 1 + self._get_nesting_level(input_list[0])
+        elif isinstance(input_list, (np.ndarray, torch.Tensor)):
+            # For arrays/tensors, the nesting level is the number of dimensions
+            return len(input_list.shape)
+        return 0
+
+    def _validate_single_input(
+        self,
+        data: torch.Tensor | np.ndarray | list,
+        expected_depth: int,
+        input_name: str,
+        expected_format: str,
+        expected_coord_size: int | None = None,
+    ) -> list:
+        """
+                Validate a single input by ensuring proper nesting and raising an error if the input is not valid.
+
+                Args:
+                    data (`torch.Tensor`, `np.ndarray`, or `list`):
+                        Input data to process.
+                    expected_depth (`int`):
+                        Expected nesting depth.
+                    input_name (`str`):
+                        Name of the input for error messages.
+                    expected_format (`str`):
+                        The expected format of the input.
+                    expected_coord_size (`int`, *optional*):
+                        Expected coordinate size (2 for points, 4 for boxes, None for labels).
+        .
+        """
+        if data is None:
+            return None
+
+        # Handle tensors and numpy arrays first
+        if isinstance(data, (torch.Tensor, np.ndarray)):
+            # For tensors/arrays, we can directly check the number of dimensions
+            if data.ndim != expected_depth:
+                raise ValueError(
+                    f"Input {input_name} must be a tensor/array with {expected_depth} dimensions. The expected nesting format is {expected_format}. Got {data.ndim} dimensions."
+                )
+            elif expected_coord_size is not None:
+                if data.shape[-1] != expected_coord_size:
+                    raise ValueError(
+                        f"Input {input_name} must be a tensor/array with {expected_coord_size} as the last dimension, got {data.shape[-1]}."
+                    )
+            return self._convert_to_nested_list(data, expected_depth)
+
+        # Handle nested lists
+        if isinstance(data, list):
+            current_depth = self._get_nesting_level(data)
+            if current_depth != expected_depth:
+                raise ValueError(
+                    f"Input {input_name} must be a nested list with {expected_depth} levels. The expected nesting format is {expected_format}. Got {current_depth} levels."
+                )
+            return self._convert_to_nested_list(data, expected_depth)
+
+    def _normalize_tensor_coordinates(self, tensor, original_sizes, is_bounding_box=False, preserve_padding=False):
+        """
+        Helper method to normalize coordinates in a tensor across multiple images.
+
+        Args:
+            tensor (`torch.Tensor`):
+                Input tensor with coordinates.
+            original_sizes (`list`):
+                Original image sizes.
+            is_bounding_box (`bool`, *optional*, defaults to `False`):
+                Whether coordinates are bounding boxes.
+            preserve_padding (`bool`, *optional*, defaults to `False`):
+                Whether to preserve padding values (for points).
+        """
+        if preserve_padding:
+            # For points: avoid normalizing pad values
+            mask = tensor != self.point_pad_value
+            coord_mask = mask.all(dim=-1, keepdim=True)
+
+        for img_idx in range(len(original_sizes)):
+            if img_idx < tensor.shape[0]:
+                original_size = original_sizes[img_idx] if img_idx < len(original_sizes) else original_sizes[0]
+                normalized_coords = self._normalize_coordinates(
+                    self.target_size, tensor[img_idx], original_size, is_bounding_box=is_bounding_box
+                )
+
+                if preserve_padding:
+                    # Only update non-padded values
+                    img_mask = coord_mask[img_idx]
+                    tensor[img_idx] = torch.where(
+                        img_mask.expand_as(tensor[img_idx]), normalized_coords, tensor[img_idx]
+                    )
+                else:
+                    tensor[img_idx] = normalized_coords
+
+    def post_process_masks(
+        self,
+        masks,
+        original_sizes,
+        mask_threshold=0.0,
+        binarize=True,
+        max_hole_area=0.0,
+        max_sprinkle_area=0.0,
+        apply_non_overlapping_constraints=False,
+        **kwargs,
+    ):
+        """
+        Remove padding and upscale masks to the original image size.
+
+        Args:
+            masks (`Union[List[torch.Tensor], List[np.ndarray]]`):
+                Batched masks from the mask_decoder in (batch_size, num_channels, height, width) format.
+            original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`):
+                The original sizes of each image before it was resized to the model's expected input shape, in (height,
+                width) format.
+            mask_threshold (`float`, *optional*, defaults to 0.0):
+                Threshold for binarization and post-processing operations.
+            binarize (`bool`, *optional*, defaults to `True`):
+                Whether to binarize the masks.
+            max_hole_area (`float`, *optional*, defaults to 0.0):
+                The maximum area of a hole to fill.
+            max_sprinkle_area (`float`, *optional*, defaults to 0.0):
+                The maximum area of a sprinkle to fill.
+            apply_non_overlapping_constraints (`bool`, *optional*, defaults to `False`):
+                Whether to apply non-overlapping constraints to the masks.
+
+        Returns:
+            (`torch.Tensor`): Batched masks in batch_size, num_channels, height, width) format, where (height, width)
+            is given by original_size.
+        """
+        return self.image_processor.post_process_masks(
+            masks,
+            original_sizes,
+            mask_threshold,
+            binarize,
+            max_hole_area,
+            max_sprinkle_area,
+            apply_non_overlapping_constraints,
+            **kwargs,
+        )
+
+    @property
+    def model_input_names(self):
+        image_processor_input_names = self.image_processor.model_input_names
+        return list(image_processor_input_names + ["original_sizes"])
+
+    def init_video_session(
+        self,
+        video: VideoInput | None = None,
+        inference_device: Union[str, "torch.device"] = "cpu",
+        inference_state_device: Union[str, "torch.device"] | None = None,
+        processing_device: Union[str, "torch.device"] | None = None,
+        video_storage_device: Union[str, "torch.device"] | None = None,
+        max_vision_features_cache_size: int = 1,
+        dtype: torch.dtype = torch.float32,
+    ):
+        """
+        Initializes a video session for inference.
+        If a video is provided (async inference), the video will be processed and stored on the `video_storage_device`.
+
+        Args:
+            video (`VideoInput`, *optional*):
+                The video to process. No need to provide when streaming.
+            inference_device (`str` or `torch.device`, *optional*, defaults to "cpu"):
+                The device to use for inference.
+            inference_state_device (`str` or `torch.device`, *optional*):
+                The device to store the inference state on.
+            processing_device (`str` or `torch.device`, *optional*):
+                The device to use for video processing.
+            video_storage_device (`str` or `torch.device`, *optional*):
+                The device to store the processed video frames on.
+            max_vision_features_cache_size (`int`, *optional*, defaults to 1):
+                The maximum number of vision features to cache.
+            dtype (`torch.dtype`, *optional*, defaults to `torch.float32`):
+                The torch dtype to use for the whole session.
+        """
+        video_storage_device = video_storage_device if video_storage_device is not None else inference_device
+        inference_state_device = inference_state_device if inference_state_device is not None else inference_device
+        processing_device = processing_device if processing_device is not None else inference_device
+        pixel_values_video = None
+        video_height = None
+        video_width = None
+        if video is not None:
+            processed_video = self.video_processor(videos=video, device=processing_device, return_tensors="pt")
+            pixel_values_video = processed_video.pixel_values_videos[0]
+            video_height = processed_video.original_sizes[0][0]
+            video_width = processed_video.original_sizes[0][1]
+        inference_session = Sam2VideoInferenceSession(
+            video=pixel_values_video,
+            video_height=video_height,
+            video_width=video_width,
+            inference_device=inference_device,
+            video_storage_device=video_storage_device,
+            inference_state_device=inference_state_device,
+            dtype=dtype,
+            max_vision_features_cache_size=max_vision_features_cache_size,
+        )
+        return inference_session
+
+    def add_inputs_to_inference_session(
+        self,
+        inference_session: Sam2VideoInferenceSession,
+        frame_idx: int,
+        obj_ids: list[int] | int,
+        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
+        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
+        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
+        input_masks: np.ndarray | torch.Tensor | list[np.ndarray] | list[torch.Tensor] | None = None,
+        original_size: tuple[int, int] | None = None,
+        clear_old_inputs: bool = True,
+    ) -> Sam2VideoInferenceSession:
+        """
+        Process new points, boxes, or masks for a video frame and add them to the inference session.
+
+        Args:
+            inference_session (`Sam2VideoInferenceSession`):
+                The inference session for the video.
+            frame_idx (`int`):
+                The index of the frame to process.
+            obj_ids (`list[int]` or `int`):
+                The object ID(s) to associate with the points or box.
+                These can be any integers and can be reused later on to specify an object.
+            input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *optional*):
+                The points to add to the frame.
+            input_labels (`list[list[list[int]]]`, `torch.Tensor`, *optional*):
+                The labels for the points.
+            input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *optional*):
+                The bounding boxes to add to the frame.
+            input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, or `list[torch.Tensor]`, *optional*):
+                The mask(s) to add to the frame.
+            original_size (`tuple[int, int]`, *optional*):
+                The original size of the video. Provide when streaming.
+            clear_old_inputs (`bool`, *optional*, defaults to `True`):
+                Whether to clear old inputs for the object.
+        """
+
+        if isinstance(obj_ids, int):
+            obj_ids = [obj_ids]
+
+        # Validate inputs
+        if (input_points is not None) != (input_labels is not None):
+            raise ValueError("points and labels must be provided together")
+        if input_points is None and input_boxes is None and input_masks is None:
+            raise ValueError("at least one of points, boxes, or masks must be provided as input")
+        if input_masks is not None and (input_points is not None or input_boxes is not None):
+            raise ValueError("masks cannot be provided together with points or boxes")
+
+        if input_masks is not None:
+            return self.process_new_mask_for_video_frame(inference_session, frame_idx, obj_ids, input_masks)
+        else:
+            return self.process_new_points_or_boxes_for_video_frame(
+                inference_session,
+                frame_idx,
+                obj_ids,
+                input_points,
+                input_labels,
+                input_boxes,
+                original_size,
+                clear_old_inputs,
+            )
+
+    def process_new_points_or_boxes_for_video_frame(
+        self,
+        inference_session: Sam2VideoInferenceSession,
+        frame_idx: int,
+        obj_ids: list[int],
+        input_points: list[list[list[list[float]]]] | torch.Tensor | None = None,
+        input_labels: list[list[list[int]]] | torch.Tensor | None = None,
+        input_boxes: list[list[list[float]]] | torch.Tensor | None = None,
+        original_size: tuple[int, int] | None = None,
+        clear_old_inputs: bool = True,
+    ) -> Sam2VideoInferenceSession:
+        """
+        Process new points or boxes for a video frame and add them to the inference session.
+
+        Args:
+            inference_session (`Sam2VideoInferenceSession`):
+                The inference session for the video.
+            frame_idx (`int`):
+                The index of the frame to process.
+            obj_ids (`list[int]`):
+                The object ID(s) to associate with the points or box.
+                These can be any integers and can be reused later on to specify an object.
+            input_points (`list[list[list[list[float]]]]`, `torch.Tensor`, *optional*):
+                The points to add to the frame.
+            input_labels (`list[list[list[int]]]`, `torch.Tensor`, *optional*):
+                The labels for the points.
+            input_boxes (`list[list[list[float]]]`, `torch.Tensor`, *optional*):
+                The bounding boxes to add to the frame.
+            original_size (`tuple[int, int]`, *optional*):
+                The original size of the video. Provide when streaming.
+            clear_old_inputs (`bool`, *optional*, defaults to `True`):
+                Whether to clear old inputs for the object.
+        """
+        if original_size is not None:
+            inference_session.video_height = original_size[0]
+            inference_session.video_width = original_size[1]
+        elif inference_session.video_height is None or inference_session.video_width is None:
+            raise ValueError("original_size must be provided when adding points or boxes on a first streamed frame")
+
+        original_sizes = [[inference_session.video_height, inference_session.video_width]]
+
+        encoded_inputs = self(
+            input_points=input_points,
+            input_labels=input_labels,
+            input_boxes=input_boxes,
+            original_sizes=original_sizes,
+            return_tensors="pt",
+        )
+        input_points = encoded_inputs.get("input_points", None)
+        input_labels = encoded_inputs.get("input_labels", None)
+        input_boxes = encoded_inputs.get("input_boxes", None)
+
+        if input_points is not None:
+            if input_points.shape[1] != len(obj_ids):
+                raise ValueError(
+                    f"Number of object ids ({len(obj_ids)}) does not match number of points ({input_points.shape[1]})"
+                )
+        else:
+            input_points = torch.zeros(1, len(obj_ids), 0, 2, dtype=torch.float32)
+        if input_labels is not None:
+            if input_labels.shape[1] != len(obj_ids):
+                raise ValueError(
+                    f"Number of object ids ({len(obj_ids)}) does not match number of labels ({input_labels.shape[1]})"
+                )
+        else:
+            input_labels = torch.zeros(1, len(obj_ids), 0, dtype=torch.int32)
+        if input_boxes is not None:
+            if input_boxes.shape[1] != len(obj_ids):
+                raise ValueError(
+                    f"Number of object ids ({len(obj_ids)}) does not match number of boxes ({input_boxes.shape[1]})"
+                )
+
+        if input_boxes is not None:
+            if not clear_old_inputs:
+                raise ValueError(
+                    "cannot add box without clearing old points, since "
+                    "box prompt must be provided before any point prompt "
+                    "(please use clear_old_points=True instead)"
+                )
+            box_coords = input_boxes.reshape(1, -1, 2, 2)
+            box_labels = torch.tensor([2, 3], dtype=torch.int32).repeat(1, box_coords.shape[1], 1)
+            input_points = torch.cat([box_coords, input_points], dim=2)
+            input_labels = torch.cat([box_labels, input_labels], dim=2)
+
+        for obj_id, idx in zip(obj_ids, range(len(obj_ids))):
+            obj_idx = inference_session.obj_id_to_idx(obj_id)
+            input_points_for_obj = input_points[:, idx, :, :].unsqueeze(1)
+            input_labels_for_obj = input_labels[:, idx, :].unsqueeze(1)
+            # Handle existing points
+            if not clear_old_inputs:
+                existing_points = inference_session.point_inputs_per_obj[obj_idx].get(frame_idx, None)
+                if existing_points is not None:
+                    # Concatenate with existing points
+                    input_points_for_obj = torch.cat(
+                        [existing_points["point_coords"].to(input_points_for_obj.device), input_points_for_obj], dim=2
+                    )
+                    input_labels_for_obj = torch.cat(
+                        [existing_points["point_labels"].to(input_labels_for_obj.device), input_labels_for_obj], dim=2
+                    )
+            point_inputs = {
+                "point_coords": input_points_for_obj,
+                "point_labels": input_labels_for_obj,
+            }
+
+            inference_session.add_point_inputs(obj_idx, frame_idx, point_inputs)
+            inference_session.remove_mask_inputs(obj_idx, frame_idx)  # Clear any mask inputs
+
+        inference_session.obj_with_new_inputs = obj_ids
+
+    def process_new_mask_for_video_frame(
+        self,
+        inference_session: Sam2VideoInferenceSession,
+        frame_idx: int,
+        obj_ids: list[int],
+        input_masks: np.ndarray | torch.Tensor | list[np.ndarray] | list[torch.Tensor],
+    ):
+        """
+        Add new mask to a frame and add them to the inference session.
+
+        Args:
+            inference_session (`Sam2VideoInferenceSession`):
+                The inference session for the video.
+            frame_idx (`int`):
+                The index of the frame to process.
+            obj_ids (`list[int]`):
+                The object ID(s) to associate with the mask.
+                These can be any integers and can be reused later on to specify an object.
+            input_masks (`np.ndarray`, `torch.Tensor`, `list[np.ndarray]`, or `list[torch.Tensor]`):
+                The mask(s) to add to the frame.
+        """
+        if not isinstance(input_masks, list):
+            input_masks = [input_masks]
+        if len(input_masks) != len(obj_ids):
+            raise ValueError(
+                f"Number of object ids ({len(obj_ids)}) does not match number of masks ({len(input_masks)})"
+            )
+
+        for obj_id, mask in zip(obj_ids, input_masks):
+            obj_idx = inference_session.obj_id_to_idx(obj_id)
+
+            device = inference_session.inference_device
+
+            # Process mask
+            if not isinstance(mask, torch.Tensor):
+                mask = torch.tensor(mask, dtype=torch.bool)
+            nb_dim = mask.dim()
+            if nb_dim > 4 or nb_dim < 2:
+                raise ValueError(f"Mask has an unsupported number of dimensions: {nb_dim}")
+            for i in range(4 - nb_dim):
+                mask = mask.unsqueeze(0)
+
+            mask_H, mask_W = mask.shape[-2:]
+            mask_inputs_orig = mask.to(device)
+            mask_inputs_orig = mask_inputs_orig.float().to(device)
+
+            # Resize mask if needed
+            if mask_H != self.target_size or mask_W != self.target_size:
+                mask_inputs = torch.nn.functional.interpolate(
+                    mask_inputs_orig,
+                    size=(self.target_size, self.target_size),
+                    align_corners=False,
+                    mode="bilinear",
+                    antialias=True,
+                )
+                mask_inputs = (mask_inputs >= 0.5).float()
+            else:
+                mask_inputs = mask_inputs_orig
+
+            inference_session.add_mask_inputs(obj_idx, frame_idx, mask_inputs)
+            inference_session.remove_point_inputs(obj_idx, frame_idx)  # Clear any point inputs
+
+        inference_session.obj_with_new_inputs = obj_ids
+
+
+__all__ = ["Sam2VideoProcessor"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/.venv_qwen35_uv/lib/python3.12/site-packages/transformers/models/sam2_video/video_processing_sam2_video.py

@@ -0,0 +1,104 @@
+# Copyright 2025 The HuggingFace Inc. 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.
+"""Fast Image processor class for SAM2."""
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+from ...image_processing_utils import BatchFeature
+from ...image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling, SizeDict
+from ...utils import TensorType
+from ...video_processing_utils import BaseVideoProcessor
+
+
+class Sam2VideoVideoProcessor(BaseVideoProcessor):
+    resample = PILImageResampling.BILINEAR
+    image_mean = IMAGENET_DEFAULT_MEAN
+    image_std = IMAGENET_DEFAULT_STD
+    size = {"height": 1024, "width": 1024}
+    do_resize = True
+    do_rescale = True
+    do_normalize = True
+    do_convert_rgb = True
+    model_input_names = ["pixel_values"]
+
+    def _preprocess(
+        self,
+        videos: list["torch.Tensor"],
+        size: SizeDict,
+        return_tensors: str | TensorType | None,
+        **kwargs,
+    ) -> BatchFeature:
+        original_sizes = [video.shape[-2:] for video in videos]
+        reshaped_input_sizes = [(size.height, size.width) for _ in range(len(videos))]
+        batch_feature = super()._preprocess(videos, size=size, return_tensors=return_tensors, **kwargs)
+        batch_feature = BatchFeature(
+            data={
+                "original_sizes": original_sizes,
+                "reshaped_input_sizes": reshaped_input_sizes,
+                **batch_feature.data,
+            },
+            tensor_type=return_tensors,
+        )
+        return batch_feature
+
+    def post_process_masks(
+        self, masks, original_sizes, reshaped_input_sizes, mask_threshold=0.0, binarize=True, pad_size=None
+    ):
+        """
+        Remove padding and upscale masks to the original image size.
+
+        Args:
+            masks (`Union[List[torch.Tensor], List[np.ndarray]]`):
+                Batched masks from the mask_decoder in (batch_size, num_channels, height, width) format.
+            original_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`):
+                The original sizes of each image before it was resized to the model's expected input shape, in (height,
+                width) format.
+            reshaped_input_sizes (`Union[torch.Tensor, List[Tuple[int,int]]]`):
+                The size of each image as it is fed to the model, in (height, width) format. Used to remove padding.
+            mask_threshold (`float`, *optional*, defaults to 0.0):
+                The threshold to use for binarizing the masks.
+            binarize (`bool`, *optional*, defaults to `True`):
+                Whether to binarize the masks.
+            pad_size (`int`, *optional*, defaults to `self.pad_size`):
+                The target size the images were padded to before being passed to the model. If None, the target size is
+                assumed to be the processor's `pad_size`.
+        Returns:
+            (`torch.Tensor`): Batched masks in batch_size, num_channels, height, width) format, where (height, width)
+            is given by original_size.
+        """
+        pad_size = self.size if pad_size is None else pad_size
+        target_image_size = (pad_size["height"], pad_size["width"])
+        if isinstance(original_sizes, (torch.Tensor, np.ndarray)):
+            original_sizes = original_sizes.tolist()
+        if isinstance(reshaped_input_sizes, (torch.Tensor, np.ndarray)):
+            reshaped_input_sizes = reshaped_input_sizes.tolist()
+        output_masks = []
+        for i, original_size in enumerate(original_sizes):
+            if isinstance(masks[i], np.ndarray):
+                masks[i] = torch.from_numpy(masks[i])
+            elif not isinstance(masks[i], torch.Tensor):
+                raise TypeError("Input masks should be a list of `torch.tensors` or a list of `np.ndarray`")
+            interpolated_mask = F.interpolate(masks[i], target_image_size, mode="bilinear", align_corners=False)
+            interpolated_mask = interpolated_mask[..., : reshaped_input_sizes[i][0], : reshaped_input_sizes[i][1]]
+            interpolated_mask = F.interpolate(interpolated_mask, original_size, mode="bilinear", align_corners=False)
+            if binarize:
+                interpolated_mask = interpolated_mask > mask_threshold
+            output_masks.append(interpolated_mask)
+
+        return output_masks
+
+
+__all__ = ["Sam2VideoVideoProcessor"]

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr3e4_elfopt_t5embed_unfixed_stateprobadd_selfcond_ce_fast_20260531_230026/step_002000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr3e4_elfopt_t5embed_unfixed_stateprobadd_selfcond_ce_fast_20260531_230026/step_008000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr3e4_elfopt_t5embed_unfixed_stateprobadd_selfcond_ce_fast_20260531_230026/step_085000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr3e4_elfopt_t5embed_unfixed_stateprobadd_selfcond_ce_fast_20260531_230026/step_129000.pt

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

LTA_openwebtext_dualt/mini_owt_logdirichlet/runs/owt_t5_elftokenized_full_len1024_C1_to_1024_pow1_d768_l12_h12_gbs512_8gpu_50ep_lr3e4_elfopt_t5embed_unfixed_stateprobadd_selfcond_ce_fast_20260531_230026/step_152000.pt

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