diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15202afd714059fbe3e89c277681d4ac4b66967f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/candidate_generator.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/candidate_generator.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4e27e8f16a731388e41043c7a9ed6f509d67a34 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/candidate_generator.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/stopping_criteria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/stopping_criteria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d8c76b6a4414820431d78a4bd861666e199020c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/stopping_criteria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/streamers.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/streamers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7f9ba9ab9453a1e86efbc6b8431612c3a1def7e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/streamers.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/watermarking.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/watermarking.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb75bd7627a5c600b37c713ad4f6d8327ed2a8e4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/__pycache__/watermarking.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__init__.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2364d08c38a8f8d624d9b1aef54d20242c56d3a3 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__init__.py @@ -0,0 +1,29 @@ +# Copyright 2025 The HuggingFace Inc. team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT 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 .cache import PagedAttentionCache +from .continuous_api import ContinuousBatchingManager, ContinuousMixin +from .requests import RequestState, RequestStatus +from .scheduler import FIFOScheduler, PrefillFirstScheduler, Scheduler + + +__all__ = [ + "ContinuousBatchingManager", + "ContinuousMixin", + "FIFOScheduler", + "PagedAttentionCache", + "PrefillFirstScheduler", + "RequestState", + "RequestStatus", + "Scheduler", +] diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cache.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cache.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be87035f8db784c68494fdf7a4064b081e32453e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cache.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cache_manager.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cache_manager.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85fb1dd05e2bbc5e023406f038191acdbe74d28e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cache_manager.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cb_logits_processors.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cb_logits_processors.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c59acd28b0461ab520c8fe0e7df86e873ab52d5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/cb_logits_processors.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/continuous_api.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/continuous_api.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..19106b8273b0da16c7da1e816fc0350729e325c3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/__pycache__/continuous_api.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache.py new file mode 100644 index 0000000000000000000000000000000000000000..7781f96ff70ce98a06dfb6e6daa86c6ef0e4f18d --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache.py @@ -0,0 +1,704 @@ +# Copyright 2025 The HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import inspect +from math import floor, gcd, sqrt +from typing import Any + +import torch + +from ...configuration_utils import PreTrainedConfig +from ...generation.configuration_utils import ContinuousBatchingConfig +from ...utils.generic import is_flash_attention_requested +from ...utils.metrics import attach_tracer, traced +from .cache_manager import BlockManager, CacheAllocator, FullAttentionCacheAllocator, SlidingAttentionCacheAllocator +from .requests import RequestState, RequestStatus, get_device_and_memory_breakdown, logger + + +def group_layers_by_attn_type(config: PreTrainedConfig) -> tuple[list[list[int]], list[str]]: + """ + Group layers depending on the attention mix, according to VLLM's hybrid allocator rules: + - Layers in each group need to have the same type of attention + - All groups have the same number of layers + + For a model with the following layer types: ["sliding", "full", "full", "sliding", "full", "full", "full", "full"] + We would get four groups: [0, 3], [1, 2], [4,5] and [6,7]. + """ + # If the config has no layer_type attribute, it means all layers are the same attention type + layer_types = getattr(config, "layer_types", None) + if layer_types is None: + attn_type = "sliding_attention" if getattr(config, "sliding_window", None) is not None else "full_attention" + layer_types = [attn_type for _ in range(config.num_hidden_layers)] + + # We then count the number of layers of each type + layer_counts = {} + for i, layer_type in enumerate(layer_types): + layer_counts[layer_type] = layer_counts.get(layer_type, []) + [i] + + # The size of all groups is the greatest common divisor of the number of layers of each type + group_size = gcd(*[len(indices) for indices in layer_counts.values()]) + + # We then group the layers by type + layer_groups = [] + for layer_type, indices in layer_counts.items(): + for i in range(0, len(indices), group_size): + layer_groups.append(indices[i : i + group_size]) + # And note the layer types + group_types = [layer_types[lg[0]] for lg in layer_groups] + return layer_groups, group_types + + +@attach_tracer() +class PagedAttentionCache: + """ + Manages the cache for a paged attention mechanism, inspired by VLLM's hybrid allocator. The cache relies on making + groups of layers to reduce the complexity of cache management and fragmentation. + + The cache uses a three-level hierarchy: + - Pages: The smallest unit of cache, a page has a size of [num_heads, head_size], which is the space needed to + store the key or value states for one token and one layer. For a model with only full-attention layers, to store + the KV cache of one token, we need `2 * num_layers` pages: key and values each take `num_layers` pages. + Pages are grouped into blocks: + - Blocks: A block is a collection of `block_size` pages, serving as the allocation unit to reduce management + complexity and fragmentation. Cache is allocated and freed block by block, not page by page. One block is + allocated to one layer group, which only has one attention type, like full-attention or sliding-attention. + If all layers in the model have the same attention type, then all layers will be in the same group. There is + more than one group if and only if the model has a mixed attention types, like layers with full-attention and + layers with sliding-attention. + - Cache tensors: The physical supports for the cache. There are as many cache tensors as there are layer in a + layer group, and the shape of the cache tensor is `[num_blocks * block_size, num_heads, head_size]`. + + Grouping layers into groups is useful because when we allocate one block to a group N, the block allocated is the + same for all layers in group N, equivalently it is allocated across all cache tensors. This allows us to + efficiently allocate and free blocks, and to efficiently read and write key and value states. + + For instance, imagine we have 8 blocks of cache and a model with two layer groups: a full-attention group with 3 + layers and a sliding-attention group with 3 layers. At creation time, the physical cache tensors look like this: + + cache_tensor_0: □ □ □ □ □ □ □ □ + cache_tensor_1: □ □ □ □ □ □ □ □ + cache_tensor_2: □ □ □ □ □ □ □ □ + + where □ means the blocks is not allocated to any layer group yet. We have 3 cache tensors because there are + 3 layers per group. + We allocate 1 block to each group, after allocation, the cache tensors look like this: + + cache_tensor_0: ✖ ◉ □ □ □ □ □ □ + cache_tensor_1: ✖ ◉ □ □ □ □ □ □ + cache_tensor_2: ✖ ◉ □ □ □ □ □ □ + + where ✖ means the block is allocated to the full-attention group, and ◉ means the block is allocated to the + sliding-attention group. + Now, if we continue to generate, and the sliding window has been reached, we only need to allocate a new block + for the full-attention group, and the cache tensors look like this: + + cache_tensor_0: ✖ ◉ ✖ □ □ □ □ □ + cache_tensor_1: ✖ ◉ ✖ □ □ □ □ □ + cache_tensor_2: ✖ ◉ ✖ □ □ □ □ □ + + And after further generation, when we need a new block allocated: + + cache_tensor_0: ✖ ◉ ✖ ✖ □ □ □ □ + cache_tensor_1: ✖ ◉ ✖ ✖ □ □ □ □ + cache_tensor_2: ✖ ◉ ✖ ✖ □ □ □ □ + + This would not have been possible if all layers were in the same group: we would have had to allocate a new block + for the sliding-attention group, although it is not needed. + """ + + def __init__( + self, + config: PreTrainedConfig, + continuous_batching_config: ContinuousBatchingConfig, + device: torch.device | str, + dtype: torch.dtype = torch.float16, + tp_size: int | None = None, + ) -> None: + """Initialize a paged attention cache for efficient memory usage. Also turns in prefix sharing if the model has + only full attention layers. + + Args: + config: Model configuration + continuous_batching_config: Continuous batching configuration containing cache parameters + device: Device for the cache tensors + dtype: Data type of the cache + tp_size: Tensor parallelism size + """ + self.config = config + self.dtype = dtype + self.device = device + + # Extract model dimensions + kv_heads = getattr(config, "num_key_value_heads", None) + self.num_key_value_heads: int = kv_heads if kv_heads is not None else config.num_attention_heads + head_dim = getattr(config, "head_dim", None) + self.head_dim: int = head_dim if head_dim is not None else config.hidden_size // config.num_attention_heads + + # Extract cache dimensions. Default used to be 32, now it's 256 to be compatible with flash_with_kvcache. + self.block_size = continuous_batching_config.block_size + if self.block_size <= 0: + raise ValueError(f"Block size must be positive, but got {self.block_size}") + + # Group layers depending on the attention mix + layer_groups, group_types = group_layers_by_attn_type(config) + group_size = len(layer_groups[0]) + self.num_groups = len(layer_groups) + + self.sliding_windows = {} + self.layer_index_to_group_indices = {} + for i, group in enumerate(layer_groups): + sliding_window = config.sliding_window if group_types[i] == "sliding_attention" else 1 + for j, layer in enumerate(group): + self.layer_index_to_group_indices[layer] = (i, j) + self.sliding_windows[layer] = sliding_window + + # Handle TP (or dont) + if tp_size is not None and tp_size > 1: + if self.num_key_value_heads % tp_size != 0: + raise ValueError( + f"Number of key value heads {self.num_key_value_heads} must be divisible by tensor parallel size {tp_size}." + ) + # If the model is using tensor parallelism, we need to adjust the number of heads accordingly. + # self.num_key_value_heads //= tp_size # TODO: why is this commented out? + + # Infer number of blocks and max batch tokens + page_size = self.head_dim * self.num_key_value_heads + + if is_flash_attention_requested(self.config): + num_attention_masks = 0 # only used to compute the default memory footprint args + elif "sliding_attention" in group_types: + # TODO: when we generalize to allow for block-attn, we can use `num_attention_masks=sum(set(group_types))` + num_attention_masks = 2 + else: + num_attention_masks = 1 + + # Peak activations coefficients (for number of blocks and number of batch tokens) + q_bytes_per_token = config.num_attention_heads * self.head_dim + lm_head_peak = ( + 0, # number of blocks does not affect the LM head peak activation + config.hidden_size + 2 * config.vocab_size, # hidden states + logits + ) + attention_peak = ( + 2 * page_size, # old K and V, read from cache (in the worst case scenario: whole cache is read) + config.hidden_size + q_bytes_per_token + 2 * page_size, # hidden state + Q + new K and V + ) + + memory_handler = PagedAttentionMemoryHandler( + continuous_batching_config=continuous_batching_config, + page_size=page_size, + num_groups=self.num_groups, + group_size=group_size, + activation_peaks=[lm_head_peak, attention_peak], + num_attention_masks=num_attention_masks, + ) + + # If somehow the max memory percent is not yet resolved, resolve it conservatively + if continuous_batching_config.max_memory_percent is None: + continuous_batching_config.resolve_max_memory_percent(has_logit_processors=True) + + num_blocks, max_batch_tokens = memory_handler.infer_num_blocks_and_max_batch_tokens( + num_blocks=continuous_batching_config.num_blocks, + max_batch_tokens=continuous_batching_config.max_batch_tokens, + max_memory_percent=continuous_batching_config.max_memory_percent, + cache_dtype=self.dtype, + ) + + # Add the inferred attributes to the class + self.num_blocks = num_blocks + self.max_batch_tokens = max_batch_tokens + self.num_pages = self.num_blocks * self.block_size + logger.info( + f"PagedAttentionCache initialized with {self.num_blocks = }, {self.block_size = }, {page_size = }, " + f"{self.max_batch_tokens = } {num_attention_masks = }" + ) + + # If max_blocks_per_request is not set, the default value is 16 max blocks. With default block size of 256, this + # means a max sequence length of 4096 tokens for the fast decode path. + max_blocks_per_request = continuous_batching_config.max_blocks_per_request + if max_blocks_per_request is None: + max_blocks_per_request = 0 + # logger.info( TODO: uncomment when we have good defaults + # f"max_blocks_per_request was not set, using {max_blocks_per_request}. This means max sequence " + # f"length for the decode fast path is {max_blocks_per_request * self.block_size}." + # ) + self.max_blocks_per_request = max_blocks_per_request + + # Initialize the cache + self.key_cache: list[torch.Tensor] = [] + self.value_cache: list[torch.Tensor] = [] + # We add two extra blocks to the cache as a padding zone that no BlockManager ever allocates from: one for the + # sentinel index (marks the spot of a new token in the read indices) and one for the trash index (for padding, + # block is never used so writes are silently discarded) + self.cache_shape = ((num_blocks + 2) * self.block_size, self.num_key_value_heads, self.head_dim) + self.sentinel_index = self.cache_shape[0] - 1 + self.trash_index = self.sentinel_index - 1 + for _ in range(group_size): + new_layer_key_cache = torch.empty(self.cache_shape, dtype=self.dtype, device=self.device) + new_layer_value_cache = torch.empty(self.cache_shape, dtype=self.dtype, device=self.device) + torch._dynamo.mark_static_address(new_layer_key_cache) + torch._dynamo.mark_static_address(new_layer_value_cache) + self.key_cache.append(new_layer_key_cache) + self.value_cache.append(new_layer_value_cache) + logger.info(f"{self.cache_shape = } {self.key_cache[0].shape = } {self.key_cache[0].numel() = }") + + # Block management data structures + self.allow_block_sharing = continuous_batching_config.allow_block_sharing + self.group_cache_managers: list[CacheAllocator] = [] + self.num_full_attention_groups = 0 + self.num_sliding_attention_groups = 0 + self.max_sliding_window_blocks_per_request = 0 + + for i, group_type in enumerate(group_types): + if group_type == "full_attention": + cm = FullAttentionCacheAllocator(i, self.block_size, allow_block_sharing=self.allow_block_sharing) + self.num_full_attention_groups += 1 + elif group_type == "sliding_attention": + cm = SlidingAttentionCacheAllocator( + i, self.block_size, config.sliding_window, self.sentinel_index, self.trash_index + ) + self.num_sliding_attention_groups += 1 + self.max_sliding_window_blocks_per_request = cm._max_blocks_per_request + else: + raise ValueError(f"Invalid group type: {group_type}") + self.group_cache_managers.append(cm) + + # We only use prefix sharing if the whole model has only full attention layers and block sharing is allowed + self.use_prefix_sharing = self.allow_block_sharing and group_types == ["full_attention"] + self._block_manager = BlockManager(num_blocks, self.block_size) + self._total_prefix_length: int = 0 # a counter to measure the impact of prefix sharing, also used in tests + + # For block table support, we lazy init the name of the block table key + self._block_table_key = None + + def will_allocation_be_successful(self, num_requested_blocks: int, allocated_blocks: int) -> bool: + """Returns a boolean indicating if the allocation of (num_requested_blocks) blocks will be successful. The + number of newly allocated blocks needed is predicted by the following rules: + - for full attention groups: since there is no sliding window for full attention layers, one requested block is + always equivalent to one newly allocated block for EACH full attention group + - for sliding window groups: because of the sliding window, the number of blocks allocated to a request is + capped. Using the number of already (allocated_blocks) we can compute the number of new blocks to actually + allocate to the request, which can be lower than the number of requested blocks. That number is the same for + all sliding window groups, as only one sliding window size is supported. + """ + # This is not in a branch, because it is very rare to have zero full attention layer + needed_blocks = num_requested_blocks * self.num_full_attention_groups + # Only take this branch if the model has sliding window attention layers + if self.num_sliding_attention_groups: + blocks_left = max(self.max_sliding_window_blocks_per_request - allocated_blocks, 0) + needed_blocks += min(blocks_left, num_requested_blocks) * self.num_sliding_attention_groups + return needed_blocks <= self.get_num_free_blocks() + + @traced + def allocate_blocks(self, n_blocks: int, request_id: str, allocated_blocks: int) -> int | None: + """Allocate cache blocks across all layer groups for a given request. Actual allocation is done by the cache + managers, and this method only returns the maximum number of blocks actually allocated across all managers.""" + # First check allocation will be successful before starting, to avoid partial allocations + if not self.will_allocation_be_successful(n_blocks, allocated_blocks): + return None + # Allocate blocks across all cache managers + max_allocated = 0 + for cm in self.group_cache_managers: + num_allocated_blocks = cm.allocate_blocks(n_blocks, request_id, self._block_manager) + if num_allocated_blocks is None: + raise ValueError(f"Failed to allocate {n_blocks} blocks for request {request_id}") + max_allocated = max(max_allocated, num_allocated_blocks) + return max_allocated + + @traced + def free_blocks(self, request_id: str) -> None: + """Free all allocated cache blocks for a given request across all layer groups. Actual deallocation is done + by the cache managers.""" + for cm in self.group_cache_managers: + cm.free_blocks(request_id, self._block_manager) + + def get_num_free_blocks(self) -> int: + """Get the current number of unallocated blocks available for new requests.""" + return self._block_manager.num_free_blocks + + @traced + def extend_read_and_write_indices( + self, + request_id: str, + past_length: int, + query_length: int, + read_index: list[list[int]] | None, + write_index: list[list[int]], + ) -> None: + """Retrieve physical cache indices for reading KV states in the cache across all layer groups. This method + coordinates with all cache managers to build the complete set of read indices needed for attention computation. + When read_index is None, the batch has no cache reads and we only compute the write indices. + """ + # Write indices are always computed + for cm, write_indices in zip(self.group_cache_managers, write_index): + write_indices.extend(cm.get_write_indices(request_id, past_length, query_length)) + # Read indices are only computed if there are cache indices + if read_index is not None: + for cm, read_indices in zip(self.group_cache_managers, read_index): + read_indices.extend(cm.get_read_indices(request_id, past_length, query_length)) + + def fill_block_table( + self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor + ) -> None: + for i, cm in enumerate(self.group_cache_managers): + cm.fill_block_table(request_id, past_length, query_length, block_table[i]) + + @traced + def get_seqlens_k(self, past_length: int, query_length: int) -> dict[str, int]: + """Retrieve the key sequence length for the given request_id across all layer types. Returns a dictionary of + layer types to their corresponding key sequence lengths.""" + seqlens_k = {} + if self.num_full_attention_groups > 0: + seqlens_k["full_attention"] = past_length + query_length + if self.num_sliding_attention_groups > 0: + seqlens_k["sliding_attention"] = query_length + min(past_length, self.config.sliding_window - 1) + # NOTE: when we add more attention types / different sliding windows, we can go back to looping over CMs + return seqlens_k + + @traced + def update( + self, + key_states: torch.Tensor, # shape [1, num_kv_heads, seqlen_kv, head_dim] + value_states: torch.Tensor, # shape [1, num_kv_heads, seqlen_kv, head_dim] + layer_idx: int, + read_index: list[torch.Tensor], # shape [num_layer_groups, seqlen_kv + past_length] + write_index: list[torch.Tensor], # shape [num_layer_groups, seqlen_q] + ) -> tuple[torch.Tensor, torch.Tensor]: # shape [seqlen_kv + past_length, num_kv_heads, head_dim] + """Update the cache with new key-value states for a specific layer, and retrieves the relevant KV states from + the cache for attention computation. The behavior differs based on the layer's attention type: + + - Full attention: New KV states are written to cache, then complete sequence is read from cache + - Sliding window: Old KV is read from cache along with extra spaces for the new KV, then new KV is written to + cache. This is because new KV might overwrite the old KV, so we need to read the old KV first. + + When the layer's read index is empty, the batch has no cache reads (all requests are non-chunked prefills): we + only write to the cache and return the input KV states directly, skipping the index_select read-back. + + Returns the complete KV states (cached + new) for attention computation. + """ + # Retrieve the layer write index and the relevant cache tensors + group_idx, layer_idx_in_group = self.layer_index_to_group_indices[layer_idx] + layer_read_index = read_index[group_idx] + layer_write_index = write_index[group_idx] + k_cache = self.key_cache[layer_idx_in_group] + v_cache = self.value_cache[layer_idx_in_group] + # Transpose the key and value states to match the cache shape, after which shape is [seqlen_kv, num_kv_heads, head_dim] + key_states = key_states.transpose(1, 2).squeeze(0) + value_states = value_states.transpose(1, 2).squeeze(0) + + # Case: write-only, no cache read. The input KV states already contain everything the attention needs. + if layer_read_index.numel() == 0: + k_cache.index_copy_(0, layer_write_index, key_states) + v_cache.index_copy_(0, layer_write_index, value_states) + return key_states, value_states + + # Case: full attention + sliding_window = self.sliding_windows[layer_idx] + if sliding_window == 1: + k_cache.index_copy_(0, layer_write_index, key_states) + v_cache.index_copy_(0, layer_write_index, value_states) + key_states_with_cache = torch.index_select(k_cache, 0, layer_read_index) + value_states_with_cache = torch.index_select(v_cache, 0, layer_read_index) + + # Case: sliding window -- we need to be careful of read/write order because of chunked prefill, because it's + # the only case where you may write over cache you need to use + else: + # Sentinel positions in read_index mark new-token slots; index_select reads garbage there, + # then masked_scatter_ overwrites them with the actual new key/value states. + mask = (layer_read_index == self.sentinel_index).unsqueeze(-1).unsqueeze(-1) + key_states_with_cache = torch.index_select(k_cache, 0, layer_read_index) + key_states_with_cache.masked_scatter_(mask, key_states) + value_states_with_cache = torch.index_select(v_cache, 0, layer_read_index) + value_states_with_cache.masked_scatter_(mask, value_states) + # Write new KV values to the cache (padding slots in write_index point to the trash position) + k_cache.index_copy_(0, layer_write_index, key_states) + v_cache.index_copy_(0, layer_write_index, value_states) + + # Return the new KV values + return key_states_with_cache, value_states_with_cache + + def get_block_table_key(self, flash_attn_with_kvcache_fn: Any) -> str: + """A function to get the name of the block table key for the given flash_attn_with_kvcache_fn. The function's + signature is only inspected once. This is necessary because different version of flash have different names for + the block table key.""" + if self._block_table_key is None: + kwarg_names = inspect.signature(flash_attn_with_kvcache_fn).parameters.keys() + if "block_table" in kwarg_names: + self._block_table_key = "block_table" + elif "page_table" in kwarg_names: + self._block_table_key = "page_table" + else: + raise ValueError( + f"flash_attn_with_kvcache_fn does not have a block_table or page_table argument: {inspect.signature(flash_attn_with_kvcache_fn)}" + ) + return self._block_table_key + + def search_prefix_match(self, request_id: str, prompt_ids: list[int]) -> int: + """Searches for a prefix match in the cache for the given (prompts_ids). If one is found, we reference the + matching blocks in the (request_id), increase the reference count of the blocks and return the number of blocks + that match. If no prefix match is found, we return 0.""" + current_hash = None + allocated_blocks = [] + for b in range(len(prompt_ids) // self.block_size): + tokens = prompt_ids[b * self.block_size : (b + 1) * self.block_size] + # Prefix sharing is only supported when there is only one full attention layer group, so group_id=0. + current_hash = self._block_manager.compute_hash(current_hash, tokens, group_id=0) + block_id = self._block_manager._hash_to_id.get(current_hash) + if block_id is not None: + allocated_blocks.append(block_id) + self._block_manager.increase_ref_count(block_id) + else: + break + # If we found a matching prefix, we reference the blocks in the request + if allocated_blocks: + logger.debug(f"Found prefix match for request {request_id} with {len(allocated_blocks)} blocks") + cm = self.group_cache_managers[0] + cm.block_table[request_id] = allocated_blocks + + prefix_length = len(allocated_blocks) * self.block_size + self._total_prefix_length += prefix_length + return prefix_length + + def mark_shareable_blocks_as_complete(self, state: RequestState, num_complete_blocks: int) -> None: + """Marks the blocks allocated to a request (state) as complete if they are shareable and they have been computed + in the forward pass. A complete block is a block where the KV cache has been fully computed: if the block has + enough space to hold the cache for N tokens, the block is marked as complete when the cache data is present for + the N tokens. If block sharing is off, this is a no-op.""" + # The status can be FINISHED in async mode, because batch N+1 offloaded the request before batch N was over. So + # we need to check for this case to avoid looking in the block table for blocks that no longer exist. + if num_complete_blocks == 0 or state.status == RequestStatus.FINISHED: + return None + for cm in self.group_cache_managers: + if cm.uses_block_sharing: + self._block_manager.mark_shareable_blocks_as_complete( + num_complete_blocks=num_complete_blocks, + allocated_blocks=cm.block_table[state.request_id], + prompt_ids=(state.initial_tokens + state.generated_tokens), + ) + + def copy_cache(self, list_source_blocks: list[int], list_forked_blocks: list[int]) -> None: + """Copy the cache from the source blocks to the forked blocks.""" + source_blocks = torch.tensor(list_source_blocks, device=self.device, dtype=torch.int32) + forked_blocks = torch.tensor(list_forked_blocks, device=self.device, dtype=torch.int32) + for key_cache, value_cache in zip(self.key_cache, self.value_cache): + key_cache = key_cache.view(-1, self.block_size, self.num_key_value_heads, self.head_dim) + value_cache = value_cache.view(-1, self.block_size, self.num_key_value_heads, self.head_dim) + key_cache[forked_blocks] = key_cache[source_blocks] + value_cache[forked_blocks] = value_cache[source_blocks] + # FIXME: consolidate the cache into a single tensor of shape (group_size, 2, *self.k_or_v_cache_shape) + # This will allow for better .update and a single copy instead of one per cache tensor + + def fork_request(self, source_request_id: str, destination_request_ids: list[str]) -> tuple[list[int], list[int]]: + """Fork the cache of a request (state) into the one of a list of requests with the given (dst_request_ids).""" + # These lists will be the accumulators for the source and destination blocks for the cache copy + source_blocks, destination_blocks = [], [] + # Main fork loop + for cm in self.group_cache_managers: + src_blocks, dst_blocks = cm.fork_blocks(source_request_id, destination_request_ids, self._block_manager) + source_blocks.extend(src_blocks) + destination_blocks.extend(dst_blocks) + return source_blocks, destination_blocks + + def free_all_requests(self) -> None: + """Free all blocks allocated to requests across all cache managers. This preserves prefix hashes in the block + manager (blocks become initialized rather than uninitialized if they were complete), allowing prefix sharing + to work across generation sessions.""" + all_request_ids = set() + for cm in self.group_cache_managers: + all_request_ids.update(cm.block_table.keys()) + for request_id in all_request_ids: + self.free_blocks(request_id) + + +# TODO: rework computation with the groups and their sizes +class PagedAttentionMemoryHandler: + """Determines the optimal number of pages (N) and max batch tokens (M) for the paged attention cache, given + available GPU memory. The relation between N and number of blocks is: num_blocks = N // block_size. + + The memory footprint is a polynomial in N and M, where each term maps to a tensor allocated in + ``ContinuousBatchingIOs._setup_static_tensors`` or ``PagedAttentionCache.__init__``: + + memory(N, M) = coeff_n · N + coeff_m · M + coeff_nm · N·M + coeff_mm · M² + + See ``_equation_coefficients`` for the breakdown. All three solving modes (auto, fixed-N, fixed-M) reduce to + solving this equation, which is at most quadratic in one variable. + """ + + _activation_dtype = torch.bfloat16 + _input_dtype = torch.int32 + _upper_bound_max_batch_tokens = 1024 + _upper_bound_num_blocks = 4096 + + def __init__( + self, + continuous_batching_config: ContinuousBatchingConfig, + page_size: int, + num_groups: int, + group_size: int, + activation_peaks: list[tuple[int, int]], + num_attention_masks: int, + ) -> None: + """Initialize the memory handler. `activation_peaks` is a list of `(Δcn, Δcm)` pairs giving the activation memory + contributions proportional to N (pages) and M (batch tokens) for each peak. Memory must satisfy the constraint + at every peak, so we solve each polynomial independently and take the most restrictive result.""" + self.block_size = continuous_batching_config.block_size + self.page_size = page_size + self.num_groups = num_groups + self.group_size = group_size + self.activation_peaks = activation_peaks + self.num_attention_masks = num_attention_masks + self.max_blocks_per_request = continuous_batching_config.max_blocks_per_request + if self.max_blocks_per_request is None: + self.max_blocks_per_request = continuous_batching_config.fallback_max_blocks_per_request + # This is the number of output rows for the output_ids tensor + self.num_output_rows = 2 if continuous_batching_config.return_logprobs else 1 + # This account for the set of 2 IOs if async batching is used + self.io_multiplier = 2 if continuous_batching_config.use_async_batching else 1 + + @staticmethod + def get_available_memory(max_memory_percent: float = 1.0) -> int: + """Calculate available GPU memory for cache allocation, accounting for already allocated tensors.""" + _, total, reserved, allocated = get_device_and_memory_breakdown() + available_memory = total - max(allocated, reserved) + available_memory = int(available_memory * max_memory_percent) + return available_memory + + # Formatting is disabled because of comment indentation, which improves readability. + # fmt: off + def _equation_coefficients( + self, peak: tuple[int, int], cache_dtype: torch.dtype + ) -> tuple[int, int, int, int]: + """Returns `(coeff_n, coeff_m, coeff_nm, coeff_mm)` for the memory polynomial of a single activation peak. + `peak = (Δcn, Δcm)` is the peak-specific activation contribution; the rest of the coefficients are shared + across peaks. Each addend is annotated with the tensor it corresponds to in + `ContinuousBatchingIOs._setup_static_tensors` (or the forward pass, for activation terms). + """ + i = self._input_dtype.itemsize # int32 + a = self._activation_dtype.itemsize # bfloat16 + c = cache_dtype.itemsize + k = self.io_multiplier # 1 sync, 2 async (IO tensors only) + delta_n, delta_m = peak + + # -- N terms: cost per cache page -------------------------------------------------- + coeff_n = ( + 2 * self.group_size * self.page_size * c # kv_cache: 2 * group_size * [N, page_size] * cache_dtype + + k * self.num_groups * 8 # read_index: [num_groups, N + M] (N part only, int64) + + delta_n * a # activation peak: N-proportional part + ) + # -- M terms: cost per batch token ------------------------------------------------- + coeff_m = ( + delta_m * a # activation peak: M-proportional part + + k * 7 * i # bulk_input: [7, M] int32, packed as 7 rows + + k * self.num_output_rows * i # output_ids: [num_output_rows, M] int32 + + k * self.num_groups # block_table: [bt_groups, M, max_blocks_per_req] int32 + * self.max_blocks_per_request * i # (zero when fast-decode is off) + + k * self.num_groups * 8 # write_index: [num_groups, M] int64 + + k * self.num_groups * 8 # read_index: [num_groups, N + M] (M part only, int64) + ) + # -- N·M terms: cost per (page × batch token) -------------------------------------- + coeff_nm = k * self.num_attention_masks * a # attention_mask: [1, 1, M, N + M] (N·M part only) + # -- M² terms: cost per (batch token squared) -------------------------------------- + coeff_mm = k * self.num_attention_masks * a # attention_mask: [1, 1, M, N + M] (M² part only) + + return coeff_n, coeff_m, coeff_nm, coeff_mm + # fmt: on + + @staticmethod + def _solve_quadratic(a: float, b: float, c: float) -> float: + """Largest positive root of a·x² + b·x + c = 0. Falls back to linear when a == 0.""" + if a == 0: + return -c / b + discriminant = b**2 - 4 * a * c + if discriminant < 0: + raise ValueError(f"No real solution (discriminant = {discriminant})") + root = (-b + sqrt(discriminant)) / (2 * a) + if root < 0: + raise ValueError(f"No positive solution (root = {root})") + return root + + def _solve_for_peak( + self, + peak: tuple[int, int], + available: int, + num_blocks: int | None, + max_batch_tokens: int | None, + cache_dtype: torch.dtype, + ) -> tuple[int, int]: + """Solve for `(num_blocks, max_batch_tokens)` against one activation peak's memory polynomial. Clamps to upper + bounds. Either input may be None; whichever is None is solved for.""" + cn, cm, cnm, cmm = self._equation_coefficients(peak, cache_dtype) + + if num_blocks is None and max_batch_tokens is None: + # Substitute M = m·N → (coeff_nm·m + coeff_mm·m²)·N² + (coeff_n + coeff_m·m)·N − avail = 0 + m = 0.01 + num_pages = self._solve_quadratic(cnm * m + cmm * m**2, cn + cm * m, -available) + max_batch_tokens = int(num_pages * m) + if max_batch_tokens > self._upper_bound_max_batch_tokens: + max_batch_tokens = self._upper_bound_max_batch_tokens + # If max_batch_tokens is clamped, we recompute num_blocks below to get a higher value + num_blocks = None + else: + num_blocks = min(floor(num_pages) // self.block_size, self._upper_bound_num_blocks) + + if num_blocks is None: + # M given → linear in N: (coeff_n + coeff_nm·M)·N = avail − coeff_m·M − coeff_mm·M² + M = max_batch_tokens + num_pages = floor((available - cm * M - cmm * M**2) / (cn + cnm * M)) + num_blocks = min(num_pages // self.block_size, self._upper_bound_num_blocks) + elif max_batch_tokens is None: + # N given → quadratic in M: coeff_mm·M² + (coeff_m + coeff_nm·N)·M + (coeff_n·N − avail) = 0 + N = num_blocks * self.block_size + M = self._solve_quadratic(cmm, cm + cnm * N, cn * N - available) + max_batch_tokens = min(floor(M), self._upper_bound_max_batch_tokens) + + return num_blocks, max_batch_tokens + + def infer_num_blocks_and_max_batch_tokens( + self, + num_blocks: int | None = None, + max_batch_tokens: int | None = None, + max_memory_percent: float = 0.9, + cache_dtype: torch.dtype = torch.float16, + ) -> tuple[int, int]: + """Solve for the missing variable(s) in the memory polynomial (see ``_equation_coefficients``). There is one + polynomial per activation peak; we solve each independently and take the most restrictive (smallest) result. + When both `N` and `M` are unknown, assumes `M = m·N` (m = 0.01, i.e. one batch fills ~1 % of the cache) and + solves the resulting quadratic in N. + """ + available = self.get_available_memory(max_memory_percent) + logger.info(f"Cache memory: {available}") + # Solve each peak independently, then take the element-wise min (tightest constraint wins) + acc_num_blocks = float("inf") + acc_max_batch_tokens = float("inf") + for peak in self.activation_peaks: + n_blocks, m_batch_tokens = self._solve_for_peak(peak, available, num_blocks, max_batch_tokens, cache_dtype) + acc_num_blocks = min(acc_num_blocks, n_blocks) + acc_max_batch_tokens = min(acc_max_batch_tokens, m_batch_tokens) + # Now update the value (cannot update in loop, it would overwrite the user-passed values) + num_blocks, max_batch_tokens = acc_num_blocks, acc_max_batch_tokens + # Validate + memory_footprint = self.compute_memory_footprint(num_blocks, max_batch_tokens, cache_dtype) + if memory_footprint > available: + raise MemoryError(f"Memory footprint {memory_footprint} is more than available memory {available}") + return num_blocks, max_batch_tokens + + def compute_memory_footprint(self, num_blocks: int, max_batch_tokens: int, cache_dtype: torch.dtype) -> int: + """Evaluate the memory polynomial at concrete (N, M) values, taking the max across activation peaks.""" + N = num_blocks * self.block_size + M = max_batch_tokens + + max_memory_footprint = 0 + for peak in self.activation_peaks: + cn, cm, cnm, cmm = self._equation_coefficients(peak, cache_dtype) + memory_footprint = cn * N + cm * M + cnm * N * M + cmm * M * M + max_memory_footprint = max(max_memory_footprint, memory_footprint) + return max_memory_footprint diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache_manager.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..71d0d3c23f710f537405044acaeca1c562943d3e --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cache_manager.py @@ -0,0 +1,533 @@ +# Copyright 2025 The HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from abc import ABC, abstractmethod +from collections import deque +from collections.abc import Iterator +from math import ceil +from typing import TypeVar + +import torch + +from .requests import logger + + +T = TypeVar("T") + + +def reverse_enumerate(xs: list[T]) -> Iterator[tuple[int, T]]: + index = len(xs) - 1 + for x in xs[::-1]: + yield index, x + index -= 1 + + +class Block: # TODO: rename to ShareableBlock and update the docs + """A class to represent a block managed by the block manager. We say that a block is complete when the physical KV + cache it points to is fully computed. A block can have a parent, which is the block that came before in the + sequence. Once a block is complete, it is given a hash, which takes into account the tokens ids of the block, the + layer (group_id) it belong to and its parent's hash (if there is a parent).""" + + def __init__(self, id_: int, parent_id: int | None, group_id: int) -> None: + self.id: int = id_ + self.parent_id: int | None = parent_id + self.group_id: int = group_id + self.hash: int | None = None + self.ref_count: int = 1 + + def __repr__(self) -> str: + return f"Block(id={self.id}, parent_id={self.parent_id}, group_id={self.group_id}, hash={self.hash}, ref_count={self.ref_count})" + + @property + def is_complete(self) -> bool: + return self.hash is not None + + +class BlockManager: + """A class to manage the number of free blocks and block re-use. When a block becomes in use, a flag is passed to + determine if the block is shareable or not. If it is, then a Block object is created and kept track of internally. + It can have the following states: + - in use: one or more requests references this block, thus it cannot be written over. The number of requests + referencing this block is stored as ref_count in the Block object. + - un-initialized: the block points to a space in the KV cache tensor that contains no data yet. Those blocks can + be given as free blocks to new requests without any overhead. + - initialized: the block is complete and was used by one or more request that are finished. It contains KV cache + data and its hash is stored in the hash table. If a new request needs a block with the same hash, we increase + the ref_count of the block and remove it from the list of initialized blocks, because it is now in use. + Still, the block can be freed if no un-initialized blocks are left. In that case, we remove its hash from the + hash table. + If the block is not shareable, we just use the block manager as a FIFO structure where blocks are either free or in + use. Sharability is determined by the type of cache allocator: blocks created for full attention layers are + shareable, while blocks created for sliding window attention layers are not. + There is no structure to keep track of the blocks in use: if a block is neither un-initialized nor initialized, + it is in use. + """ + + def __init__(self, num_blocks: int, block_size: int) -> None: + """Initializes the block manager with a given number of blocks (num_blocks) of size (block_size).""" + self.num_blocks = num_blocks + self.block_size = block_size + self._uninit_block_ids = deque(range(num_blocks)) + self._init_block_ids: dict[int, None] = {} # effectively act as an ordered set + self._hash_to_id: dict[int, int] = {} + self._id_to_block: dict[int, Block] = {} + + @property + def num_free_blocks(self) -> int: + """Returns the number of free blocks left. Both initialized and uninitialized blocks are considered free.""" + return len(self._uninit_block_ids) + len(self._init_block_ids) + + def has_enough_free_blocks(self, n_blocks: int) -> bool: + """Checks if there are enough free blocks to allocate the requested number of blocks (n_blocks). If there are + not enough uninitialized blocks, we uninitialize the required number of initialized blocks.""" + # Exit early if there are enough uninitialized blocks + if len(self._uninit_block_ids) >= n_blocks: + return True + # Exit early if even after uninitializing all initialized blocks, there are not enough free blocks + block_to_uninitialize = n_blocks - len(self._uninit_block_ids) + if len(self._init_block_ids) < block_to_uninitialize: + return False + # Uninitialize the required amount of blocks + for _ in range(block_to_uninitialize): + id_to_uninitialize = self._init_block_ids.popitem()[0] + block = self._id_to_block[id_to_uninitialize] + # Since the block is initialized it must have a hash, thus no need to check .hash is not None + self._hash_to_id.pop(block.hash) # ty:ignore[invalid-argument-type] + self._uninit_block_ids.append(id_to_uninitialize) + return True + + def get_free_blocks( + self, n_blocks: int, last_block_id: int | None, shareable: bool, group_id: int + ) -> list[int] | None: + """Returns a list of (n_blocks) free block and mark them as no longuer free in the internal data structures. + If the (shareable) flag is set to True, a Block object is created to keep track of the block, with the + (last_block_id) to indicate the last block id in the sequence, also named the parent block. If the manager + cannot find enough free blocks, it returns None.""" + if not self.has_enough_free_blocks(n_blocks): + return None + allocated_block_ids = [self._uninit_block_ids.popleft() for _ in range(n_blocks)] + # If the block is shareable, we keep track of the allocated blocks as partial blocks + if shareable: + for block_id in allocated_block_ids: + block = Block(block_id, last_block_id, group_id) + self._id_to_block[block_id] = block + last_block_id = block_id + # In both cases, we return the allocated block ids + return allocated_block_ids + + def fork_blocks( + self, parent_blocks: list[int], num_forks: int, shareable: bool, group_id: int + ) -> tuple[list[list[int]] | None, list[int], list[int]]: + """Fork a given list of (parent_blocks) as many times as (num_forks). If the blocks are (shareable), we use + reference on the blocks that are complete. Otherwise, we allocate new blocks and keep track of their indices to + later copy the physical cache. For instance, when forking 4 blocks for 2 children: + + Parent blocks: [0, 1, 2, 3], with all blocks being complete except the last one (block 3). + + ----------------------------------------- IF BLOCKS ARE NOT SHAREABLE ----------------------------------------- + + Forked blocks lists: [[5, 6, 7, 8], [9, 10, 11, 12]] + Copy source: [0, 1, 2, 3, 0, 1, 2, 3] + ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ + Copy destination: [5, 6, 7, 8, 9, 10, 11, 12] → 8 blocks are newly allocated and copied + + ----------------------------------------- IF BLOCKS ARE SHAREABLE --------------------------------------------- + + Forked blocks lists: [[0, 1, 2, 5], [0, 1, 2, 6]] + Copy source: [ 3, 3] (block 3 is not complete so it's copied, not referenced) + ↓ ↓ + Copy destination: [ 5, 6] → only 2 blocks are newly allocated and copied + """ + # First phase: reference all complete blocks + forked_by_reference = [] + + if shareable: + for block_id in parent_blocks: + block = self._id_to_block[block_id] + if block.is_complete: + forked_by_reference.append(block.id) + block.ref_count += num_forks + else: + break + + # Early return if we have forked all blocks by reference + blocks_to_copy = len(parent_blocks) - len(forked_by_reference) + if blocks_to_copy == 0: + return [forked_by_reference[:] for _ in range(num_forks)], [], [] + + # From now on, each child will have its own list of blocks + forked_blocks_lists = [] + copy_src = [] + copy_dst = [] + + # Second phase: allocate new blocks if needed + parent_id = forked_by_reference[-1] if forked_by_reference else None + for _ in range(num_forks): + allocated_block_ids = self.get_free_blocks(blocks_to_copy, parent_id, shareable, group_id) + if allocated_block_ids is None: + return None, [], [] + forked_blocks_lists.append(forked_by_reference + allocated_block_ids) + copy_src.extend(parent_blocks[-blocks_to_copy:]) + copy_dst.extend(allocated_block_ids) + return forked_blocks_lists, copy_src, copy_dst + + def increase_ref_count(self, block_id: int) -> None: + """Increases the reference count of a given (block_id).""" + block = self._id_to_block[block_id] + block.ref_count += 1 + if block.ref_count == 1: + self._init_block_ids.pop(block_id) + + def decrease_ref_count(self, block_id: int) -> None: + """Decreases the reference count of a given (block_id). If the reference count reaches 0, the block is no longer + in use, and becomes initialized (if it was complete) or uninitialized (if it was incomplete).""" + block = self._id_to_block[block_id] + block.ref_count -= 1 + if block.ref_count == 0: + if block.is_complete: + self._init_block_ids[block_id] = None + else: + self._id_to_block.pop(block_id) + self._uninit_block_ids.append(block_id) + + def free_blocks(self, blocks: list[int], shareable: bool) -> None: + """Marks a list of (blocks) as free. If the blocks were not (shareable), we simply add them to the uninitialized + blocks queue. Otherwise, their new state depends on whether they are complete.""" + if shareable: + for block_id in blocks: + self.decrease_ref_count(block_id) + else: + self._uninit_block_ids.extend(blocks) + + def uninitialize_unshared_block(self, block_id: int) -> None: + """Marks a block as uninitialized. Raises an error if the block has more than one reference.""" + # Make sure the block has only one reference and remove it from the block table + block = self._id_to_block.pop(block_id) + if block.ref_count > 1: + raise RuntimeError(f"Block {block_id} has more than one reference: {block.ref_count = }") + # Add the block to the uninitialized blocks queue + self._uninit_block_ids.append(block_id) + + def mark_shareable_blocks_as_complete( + self, num_complete_blocks: int, allocated_blocks: list[int], prompt_ids: list[int] + ) -> None: + """Among the list of (allocated_blocks), mark (num_complete_blocks) incomplete blocks as now complete. The list + of (prompt_ids) is used to compute the hash of the new block.""" + # Look for the first complete block, starting from the last block in the sequence + parent_hash = None + incomplete_blocks: list[tuple[int, Block]] = [] + for i, block_id in reverse_enumerate(allocated_blocks): + block = self._id_to_block[block_id] + if block.is_complete: + parent_hash = block.hash + break + incomplete_blocks.append((i, block)) + + # Now go through the incomplete blocks and updated them + new_parent_id = None + while incomplete_blocks: + i, block = incomplete_blocks.pop() + + # If the parent id has been updated, we apply the change + if new_parent_id is not None: + block.parent_id = new_parent_id + new_parent_id = None + + # If we have set the hash for all complete blocks, we can stop + if num_complete_blocks == 0: + break + + # Otherwise, we compute the hash + num_complete_blocks -= 1 + tokens = prompt_ids[i * self.block_size : (i + 1) * self.block_size] + block.hash = self.compute_hash(parent_hash, tokens, block.group_id) + + existing_block_id = self._hash_to_id.get(block.hash) + # If their was a different block with the same hash, we reference the existing block instead + if existing_block_id is not None: + if existing_block_id == block.id: + # This should not happen, but is not a problem in itself, so we just log a warning + logger.warning(f"Block {block.id} was marked as complete more than once") + else: + logger.debug(f"Found existing block {existing_block_id} for block {block.id}") + allocated_blocks[i] = existing_block_id + new_parent_id = existing_block_id + self.increase_ref_count(existing_block_id) + self.uninitialize_unshared_block(block.id) + + # Otherwise, we add the completed block to the hash table + else: + logger.debug(f"Adding new block {block.id} (group {block.group_id}) with hash {block.hash}") + self._hash_to_id[block.hash] = block.id + + # Update loop variables + parent_hash = block.hash + + def compute_hash(self, parent_hash: int | None, tokens: list[int], group_id: int) -> int: + """Computes the hash of a block identified by the (tokens) it contains, its (parent_hash) and the layer + (group_id) it belong to. If the block has no parent, the parent hash is None.""" + return hash((parent_hash, tuple(tokens), group_id)) + + +class CacheAllocator(ABC): + """Abstract base class for cache managers. Cache managers keep track of per-request cache allocations, determine + when a new physical block needs to be allocated and compute physical indices for reading or writing to the cache.""" + + _index: int + block_table: dict[str, list[int]] # request_id -> list of block_ids allocated to the request + uses_block_sharing: bool # flag to determine if the blocks are shareable + + @abstractmethod + def allocate_blocks(self, n_blocks: int, request_id: str, block_manager: BlockManager) -> int | None: + """Allocates (n_blocks) for a given (request_id) using the (block_manager). Returns the num of blocks allocated + if successful and None otherwise.""" + + def free_blocks(self, request_id: str, block_manager: BlockManager) -> None: + """Frees all blocks associated with a (request_id) using the (block_manager).""" + if request_id in self.block_table: + blocks_to_free = self.block_table.pop(request_id) + block_manager.free_blocks(blocks_to_free, shareable=self.uses_block_sharing) + else: + logger.warning( + f"CacheAllocator {self._index} attempted to free blocks for non-existent request_id: {request_id}" + ) + + @abstractmethod + def get_read_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]: + """Returns the physical indices of where to read request_id's cache in the cache tensor.""" + + @abstractmethod + def get_write_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]: + """Returns the physical indices of where to write request_id's cache in the cache tensor.""" + + @abstractmethod + def fill_block_table( + self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor + ) -> None: + """Fills the block table for a given request_id, past_length and query_length.""" + + def fork_blocks( + self, parent_request_id: str, children_request_ids: list[str], block_manager: BlockManager + ) -> tuple[list[int], list[int]]: + """Forks the cache blocks of a (parent_request_id) to a list of (children_request_ids). To manage the blocks, + the (block_manager) is used. When forking, the child's block are either shared with the parent, or they need to + be copied from the parent. Hence we return two lists of blocks that need to be copied: one for the source and + one for the destination.""" + + # Sanity checks + if parent_request_id not in self.block_table: + raise ValueError(f"No block table found for request {parent_request_id}") + + # Actual forking + parent_blocks = self.block_table[parent_request_id] + list_forked_blocks, copy_src, copy_dst = block_manager.fork_blocks( + parent_blocks=parent_blocks, + num_forks=len(children_request_ids), + shareable=self.uses_block_sharing, + group_id=self._index, + ) + if list_forked_blocks is None: + raise ValueError(f"Failed to fork blocks for request {parent_request_id}") + + # Update the block table for all children requests + for children_request_id, forked_blocks in zip(children_request_ids, list_forked_blocks): + if children_request_id in self.block_table: + raise ValueError(f"Block table already exists for request {children_request_id}") + self.block_table[children_request_id] = forked_blocks + return copy_src, copy_dst + + +class FullAttentionCacheAllocator(CacheAllocator): + """Cache manager for a group of full attention layers.""" + + def __init__(self, index: int, block_size: int, allow_block_sharing: bool) -> None: + """Initializes the cache manager for a group of full attention layers. + Args: + - index: the index of the associated layer group + - block_size: the size of the blocks in the cache + """ + self._index = index + self.uses_block_sharing = allow_block_sharing + self.block_size = block_size + self.block_table = {} + + def allocate_blocks(self, n_blocks: int, request_id: str, block_manager: BlockManager) -> int | None: + """Allocate (n_blocks) for a given (request_id) using the (block_manager). Returns the number of blocks + allocated if successful and None otherwise. For group of full attention layers, we always allocate the number of + requested blocks.""" + # Make sure the request_id is in the block table and get the first block id + block_table = self.block_table.get(request_id, []) + if block_table: + last_block_id = block_table[-1] + else: + self.block_table[request_id] = block_table # TODO: check the impact of making this a deque + last_block_id = None + # Actual allocation, return early if failed + allocated_blocks = block_manager.get_free_blocks(n_blocks, last_block_id, self.uses_block_sharing, self._index) + if allocated_blocks is None: + return None + block_table.extend(allocated_blocks) + return n_blocks + + def get_read_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]: + """Returns the physical indices of where to read request_id's cache. For a group of full attention layers, we + first write the new cache to the cache tensor and then read the entire cache from the beginning to the end.""" + # Retrieve the block table for the request and raise an error if it doesn't exist + block_table = self.block_table.get(request_id) + if block_table is None: + raise ValueError(f"No block table found for request {request_id}") + # Compute auxiliary variable so we can perform only two loops + total_length = past_length + query_length + num_full_blocks = total_length // self.block_size + remainder = total_length % self.block_size + # Compute the physical indices + physical_indices = [] + for b in range(num_full_blocks): + start = block_table[b] * self.block_size + physical_indices.extend(range(start, start + self.block_size)) + if remainder: + start = block_table[num_full_blocks] * self.block_size + physical_indices.extend(range(start, start + remainder)) + return physical_indices + + def get_write_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]: + """Returns the physical indices for writing to the cache. For a group of full attention layers, we write the new + cache as a continuation of the existing cache for the same request.""" + block_table = self.block_table.get(request_id) + if block_table is None: + raise ValueError(f"No block table found for request {request_id}") + # Compute auxiliary variables so we can perform only one loop + start_block = past_length // self.block_size + start_offset = past_length % self.block_size + end_pos = past_length + query_length + end_block = (end_pos - 1) // self.block_size # -1 because if end_pos == block_size, we still end on block 0 + # Compute the physical indices + physical_indices = [] + for b in range(start_block, end_block + 1): + block_start = block_table[b] * self.block_size + # First block may start mid-block, last block may end mid-block + local_start = start_offset if b == start_block else 0 + local_end = (end_pos - 1) % self.block_size + 1 if b == end_block else self.block_size + physical_indices.extend(range(block_start + local_start, block_start + local_end)) + return physical_indices + + def fill_block_table( + self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor + ) -> None: + """Fills the block table for a given request_id, past_length and query_length.""" + request_blocks = self.block_table.get(request_id) + if request_blocks is None: + raise ValueError(f"No block table found for request {request_id}") + total_length = past_length + query_length + # Use ceiling division to include the partial block at the end + num_blocks_needed = (total_length + self.block_size - 1) // self.block_size + block_table[:num_blocks_needed] = torch.tensor( + request_blocks[:num_blocks_needed], device=block_table.device, dtype=block_table.dtype + ) + # TODO: this creates a lot of H2D transfers when not using async batching, but we will update to always using + # an IO pair in the future or a CPU-side block table. This also entails a small memory allocation. + + +class SlidingAttentionCacheAllocator(CacheAllocator): + """Cache manager for sliding window attention layers.""" + + def __init__( + self, index: int, block_size: int, sliding_window: int, sentinel_index: int, trash_index: int + ) -> None: + """Initializes the cache manager for a group of sliding window attention layers. ``sentinel_index`` and + ``trash_index`` are valid cache positions in the padding zone, used instead of -1 in read and write indices + respectively so that index_select/index_copy_ never receive negative values. + """ + self._index = index + self.uses_block_sharing = False + self.block_size = block_size + self.sliding_window = sliding_window + self.sentinel_index = sentinel_index + self.trash_index = trash_index + self._max_blocks_per_request = ceil(self.sliding_window / self.block_size) + self.block_table = {} + + def allocate_blocks(self, n_blocks: int, request_id: str, block_manager: BlockManager) -> int | None: + """Allocate (n_blocks) for a given (request_id) using the (block_manager). Returns the number of blocks + allocated otherwise. For group of sliding window attention layers, we only allocate up to the point where we can + fit an entire sliding window in the cache tensor.""" + if request_id not in self.block_table: + self.block_table[request_id] = [] + # Early return if we are already at the max number of blocks per request + already_allocated = len(self.block_table[request_id]) + if already_allocated == self._max_blocks_per_request: + return 0 + # Compute actual number of blocks to allocate + after_allocation = min(already_allocated + n_blocks, self._max_blocks_per_request) + actual_n_blocks = after_allocation - already_allocated + # Classic allocation + allocated_blocks = block_manager.get_free_blocks( + actual_n_blocks, None, self.uses_block_sharing, self._index + ) # no block sharing w/ sliding window + if allocated_blocks is None: + return None + self.block_table[request_id].extend(allocated_blocks) + return actual_n_blocks + + def get_read_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]: + """Returns the physical indices of where to read request_id's cache in the cache tensor. + For a group of sliding window attention layers, we read from the cache tensor before writing on it, because the + new cache can overwrite the old one. To form the cache + new key / values states, we read the at most + sliding_window - 1 cache page and then manually add the new key / values states after. Hence the sentinel + indices which indicate where to store the new key or values indices.""" + # Retrieve the block table for the request and raise an error if it doesn't exist + block_table = self.block_table.get(request_id) + if block_table is None: + raise ValueError(f"No block table found for request {request_id}") + # Apply sliding window + start_index = 0 if past_length < self.sliding_window else past_length % self.sliding_window + cache_length = min(past_length, self.sliding_window - 1) + # Compute the physical indices + physical_indices = [] + for i in range(start_index, start_index + cache_length): + i %= self.sliding_window + block_idx = i // self.block_size + block_offset = i % self.block_size + physical_index = block_table[block_idx] * self.block_size + block_offset + physical_indices.append(physical_index) + return physical_indices + [self.sentinel_index] * query_length + + def get_write_indices(self, request_id: str, past_length: int, query_length: int) -> list[int]: + """Returns the physical indices of where to write request_id's cache in the cache tensor. For a group of + sliding window attention layers, we write the new cache in rolling-buffer kind of way: if we reach the end of + the allocated physical cache, we start writing from the beginning of the physical cache again.""" + # Retrieve the block table for the request and raise an error if it doesn't exist + block_table = self.block_table.get(request_id) + if block_table is None: + raise ValueError(f"No block table found for request {request_id}") + # Apply sliding window + start_index = past_length % self.sliding_window + cache_length = min(query_length, self.sliding_window) + padding_length = query_length - cache_length + # Compute the physical indices + physical_indices = [] + for i in range(start_index, start_index + cache_length): + i %= self.sliding_window + block_idx = i // self.block_size + block_offset = i % self.block_size + physical_index = block_table[block_idx] * self.block_size + block_offset + physical_indices.append(physical_index) + if padding_length > 0: + physical_indices = [self.trash_index] * padding_length + physical_indices + return physical_indices + + # TODO: implement this + def fill_block_table( + self, request_id: str, past_length: int, query_length: int, block_table: torch.Tensor + ) -> None: + raise NotImplementedError("Sliding window attention layers do not support block table") diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cb_logits_processors.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cb_logits_processors.py new file mode 100644 index 0000000000000000000000000000000000000000..c98bcbed66eae0b145edb11ef927d7d594c2a8bc --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/cb_logits_processors.py @@ -0,0 +1,325 @@ +# Copyright 2025 The HuggingFace Inc. team. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from abc import ABC, abstractmethod + +import torch + +from ..logits_process import ( + LogitsProcessorList, + TemperatureLogitsWarper, + TopKLogitsWarper, + TopPLogitsWarper, +) +from .requests import FutureRequestState, logger + + +# Abstract base class for all continuous batching logits processors +class ContinuousBatchingLogitsProcessor(ABC): + # Kwargs that this processor uses, mapped to their expected type. Only the type is checked at runtime, value-range + # validation (e.g. temperature > 0) is not performed to keep a light API. You can open a PR if this is needed. + supported_kwargs: dict[str, type] + # Kwargs that this processor recognizes but ignores + ignored_kwargs: tuple[str, ...] + + @abstractmethod + def fill_defaults(self, int32_tensor: torch.Tensor) -> None: + """Fills the given tensor int32 tensor with the default values for this processor.""" + pass + + @abstractmethod + def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor: + pass + + @abstractmethod + def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor: + """Applies the logits processor in a per-token manner. + Args: + - scores (torch.FloatTensor): The scores to process, with shape [num_tokens, vocab_size] + - tensor_arg (torch.Tensor): The tensor argument to use for the logits processor, with shape + [max_num_tokens] and dtype torch.int32. The dtype might not be representative of the actual data, for + instance it's common to have a float32 tensor viewed as int32 (eg. temperature) + Returns: + - torch.FloatTensor: The processed scores, with shape [num_tokens, vocab_size] + """ + pass + + +# Main class for managing a list of processors (CB version or not) for batched generation +class ContinuousBatchingLogitsProcessorList: + """A class to hold logits processors for continuous batching (CB). + + Each processor has a base class, which is the one used in regular `generate` and some have a per-request version + adapted for CB. The list of logits processors present is generated using the `_get_logits_processor` method from + the model, which will only include processors if their presence is required by the generation config. For instance, + if you want to use temperature scaling, you need to specify a temperature that's neither None nor 1.0. Otherwise + no processors will be created for temperature, and per-request temperature scaling will not be available. + + On support of base processors: + Some base processors are not supported by CB and will be dropped when this class is instantiated. Some + processors have not yet been categorized as supported or not and will be kept but with a warning. All processors + can be kept by setting the flag `drop_unsupported_processors` to False. + On per-request processors: + Some base processors have a per-request version adapted for CB and will be converted to their per-request + version when this class is instantiated. This is the default behavior unless the flag `per_request_processors` + is set to False. + """ + + def __init__( + self, + logits_processor: LogitsProcessorList, + per_request_processors: bool = False, + drop_unsupported_processors: bool = True, + ) -> None: + self.logits_processor = logits_processor + self.tensors_required = 0 # number of tensors required to store CB logits processors arguments + # If needed, convert compatible logits processors to their per-request versions + if per_request_processors: + self._convert_to_per_request_processors() + # Validate and optionally filter processors based on their CB support + self._validate_processors(drop_unsupported_processors) + self._retrieve_processors_kwargs() + # Static boolean to know if there is any logits processing to do. Helps with torch.compile(). + self.do_processing = len(self.logits_processor) > 0 + + def __repr__(self) -> str: + return f"ContinuousBatchingLogitsProcessorList(logits_processor={self.logits_processor}, tensors_required={self.tensors_required})" + + def clear(self) -> None: + self.logits_processor = LogitsProcessorList() + self.tensors_required = 0 + self.supported_keys = {} + self.ignored_keys = set() + self.do_processing = False + + def _convert_to_per_request_processors(self) -> None: + """Replaces the compatible logits processors with their per-request versions.""" + for i, processor in enumerate(self.logits_processor): + for regular_cls, cb_cls in CLASSIC_TO_CB_PROCESSORS_MAP.items(): + if isinstance(processor, regular_cls): + self.logits_processor[i] = cb_cls(processor) + self.tensors_required += 1 # in the future, this might be more than 1 (will be stored in mapping) + break + + def _validate_processors(self, drop_unsupported: bool) -> None: + """Validates the logits processors and optionally removes unsupported ones. When drop_unsupported is True, + processors explicitly marked as unsupported are removed. Otherwise, all processors are kept but warnings are + logged for unsupported or unknown ones. + """ + filtered_processors = [] + for processor in self.logits_processor: + class_name = processor.__class__.__name__ + supported = getattr(processor, "supports_continuous_batching", None) + + # Keep all ContinuousBatchingLogitsProcessor or supported processors + if isinstance(processor, ContinuousBatchingLogitsProcessor) or supported: + filtered_processors.append(processor) + # Keep processors with support status unknown + elif supported is None: + logger.warning(f"Processor {class_name} might not be supported by CB.") + filtered_processors.append(processor) + # Otherwise, processor is not supported, then behavior depends on the flag drop_unsupported + elif drop_unsupported: + logger.warning(f"Processor {class_name} isn't supported by CB. Dropping it.") + else: + logger.warning(f"Processor {class_name} isn't supported by CB. Kept it because {drop_unsupported = }.") + filtered_processors.append(processor) + + # Update the list of logits processors (preserve LogitsProcessorList type) + self.logits_processor = LogitsProcessorList(filtered_processors) + + def _retrieve_processors_kwargs(self) -> None: + """Retrieves the supported (with types) and ignored kwargs from continuous batching processors.""" + self.supported_keys: dict[str, type] = {} + self.ignored_keys = set() + for processor in self.logits_processor: + if isinstance(processor, ContinuousBatchingLogitsProcessor): + self.supported_keys.update(processor.supported_kwargs) + self.ignored_keys.update(processor.ignored_kwargs) + + def check_kwargs(self, kwargs: dict) -> None: + """Checks that the provided kwargs are compatible with the current CB processors. Warn for ignored kwargs.""" + if not kwargs: + return None + # Validate types for supported keys, detect unsupported keys + problematic_keys = set() + for key, value in kwargs.items(): + if key not in self.supported_keys: + problematic_keys.add(key) + else: + expected_type = self.supported_keys[key] + if not isinstance(value, expected_type): + raise TypeError( + f"logit_processor_kwargs['{key}'] has type {type(value).__name__}, expected {expected_type.__name__}" + ) + # Stop if there are only supported keys + if not problematic_keys: + return + # Check if there are unknown keys + unknown_keys = problematic_keys - self.ignored_keys + if unknown_keys: + raise ValueError( + f"Unknown logit_processor_kwargs: {unknown_keys}. {self.supported_keys = } and {self.ignored_keys = }" + "If you expect a key to not be ignored, make sure its default value (in the generation config) is not " + "None. Eg. if temperature is None or 1.0 at creation time, no processor will be created for temperature" + ) + # If there are none, throw a warning about the ignored keys + logger.warning( + f"Ignored logit_processor_kwargs: {problematic_keys}. {self.supported_keys = } and {self.ignored_keys = }" + ) + + def fill_defaults(self, int32_tensor: torch.Tensor) -> None: + """Fills the given tensor int32 tensor with the default values for this processor.""" + i = 0 + for processor in self.logits_processor: + if isinstance(processor, ContinuousBatchingLogitsProcessor): + processor.fill_defaults(int32_tensor[i]) + i += 1 + + def prepare_tensor_args( + self, requests_in_batch: list[FutureRequestState], arg_storage: torch.Tensor + ) -> torch.Tensor: + current_arg_id = 0 + for processor in self.logits_processor: + if isinstance(processor, ContinuousBatchingLogitsProcessor): + tensorized_arg = processor.prepare_tensor_args(requests_in_batch) + arg_storage[current_arg_id, : tensorized_arg.size(0)] = tensorized_arg.to(arg_storage.device) + current_arg_id += 1 + return arg_storage + + def __call__( + self, input_ids: torch.LongTensor, scores: torch.FloatTensor, logits_processor_args: torch.Tensor + ) -> torch.FloatTensor: + current_arg_id = 0 + for processor in self.logits_processor: + if isinstance(processor, ContinuousBatchingLogitsProcessor): + scores = processor(scores, logits_processor_args[current_arg_id]) + current_arg_id += 1 + else: + scores = processor(input_ids, scores) + return scores + + +# Here are all the continuous batching logits processors that are supported +class ContinuousBatchingTemperatureLogitsWarper(ContinuousBatchingLogitsProcessor): + supported_kwargs: dict[str, type] = {"temperature": float} + ignored_kwargs: tuple[str, ...] = () + + def __init__(self, temperature_processor: TemperatureLogitsWarper) -> None: + self.temperature = temperature_processor.temperature + + def fill_defaults(self, int32_tensor: torch.Tensor) -> None: + """Fills the given tensor int32 tensor with the default temperature.""" + default = torch.empty_like(int32_tensor, dtype=torch.float32) + default.fill_(self.temperature) + int32_tensor.copy_(default.view(dtype=torch.int32)) + + def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor: + data = [] + for request in requests_in_batch: + temp = request.state.logit_processor_kwargs.get("temperature", self.temperature) + data.extend([temp] * request.query_length) + tensorized = torch.tensor(data, dtype=torch.float32, device="cpu") + # View the output with the bulk storage dtype (int32) but keeps the underlying data the same + return tensorized.view(dtype=torch.int32) + + def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor: + temperatures = tensor_arg[: scores.size(0)].view(dtype=torch.float32) # shape [N] + return scores / temperatures.unsqueeze(-1) # broadcast [N, 1] over [N, V] + + +class ContinuousBatchingTopKLogitsWarper(ContinuousBatchingLogitsProcessor): + supported_kwargs: dict[str, type] = {"top_k": int} + ignored_kwargs: tuple[str, ...] = ("filter_value", "min_tokens_to_keep") + + def __init__(self, top_k_processor: TopKLogitsWarper): + self.top_k = top_k_processor.top_k + self.filter_value = top_k_processor.filter_value + self.min_tokens_to_keep = top_k_processor.min_tokens_to_keep + + def fill_defaults(self, int32_tensor: torch.Tensor) -> None: + """Fills the given tensor int32 tensor with the default top_k.""" + int32_tensor.fill_(self.top_k) + + def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor: + top_ks = [] + for request in requests_in_batch: + top_k = request.state.logit_processor_kwargs.get("top_k", self.top_k) + top_k = max(top_k, self.min_tokens_to_keep) + top_ks.extend([top_k] * request.query_length) + # Prepare tensor arg with int32 as the main type + tensor_args = torch.tensor(top_ks, dtype=torch.int32, device="cpu") + return tensor_args + + def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor: + """Applies top-k selection to the scores tensor (shape [N, V]).""" + top_k = tensor_arg[: scores.size(0)] # shape [N] + # Sort descending, get threshold at position (top_k - 1) which is the k-th largest + sorted_scores = torch.sort(scores, dim=-1, descending=True)[0] # [N, V] + top_k_indices = (top_k - 1).unsqueeze(-1).to(dtype=torch.int64) # [N, 1] + thresholds = sorted_scores.gather(dim=-1, index=top_k_indices) # [N, 1] + return scores.masked_fill(scores < thresholds, self.filter_value) + + +class ContinuousBatchingTopPLogitsWarper(ContinuousBatchingLogitsProcessor): + supported_kwargs: dict[str, type] = {"top_p": float} + ignored_kwargs: tuple[str, ...] = ("filter_value", "min_tokens_to_keep") + + def __init__(self, top_p_processor: TopPLogitsWarper): + self.top_p = top_p_processor.top_p + self.filter_value = top_p_processor.filter_value + self.min_tokens_to_keep = top_p_processor.min_tokens_to_keep + + def fill_defaults(self, int32_tensor: torch.Tensor) -> None: + """Fills the given tensor int32 tensor with the default top_p.""" + default = torch.empty_like(int32_tensor, dtype=torch.float32) + default.fill_(self.top_p) + int32_tensor.copy_(default.view(dtype=torch.int32)) + + def prepare_tensor_args(self, requests_in_batch: list[FutureRequestState]) -> torch.Tensor: + top_ps = [] + for request in requests_in_batch: + # Retrieve config for this request + top_p = request.state.logit_processor_kwargs.get("top_p", self.top_p) + top_ps.extend([top_p] * request.query_length) + # Store top_p as float32 viewed as int32 to match the bulk storage dtype + tensorized = torch.tensor(top_ps, dtype=torch.float32, device="cpu") + return tensorized.view(dtype=torch.int32) + + def __call__(self, scores: torch.FloatTensor, tensor_arg: torch.Tensor) -> torch.FloatTensor: + """Applies top-p (nucleus) sampling to the scores tensor (shape [N, V]).""" + top_p = tensor_arg[: scores.size(0)].view(dtype=torch.float32) # shape [N] + + # Sort logits in ascending order + sorted_logits, sorted_indices = torch.sort(scores, descending=False, dim=-1) # [N, V] + cumulative_probs = sorted_logits.softmax(dim=-1).cumsum(dim=-1) # [N, V] + + # Remove tokens with cumulative probability <= (1 - top_p) + threshold = (1 - top_p).unsqueeze(-1) # [N, 1] + sorted_indices_to_remove = cumulative_probs <= threshold # [N, V] + + # Keep at least min_tokens_to_keep (always keep the last tokens in sorted order = highest prob) + sorted_indices_to_remove[..., -self.min_tokens_to_keep :] = False + + # Scatter sorted mask back to original indexing + indices_to_remove = sorted_indices_to_remove.scatter(-1, sorted_indices, sorted_indices_to_remove) + return scores.masked_fill(indices_to_remove, self.filter_value) + + +# TODO: add non-per-request CB variants so the memory-efficient warpers work when `per_request_processors=False`. +# TODO: fuse temperature + top-k + top-p into a single pass to reuse the softmax/sort and cut activation peak. +CLASSIC_TO_CB_PROCESSORS_MAP = { + TemperatureLogitsWarper: ContinuousBatchingTemperatureLogitsWarper, + TopKLogitsWarper: ContinuousBatchingTopKLogitsWarper, + TopPLogitsWarper: ContinuousBatchingTopPLogitsWarper, +} diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/continuous_api.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/continuous_api.py new file mode 100644 index 0000000000000000000000000000000000000000..34c0f95dffdc8ab0145e3a20c50f90f6f6956bed --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/continuous_api.py @@ -0,0 +1,1387 @@ +# Copyright 2024 The HuggingFace Inc. team. +# Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import asyncio +import gc +import queue +import threading +from abc import abstractmethod +from collections.abc import Callable, Generator +from contextlib import contextmanager, nullcontext +from math import ceil +from time import perf_counter +from typing import Any + +import torch +from torch import nn +from tqdm import tqdm +from tqdm.contrib.logging import logging_redirect_tqdm + +from ...configuration_utils import PretrainedConfig +from ...generation.configuration_utils import ContinuousBatchingConfig, GenerationConfig +from ...modeling_flash_attention_utils import lazy_import_paged_flash_attention +from ...utils.generic import is_flash_attention_requested +from ...utils.logging import logging +from ...utils.metrics import ContinuousBatchProcessorMetrics, attach_tracer, traced +from ..logits_process import LogitsProcessorList +from .cache import PagedAttentionCache +from .cb_logits_processors import ContinuousBatchingLogitsProcessorList +from .input_outputs import ContinuousBatchingAsyncIOs, ContinuousBatchingIOs +from .offloading_manager import OffloadingManager +from .requests import GenerationOutput, RequestState, RequestStatus, logger +from .scheduler import SCHEDULER_MAPPING, FIFOScheduler, Scheduler +from .utils import WorkloadHints, attn_mask_is_needed, create_warmup_future_states, pad_to_interval, pad_to_pow2 + + +""" +To enable cuda graphs, we need the dimensions of all tensors to be static, which is counter-intuitive for CB. In CB, as +generation goes on, there are two dimensions that change: +- the number of queries tokens (Q), which can vary from batch to batch +- the number of keys/values tokens (KV), which grows as the cache does + +To solve this, we slice along those dimensions to fixed lengths. The size of the slices is controlled by interval sizes: +- q_padding_interval_size: the padding granularity for queries (in tokens) +- kv_padding_interval_size: the padding granularity for KV cache (in tokens) + +For example, with q_padding_interval_size=64 and an actual query length of 100, we pad to 128 tokens. + +Smaller intervals mean finer granularity and thus less padding, but more unique graph signatures. Since graphs take +memory and time to create, we use an LRU cache with a fixed size to limit memory usage. Good defaults: +- Q: 64 tokens gives ~4 graphs for max_batch_tokens=256, which is a good balance +- KV: 8192 tokens (256 blocks at block_size=32) gives reasonable granularity for large caches + +The maximum number of cached graphs is controlled by max_cached_graphs (default 32), which uses LRU eviction. +All defaults are stored in ContinuousBatchingConfig.resolve_sentinel_values(). +""" + + +# We cannot use `PreTrainedModel` for circular import reasons, so this helps keep track of the basic types +class ProtoPretrainedModel(nn.Module): + config: PretrainedConfig + dtype: torch.dtype + device: torch.device + + @abstractmethod + def set_attn_implementation(self, attn_implementation: str) -> None: + pass + + @abstractmethod + def _get_logits_processor(self, generation_config: GenerationConfig) -> LogitsProcessorList: + pass + + +class OutputRouter: + """Dedicated object for routing generation outputs to the right destination. + + When an async handler is registered for a request, the output is forwarded + to that handler via ``call_soon_threadsafe``. Otherwise the output is placed + on the shared ``output_queue``. + """ + + def __init__(self) -> None: + self.output_queue = queue.Queue() + self.result_handlers: dict[str, tuple[Callable, asyncio.AbstractEventLoop]] = {} + self._lock = threading.Lock() + + def deliver(self, output: GenerationOutput) -> None: + """Route a single output to its registered handler or the output_queue.""" + with self._lock: + entry = self.result_handlers.get(output.request_id) + if entry is not None: + callback, loop = entry + loop.call_soon_threadsafe(callback, output) + else: + self.output_queue.put(output) + + def deliver_batch(self, outputs: list[GenerationOutput]) -> None: + """Route a batch of outputs, using a single ``call_soon_threadsafe`` to minimize cross-thread overhead. + + Outputs without a registered handler fall back to the shared ``output_queue``. + """ + callbacks: list[tuple[Callable, GenerationOutput]] = [] + loop = None + with self._lock: + for output in outputs: + entry = self.result_handlers.get(output.request_id) + if entry is not None: + callback, loop = entry + callbacks.append((callback, output)) + else: + self.output_queue.put(output) + if callbacks and loop is not None: + + def _run_batch(batch=callbacks): + for cb, out in batch: + cb(out) + + loop.call_soon_threadsafe(_run_batch) + + +# Continuous Batch Processor (Internal Logic) +@attach_tracer() +class ContinuousBatchProcessor: + inputs_and_outputs: ContinuousBatchingIOs | ContinuousBatchingAsyncIOs + scheduler: Scheduler + + def __init__( + self, + cache: PagedAttentionCache, + config: PretrainedConfig, + generation_config: GenerationConfig, + continuous_batching_config: ContinuousBatchingConfig, + logit_processor: ContinuousBatchingLogitsProcessorList, + input_queue: queue.Queue, + output_router: OutputRouter, + stop_event: threading.Event, + model_device: torch.device, + model_dtype: torch.dtype, + scheduler: Scheduler, + ) -> None: + """Initialize the continuous batch processor. + + Args: + cache: A [`PagedAttentionCache`] object + config: The model configuration + generation_config: The generation configuration + continuous_batching_config: The continuous batching configuration + logit_processor: The [`ContinuousBatchingLogitsProcessorList`] object used to process the logits. + input_queue: Queue for incoming requests + output_router: An [`OutputRouter`] object that routes outputs to handlers or the output queue. + stop_event: Event to signal processing should stop + model_device: Device for model inputs/outputs + model_dtype: Data type for model inputs/outputs + scheduler: The [`Scheduler`] to use + """ + self.cache = cache + self.config = config + self.cb_config = continuous_batching_config + self.logit_processor = logit_processor + self.input_queue = input_queue + self.output_router = output_router + self.stop_event = stop_event + self.model_device = model_device + self.model_dtype = model_dtype + self.scheduler = scheduler + + # Generation-related attributes + self.do_sample = getattr(generation_config, "do_sample", True) + self.return_logprobs = continuous_batching_config.return_logprobs + + # Retrieve the size of the sliding window if there is one + self.sliding_window = 1 if getattr(config, "sliding_window", None) is None else config.sliding_window + # Cuda graphs for the generation step + self.q_padding_interval_size = self.cb_config.q_padding_interval_size + self.kv_padding_interval_size = self.cb_config.kv_padding_interval_size + self.use_cuda_graph_varlen, self.use_cuda_graph_decode = self.cb_config.get_cuda_graph_booleans() + + # Set up metrics collector + self.max_batch_tokens = cache.max_batch_tokens + self.metrics = ContinuousBatchProcessorMetrics(cache.max_batch_tokens) + + # If the user turned on the decode fast path (ie. using a block table), check if it is available + self._ensure_decode_fast_path_is_available() # this needs to happen before self.inputs_and_outputs is created + + # Resolve compile behavior + self.cb_config.resolve_compile_configs( + fallback_compile_config=getattr(generation_config, "compile_config", None), + is_flash_attn=is_flash_attention_requested(config=config), + decode_fast_path_available=self.cache.max_blocks_per_request > 0, + ) + varlen_config, decode_config = self.cb_config.varlen_compile_config, self.cb_config.decode_compile_config + + # Compile the varlen path if config provided + self._compiled_varlen = None + if varlen_config is not None: + self._compiled_varlen = torch.compile(self._forward_process_and_sample, **varlen_config.to_dict()) + + # Compile the decode path if config provided + self._compiled_decode = None + if decode_config is not None: + self._compiled_decode = torch.compile(self._forward_process_and_sample, **decode_config.to_dict()) + + # Padding is turned on when either cuda graphs or compile is used + use_cuda_graphs = self.use_cuda_graph_varlen or self.use_cuda_graph_decode + self._pad_inputs = use_cuda_graphs or (varlen_config is not None or decode_config is not None) + # Set up the graph pool. This allows all graphs to share the same memory pool, greatly saving memory. + self.graph_pool = torch.cuda.graph_pool_handle() if use_cuda_graphs else None + + # Setup inputs and outputs + io_kwargs = { + "cache": cache, + "config": config, + "device": model_device, + "model_dtype": model_dtype, + "return_logprobs": self.return_logprobs, + "logit_processor": self.logit_processor, + "use_cuda_graph_varlen": self.use_cuda_graph_varlen, + } + self.use_async_batching = self.cb_config.use_async_batching + + if self.use_async_batching: + # Since in async there are 2 IO pairs, there are also 2 graph buffers: we divide the max_cached_graphs by 2 + io_kwargs["max_graphs"] = ceil(self.cb_config.max_cached_graphs / 2) + self.inputs_and_outputs = ContinuousBatchingAsyncIOs(**io_kwargs) + else: + io_kwargs["max_graphs"] = self.cb_config.max_cached_graphs + self.inputs_and_outputs = ContinuousBatchingIOs(**io_kwargs) + + # Offloading manager: handles CPU offloading, soft reset, and restoration + self.offloading_manager = OffloadingManager( + cache=cache, + scheduler=scheduler, + cpu_offload_space_gib=continuous_batching_config.cpu_offload_space, + safety_threshold=continuous_batching_config.cpu_offload_space_safety_threshold, + compute_stream=self.inputs_and_outputs.compute_stream, + ) + + def __repr__(self) -> str: + return ( + f"ContinuousBatchProcessor(input_queue={self.input_queue}, " + f"active_requests={self.scheduler.active_requests}, waiting_requests={self.scheduler.waiting_requests})" + + self.inputs_and_outputs.get_model_kwargs().__repr__() + ) + + def __del__(self) -> None: + self.inputs_and_outputs = None # clean up CUDA graphs in priority + gc.collect() + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + def _ensure_decode_fast_path_is_available(self) -> None: + """Ensures the decode fast path is available. If it is not, set the max blocks per request to 0. If it is + available, and no user-provided max blocks per request, set it to the fallback default.""" + # First, set max blocks per request to 32 if it needs to be auto-inferred + user_requested = self.cb_config.max_blocks_per_request is not None + if not user_requested: + self.cache.max_blocks_per_request = self.cb_config.fallback_max_blocks_per_request + logger_warning = lambda x: x # silences warning for user_requested=False # noqa: E731 + else: + logger_warning = logger.warning + + # Then, if the decode fast path is not turned off, check if it is available + if self.cache.max_blocks_per_request != 0: + # NOTE: block table should be available with FA2 and FA3, but there seems to be an issue with FA2 atm + if is_flash_attention_requested(self.config, version=3): + flash_attn_with_kvcache = lazy_import_paged_flash_attention(self.config._attn_implementation)[1] + conditions = [ + self.cache.num_sliding_attention_groups == 0, # TODO: add support for sliding window layers + torch.cuda.is_available(), # Block table is only supported on CUDA + flash_attn_with_kvcache is not None, # The `flash_attn_with_kvcache` fn is needed + ] + # Throw a warning only if the decode fast path was requested by the user + if not all(conditions): + logger_warning( + f"Although {self.cache.max_blocks_per_request = }, the decode fast path is not available " + f"because the one condition is not met: {conditions}." + ) + self.cache.max_blocks_per_request = 0 + # Specific warning for attn implementation other than FA3 + else: + logger_warning( + f"Although {self.cache.max_blocks_per_request = }, the decode fast path is not available " + f"because the attention implementation is not FA3. Got {self.config._attn_implementation = }." + ) + self.cache.max_blocks_per_request = 0 + + def reset(self) -> None: + """Reset the batch processor for a new generation loop.""" + self.offloading_manager.reset() + self.scheduler.reset() + self.inputs_and_outputs.reset() + self.cache.free_all_requests() + self.metrics = ContinuousBatchProcessorMetrics(self.cache.max_batch_tokens) + + @traced + def _get_new_requests(self) -> None: + """Pull new requests from the input queue and add to waiting list.""" + while not self.input_queue.empty(): + try: + state = self.input_queue.get_nowait() + if state is None: # Sentinel value + continue + self.logit_processor.check_kwargs(state.logit_processor_kwargs) + self.scheduler.add_waiting_request(state) + + except queue.Empty: + break + except Exception as e: + logger.error(f"Error processing new request: {e}", exc_info=True) + state: RequestState = locals().get("state") + if state is not None: + self._handle_request_error(e, state) + + @traced + def _handle_request_error(self, error: Exception, state: RequestState) -> None: + """Handle general request processing error.""" + state.status = RequestStatus.FAILED + state.error = str(error) + + # Include any generated tokens if this is an active request + if isinstance(state.request_id, str): + state.generated_tokens = self.scheduler.get_active_request_static_outputs(state.request_id) + else: + state.generated_tokens = [] + + self.metrics.record_request_completion(state.created_time, state.request_id) + self.output_router.deliver(state.to_generation_output()) + + def maybe_pad_inputs(self, num_q_tokens: int, max_kv_read: int, use_decode_fast_path: bool) -> tuple[int, int]: + """Pads the inputs sizes for the next batch if it is needed. Often it is, for max performance.""" + if self._pad_inputs: + # For varlen batches, we pad using interval sizes + if not use_decode_fast_path: + num_q_tokens = pad_to_interval(num_q_tokens, self.q_padding_interval_size, self.max_batch_tokens) + max_kv_read = pad_to_interval(max_kv_read, self.kv_padding_interval_size, self.cache.num_pages) + # For decode fast path batches, we pad using powers of 2 and use no KV + else: + num_q_tokens = pad_to_pow2(num_q_tokens, self.max_batch_tokens) + max_kv_read = 0 + return num_q_tokens, max_kv_read + + @traced + def prepare_next_batch(self) -> bool: + """Prepare tensors and metadata for the next model forward pass. Returns True if there are requests to process, + False otherwise.""" + + # Get new requests from the queue, stop if there are no pending requests + self._get_new_requests() + cancelled_states = self.scheduler.clear_cancelled_requests() + # Also free CPU-offloaded cache for cancelled states. This is CPU-only, so it isn't batched like D2H transfers + for state in cancelled_states: + self.offloading_manager.free_request_cpu_cache(state) + if not self.scheduler.has_pending_requests(): + return False + self.metrics.record_queue_metrics(len(self.scheduler.active_requests), len(self.scheduler.waiting_requests)) + + # Schedule the next batch of requests + requests_in_batch, use_decode_fast_path, num_q_tokens, max_kv_read = self.scheduler.schedule_batch( + self.max_batch_tokens, self.cache.num_pages + ) + # If requests_in_batch is None, it means we need to offload some requests if possible + if requests_in_batch is None: + if len(self.scheduler.active_requests) > 1: + self.offloading_manager.offload_one_request() + return False + else: + raise RuntimeError("No requests can be scheduled and no request can be offloaded.") + # If it's an empty list, it means we have no requests to process + if not requests_in_batch: + return False + + # Restore any CPU-offloaded requests that were just scheduled + self.offloading_manager.restore_scheduled_requests(requests_in_batch) + + # Otherwise, we can continue with the non-empty batch and log in the dimensions before padding + self.metrics.record_batch_metrics(requests_in_batch) + logger.debug( + f"Scheduled: {len(requests_in_batch)}, Waiting: {len(self.scheduler.waiting_requests)}, " + f"Active: {len(self.scheduler.active_requests)}. cum Q: {num_q_tokens}. " + f"cum KV: {max_kv_read}, free blocks: {self.cache.get_num_free_blocks()}" + ) + + # If inputs are static sized, eg. for compile, we find the padded sizes of the queries and keys/values + num_q_tokens, max_kv_read = self.maybe_pad_inputs(num_q_tokens, max_kv_read, use_decode_fast_path) + + self.inputs_and_outputs.prepare_batch_tensors( + requests_in_batch, self.logit_processor, use_decode_fast_path, num_q_tokens, max_kv_read + ) + self.metrics.record_kv_cache_memory_metrics(self.cache) + return True + + @traced + def update_batch(self) -> None: + """Update request states based on generated tokens.""" + requests_in_batch, new_tokens, logprobs = self.inputs_and_outputs.prepare_batch_update() + current_logits_index = 0 + pending_outputs = [] + for future_state in requests_in_batch: + state = future_state.state + # Early return if the request was finished or offloaded between scheduling and update (async mode) + if state.status in (RequestStatus.FINISHED, RequestStatus.PENDING): + if self.use_async_batching: + # Skip this request, but still consume its token from new_tokens if it had one + if future_state.has_new_token: + current_logits_index += 1 + continue + raise RuntimeError(f"Tried to update {state.status.name} request {state.request_id} in sync mode.") + # If the request has a new token, it means prefill has already ended or just finished + if future_state.has_new_token: + # If there is just one temporary token, it means prefill just ended + if state.generated_len() == 0: + self.metrics.record_ttft_metric(state.created_time, state.request_id) + state.status = RequestStatus.DECODING + + token = new_tokens[current_logits_index] + logprob = logprobs[current_logits_index] if logprobs is not None else None + current_logits_index += 1 + + # Update the request and stop if it is complete + is_finished = state.update_and_check_completion(token, logprob) + # We mark the completed blocks as such + self.cache.mark_shareable_blocks_as_complete(state, future_state.complete_blocks) + if is_finished: + self.metrics.record_request_completion(state.created_time, state.request_id) + self.scheduler.finish_request(state.request_id) + self.scheduler.block_new_requests = False + if state.streaming or state.status == RequestStatus.FINISHED: + pending_outputs.append(state.to_generation_output()) + # Otherwise, the request is still prefilling, but the prefill has been split + elif state.status == RequestStatus.PREFILLING: + self.cache.mark_shareable_blocks_as_complete(state, future_state.complete_blocks) + + if pending_outputs: + self.output_router.deliver_batch(pending_outputs) + + # If some requests need to be forked, we do it now + copy_source, copy_destination = [], [] + while self.scheduler._requests_to_fork: + # Get the number of children and reset it so it's not forked again + state_to_fork = self.scheduler._requests_to_fork.pop() + num_children = state_to_fork.num_children + state_to_fork.num_children = 0 + # Create the new request and add them to the scheduler + new_request_ids = [f"{state_to_fork.request_id}__child#{i}" for i in range(num_children)] + for new_request_id in new_request_ids: + self.scheduler.active_requests[new_request_id] = state_to_fork.fork(new_request_id) + # Fork the cache + copy_src, copy_dst = self.cache.fork_request(state_to_fork.request_id, new_request_ids) + copy_source.extend(copy_src) + copy_destination.extend(copy_dst) + # FIXME: if fork cant be done, create a new pending request without forking instead of crashing everything + + # The copy induced by the fork is done in one go (if it's even needed) + if copy_source: + # FIXME: this will avoid any race condition, but it can cause issue when using async batching with a sliding + # window model. Fix will be fixed in a PR in the near future (tempfix, v5.3) + compute_stream = self.inputs_and_outputs.compute_stream + maybe_stream = torch.cuda.stream(compute_stream) if compute_stream is not None else nullcontext() + with maybe_stream: + self.cache.copy_cache(copy_source, copy_destination) + + @traced + def has_pending_requests(self) -> bool: + """Check if there are any active or waiting requests.""" + return self.scheduler.has_pending_requests() + + @traced + def handle_batch_error(self, error): + """Handle errors during batch processing.""" + failed_future_states = self.inputs_and_outputs.prepare_batch_update()[0] + for future_state in failed_future_states: + self._handle_request_error(error, future_state.state) + self.scheduler.finish_request(future_state.state.request_id) + + @traced + def fail_all_requests(self, error: Exception) -> None: + """Fail all active requests with the given error.""" + + requests = list(self.scheduler.active_requests.values()) + for state in requests: + self._handle_request_error(error, state) + self.scheduler.finish_request(state.request_id) + + # Also fail any requests in the waiting queue + self.offloading_manager.free_all_waiting_cpu_caches() + for req_id in list(self.scheduler.waiting_requests.keys()): + state = self.scheduler.waiting_requests.pop(req_id) + self._handle_request_error(error, state) + + # Clear the ordering queue + self.scheduler.waiting_requests_order.clear() + + @traced + @torch.no_grad() + def _generation_step(self, model: nn.Module) -> None: + """Perform a single generation step.""" + + # Retrieve the model kwargs with or without padding + batch_data = self.inputs_and_outputs.get_model_kwargs(use_padding=self._pad_inputs) + carry_over_ids, prev_output_ids, output_ids = self.inputs_and_outputs.get_cb_kwargs() + compute_stream = self.inputs_and_outputs.compute_stream + + # Get the appropriate forward function (compiled or not, based on current path) + if self.inputs_and_outputs.use_block_table: + forward_fn = self._forward_process_and_sample if self._compiled_decode is None else self._compiled_decode + use_cuda_graph = self.use_cuda_graph_decode + else: + forward_fn = self._forward_process_and_sample if self._compiled_varlen is None else self._compiled_varlen + use_cuda_graph = self.use_cuda_graph_varlen + + # If we are not using cuda graphs, we perform the generation step and return + if not use_cuda_graph: + maybe_stream = torch.cuda.stream(compute_stream) if compute_stream is not None else nullcontext() + with maybe_stream: + forward_fn(model, batch_data, carry_over_ids, prev_output_ids, output_ids) + + # Otherwise, we use create or replay the graph (cuda is available in this path) + else: + graph = self.inputs_and_outputs.get_graph() + # Case: the graph already exists, so we replay it + if graph is not None: + with torch.cuda.stream(compute_stream): + graph.replay() + # Otherwise, the graph does not exist, so we create it + else: + args = (model, batch_data, carry_over_ids, prev_output_ids, output_ids) + self.capture_graph(forward_fn, compute_stream, *args) + + # In any case, we transfer the outputs to the host + self.inputs_and_outputs.retrieve_device_outputs() + + def capture_graph(self, forward_fn: Any, compute_stream: torch.cuda.Stream, *args) -> None: + # Warmup (ensures the right result is computed before capturing the graph) + with torch.cuda.stream(compute_stream): + forward_fn(*args) + # Capture + graph = torch.cuda.CUDAGraph() + # Continuous batching can run multiple manager threads concurrently in one process, but PyTorch's + # default capture mode ("global") errors on CUDA actions from other threads. This means capture can be + # invalidated even when each manager uses a different device. To avoid this, we use "thread_local" mode. + with torch.cuda.graph(graph, stream=compute_stream, pool=self.graph_pool, capture_error_mode="thread_local"): + forward_fn(*args) + # Store + self.inputs_and_outputs.set_graph(graph) + + @traced + def _forward_process_and_sample( + self, + model: nn.Module, + batch_data: dict, + carry_over_ids: torch.Tensor, + prev_output_ids: torch.Tensor, + output_ids: torch.Tensor, + ) -> None: + """This function performs the forward pass, logits processing, and sampling; which are broken down into smaller + function to be easier to trace with OpenTelemetry.""" + self.inputs_and_outputs.carry_over_tokens(batch_data["input_ids"], carry_over_ids, prev_output_ids) + logits = self._model_forward(model, batch_data).float() # convert to fp32 to match generate + scores = self._process_logit(batch_data, logits) if self.logit_processor.do_processing else logits + self._sample(scores, batch_data["logits_indices"], output_ids) + + @traced(span_name="model_forward") + def _model_forward(self, model: nn.Module, batch_data: dict) -> torch.Tensor: + return model(**batch_data).logits + + @traced(span_name="logit_processing") + def _process_logit(self, batch_data: dict, logits: torch.Tensor) -> torch.Tensor: + # Handle shape compatibility: logit processors expect 2D tensors [batch_size, vocab_size] + # but continuous batching always produces 3D tensors [batch_size, seq_len, vocab_size] + batch_size, seq_len, vocab_size = logits.shape + logits_2d = logits.view(batch_size * seq_len, vocab_size) + input_ids_2d = batch_data["input_ids"].view(batch_size * seq_len) + # Process with 2D tensors + processed_logits_2d = self.logit_processor(input_ids_2d, logits_2d, batch_data["logits_processor_args"]) + # Reshape back to 3D + return processed_logits_2d.view(batch_size, seq_len, vocab_size) + + @traced(span_name="sampling") + def _sample(self, scores: torch.Tensor, logits_indices: torch.Tensor, output_ids: torch.Tensor) -> None: + # Apply softmax if we are sampling or if we are generating log probabilities + if self.do_sample or self.return_logprobs: + probs = nn.functional.softmax(scores[0], dim=-1) # shape [seq_len, vocab_size] + # Otherwise just remove the batch size dimension, which is always 1 + else: + probs = scores.squeeze(0) # shape [seq_len, vocab_size] + + # Retrieve next tokens through sampling or argmax + if self.do_sample: + next_tokens = torch.multinomial(probs, num_samples=1) # shape [seq_len, 1] + else: + next_tokens = torch.argmax(probs, dim=-1, keepdim=True) # shape [seq_len, 1] + + # Maybe retrieve log probabilities + if self.return_logprobs: + per_token_probs = probs.gather(dim=1, index=next_tokens).squeeze(-1) + logprobs = per_token_probs.log() # shape [seq_len] + # And always remove the extra dimension for the gather + next_tokens = next_tokens.squeeze(-1) # shape [seq_len] + + # Get seq_len dimension to slice the logits indices + tokens = next_tokens.size(0) + # Shuffle the next tokens to match the order of the batch's requests + indices = logits_indices[:tokens] + next_tokens = next_tokens[indices] + # Copy the next tokens and maybe their logprobs to the static output tensor + output_ids[0, :tokens].copy_(next_tokens) + if self.return_logprobs: + # Shuffle the logprobs the same way as the next tokens + logprobs = logprobs[indices] + # In order to match the dtype of output_ids, we cast the fp32 logprobs as int32 without changing the + # underlying data. It's just a trick to use the same storage for both tensors. + output_ids[1, :tokens].copy_(logprobs.view(dtype=torch.int32)) + + @torch.inference_mode() + def warmup(self, model: nn.Module) -> None: + """Pre-capture CUDA graphs (or trigger compile warmup) for varlen and decode paths. In async mode, both IO + pairs are warmed up since each has its own graph buffer and static tensors. The varlen path is warmed up at + the largest possible `(q, kv)` sizes so subsequent captures fit inside it without growing the pool.""" + + if not self._pad_inputs: + logger.info("CUDA graphs and compile are disabled, skipping warmup.") + return None + + num_query_tokens = self.max_batch_tokens + num_pages = self.cache.num_blocks * self.cache.block_size + num_cache_tokens = num_pages - num_query_tokens + compute_stream = self.inputs_and_outputs.compute_stream + + # In async mode, each IO pair has its own graph buffer and static tensors, so we warm up both + num_io_pairs = 2 if self.use_async_batching else 1 + + for pair_idx in range(num_io_pairs): + if self.use_async_batching: + self.inputs_and_outputs.current_pair = pair_idx + logger.info(f"Warming up IO pair {pair_idx + 1}/2...") + + # --- Varlen path --- + padded_q, padded_kv = self.maybe_pad_inputs( + num_q_tokens=num_query_tokens, + max_kv_read=num_cache_tokens + num_query_tokens, + use_decode_fast_path=False, + ) + logger.info(f"Warming up varlen path ({padded_q} Q tokens, {padded_kv} KV tokens)...") + + future_states = create_warmup_future_states( + 1, RequestStatus.PREFILLING, num_query_tokens, num_cache_tokens, self.cache + ) + try: + start = perf_counter() + self.inputs_and_outputs.prepare_batch_tensors( + future_states, self.logit_processor, False, padded_q, padded_kv - padded_q + ) + batch_data = self.inputs_and_outputs.get_model_kwargs(use_padding=True) + carry_over_ids, prev_output_ids, output_ids = self.inputs_and_outputs.get_cb_kwargs() + forward_fn = self._compiled_varlen or self._forward_process_and_sample + forward_fn_args = (model, batch_data, carry_over_ids, prev_output_ids, output_ids) + if self.use_cuda_graph_varlen: + self.capture_graph(forward_fn, compute_stream, *forward_fn_args) + else: + with torch.cuda.stream(compute_stream): + forward_fn(*forward_fn_args) + logger.info(f"Varlen warmup completed in {perf_counter() - start:.2f}s") + except Exception as e: + logger.warning(f"Failed to warm up varlen path: {e}. Graph pool may fragment and OOM under load.") + finally: + for fs in future_states: + self.cache.free_blocks(fs.state.request_id) + + # Exit here if the decode fast path is not available + if self.cache.max_blocks_per_request == 0: + continue + + # --- Decode fast path --- + logger.info("Warming up decode fast path...") + decode_graphs = 0 + start = perf_counter() + + num_requests = 1 + while True: + future_states = create_warmup_future_states( + num_requests, RequestStatus.DECODING, 1, self.cache.block_size, self.cache + ) + if not future_states: + break + try: + padded_q, _ = self.maybe_pad_inputs( + num_q_tokens=num_requests, max_kv_read=0, use_decode_fast_path=True + ) + self.inputs_and_outputs.prepare_batch_tensors( + future_states, self.logit_processor, True, padded_q, 0 + ) + batch_data = self.inputs_and_outputs.get_model_kwargs(use_padding=True) + carry_over_ids, prev_output_ids, output_ids = self.inputs_and_outputs.get_cb_kwargs() + forward_fn = self._compiled_decode or self._forward_process_and_sample + forward_fn_args = (model, batch_data, carry_over_ids, prev_output_ids, output_ids) + if self.use_cuda_graph_decode: + self.capture_graph(forward_fn, compute_stream, *forward_fn_args) + else: + with torch.cuda.stream(compute_stream): + forward_fn(*forward_fn_args) + decode_graphs += 1 + except Exception as e: + logger.warning(f"Failed to warm up decode path for {num_requests} requests: {e}") + finally: + for fs in future_states: + self.cache.free_blocks(fs.state.request_id) + if num_requests >= self.max_batch_tokens: + break + num_requests = min(2 * num_requests, self.max_batch_tokens) + logger.info(f"Decode warmup completed ({decode_graphs} graphs) in {perf_counter() - start:.2f}s.") + + # If using async batching, reset to pair 0 for the generation loop + if self.use_async_batching: + self.inputs_and_outputs.current_pair = 0 + + +# Manager Class (User Interface) +@attach_tracer() +class ContinuousBatchingManager: + """Manager for handling continuous batching of generation requests. It provides a user interface for submitting + generation requests, retrieving results, and managing the background generation thread. This class should not be + created directly, but through one of the following entry points (all methods of the `ContinuousMixin` mixin): + - `init_continuous_batching` + - `continuous_batching_context_manager` + - `generate_batch` + """ + + def __init__( + self, + model: ProtoPretrainedModel, + generation_config: GenerationConfig, + continuous_batching_config: ContinuousBatchingConfig, + ) -> None: + """Initialize the continuous batching manager. + + Args: + model: The language model for generation + generation_config: Configuration for generation parameters + continuous_batching_config: Configuration for continuous batching parameters + """ + # Reload paged version of the attention implementation if necessary + if "paged|" not in model.config._attn_implementation: + model.set_attn_implementation(f"paged|{model.config._attn_implementation}") + + # Internal arguments + self.model = model.eval() + self.generation_config = generation_config + self.continuous_batching_config = continuous_batching_config + self.warmed_up = False # Set to True after warmup is completed. Useful for persistent managers. + # This is an approximation until the cache is created: it will infer the correct value in cache.__init__ + self._use_prefix_sharing = self.continuous_batching_config.allow_block_sharing + + self.input_queue = queue.Queue(maxsize=self.continuous_batching_config.max_queue_size) + self._has_new_requests = threading.Event() + self.output_router = OutputRouter() + self.stop_event = threading.Event() + self.batch_processor: ContinuousBatchProcessor | None = None + self._generation_thread = None + self._request_counter = 0 + self._request_lock = threading.Lock() + self.fatal_error: Exception | None = None + + # Generation config related arguments + num_return_sequences = getattr(generation_config, "num_return_sequences", None) + self.num_return_sequences = num_return_sequences if num_return_sequences is not None else 1 + + self.logit_processor = ContinuousBatchingLogitsProcessorList( + logits_processor=self.model._get_logits_processor(generation_config), + per_request_processors=self.continuous_batching_config.per_request_processors, + drop_unsupported_processors=self.continuous_batching_config.drop_unsupported_processors, + ) + + # Cuda graph behavior is determined below using either user-specified arguments or heuristics + is_attn_mask_needed = attn_mask_is_needed(self.model.config) + self.continuous_batching_config.decide_use_cuda_graphs( + compile_config=getattr(generation_config, "compile_config", None), + is_attn_mask_needed=is_attn_mask_needed, + ) + # Same for asynchronous batching behavior + self.use_async_batching = self.continuous_batching_config.decide_use_async_batching(is_attn_mask_needed) + + # Resolve default parameters for Q and KV interval sizes, and max cached graphs. If one of those parameters is + # not specified (set to 0) then we use the default value and change its value in the config. + self.continuous_batching_config.resolve_sentinel_values() + self.q_padding_interval_size = self.continuous_batching_config.q_padding_interval_size + self.kv_padding_interval_size = self.continuous_batching_config.kv_padding_interval_size + self.max_cached_graphs = self.continuous_batching_config.max_cached_graphs + + @traced + def start(self) -> None: + """Start the background generation thread.""" + if self._generation_thread is not None and self._generation_thread.is_alive(): + logger.warning("Manager thread is already running.") + return + self.stop_event.clear() + self.fatal_error = None + self._generation_thread = threading.Thread(target=self._run_generation_loop) + self._generation_thread.start() + + def is_running(self) -> bool: + """Check if the background generation thread is running.""" + return self._generation_thread is not None and self._generation_thread.is_alive() + + def warmup(self) -> None: + """Pre-capture CUDA graphs for varlen and decode paths by running dummy batches. Initializes the batch + processor if not already done.""" + if self.batch_processor is None: + self.batch_processor = self._create_batch_processor() + self.batch_processor.warmup(self.model) + self.warmed_up = True + + # NOTE: don't forget to update `continuous_batching_context_manager` when changing this method's definition + def stop(self, block: bool = True, timeout: float | None = None, keep_for_next_session: bool = False) -> None: + """Signal the background thread to stop. + + Args: + block: Whether to wait for the thread to stop + timeout: Maximum time to wait for the thread to stop + keep_for_next_session: Whether to cache this on the model for future use + """ + if self.batch_processor is None: + logger.warning("\nBatch processor was not initialized.") + elif self.batch_processor.cache.use_prefix_sharing: + logger.info( + f"\nPrefix sharing was on. Total prefix length: {self.batch_processor.cache._total_prefix_length}" + ) + + if self._generation_thread is None: + suffix = " Hence the unstarted manager will not be kept for next session." if keep_for_next_session else "" + logger.warning("Manager not started." + suffix) + return + + stop_trigger_time = perf_counter() + if not self.stop_event.is_set(): + self.stop_event.set() + logger.info("Stopping continuous batching manager...") + + if block: + self.join(stop_trigger_time, timeout) + + # If the manager is not being kept for next session, we clear the batch processor + if not keep_for_next_session: + self.batch_processor = None + # Otherwise, we keep the batch processor and cache the manager as a model attribute + else: + logger.info("Continuous batching manager will be kept for next session.") + self.model._cached_continuous_batching_manager = self + # In all cases, a little cleanup is good + gc.collect() + if torch.cuda.is_available(): + torch.cuda.empty_cache() + + def join(self, stop_trigger_time: float, timeout: float | None = None) -> None: + """Wait for the background thread to finish. + + Args: + timeout: Maximum time to wait for the thread to stop + """ + if self._generation_thread is not None: + self._generation_thread.join(timeout=timeout) + if self._generation_thread.is_alive(): + logger.warning(f"Generation thread did not exit after join timeout ({timeout}).") + else: + end = perf_counter() + logger.info(f"Continuous Batching Manager stopped after {end - stop_trigger_time:.2f}s.") + self._generation_thread = None + + def add_request( + self, + input_ids: list[int], + request_id: str | None = None, + max_new_tokens: int | None = None, + streaming: bool = False, + record_timestamps: bool = False, + eos_token_id: int | list[int] | None = None, + **logit_processor_kwargs: Any, + ) -> str: + """Add a new generation request to the queue. + + Args: + input_ids: Input token IDs to use as prompt + request_id: Optional custom request ID (auto-generated if None) + max_new_tokens: Maximum number of new tokens to generate + streaming: Whether to stream tokens as they're generated + record_timestamps: Whether to record timestamps for each generated token + eos_token_id: End-of-sequence token ID(s) + logit_processor_kwargs: Keyword arguments for the logits processor. + + Returns: + str: The request ID + """ + if request_id is None: + with self._request_lock: + request_id = f"req_{self._request_counter}" + self._request_counter += 1 + + max_new_tokens = self.generation_config.max_new_tokens if max_new_tokens is None else max_new_tokens + eos_token_id = self.generation_config.eos_token_id if eos_token_id is None else eos_token_id + + # NOTE: do we want to handle a case when the user wants token ids returned instead of decoded text? + state = RequestState( + request_id=request_id, + initial_tokens=list(input_ids), + num_children=self.num_return_sequences - 1, + record_timestamps=record_timestamps, + max_new_tokens=max_new_tokens, + eos_token_id=eos_token_id, + streaming=streaming, + logit_processor_kwargs=logit_processor_kwargs, + ) + + # Use block=True with timeout to handle backpressure if queue is full + self.input_queue.put(state, block=True, timeout=10) + self._has_new_requests.set() + return request_id + + def add_requests( + self, + inputs: list[list[int]], + max_new_tokens: int | None = None, + streaming: bool = False, + record_timestamps: bool = False, + **logit_processor_kwargs: Any, + ) -> None: + # Infer the request ids of all incoming requests + with self._request_lock: + request_ids = [f"req_{i}" for i in range(self._request_counter, self._request_counter + len(inputs))] + self._request_counter += len(inputs) + # If there is prefix sharing, we sort the inputs to maximize cache hits but keep the order of the requests + ids_and_inputs = list(zip(request_ids, inputs)) + if self._use_prefix_sharing: + ids_and_inputs = sorted(ids_and_inputs, key=lambda x: x[1], reverse=True) + # Look for an EOS token ID in the generation config and then in the model config. If no EOS is found, we set it + # to -1 to avoid looking for it in each add_request call + eos_token_id = self.generation_config.eos_token_id + eos_token_id = self.model.config.eos_token_id if eos_token_id is None else eos_token_id + eos_token_id = -1 if eos_token_id is None else eos_token_id + # Add requests in order + for request_id, input_ids in ids_and_inputs: + self.add_request( + input_ids=input_ids, + request_id=request_id, + max_new_tokens=max_new_tokens, + streaming=streaming, + record_timestamps=record_timestamps, + eos_token_id=eos_token_id, + **logit_processor_kwargs, + ) + + def cancel_request(self, request_id: str) -> None: + """Cancel a request by its ID. + + Args: + request_id: The ID of the request to cancel + """ + if self.batch_processor is not None: + self.batch_processor.scheduler.set_request_cancellation(request_id) + + # TODO:handle benchmarking properly when updating / fixing the requeue logic + def get_result(self, request_id: str | None = None, timeout: float | None = None) -> GenerationOutput | None: + """Retrieve one result from the output queue. + + Args: + request_id: If set, only return results matching this ID (others are requeued). + timeout: Maximum time to wait for a result. + + Returns: + Optional[GenerationOutput]: The result data or None if timeout. + """ + if self._generation_thread is None and self.output_router.output_queue.empty(): + return None + try: + result = self.output_router.output_queue.get(block=True, timeout=timeout) + if request_id is not None and result.request_id != request_id: + self.output_router.output_queue.put(result) + return None + return result + except queue.Empty: + return None + + def __iter__(self): + """Iterate over results as they become available.""" + while self._generation_thread is not None and self._generation_thread.is_alive(): + result = self.get_result(timeout=0.1) + if result is not None: + yield result + + def request_id_iter(self, request_id: str) -> Generator[GenerationOutput]: + """Iterate over results matching a specific request id (blocking). + + Uses the shared output queue with requeue. For high-concurrency serving, + use :meth:`register_result_handler` instead. + """ + while self._generation_thread is not None and self._generation_thread.is_alive(): + result = self.get_result(request_id=request_id, timeout=0.1) + if result is not None: + yield result + if result.is_finished(): + return + + def register_result_handler(self, request_id: str, callback: Callable) -> None: + """Register a callback for result delivery (streaming or non-streaming). + + The callback is invoked on the event loop via ``call_soon_threadsafe`` + each time a result is produced for this request. For streaming requests, + this happens on every token; for non-streaming, only on completion. + + The handler is automatically cleaned up when the request finishes. + + Args: + request_id (`str`): The request ID to receive outputs for. + callback (`callable`): Called with a ``GenerationOutput`` for each result. + """ + loop = asyncio.get_running_loop() + + def _auto_cleanup(result): + callback(result) + if result.is_finished(): + with self.output_router._lock: + self.output_router.result_handlers.pop(request_id, None) + + with self.output_router._lock: + self.output_router.result_handlers[request_id] = (_auto_cleanup, loop) + + @traced + def _generation_step(self) -> None: + """Perform a single generation step. This is mostly cuda graphed""" + if self.batch_processor is None: + raise RuntimeError("Tried to perform a generation step before the batch processor was initialized.") + self.batch_processor._generation_step(self.model) + + def _create_batch_processor(self) -> ContinuousBatchProcessor: + # Resolve max_memory_percent now that we know whether any logit processors are active. + self.continuous_batching_config.resolve_max_memory_percent(self.logit_processor.do_processing) + # Create the PagedAttentionCache + paged_attention_cache = PagedAttentionCache( + self.model.config, + self.continuous_batching_config, + self.model.device, + self.model.dtype, + tp_size=getattr(self.model, "_tp_size", None), # Use model's actual TP setting + ) + self._use_prefix_sharing = paged_attention_cache.use_prefix_sharing # update the approximation + + # Create the scheduler + scheduler_type = self.continuous_batching_config.scheduler_type + scheduler = SCHEDULER_MAPPING.get(scheduler_type, None) + if scheduler is None: + logger.warning(f"Scheduler '{scheduler_type}' not found. Defaulting to FIFO.") + scheduler = FIFOScheduler + + # Create the batch processor + batch_processor = ContinuousBatchProcessor( + cache=paged_attention_cache, + config=self.model.config, + generation_config=self.generation_config, + continuous_batching_config=self.continuous_batching_config, + logit_processor=self.logit_processor, + input_queue=self.input_queue, + output_router=self.output_router, + stop_event=self.stop_event, + model_device=self.model.device, + model_dtype=self.model.dtype, + scheduler=scheduler(paged_attention_cache), + ) + return batch_processor + + @torch.inference_mode() + def _run_generation_loop(self) -> None: + """Main processing loop running in the background thread.""" + try: + # Try to retrieve an already initialized batch processor + batch_processor = getattr(self, "batch_processor", None) + # If the batch processor already exists, we just reset it for a new generation loop + if isinstance(batch_processor, ContinuousBatchProcessor): + batch_processor.reset() + # Otherwise, we create a new batch processor + else: + batch_processor = self._create_batch_processor() + + # Start the generation loop + self.batch_processor = batch_processor + self.current_batch = 0 + + # If using the async API, we bootstrap the first batch w/out update + if batch_processor.use_async_batching: + if not batch_processor.prepare_next_batch(): + raise RuntimeError("Failed to bootstrap the first batch.") + self._generation_step() + self.current_batch += 1 + + while (not self.stop_event.is_set()) or batch_processor.has_pending_requests(): + self._inner_generation_loop(batch_processor) + self.current_batch += 1 + + # In async mode, the last batch's results are still in flight - process them now + # We need to switch back to the pair that has the last batch's D2H pending + if isinstance(batch_processor.inputs_and_outputs, ContinuousBatchingAsyncIOs): + batch_processor.inputs_and_outputs.current_pair = 1 - batch_processor.inputs_and_outputs.current_pair + batch_processor.update_batch() + + except Exception as e: + logger.error(f"Error in generation loop: {e}", exc_info=True) + self._handle_critical_error(e, batch_processor) + finally: + logger.info("Generation loop finished.") + + @traced(span_name="generation_loop") + def _inner_generation_loop(self, batch_processor: ContinuousBatchProcessor) -> None: + # Loop body ends if there is no requests in the batch + if not batch_processor.prepare_next_batch(): + # Wait for new requests instead of busy-spinning. + self._has_new_requests.wait(timeout=0.1) + self._has_new_requests.clear() + return + self._generation_step() + batch_processor.update_batch() + + @traced + def _handle_critical_error(self, error: Exception, batch_processor: ContinuousBatchProcessor | None) -> None: + """Handle critical errors that terminate the generation loop.""" + # Record so callers (e.g. the serving layer) can fail fast on subsequent requests + # instead of enqueuing into a worker that will never drain. + self.fatal_error = error + # Signal stop + self.stop_event.set() + + # Fail pending requests in input queue + try: + while True: + req_data = self.input_queue.get_nowait() + if batch_processor is not None: + batch_processor._handle_request_error(error, req_data) + except queue.Empty: + pass + + # Fail active requests + if batch_processor is not None: + batch_processor.fail_all_requests(error) + + +class ContinuousMixin: + """Mixin class for models to add continuous batching capabilities. Continuous batching has three entry points: + - `init_continuous_batching`, which is the actual entry point for continuous batching + - `continuous_batching_context_manager`, which itself is a wrapper around `init_continuous_batching` + - `generate_batch`, which is really a wrapper around `continuous_batching_context_manager` + + They are defined in this order. Any change made to any of those three entry points should be reflected in the other + two. + """ + + generation_config: GenerationConfig + + @torch.inference_mode() + def init_continuous_batching( + self, + generation_config: GenerationConfig | None = None, + continuous_batching_config: ContinuousBatchingConfig | None = None, + workload_hints: WorkloadHints | None = None, + **deprecated_kwargs, + ) -> ContinuousBatchingManager: + """Initialize a manager for continuous batching inference. + + Args: + generation_config: An optional generation configuration, which may contain a CompileConfig object + continuous_batching_config: An optional continuous batching configuration + workload_hints: Optional WorkloadHints to help the continuous batching manager make better decisions for + default values + **deprecated_kwargs: Deprecated arguments that are now passed in the continuous_batching_config. Those are: + max_queue_size, q_padding_interval_size, kv_padding_interval_size, allow_block_sharing, + use_async_batching, max_cached_graphs + Returns: + `ContinuousBatchingManager`: The manager instance to add requests and retrieve results. + """ + # Mandatory attributes + if not hasattr(self, "config") or not hasattr(self, "device") or not hasattr(self, "dtype"): + raise AttributeError("Model must have 'config', 'device', and 'dtype' attributes.") + + # If a persistent manager is found we return it + cached_manager = getattr(self, "_cached_continuous_batching_manager", None) + if isinstance(cached_manager, ContinuousBatchingManager): + logger.info( + "Cached continuous batching manager found: it will be re-used instead of creating a new one. If you" + " want to create a new manager, you should call `destroy_cached_continuous_batching_manager` first." + ) + return cached_manager + + # Retrieve generation config + gen_config = generation_config if generation_config is not None else self.generation_config + if gen_config is None: + raise ValueError("A GenerationConfig must be provided or set in the model.") + # Warn about EOS + if gen_config.eos_token_id is None: + logger.warning("`eos_token_id` not set in GenerationConfig. Setting to -1 (disabled).") + gen_config.eos_token_id = -1 + + # Retrieve continuous batching config, or create it if none is provided + if continuous_batching_config is None: + if isinstance(getattr(gen_config, "continuous_batching_config", None), ContinuousBatchingConfig): + continuous_batching_config = gen_config.continuous_batching_config + else: + continuous_batching_config = ContinuousBatchingConfig() + continuous_batching_config.account_for_cb_deprecated_arguments(**deprecated_kwargs) + if workload_hints is not None: + workload_hints.resolve_using_hints(continuous_batching_config) + + # Create and return the manager + return ContinuousBatchingManager( + model=self, generation_config=gen_config, continuous_batching_config=continuous_batching_config + ) + + def destroy_cached_continuous_batching_manager(self) -> None: + """Destroy the cached continuous batching manager and free GPU resources.""" + cached_manager = getattr(self, "_cached_continuous_batching_manager", None) + if isinstance(cached_manager, ContinuousBatchingManager): + cached_manager.stop(block=True, timeout=None, keep_for_next_session=False) + delattr(self, "_cached_continuous_batching_manager") + + @contextmanager + @torch.inference_mode() + def continuous_batching_context_manager( + self, + generation_config: GenerationConfig | None = None, + block: bool = True, + timeout: float | None = None, + continuous_batching_config: ContinuousBatchingConfig | None = None, + persistent_manager: bool = False, + warmup: bool = True, + workload_hints: WorkloadHints | None = None, + **deprecated_kwargs, + ) -> Generator[ContinuousBatchingManager]: + """A context manager to safely use the continuous batching manager. Arguments are similar to the ones of + `init_continuous_batching`, except for: + - block: whether to block the thread when stopping the manager. Default is True. + - timeout: maximum time to wait for the thread to stop. Default is None (no timeout). + - warmup: whether to pre-capture CUDA graphs at the largest sizes before running. Default is True. + """ + manager = self.init_continuous_batching( + generation_config=generation_config, + continuous_batching_config=continuous_batching_config, + workload_hints=workload_hints, + **deprecated_kwargs, + ) + if warmup and not manager.warmed_up: + # Warmup is long (~30 sec): best to signal the user it's happening than let them think the manager is stuck + logger.warning("Warming up for continuous batching...") + start = perf_counter() + manager.warmup() + logger.warning(f"Warming up completed in {perf_counter() - start:.2f}s.") + manager.start() + try: + yield manager + finally: + # This is a dummy log needed for the logs of stop to show. It won't show. + logger.debug("Continuous batching loop finished") + manager.stop(block=block, timeout=timeout, keep_for_next_session=persistent_manager) + + # TODO: support streaming + @traced + @torch.inference_mode() + def generate_batch( + self, + inputs: list[list[int]], + generation_config: GenerationConfig | None = None, + continuous_batching_config: ContinuousBatchingConfig | None = None, + record_timestamps: bool = False, + progress_bar: bool = True, + persistent_manager: bool = False, + warmup: bool = True, + **kwargs, + ) -> dict[str, GenerationOutput]: + """Generate sequences for a batch of prompts using continuous batching. + + Args: + inputs: List of input token sequences (prompts) + generation_config: Optional generation configuration + continuous_batching_config: Optional continuous batching configuration + record_timestamps: If set to true, the requests will have a timestamp for each token generated + progress_bar: If set to true, a progress bar will be displayed + persistent_manager: whether to persist the manager after the generation is finished. Default is False. + warmup: whether to pre-capture CUDA graphs before processing requests. Default is True. + **kwargs: Additional generation parameters. Only max_new_tokens is used, but other deprecated arguments + are extracted and passed to the continuous_batching_config object. + Returns: + `dict[str, GenerationOutput]`: a dictionary of request ids to GenerationOutput objects + """ + # If no input are provided, return an empty dictionary + if not inputs: + return {} + + # If the logger level is less than DEBUG, disable the progress bar + if logger.getEffectiveLevel() <= logging.DEBUG: + logger.warning("Progress bar is disabled when logger level is less than DEBUG") + progress_bar = False + + # Extract deprecated arguments from regular kwargs (deprecated in v5.3). These args are now expected in the + # continuous_batching_config object. + deprecated_kwargs = {} + deprecated_keys = [ + "q_padding_interval_size", + "kv_padding_interval_size", + "allow_block_sharing", + "use_async_batching", + "max_cached_graphs", + "max_queue_size", + ] + for depr_key in deprecated_keys: + if depr_key in kwargs: + deprecated_kwargs[depr_key] = kwargs.pop(depr_key) + + # Compute the total number of requests + gen_cfg = self.generation_config if generation_config is None else generation_config + num_return_sequences = gen_cfg.num_return_sequences if gen_cfg.num_return_sequences is not None else 1 + num_requests = len(inputs) * num_return_sequences + + # Extract max_new_tokens from kwargs because it's the only expected kwarg + max_new_tokens = kwargs.pop("max_new_tokens", None) + max_new_tokens = gen_cfg.max_new_tokens if max_new_tokens is None else max_new_tokens + + # Compute workload hints + workload_hints = WorkloadHints( + max_prompt_length=max(len(input_ids) for input_ids in inputs), + max_generated_length=max_new_tokens if max_new_tokens is not None else 0, + ) + + # Prepare context managers for the main loop + manager_cm = self.continuous_batching_context_manager( + generation_config=generation_config, + continuous_batching_config=continuous_batching_config, + block=True, + timeout=5, + persistent_manager=persistent_manager, + warmup=warmup, + workload_hints=workload_hints, + **deprecated_kwargs, + ) + logging_cm = logging_redirect_tqdm([logger]) + pbar_cm = tqdm( + total=num_requests, + disable=(not progress_bar), + desc=f"Solving {num_requests} requests", + unit="request", + ) + + # Main loop + results = {} + finished_count = 0 + with manager_cm as manager, logging_cm, pbar_cm as pbar: + try: + manager.add_requests(inputs=inputs, max_new_tokens=max_new_tokens, record_timestamps=record_timestamps) + while finished_count < num_requests: + result = manager.get_result(timeout=1) + if result: + req_id = result.request_id + if result.is_finished(): + results[req_id] = result + finished_count += 1 + pbar.update(1) + elif not manager.is_running(): + logger.error("Generation thread terminated unexpectedly.") + # This helps get some information in stdout + print("Returning results of generate_batch despite unexpected termination.") + break + + except Exception as e: + logger.error(f"Error during batch generation: {e}", exc_info=True) + + # Re-order requests to match the order of the inputs + reordered_results = {} + for i in range(len(inputs)): + # We cannot guarantee generation success for all requests, so check if the request is in the results + result = results.get(f"req_{i}") + if result is not None: + reordered_results[f"req_{i}"] = result + else: + logger.error(f"Request req_{i} not found in results.") + return reordered_results diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/input_outputs.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/input_outputs.py new file mode 100644 index 0000000000000000000000000000000000000000..fbe7890a15b988555711306273675ff982fd7cd7 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/input_outputs.py @@ -0,0 +1,821 @@ +# Copyright 2026 The HuggingFace Inc. team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from contextlib import nullcontext +from dataclasses import dataclass +from functools import partial +from typing import Any + +import torch + +from transformers.configuration_utils import PretrainedConfig + +from ...utils import get_available_devices +from ...utils.metrics import traced +from .cache import PagedAttentionCache +from .cb_logits_processors import ContinuousBatchingLogitsProcessorList +from .requests import TMP_TOKEN_ID, FutureRequestState, logger +from .utils import CudaGraphBuffer, aligned_divide, attn_mask_is_needed, build_attention_mask, pad_to_pow2 + + +@dataclass +class PagedAttentionArgs: + """Dataclass containing the keyword arguments for a forward pass using paged attention. + + Attributes: + input_ids: Input token IDs tensor of shape `(1, total_query_tokens)`. + attention_mask: Attention mask tensor or dictionary mapping layer types to masks. Can be `None` if the + attention implementation doesn't require explicit masks. + position_ids: Position IDs tensor of shape `(1, total_query_tokens)`. + cu_seq_lens_q: Cumulative sequence lengths for queries, used for variable-length batching. + cu_seq_lens_k: Cumulative sequence lengths for keys/values. Can be a tensor or dictionary mapping layer + types (e.g., "full_attention", "sliding_attention") to tensors for hybrid models. + max_seqlen_q: Maximum query sequence length in the batch. + max_seqlen_k: Maximum key/value sequence length. Can be an int or dictionary for hybrid models. + write_index: List of tensors indicating where to write new KV states in the cache, one per attention group. + read_index: List of tensors indicating which cache positions to read from, one per attention group. + logits_indices: Tensor indicating which positions in the output should be used for next-token prediction. + cache: The [`PagedAttentionCache`] instance managing the KV cache. + block_table: Block table for paged KV cache. If provided, uses `flash_attn_with_kvcache` for fused attention + + cache update. More information in src/transformers/integrations/flash_paged.py + logits_processor_args: List of tensors containing the arguments for the logits processors, one per request. + use_cache: Whether to use caching (always `False` in continuous batching as the cache is managed externally). + """ + + input_ids: torch.Tensor + attention_mask: torch.Tensor | dict[str, torch.Tensor] | None + position_ids: torch.Tensor + cu_seq_lens_q: torch.Tensor + cu_seq_lens_k: torch.Tensor | dict[str, torch.Tensor] + max_seqlen_q: int + max_seqlen_k: int | dict[str, int] + write_index: list[torch.Tensor] + read_index: list[torch.Tensor] + logits_indices: torch.Tensor + cache: PagedAttentionCache + block_table: torch.Tensor | None + logits_processor_args: torch.Tensor + use_cache: bool = False + + def asdict(self) -> dict[str, Any]: + return { + "input_ids": self.input_ids, + "attention_mask": self.attention_mask, + "position_ids": self.position_ids, + "cu_seq_lens_q": self.cu_seq_lens_q, + "cu_seq_lens_k": self.cu_seq_lens_k, + "max_seqlen_q": self.max_seqlen_q, + "max_seqlen_k": self.max_seqlen_k, + "write_index": self.write_index, + "read_index": self.read_index, + "logits_indices": self.logits_indices, + "cache": self.cache, + "block_table": self.block_table, + "logits_processor_args": self.logits_processor_args, + "use_cache": self.use_cache, + } + + +class ContinuousBatchingIOs: + """A class to hold inputs and outputs for a continuous batching forward pass, using static tensors as storage. The + class is meant to be self-contained, so once a set of inputs have been created, the class can be used to update the + batch alone. + """ + + static_inputs: int = 7 # Number of static inputs always present in the bulk tensor + + def __init__( + self, + cache: PagedAttentionCache, + config: PretrainedConfig, + device: torch.device, + model_dtype: torch.dtype, + max_graphs: int, + return_logprobs: bool, + logit_processor: ContinuousBatchingLogitsProcessorList, + use_cuda_graph_varlen: bool = False, + ) -> None: + """Initialize the continuous batching I/O manager. Args: + - cache: The [`PagedAttentionCache`] instance managing the KV cache. Meant to be unique. + - config: The model's pretrained configuration. + - device: The device to allocate tensors on. If the device is CPU, then the memory is pinned. + - model_dtype: The data type for model computations. + - max_graphs: Maximum number of CUDA graphs to cache. Uses LRU eviction when full. + - return_logprobs: Whether to return log probabilities along with the token IDs. + - logit_processor: The [`ContinuousBatchingLogitsProcessorList`] object used to process the logits. + - use_cuda_graph_varlen: Whether CUDA graphs are enabled for the varlen (prefill) path. + """ + # Memoize attributes + self.cache = cache + self.device = device + self.config = config + self.model_dtype = model_dtype + self.use_cuda_graph_varlen = use_cuda_graph_varlen + self.sliding_window = 1 if getattr(config, "sliding_window", None) is None else config.sliding_window + self.return_logprobs = return_logprobs + # Setup input-related accumulators + self.num_q_tokens = 0 # number of query tokens in the batch. Can be padded. + self.max_kv_read = 0 # number of KV tokens read from cache (maxed across all groups). Can be padded. + self.true_batch_size = 0 + self.true_read_sizes = [0 for _ in range(cache.num_groups)] + self.true_write_sizes = [0 for _ in range(cache.num_groups)] + self.use_block_table = False # True if all requests in batch have query_length == 1 + # Setup other accumulators + self.requests_in_batch: list[FutureRequestState] = [] + self.req_id_to_new_token_position: dict[str, int] = {} # only used for async API + self.graphs: CudaGraphBuffer = CudaGraphBuffer(max_graphs) + self._trash_index = cache.trash_index + # Setup static tensors and compute stream + self._setup_static_tensors(logit_processor=logit_processor) + self._reset_static_tensors(full_reset=True) + self.compute_stream = torch.cuda.Stream(device=self.device) if device.type == "cuda" else None + + @traced(standalone=True) + def _setup_static_tensors(self, logit_processor: ContinuousBatchingLogitsProcessorList) -> None: + """Allocates static tensors for generation inputs and outputs. This is called only once at init time, to avoid + repeated allocations and enable CUDA graphs. All tensors are allocated with maximum possible sizes. + The allocated tensors are: + + - `_bulk_input_tensor`: Storage for all the small inputs: `input_ids`, `position_ids`, `cumulative_seqlens_q`, + `logits_indices`, `cumulative_seqlens_k`, `carry_over_ids`. + - `attention_mask`: Optional attention masks (only for eager/SDPA implementations) + - `write_index` and `read_index` storage: Cache indexing tensors for each attention group + - `output_ids`: Storage for generated token IDs and maybe log probabilities if return_logprobs is True + """ + num_groups = self.cache.num_groups + max_batch_tokens = self.cache.max_batch_tokens + num_pages = self.cache.num_blocks * self.cache.block_size + # Pin memory on CPU only when an accelerator is available, to speed up H2D transfers + pin_memory = self.device.type == "cpu" and len(get_available_devices()) > 1 + + # Small inputs are allocated as slices in a larget tensor aligned to 128 bytes (32 * 4b). This reduces the + # reduces fragmentation, so it lowers the number of D2H transfers and speeds up transfers. + bulk_lines = self.static_inputs + logit_processor.tensors_required + bulk_columns = aligned_divide(max_batch_tokens + 1, 1, 32) + self._bulk_input_tensor = torch.empty( + (bulk_lines, bulk_columns), dtype=torch.int32, device=self.device, pin_memory=pin_memory + ) + # Prepare a tensor to hold the default values for the logits processors + self.logits_processors_defaults = torch.empty( + (logit_processor.tensors_required, 1), dtype=torch.int32, device=self.device + ) + logit_processor.fill_defaults(self.logits_processors_defaults) + + self.input_ids = self._bulk_input_tensor[0, :max_batch_tokens] + self.position_ids = self._bulk_input_tensor[1, :max_batch_tokens] + self.cumulative_seqlens_q = self._bulk_input_tensor[2, : max_batch_tokens + 1] + self.logits_indices = self._bulk_input_tensor[3, :max_batch_tokens] + full_attention_cumulative_seqlens_k = self._bulk_input_tensor[4, : max_batch_tokens + 1] + sliding_attention_cumulative_seqlens_k = self._bulk_input_tensor[5, : max_batch_tokens + 1] + self.carry_over_ids = self._bulk_input_tensor[6, :max_batch_tokens] # only used for async API + + # For sequence length of KV, the entries in the dict depend on the model + self.cumulative_seqlens_k: dict[str, torch.Tensor] = {} + if self.cache.num_full_attention_groups: + self.cumulative_seqlens_k["full_attention"] = full_attention_cumulative_seqlens_k + if self.cache.num_sliding_attention_groups: + self.cumulative_seqlens_k["sliding_attention"] = sliding_attention_cumulative_seqlens_k + + # Output tensor and scalars + num_output_rows = 2 if self.return_logprobs else 1 + self.output_ids = torch.empty( + (num_output_rows, max_batch_tokens + 1), dtype=torch.int32, device=self.device, pin_memory=pin_memory + ) + # Last output token is never changed and set to 0 for async carry on purpose + self.output_ids.zero_() + self.total_seqlen_q = 0 + self.max_seqlen_q = 0 + self.max_seqlen_k = dict.fromkeys(self.cumulative_seqlens_k.keys(), 0) + + # If the attention mask is needed, it is allocated separately + if attn_mask_is_needed(self.config): + self.attention_mask = {} + for layer_type in self.cumulative_seqlens_k.keys(): + self.attention_mask[layer_type] = torch.empty( + size=(1, 1, max_batch_tokens, num_pages + max_batch_tokens), + dtype=self.model_dtype, + device=self.device, + pin_memory=pin_memory, + ) + else: + self.attention_mask = None + + # No block table == No elements in the block table tensor + n = num_groups if self.cache.max_blocks_per_request > 0 else 0 + self.block_table = torch.empty( + (n, max_batch_tokens, self.cache.max_blocks_per_request), + dtype=torch.int32, + device=self.device, + pin_memory=pin_memory, + ) + + # For other kwargs, we need a list of tensors with as many tensors as there are groups + self.write_index_storage = torch.empty( + (num_groups, max_batch_tokens), dtype=torch.int64, device=self.device, pin_memory=pin_memory + ) + self.read_index_storage = torch.empty( + (num_groups, num_pages + max_batch_tokens), dtype=torch.int64, device=self.device, pin_memory=pin_memory + ) + # For read index, the +T is because there are sentinel indices for seqlen_q when model uses a sliding window + + def _transfer_inputs( + self, other: "ContinuousBatchingIOs", stream: torch.cuda.Stream, non_blocking: bool = False + ) -> None: + # Transfer accumulators + other.num_q_tokens = self.num_q_tokens + other.max_kv_read = self.max_kv_read + other.true_batch_size = self.true_batch_size + other.true_read_sizes = self.true_read_sizes[:] + other.true_write_sizes = self.true_write_sizes[:] + other.use_block_table = self.use_block_table + # Transfer scalar attributes + other.total_seqlen_q = self.total_seqlen_q + other.max_seqlen_q = self.max_seqlen_q + other.max_seqlen_k = dict(self.max_seqlen_k.items()) + # Transfer static tensors + maybe_stream = torch.cuda.stream(stream) if stream is not None else nullcontext() + with maybe_stream: + other._bulk_input_tensor.copy_(self._bulk_input_tensor, non_blocking=non_blocking) # fast bulk transfer + # Only transfer block_table for decode-only batches (when it's actually used) + if self.use_block_table: + other.block_table.copy_(self.block_table, non_blocking=non_blocking) + # Otherwise, we transfer the write indices (and read indices if the batch uses any cache reads) + else: + other.write_index_storage.copy_(self.write_index_storage, non_blocking=non_blocking) + if self.max_kv_read > 0: + other.read_index_storage.copy_(self.read_index_storage, non_blocking=non_blocking) + # Transfer the attention masks if needed + if self.attention_mask is not None and other.attention_mask is not None: + for layer_type in self.attention_mask.keys(): + other.attention_mask[layer_type].copy_(self.attention_mask[layer_type], non_blocking=non_blocking) + + @traced + @torch.no_grad() + def _reset_static_tensors(self, full_reset: bool = False) -> None: + """Reset static tensors for the next batch. For efficiency, this only resets the portions of tensors that were + actually used in the previous batch, using the attributes num_q_tokens and max_kv_read. If a (full_reset) + is requested, the entire tensor storage is reset. + """ + # Compute the slice to reset + q_len = self.write_index_storage.size(-1) if full_reset else self.num_q_tokens + kv_len = self.read_index_storage.size(-1) if full_reset else self.max_kv_read + + # Reset the attributes part of the bulk input tensor in one kernel + self._bulk_input_tensor[: self.static_inputs, : q_len + 1].zero_() + if full_reset: + self._bulk_input_tensor[self.static_inputs :] = self.logits_processors_defaults + self.max_seqlen_q = 0 + + # Reset the logits indices and output ids + self.logits_indices[:q_len].zero_() + self.output_ids[:, :q_len].zero_() + + # Reset the attributes that are either tensors or dict of tensors + for layer_type in self.cumulative_seqlens_k: + self.max_seqlen_k[layer_type] = 0 + if self.attention_mask is not None: + self.attention_mask[layer_type][:, :, :q_len, : q_len + kv_len].fill_( + torch.finfo(self.model_dtype).min + ) + + # If this is a full reset, we reset every tensors + if full_reset: + self.block_table[:, :q_len].fill_(-1) + self.write_index_storage[:, :q_len].fill_(self._trash_index) + self.read_index_storage[:, : q_len + kv_len].fill_(self._trash_index) + # If this is not a full reset, and we are going to use the block table, we only reset it + elif self.use_block_table: + self.block_table[:, :q_len].fill_(-1) + # Otherwise, the read and write indices are the ones used, so we reset them + else: + self.write_index_storage[:, :q_len].fill_(self._trash_index) + self.read_index_storage[:, : q_len + kv_len].fill_(self._trash_index) + + def reset(self) -> None: + """Reset all relevant states for a new generation loop.""" + self._reset_static_tensors(full_reset=True) + self.requests_in_batch = [] + self.req_id_to_new_token_position = {} + if self.compute_stream is not None: + self.compute_stream.synchronize() + + # These getter function help create a common interface for the sync and async IOs + def get_cumulative_seqlens(self) -> tuple[torch.Tensor, dict[str, torch.Tensor]]: + """Get the cumulative sequence lengths for the current batch.""" + return self.cumulative_seqlens_q, self.cumulative_seqlens_k + + def carry_over_tokens( + self, input_ids: torch.Tensor, carry_over_ids: torch.Tensor, prev_output_ids: torch.Tensor + ) -> None: + pass + + def retrieve_device_outputs(self) -> None: + if self.compute_stream is not None: + self.compute_stream.synchronize() + + def prepare_batch_update(self) -> tuple[list[FutureRequestState], list[int], list[float] | None]: + requests_in_batch = self.requests_in_batch + new_tokens = self.output_ids[0, : len(self.requests_in_batch)].tolist() + # If logprobs are generated, we retrieve them from the output tensor and cast them to the right dtype + if self.return_logprobs: + logprobs = self.output_ids[1, : len(self.requests_in_batch)].view(dtype=torch.float32).tolist() + # Otherwise, we can return an empty list because they wont be used + else: + logprobs = None + return requests_in_batch, new_tokens, logprobs + + @traced + def prepare_batch_tensors( + self, + requests_in_batch: list[FutureRequestState], + logits_processors: ContinuousBatchingLogitsProcessorList, + use_decode_fast_path: bool, + num_q_tokens: int, + max_kv_read: int, + ) -> None: + """Prepare tensors and metadata for the next model forward pass, using the given requests as data. This method: + + 1. Resets the static tensors from the previous batch + 2. Iterates through requests to accumulate input_ids, position_ids, and sequence lengths + 3. Extends read/write indices for cache management + 4. Builds attention masks if needed (for eager/SDPA implementations) + 5. Converts accumulated lists to tensors and copies them to static storage + + This method also modifies the `position_offset` attribute of each request to track progress and adds a + temporary token at the end of the requests for which there will a new token. + """ + # Keep track of this requests in the batch, which will be useful to update the batch later + if not requests_in_batch: + raise ValueError("No requests in batch") + + # Determine if the block table is used before we start to prepare the batch, to avoid useless preparation + self.use_block_table = use_decode_fast_path and self.block_table.numel() > 0 + # Memoize the length of Q and KV + self.num_q_tokens = num_q_tokens + self.max_kv_read = 0 if self.use_block_table else max_kv_read # No need to track KV read for decode-fast-path + self.true_batch_size = len(requests_in_batch) + # Reset the static storage that is going to be used for the next batch + self._reset_static_tensors() + + # Reset accumulators + self.true_read_sizes = [0 for _ in range(self.cache.num_groups)] + self.true_write_sizes = [0 for _ in range(self.cache.num_groups)] + self.requests_in_batch = [] + self.req_id_to_new_token_position = {} + + # Prepare accumulators. For batches with no past cache to read, we leave read_index empty: the cache.update + # will detect the 0-size indices and skip the read. + input_ids = [] + position_ids = [] + cumulative_seqlens_q = [0] + logits_indices = [] + cumulative_seqlens_k = {layer_type: [0] for layer_type in self.cumulative_seqlens_k.keys()} + write_index = [[] for _ in range(self.cache.num_groups)] + read_index = None if self.max_kv_read == 0 else [[] for _ in range(self.cache.num_groups)] + + # Go through all the requests in the batch + for i, future_state in enumerate(requests_in_batch): + # First we retrieve the lengths related to the request + state = future_state.state + past_length = state.position_offset + query_length = future_state.query_length + seqlens_k = self.cache.get_seqlens_k(past_length, query_length) + + # Update the internal state of the request + state.position_offset += query_length + + # Then we accumulate for the object used in the kwargs + input_ids.extend(state.tokens_to_process) + position_ids.extend(range(past_length, past_length + query_length)) + cumulative_seqlens_q.append(cumulative_seqlens_q[-1] + query_length) + self.max_seqlen_q = max(self.max_seqlen_q, query_length) + + # Accumulate the key sequence lengths for the current request + for layer_type, layer_type_seqlen_k in seqlens_k.items(): + cumulative_seqlens_k[layer_type].append(cumulative_seqlens_k[layer_type][-1] + layer_type_seqlen_k) + self.max_seqlen_k[layer_type] = max(self.max_seqlen_k[layer_type], layer_type_seqlen_k) + + # We extend the read and write indices for the cache, or fill the block table for decode-only batches + if self.use_block_table: + self.cache.fill_block_table(state.request_id, past_length, query_length, self.block_table[:, i]) + else: + self.cache.extend_read_and_write_indices( + state.request_id, past_length, query_length, read_index, write_index + ) + + # If the request has no remaining prefill tokens, it means the next token prediction is relevant + if future_state.has_new_token: + logits_indices.append(cumulative_seqlens_q[-1] - 1) + state.tokens_to_process = [TMP_TOKEN_ID] + self.req_id_to_new_token_position[state.request_id] = logits_indices[-1] + + self.requests_in_batch.append(future_state) + + # Also prepare the tensor arguments for the logits processors + logits_processors.prepare_tensor_args( + requests_in_batch=requests_in_batch, + arg_storage=self._bulk_input_tensor[self.static_inputs :], + ) + + # When looping over request is done, we can build the actual tensors. This is faster than modifying the static + # tensors inside the loop. + to_tensor = partial(torch.tensor, dtype=torch.int32, device=self.device) + + # Those kwargs always have the same type regardless of the model + self.input_ids[: len(input_ids)] = to_tensor(input_ids) + self.position_ids[: len(position_ids)] = to_tensor(position_ids) + self.cumulative_seqlens_q[: len(cumulative_seqlens_q)] = to_tensor(cumulative_seqlens_q) + self.logits_indices[: len(logits_indices)] = to_tensor(logits_indices) + self.total_seqlen_q = cumulative_seqlens_q[-1] + + # Those kwargs are either dict of tensors or tensors, so we need to handle both cases + for layer_type, layer_type_seqlens_k in cumulative_seqlens_k.items(): + self.cumulative_seqlens_k[layer_type][: len(layer_type_seqlens_k)] = to_tensor(layer_type_seqlens_k) + if self.attention_mask is not None: + build_attention_mask( + attention_mask=self.attention_mask[layer_type], + cumulative_seqlens_q=cumulative_seqlens_q, + cumulative_seqlens_k=layer_type_seqlens_k, + sliding_window=self.sliding_window if layer_type == "sliding_attention" else 1, + ) + + # If we are not using the block table, we populate the write indices (and maybe the read indices) + if not self.use_block_table: + to_index_tensor = partial(torch.tensor, dtype=torch.int64, device=self.device) + for i, group_write_indices in enumerate(write_index): + self.write_index_storage[i, : len(group_write_indices)] = to_index_tensor(group_write_indices) + self.true_write_sizes[i] = len(group_write_indices) + if read_index is not None: + for i, group_read_indices in enumerate(read_index): + self.read_index_storage[i, : len(group_read_indices)] = to_index_tensor(group_read_indices) + self.true_read_sizes[i] = len(group_read_indices) + + def get_model_kwargs(self, use_padding: bool = False) -> dict[str, Any]: + """Get model keyword arguments for the current batch, eventually padding the query dimension and KV dimensions + if use_padding is True. The padding is only useful if we want static shapes, like when using cuda graphs.""" + q_size = self.num_q_tokens + kv_size = self.max_kv_read + self.num_q_tokens + batch_size = self.num_q_tokens if use_padding else self.true_batch_size + + # Prepare the kwargs, the attributes that are either tensors or dict of tensors are initialized to empty dicts. + kwargs = PagedAttentionArgs( + input_ids=self.input_ids[:q_size].unsqueeze(0), + position_ids=self.position_ids[:q_size].unsqueeze(0), + cu_seq_lens_q=self.cumulative_seqlens_q[: batch_size + 1], + max_seqlen_q=self.max_seqlen_q, + logits_indices=self.logits_indices[:q_size], + logits_processor_args=self._bulk_input_tensor[self.static_inputs :, :q_size], + cu_seq_lens_k={}, + max_seqlen_k={}, + attention_mask=None if self.attention_mask is None else {}, + read_index=[], + write_index=[], + cache=self.cache, + block_table=self.block_table[:, :batch_size] if self.use_block_table else None, + use_cache=False, + ) + + # If there is padding, make sure the padding sequences have length 0 (ie. cumulative lengths plateau) + if use_padding: + kwargs.cu_seq_lens_q[self.true_batch_size + 1 :] = self.total_seqlen_q + # Additionally, if there are CUDA graphs, we need to pad max_seqlen so graph capture will work regardless of + # the future Q / KV lengths of the next batches + if not self.use_block_table and self.use_cuda_graph_varlen: + self.max_seqlen_q = q_size + self.max_seqlen_k = { + layer_type: pad_to_pow2(self.max_seqlen_k[layer_type], self.cache.num_pages, 1024) + for layer_type in self.max_seqlen_k.keys() + } + + # When using block table, max_seqlen_q and max_seqlen_k are not used by flash_attn_with_kvcache, so we set them + # to constant `1` to avoid dynamo guards on these changing integer values. This applies throughout this method. + kwargs.max_seqlen_q = 1 if self.use_block_table else self.max_seqlen_q + + # For the attributes that are lists of tensors, we construct list of tensor references + for i in range(self.cache.num_groups): + write_index_size = q_size if use_padding else self.true_write_sizes[i] + kwargs.write_index.append(self.write_index_storage[i, :write_index_size]) + # If there is no cache to read, pass a list of empty tensors so `cache.update` uses the write-only fast path + if self.max_kv_read == 0: + read_index_size = 0 + else: + read_index_size = kv_size if use_padding else self.true_read_sizes[i] + kwargs.read_index.append(self.read_index_storage[i, :read_index_size]) + + # For the attributes that are dict of tensors, we first fill the dict with the actual values + for layer_type, seqlens_k in self.cumulative_seqlens_k.items(): + kwargs.cu_seq_lens_k[layer_type] = seqlens_k[: batch_size + 1] + if use_padding: + kwargs.cu_seq_lens_k[layer_type][self.true_batch_size + 1 :] = seqlens_k[self.true_batch_size] + kwargs.max_seqlen_k[layer_type] = 1 if self.use_block_table else self.max_seqlen_k[layer_type] + if self.attention_mask is not None: + k_len = kv_size if use_padding else seqlens_k[batch_size] + kwargs.attention_mask[layer_type] = self.attention_mask[layer_type][..., :q_size, :k_len] + + # If there is only one layer type, we remove the dicts around some attributes to avoid unnecessary overhead + if len(self.cumulative_seqlens_k.keys()) == 1: + kwargs.cu_seq_lens_k = kwargs.cu_seq_lens_k.popitem()[1] # type: ignore + kwargs.max_seqlen_k = kwargs.max_seqlen_k.popitem()[1] # type: ignore + if self.attention_mask is not None: + kwargs.attention_mask = kwargs.attention_mask.popitem()[1] # type: ignore + + return kwargs.asdict() # TODO: this is imperfect, check if there is no better way to juggle dict / dataclass + + def get_cb_kwargs(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Returns the tensors used inside the generation step that are not inputs to the model forward pass. In + synchronous batching, there is no carry over, so the only tensor that will be used is output_ids, but we still + return 3 tensors to have the same interface as when using async batching.""" + return self.carry_over_ids, self.output_ids, self.output_ids + + def _get_graph_key(self) -> tuple[int, ...]: + # Keys for decode fast path + if self.use_block_table: + return (self.num_q_tokens,) + # Keys for varlen path + return (self.num_q_tokens, self.max_kv_read, *self.max_seqlen_k.values()) + + def get_graph(self) -> torch.cuda.CUDAGraph | None: + key = self._get_graph_key() + graph = self.graphs.get_graph(key) + # If this point is reached, it means the next step will be a new graph capture + if graph is None: + self.graphs.plan_for_new_graph() + logger.info(f"Creating graph for {key = }") + return graph + + def set_graph(self, graph: torch.cuda.CUDAGraph) -> None: + key = self._get_graph_key() + self.graphs.set_graph(key, graph) + logger.info(f"Setting graph for {key = }") + + +class HostDeviceIOPair: + def __init__( + self, + cache: PagedAttentionCache, + config: PretrainedConfig, + device: torch.device, + model_dtype: torch.dtype, + max_graphs: int, + return_logprobs: bool, + logit_processor: ContinuousBatchingLogitsProcessorList, + use_cuda_graph_varlen: bool = False, + ) -> None: + # The host IO has automatic pinned memory because it is created on the CPU + self.host_io = ContinuousBatchingIOs( + cache, + config, + torch.device("cpu"), + model_dtype, + max_graphs, + return_logprobs, + logit_processor, + use_cuda_graph_varlen, + ) + self.device_io = ContinuousBatchingIOs( + cache, + config, + device, + model_dtype, + max_graphs, + return_logprobs, + logit_processor, + use_cuda_graph_varlen, + ) + # Create events only on CUDA devices + self.h2d_over = torch.cuda.Event() if torch.cuda.is_available() else None + self.compute_over = torch.cuda.Event() if torch.cuda.is_available() else None + self.d2h_over = torch.cuda.Event() if torch.cuda.is_available() else None + + def reset(self) -> None: + self.host_io.reset() + self.device_io.reset() + for event in [self.h2d_over, self.compute_over, self.d2h_over]: + if event is not None: + event.synchronize() + + def transfer_inputs_h2d(self, stream: torch.cuda.Stream) -> None: + self.host_io._transfer_inputs(self.device_io, stream=stream, non_blocking=True) + + def transfer_outputs_d2h(self, stream: torch.cuda.Stream | None) -> None: + maybe_stream = torch.cuda.stream(stream) if stream is not None else nullcontext() + with maybe_stream: + self.host_io.output_ids.copy_(self.device_io.output_ids, non_blocking=True) + + +class ContinuousBatchingAsyncIOs: + """A class to handle the inputs and outputs for the asynchronous API. It uses two IO pairs to avoid race conditions + between the two batches, which means twice as more VRAM is used for static input tensors and CUDA graph. If your GPU + is large enough or you want to generate long sequences, this is a good trade-off to make. + + Asynchronous batching works by creating two pairs of host - device inputs and ouputs: + + inputs + ┌──────────┐ ────────► ┌────────────┐ + IO pair object: │ Host IOs │ │ Device IOs │ (for a CUDA sytem, Host = CPU and Device = GPU) + └──────────┘ ◄──────── └────────────┘ + outputs + + Each pair is separate from the other. This means that each pairs has its own CUDA graphs set, because CUDA graphs + need to have static adresses for input tensors. To have a unique set of CUDA graph, we would need to copy the input + tensors to a third device-side buffer. This could limit the memory cost of CUDA graphs but would slow down the + forward pass. + But the CUDA streams orchestrating the transfer from host to device (H2D) and device to host (D2H) are the same for + both pairs. Same for the compute stream. + The order of steps in async batching looks like this (for 3 batches of compute): + + │ ┌────┬────┐ ┌────┬────┐ ┌────┬────┐ ┌────┐ ┌────┐ + CPU │ │PR 0│PR 1│ │UP 0│PR 2│ │UP 1│PR 3│ │UP 2│ │UP 3│ + │ └────┼───┬┴──┐ └────┴────┼───┐ └────┴────┼───┐ └────┘ └────┘ + H2D │ │0->│1->│ ¦ │2->│ ¦ │3->│ ¦ ¦ + │ └───┼───┴───────────┬─────────────┴─┬─┼───────────┴───┼───────────────┐ ¦ + GPU │ │ COMPUTE 0 │ COMPUTE 1 │█│ COMPUTE 2 │ COMPUTE 3 │ ¦ + │ └───────────────┼───┬───────────┼─┴─┬─────────────┼───┬───────────┼───┤ + D2H │ │0<-│ │1<-│ │2<-│ │3<-│ + │ └───┘ └───┘ └───┘ └───┘ + + with: - CPU: actions happening on the CPU (host-side) + - GPU: actions happening on the GPU (device-side) + - H2D: host to device transfer + - D2H: device to host transfer + and: + - PR N: preparation of batch N + - ->N: host to device transfer of batch N + - COMPUTE N: compute step for batch N + - <-N: device to host transfer of batch N + - UP N: update of batch N + + You can see that the GPU is almost always busy, except where the █ is. + Proper ordering of steps is ensured through the use of CUDA events and streams. + """ + + def __init__( + self, + cache: PagedAttentionCache, + config: PretrainedConfig, + device: torch.device, + model_dtype: torch.dtype, + max_graphs: int, + return_logprobs: bool, + logit_processor: ContinuousBatchingLogitsProcessorList, + use_cuda_graph_varlen: bool = False, + ) -> None: + # Async batching needs streams to function, so check is CUDA is available + if not torch.cuda.is_available(): + raise RuntimeError(f"Async batching requires CUDA, but {torch.cuda.is_available() = }") + # IO pairs used to avoid race conditions + self.current_pair = 0 + self.io_pairs = [ + HostDeviceIOPair( + cache, + config, + device, + model_dtype, + max_graphs, + return_logprobs, + logit_processor, + use_cuda_graph_varlen, + ) + for _ in range(2) + ] + # CUDA streams + self.h2d_stream = torch.cuda.Stream(device=device) + self.d2h_stream = torch.cuda.Stream(device=device) + self.compute_stream = torch.cuda.Stream(device=device) + # Set all unused compute streams to None + self.io_pairs[0].host_io.compute_stream = None + self.io_pairs[0].device_io.compute_stream = None + self.io_pairs[1].host_io.compute_stream = None + self.io_pairs[1].device_io.compute_stream = None + # Used in carry over ids computation + self.max_batch_tokens = cache.max_batch_tokens + + # These methods are simple wrapper dispatching to the current IO pair + def get_cumulative_seqlens(self) -> tuple[torch.Tensor, dict[str, torch.Tensor]]: + return self.io_pairs[self.current_pair].host_io.get_cumulative_seqlens() + + # The prepare_batch_tensor method also has to prepare the carry over ids + def prepare_batch_tensors( + self, + requests_in_batch: list[FutureRequestState], + logits_processors: ContinuousBatchingLogitsProcessorList, + use_decode_fast_path: bool, + num_q_tokens: int, + max_kv_read: int, + ) -> None: + io_pair = self.io_pairs[self.current_pair] + io_pair.host_io.prepare_batch_tensors( + requests_in_batch, logits_processors, use_decode_fast_path, num_q_tokens, max_kv_read + ) + io_pair.host_io.carry_over_ids.copy_(self.infer_carry_over_ids()) + + def infer_carry_over_ids(self) -> torch.Tensor: + """Infers the ids of the tokens to carry over from batch N to batch N+1. In asynchronous batching mode, we can + schedule a request for batch N+1 without knowing the token predicted for that request in batch N. For that + reason, we might need to carry over tokens just predicted in batch N before launching the forwar pass of batch + N+1. This method computes the ids of the tokens to carry over.""" + next_req_id_to_new_token_position = self.io_pairs[self.current_pair].host_io.req_id_to_new_token_position + prev_req_id_to_new_token_position = self.io_pairs[1 - self.current_pair].host_io.req_id_to_new_token_position + carry_over_ids = [-1 for _ in range(self.max_batch_tokens)] + # Carry over happens after the raw predictions have been indexed with logits_indices. So output_ids contains the + # a sequence of contiguous new tokens in the order the request were added to the batch. Eg: + # output_ids = [new_tok_req3, new_tok_req1, new_tok_req2] + # Since it's also the order of req_id_to_new_token_position, we just iterate over the old positions and look for + # a request_id match: if there is one, we carry the predicted token over to its new position. + for i, req_id in enumerate(prev_req_id_to_new_token_position.keys()): + new_token_position = next_req_id_to_new_token_position.get(req_id) + if new_token_position is not None: + carry_over_ids[new_token_position] = i + return torch.tensor(carry_over_ids, dtype=torch.int32) + + # The get_model_kwargs method is where the H2D transfer happens + def get_model_kwargs(self, use_padding: bool = False) -> dict[str, Any]: + io_pair = self.io_pairs[self.current_pair] + io_pair.transfer_inputs_h2d(self.h2d_stream) + self.h2d_stream.record_event(io_pair.h2d_over) + self.compute_stream.wait_event(io_pair.h2d_over) + return io_pair.device_io.get_model_kwargs(use_padding=use_padding) + + def get_cb_kwargs(self) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """Returns the tensors used inside the generation step that are not inputs to the model forward pass. Those + tensors could be retrieved using this object, but it would trigger a recompile if using torch.compile. They are: + - output_ids: the output ids of the current batch + - prev_output_ids: the output ids of the previous batch, required to carry over outputs tokens of the previous + batch to the input tokens of the next batch. + - carry_over_ids: a mask representing how to carry over tokens. + """ + current_pair = self.io_pairs[self.current_pair] + previous_pair = self.io_pairs[1 - self.current_pair] + return ( + current_pair.device_io.carry_over_ids, + previous_pair.device_io.output_ids, + current_pair.device_io.output_ids, + ) + + def carry_over_tokens( + self, input_ids: torch.Tensor, carry_over_ids: torch.Tensor, prev_output_ids: torch.Tensor + ) -> None: + """As explained in the infer_carry_over_ids method, we might need to carry over tokens just predicted in batch N + before launching the forwar pass of batch N+1. This method performs the carry over, and is recorded in CUDA + graphs if they are enabled.""" + # Compute tokens to carry over and the corresponding mask + carried_over_ids = prev_output_ids[0, carry_over_ids] + carried_over_mask = (carry_over_ids != -1).int() + # Truncate everything to the right size + carried_over_ids = carried_over_ids[: input_ids.size(1)] + carried_over_mask = carried_over_mask[: input_ids.size(1)] + # Perform the carry over + input_ids[0] = carried_over_ids * carried_over_mask + input_ids[0] * (1 - carried_over_mask) + + # This is called during compute, so we always pick the device IO in the IO pair + @property + def output_ids(self) -> torch.Tensor: + # The output ids are used to copy_ the infered tokens: they need to be on the device + return self.io_pairs[self.current_pair].device_io.output_ids + + def get_graph(self) -> torch.cuda.CUDAGraph | None: + return self.io_pairs[self.current_pair].device_io.get_graph() + + def set_graph(self, graph: torch.cuda.CUDAGraph) -> None: + self.io_pairs[self.current_pair].device_io.set_graph(graph) + + @property + def use_block_table(self) -> bool: + return self.io_pairs[self.current_pair].host_io.use_block_table + + # The retrieve_device_outputs method is where the D2H transfer happens AND where we switch IO pair + def retrieve_device_outputs(self) -> None: + io_pair = self.io_pairs[self.current_pair] + # Wait for compute to finish before starting D2H transfer + self.compute_stream.record_event(io_pair.compute_over) + self.d2h_stream.wait_event(io_pair.compute_over) + # Transfer the outputs to the host + io_pair.transfer_outputs_d2h(self.d2h_stream) + self.d2h_stream.record_event(io_pair.d2h_over) + # Switch IO pair + self.current_pair = 1 - self.current_pair + + # This method is called after the switch and not during the first batch + def prepare_batch_update(self) -> tuple[list[FutureRequestState], list[int], list[float] | None]: + io_pair = self.io_pairs[self.current_pair] + io_pair.d2h_over.synchronize() # ty:ignore[unresolved-attribute] <- this is always a CUDA event + return io_pair.host_io.prepare_batch_update() + + def reset(self) -> None: + """Reset all state for a new generation session. Used in persistent mode between sessions.""" + self.current_pair = 0 + for io_pair in self.io_pairs: + io_pair.reset() + self.h2d_stream.synchronize() + self.d2h_stream.synchronize() + self.compute_stream.synchronize() diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/offloading_manager.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/offloading_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..3f257fa92a682fdebe96b35165c71bf5f1947423 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/offloading_manager.py @@ -0,0 +1,307 @@ +# Copyright 2026 The HuggingFace Inc. team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +"""Centralized offloading logic for continuous batching. + +Handles two offloading strategies when the GPU KV cache is full: + 1. CPU offloading: copy the KV cache to a pre-allocated pinned CPU buffer, preserving exact request state. + 2. Soft reset: discard the KV cache and re-prefill from scratch when the request is re-scheduled. This incurs no data + transfer overhead, but we need to re-run prefill over all intial + generated tokens (so more compute overhead). + +The CPU swap pool is a static set of pinned tensors allocated once at init (like vLLM/SGLang). Blocks are tracked +with a simple free set — no dynamic allocation or deallocation of tensors ever happens at runtime. +""" + +from collections import deque +from contextlib import nullcontext + +import torch + +from ...utils import is_psutil_available +from .cache import PagedAttentionCache +from .requests import FutureRequestState, RequestState, RequestStatus, logger +from .scheduler import Scheduler + + +class OffloadingManager: + """Manages request offloading and restoration for continuous batching. + + Owns a static CPU swap pool (pre-allocated pinned tensors mirroring the GPU cache layout), performs GPU↔CPU block + copies, decides between CPU offloading and soft reset, and ensures cleanup on cancellation/failure/reset. + """ + + def __init__( + self, + cache: PagedAttentionCache, + scheduler: Scheduler, + cpu_offload_space_gib: float | None, + safety_threshold: float, + compute_stream: torch.cuda.Stream | None, + ) -> None: + self.cache = cache + self.scheduler = scheduler + # All offloading transfers run on the compute stream (stream-ordered, like the fork copy path) + self._compute_stream = compute_stream + + # Bookkeeping defaults, valid whether or not the pool is allocated + self._cpu_key_cache: list[torch.Tensor] = [] + self._cpu_value_cache: list[torch.Tensor] = [] + self._gpu_key_views: list[torch.Tensor] = [] + self._gpu_value_views: list[torch.Tensor] = [] + self._free_cpu_blocks: deque[int] = deque() + self._request_id_to_cpu_blocks: dict[str, list[int]] = {} + self._request_id_to_group_block_counts: dict[str, list[int]] = {} + + # Compute the size of the CPU swap pool in blocks + self._num_cpu_blocks = self._compute_num_cpu_blocks(cpu_offload_space_gib, safety_threshold) + offloading_enabled = cpu_offload_space_gib is not None and cpu_offload_space_gib > 0 + if self._num_cpu_blocks == 0: + if offloading_enabled: + logger.warning( + f"cpu_offload_space={cpu_offload_space_gib:.1f} GiB is too small for even one block. " + "No CPU offloading." + ) + return None + + # Allocate the CPU swap pool + cpu_cache_shape = (self._num_cpu_blocks, cache.block_size, cache.num_key_value_heads, cache.head_dim) + for _ in cache.key_cache: + self._cpu_key_cache.append(torch.empty(cpu_cache_shape, dtype=cache.dtype, pin_memory=True)) + self._cpu_value_cache.append(torch.empty(cpu_cache_shape, dtype=cache.dtype, pin_memory=True)) + + # Pre-view the GPU cache tensors as block-shaped so the hot copy paths avoid per-op .view() calls + block_shape = (-1, cache.block_size, cache.num_key_value_heads, cache.head_dim) + for k_cache, v_cache in zip(cache.key_cache, cache.value_cache): + self._gpu_key_views.append(k_cache.view(*block_shape)) + self._gpu_value_views.append(v_cache.view(*block_shape)) + + # FIFO order favors contiguity when blocks are returned in bulk + self._free_cpu_blocks = deque(range(self._num_cpu_blocks)) + + # Reusable int32 scratch for cpu_ids / gpu_ids (bounded by _num_cpu_blocks on both paths) + self._cpu_ids_scratch = torch.empty(self._num_cpu_blocks, dtype=torch.int32, pin_memory=True) + self._gpu_ids_scratch = torch.empty(self._num_cpu_blocks, dtype=torch.int32, device=cache.device) + + # Log the size of the CPU swap pool + cache_tensor = self._cpu_key_cache[0] + size_in_bytes = 2 * cache_tensor.numel() * cache_tensor.element_size() * len(cache.key_cache) + logger.info( + f"CPU swap pool initialized: {self._num_cpu_blocks} blocks ({size_in_bytes / (1024**3):.2f} GiB pinned)" + ) + + def _compute_num_cpu_blocks(self, cpu_offload_space_gib: float | None, safety_threshold: float) -> int: + """Returns the number of blocks that can fit in the CPU swap pool.""" + # Compute the CPU pool size in bytes + offload_bytes = int(cpu_offload_space_gib * (1024**3)) if cpu_offload_space_gib is not None else None + + # Determine the maximum number of bytes that can be offloaded based on the safety threshold + if is_psutil_available(): + import psutil + + total_ram = psutil.virtual_memory().available + max_bytes = int(total_ram * safety_threshold) + else: + max_bytes = None + + # If both the request number of bytes and its limit are not None, we just clamp one to the other + if offload_bytes is not None and max_bytes is not None: + if offload_bytes > max_bytes: + clamped_gib = max_bytes / (1024**3) + logger.warning( + f"cpu_offload_space={cpu_offload_space_gib:.1f} GiB exceeds {safety_threshold:.0%} of total RAM " + f"({total_ram / (1024**3):.1f} GiB). Clamping to {clamped_gib:.1f} GiB." + ) + offload_bytes = max_bytes + # Else if the max is None, throw a warning and accept the requested number of bytes as is + elif offload_bytes is not None: + logger.warning( + "psutil is not available — cpu_offload_space_safety_threshold cannot be enforced. " + "Install psutil to enable the safety cap." + ) + # Else if the requested number of bytes is None, we use the max number of bytes as the requested number of bytes + elif max_bytes is not None: + offload_bytes = max_bytes + logger.warning(f"Auto-sizing CPU swap pool from safety threshold: {max_bytes / (1024**3):.2f} GiB.") + # Otherwise, it means the pool was supposed to be sized using psutil but it is not available + else: + raise ImportError( + "cpu_offload_space=None requires psutil to auto-size the CPU swap pool. Install psutil or pass an " + "explicit GiB value." + ) + + # Compute how many blocks fit in CPU pool + bytes_per_block = ( + 2 # one for key, one for value + * len(self.cache.key_cache) # number of layers in a layer group + * self.cache.block_size # block size + * self.cache.num_key_value_heads # number of key value heads + * self.cache.head_dim # head dimension + * self.cache.dtype.itemsize # data type size in bytes + ) # fmt: skip + if bytes_per_block == 0: + raise ValueError("The number of bytes per block is 0. This is not possible.") + return offload_bytes // bytes_per_block + + def _stream_ctx(self): + """Returns a context manager that runs enclosed ops on the compute stream, or a no-op when none is set.""" + return torch.cuda.stream(self._compute_stream) if self._compute_stream is not None else nullcontext() + + def offload_one_request(self) -> None: + """Offload one active request to make room in the GPU cache. Tries CPU offloading first; if the pool is full, + falls back to the legacy soft reset.""" + scheduler = self.scheduler + request_id, state = scheduler.pop_request_to_evict() + logger.info( + f"Offloading request {request_id} with {len(state.initial_tokens)} initial tokens and " + f"{len(state.generated_tokens)} generated tokens." + ) + + # Try CPU offloading first, if it fails, we soft reset the request + offloaded_to_cpu = self._offload_to_cpu(request_id, state) + if offloaded_to_cpu: + # We set the allocated blocks to 0 so the scheduler re-allocates all blocks using position_offset. + state.allocated_blocks = 0 + # DECODING requests have empty remaining_prefill_tokens, so we use tokens_to_process as a placeholder + # so the scheduler has at least 1 token to schedule and enters the allocation path. + if state._status == RequestStatus.DECODING: + state.remaining_prefill_tokens = state.tokens_to_process[:] + # Here, the new state is the same as the old one, but with the status set to PENDING. We bypass the setter + # to avoid the lifespan bookeeping and the associated warning + state._status = RequestStatus.PENDING + new_state = state + logger.debug(f"Offloaded request {request_id} to CPU: {len(self._free_cpu_blocks)} free blocks remaining.") + else: + new_state = state.create_equivalent_initial_request() + state._status = RequestStatus.FINISHED + logger.debug(f"Soft reset request {request_id}.") + + scheduler.finish_request(request_id) + scheduler.add_waiting_request(new_state) + scheduler.block_new_requests = True + + def restore_scheduled_requests(self, requests_in_batch: list[FutureRequestState]) -> None: + """Restore KV caches from CPU for any CPU-offloaded requests in the scheduled batch. Indices are accumulated + per group across all requests, then copied in one batched operation per layer.""" + cache = self.cache + all_cpu_indices: list[int] = [] + all_gpu_indices: list[int] = [] + + for future_state in requests_in_batch: + # Skip state that are not CPU-offloaded + state = future_state.state + if not state.is_cpu_offloaded: + continue + # TODO: if the H2D copy below raises, already-popped entries leak (never returned to _free_cpu_blocks) + # Accumulate CPU indices for this request + cpu_indices = self._request_id_to_cpu_blocks.pop(state.request_id) + group_counts = self._request_id_to_group_block_counts.pop(state.request_id) + all_cpu_indices.extend(cpu_indices) + # Accumulate GPU indices for this request, but since there may be extra block due to re-allocation, slice to + # match the number of blocks offloaded. + max_allocated_blocks = 0 + for group_idx, n in enumerate(group_counts): + gpu_blocks = cache.group_cache_managers[group_idx].block_table.get(state.request_id, []) + all_gpu_indices.extend(gpu_blocks[:n]) + max_allocated_blocks = max(max_allocated_blocks, n) + # Restore the state to non-offloaded state + state.is_cpu_offloaded = False + state.allocated_blocks = max_allocated_blocks # ensures re-allocation is accounted for + # Prefix sharing: restored blocks will be re-hashed during the next update + if cache.allow_block_sharing: + future_state.complete_blocks += state.position_offset // cache.block_size + logger.debug( + f"Restored CPU-offloaded request {state.request_id} with {len(state.initial_tokens)} prefill tokens " + f"and {len(state.generated_tokens)} generated tokens." + ) + + # Early return if there are no copy to perform + if not all_cpu_indices: + return None + + # Single batched copy for all requests (still, one copy per layer) + cpu_ids = self._cpu_ids_scratch[: len(all_cpu_indices)] + gpu_ids = self._gpu_ids_scratch[: len(all_cpu_indices)] + cpu_ids.copy_(torch.as_tensor(all_cpu_indices, dtype=torch.int32)) # cpu op, not in the stream + with self._stream_ctx(): + gpu_ids.copy_(torch.as_tensor(all_gpu_indices, dtype=torch.int32)) + for cpu_k, gpu_k in zip(self._cpu_key_cache, self._gpu_key_views): + gpu_k[gpu_ids].copy_(cpu_k[cpu_ids]) + for cpu_v, gpu_v in zip(self._cpu_value_cache, self._gpu_value_views): + gpu_v[gpu_ids].copy_(cpu_v[cpu_ids]) + self._free_cpu_blocks.extend(all_cpu_indices) + + def free_request_cpu_cache(self, state: RequestState) -> None: + """Free CPU blocks for a single request (e.g., on cancellation).""" + if state.is_cpu_offloaded: + self._return_cpu_blocks(state.request_id) + state.is_cpu_offloaded = False + + def free_all_waiting_cpu_caches(self) -> None: + """Free all CPU-offloaded caches in the waiting queue (e.g., on fail_all or reset).""" + for state in self.scheduler.waiting_requests.values(): + self.free_request_cpu_cache(state) + + def reset(self) -> None: + """Reset CPU offloading state for a new generation session.""" + self.free_all_waiting_cpu_caches() + self._request_id_to_cpu_blocks.clear() + self._request_id_to_group_block_counts.clear() + self._free_cpu_blocks = deque(range(self._num_cpu_blocks)) + + def _offload_to_cpu(self, request_id: str, state: RequestState) -> bool: + """Copy a request's KV cache blocks from GPU to the static CPU swap pool. Returns True on success, False if + the pool is full.""" + + # Get the indices to offload from + gpu_indices = [] + group_block_counts = [] + for cm in self.cache.group_cache_managers: + blocks = cm.block_table.get(request_id, []) + gpu_indices.extend(blocks) + group_block_counts.append(len(blocks)) + + # No CPU offloading if there are no blocks to offload or not enough free blocks in the CPU swap pool + total_gpu_blocks = len(gpu_indices) + if total_gpu_blocks == 0 or len(self._free_cpu_blocks) < total_gpu_blocks: + return False + + # Reserve CPU blocks from the free pool + cpu_indices = [self._free_cpu_blocks.popleft() for _ in range(total_gpu_blocks)] + + # Offload using the compute stream so it does not interfere with current generation + cpu_ids = self._cpu_ids_scratch[:total_gpu_blocks] + gpu_ids = self._gpu_ids_scratch[:total_gpu_blocks] + cpu_ids.copy_(torch.as_tensor(cpu_indices, dtype=torch.int32)) # cpu op, not in the stream + with self._stream_ctx(): + gpu_ids.copy_(torch.as_tensor(gpu_indices, dtype=torch.int32)) + # Keys + for cpu_key_cache, gpu_key_view in zip(self._cpu_key_cache, self._gpu_key_views): + cpu_key_cache[cpu_ids].copy_(gpu_key_view[gpu_ids]) + # Values + for cpu_value_cache, gpu_value_view in zip(self._cpu_value_cache, self._gpu_value_views): + cpu_value_cache[cpu_ids].copy_(gpu_value_view[gpu_ids]) + # TODO: add asynchronous version of this + # TODO: can we get rid of this for loop? eg. by consolidating the cache. + + # No explicit sync needed: finish_request is logical, and the next forward pass serializes on the same stream. + self._request_id_to_cpu_blocks[request_id] = cpu_indices + self._request_id_to_group_block_counts[request_id] = group_block_counts + state.is_cpu_offloaded = True + return True + + def _return_cpu_blocks(self, request_id: str) -> tuple[list[int], list[int]]: + """Return CPU blocks to the free pool without copying anything.""" + cpu_ids = self._request_id_to_cpu_blocks.pop(request_id) + group_counts = self._request_id_to_group_block_counts.pop(request_id) + self._free_cpu_blocks.extend(cpu_ids) + return cpu_ids, group_counts diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/requests.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/requests.py new file mode 100644 index 0000000000000000000000000000000000000000..816c5e0f14d3a311fde4cc9416d50bcc76463d5f --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/requests.py @@ -0,0 +1,361 @@ +# Copyright 2025 The HuggingFace Inc. team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import time +from copy import deepcopy +from dataclasses import dataclass, field +from enum import IntEnum + +import torch + +from ...utils import is_psutil_available, is_torch_xpu_available +from ...utils.logging import logging +from ...utils.metrics import traced + + +if is_psutil_available(): + import psutil + +# This is a temporary token ID used to represent a token that is not yet generated +# TODO: update this to 0 and check it breaks nothing + simplify carry over and time new logic +TMP_TOKEN_ID = -1 + + +# We centralize the logger here to coordinate between logging and progress bar +logger = logging.getLogger("ContinuousBatchingLogger") +# Add a handler to the logger to print the logs to the console. Only happens once thanks to setting propagate to False. +if logger.propagate: + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")) + logger.addHandler(handler) + logger.propagate = False + + +def get_device_and_memory_breakdown() -> tuple[torch.device, int, int, int]: + if torch.cuda.is_available(): + device = torch.device("cuda") + torch.cuda.empty_cache() + torch.cuda.synchronize() + # Use mem_get_info to get actual free memory: device_properties().total_memory returns the physical device + # total which ignores CUDA context and driver overhead (~0.5 GiB), leading to overcommit. + free_memory, total_memory = torch.cuda.mem_get_info(device) + reserved_memory = torch.cuda.memory_reserved(device) + allocated_memory = total_memory - free_memory + elif is_torch_xpu_available(): + device = torch.device("xpu") + torch.xpu.empty_cache() + torch.xpu.synchronize() + total_memory = torch.xpu.get_device_properties(device).total_memory + reserved_memory = torch.xpu.memory_reserved(device) + allocated_memory = torch.xpu.memory_allocated(device) + elif torch.backends.mps.is_available() and torch.backends.mps.is_built(): + device = torch.device("mps") + # MPS memory reporting (PyTorch 2.0+) + total_memory = torch.mps.driver_allocated_memory() + allocated_memory = total_memory - getattr(torch.mps, "recommended_max_memory")() + reserved_memory = 0 # MPS does not track reserved separately + else: + device = torch.device("cpu") + if is_psutil_available(): + total_memory = psutil.virtual_memory().total + allocated_memory = psutil.Process().memory_info().rss + reserved_memory = allocated_memory + else: + logger.error( + "Cannot get memory breakdown on CPU without psutil: returning 0 for all memory values. Please install " + "psutil to get an actual memory breakdown." + ) + total_memory = 0 + reserved_memory = 0 + allocated_memory = 0 + + return device, total_memory, reserved_memory, allocated_memory + + +class RequestStatus(IntEnum): + """Status of a generation request through its lifecycle.""" + + PENDING = 0 + PREFILLING = 1 + DECODING = 2 + FINISHED = 3 + FAILED = 4 + + +@dataclass +class GenerationOutput: + """Tracks the output of a generation request. + + Attributes: + request_id (str): The ID of the generation request. + prompt_ids (list[int]): The IDs of the prompt tokens. + generated_tokens (list[int]): The generated tokens. + logprobs (list[float]): The log probabilities of the generated tokens. + error (Optional[str]): Any error message associated with the request. When None, the request was successful. + status (RequestStatus): The status of the request. + created_time (float): The time the request was created. + lifespan (tuple[float, float]): The time the request was no longer pending and the time the request finished. + """ + + request_id: str + prompt_ids: list[int] = field(default_factory=list) + generated_tokens: list[int] = field(default_factory=list) + logprobs: list[float] = field(default_factory=list) + error: str | None = None + status: RequestStatus = RequestStatus.PENDING + created_time: float = field(default_factory=time.perf_counter) + lifespan: tuple[float, float] = (-1, -1) # (time request was no longer pending, time request finished) + timestamps: list[float] | None = None # Timestamps of the generated tokens + + def is_finished(self) -> bool: + return self.status == RequestStatus.FINISHED + + +@dataclass +class RequestState: + """Tracks the state of a generation request through its lifecycle. + + Attributes: + request_id (str): The ID of the generation request. + initial_tokens (list[int]): The initial prompt tokens. + num_children (int): The number of children requests + full_prompt_ids (list[int] | None): The tokens IDs of the full prompt. + prompt_ids (list[int] | None): The tokens IDs currently being processed. + remaining_prompt_ids (list[int]): The initial tokens IDs remaining to be processed. + static_outputs (list[int]): The generated tokens. + allocated_blocks (int): The number of blocks allocated to the request. + position_offset (int): The current position in the sequence for position_ids. + status (RequestStatus): The status of the request: can be one of PENDING, PREFILLING, PREFILLING_SPLIT, + SPLIT_PENDING_REMAINDER, DECODING, FINISHED, FAILED + max_new_tokens (int | None): The maximum number of new tokens to generate. + eos_token_id (None | int | list[int]): The ID(s) of the end-of-sequence tokens. Only used in post-init. + _eos_token_ids (set[int]): The IDs of the end-of-sequence tokens, formatted as a set. + streaming (bool): Whether to stream tokens as they're generated + created_time (float): The time the request was created. + error (Optional[str]): Any error message associated with the request. When None, has had no error yet. + """ + + # Required fields + request_id: str + initial_tokens: list[int] # Initial prompt tokens # TODO: rename this as prefill tokens + + # Optional fields (CB parameters) + streaming: bool = False # Whether to stream tokens as they're generated + record_timestamps: bool = False # Whether to record timestamps for the generated tokens + + # Optional fields (generation parameters) + max_new_tokens: int | None = 20 # Maximum number of new tokens to generate. None means no limit. Default to 20. + eos_token_id: int | list[int] | None = None # ID(s) of the end-of-sequence tokens. Only used in post-init. + num_children: int = 0 # Number of children requests + logit_processor_kwargs: dict = field(default_factory=dict) # Keyword arguments for the logits processor. + + # Internal fields (for scheduling) + tokens_to_process: list[int] = field(default_factory=list) # Tokens IDs currently being processed + generated_tokens: list[int] = field(default_factory=list) # Generated tokens + logprobs: list[float] = field(default_factory=list) # Log probabilities of the generated tokens + position_offset: int = 0 # Current position in the sequence for position_ids + allocated_blocks: int = 0 # Number of blocks allocated to the request + + _status: RequestStatus = RequestStatus.PENDING # Status of the request, hidden behind a property + _eos_token_ids: set[int] = field(default_factory=set) # IDs of the end-of-sequence tokens, formatted as a set + + # Internal fields (for tracking) + created_time: float = field(default_factory=time.perf_counter) # Time the request was created + error: str | None = None # Error message if the request failed + lifespan: tuple[float, float] = (-1, -1) # (time request was no longer pending, time request finished) + _timestamps: list[float] = field(default_factory=list) # Timestamps of the generated tokens + _true_initial_tokens: int = 0 # The true number of initial tokens, useful when soft resetting requests + # TODO: remove the attribute above to _num_initial_tokens once initial_tokens is renamed + + # Fields overwritten in __post_init__ + _new_tokens_limit: int = 2147483647 # An int to check the max number of new tokens w/out always comparing w/ None + remaining_prefill_tokens: list[int] = field(default_factory=list) # Initial tokens left to process + is_cpu_offloaded: bool = False # True when the request's KV cache is in the CPU swap pool + + def __post_init__(self): + # If no max length is set, we set an absurdly high value which will never be reached + self._new_tokens_limit = 2147483647 if self.max_new_tokens is None else self.max_new_tokens + # Keep a copy of the initial tokens to process + self.remaining_prefill_tokens = self.initial_tokens[:] + # Format the EOS token ID(s) as a set of ints. If there is no EOS token ID, it's an empty set + if self.eos_token_id is None: + pass + # If there is a single EOS token ID, add it to the set only if the ID is valid, ie. non-negative + elif isinstance(self.eos_token_id, int): + if self.eos_token_id >= 0: + self._eos_token_ids.add(self.eos_token_id) + # If there are multiple EOS token IDs, add them to the set only if they are valid, ie. non-negative + else: + for token_id in self.eos_token_id: + if token_id >= 0: + self._eos_token_ids.add(token_id) + + @property + def status(self) -> RequestStatus: + return self._status + + @status.setter + def status(self, value: RequestStatus): + if self._status == RequestStatus.PENDING: + self.lifespan = (time.perf_counter(), -1) + elif value == RequestStatus.FINISHED: + self.lifespan = (self.lifespan[0], time.perf_counter()) + self.log_end_of_request() + self._status = value + + @property + def timestamps(self) -> list[float] | None: + return self._timestamps if self.record_timestamps else None + + def log_end_of_request(self): + prefill_len = len(self.initial_tokens) + decode_len = self.generated_len() + start_time = self.lifespan[0] - self.created_time + end_time = self.lifespan[1] - self.created_time + logger.info( + f"Request {self.request_id} finished: {prefill_len = } {decode_len = } {start_time = } {end_time = }" + ) + + def current_len(self) -> int: + """Get the current length of the sequence (prompt + generated tokens).""" + return self.position_offset + + def generated_len(self) -> int: + """Get the number of tokens generated so far.""" + return len(self.generated_tokens) + + # TODO: this logic seems one token off, check it out + @traced + def update_and_check_completion(self, token_id: int, logprob: float | None) -> bool: + """Update the request with a newly generated token (and optional log probability of the token) and check for + completion. Returns True if the request is now complete, False otherwise.""" + # Only update if we're in decoding state # TODO: seems useless (always true) -- remove this + if self.status != RequestStatus.DECODING: + return False + + # If we're recording timestamps, add timestamp to the list + if self.record_timestamps: + self._timestamps.append(time.perf_counter()) + + # Stop if we reached an EOS token + is_eos = token_id in self._eos_token_ids + current_len = self.generated_len() + + # Replace the temporary token if we're not finishing due to max length + # (EOS tokens should still be added to the output) + if is_eos or (current_len < self._new_tokens_limit): + self.generated_tokens.append(token_id) + self.tokens_to_process = [token_id] # this works for 2 levels of pipelines, but not sure for more + current_len += 1 + if logprob is not None: + self.logprobs.append(logprob) + else: + logger.warning(f"Request {self.request_id} generated a useless token: {token_id}") + + if is_eos or current_len >= self._new_tokens_limit: + self.status = RequestStatus.FINISHED + return True + return False # We still need to process more tokens + + def __repr__(self): + msg = [ + f"request_id={self.request_id}", + f"status={self._status}", + f"out_tokens={self.generated_len()}", + f"query_length={len(self.tokens_to_process)}", + f"remaining_tokens={len(self.remaining_prefill_tokens)}", + f"kv_length={self.position_offset}", + f"full_prompt_length={len(self.initial_tokens)}", + f"allocated_blocks={self.allocated_blocks}", + f"generated_tokens={self.generated_tokens}", + f"logit_processor_kwargs={self.logit_processor_kwargs}", + ] + return "RequestState(\n\t" + ",\n\t".join(msg) + "\n)" + + def to_generation_output(self): + """Convert the request state to a GenerationOutput object.""" + if self._true_initial_tokens: + self.generated_tokens = self.initial_tokens[self._true_initial_tokens :] + self.generated_tokens + self.initial_tokens = self.initial_tokens[: self._true_initial_tokens] + return GenerationOutput( + request_id=self.request_id, + prompt_ids=self.initial_tokens, + generated_tokens=self.generated_tokens, + logprobs=self.logprobs, + error=self.error, + status=self.status, + created_time=self.created_time, + lifespan=self.lifespan, + timestamps=self.timestamps, + ) + + def fork(self, new_request_id: str) -> "RequestState": + """Fork the request into a new request with the same state except for request_id, created_time and lifespan.""" + new_request = deepcopy(self) + # Update tracking fields + new_request.request_id = new_request_id + new_request.created_time = time.perf_counter() + new_request.lifespan = (new_request.created_time, -1) + new_request._timestamps = [] + # Update fields overwritten in __post_init__ + new_request.remaining_prefill_tokens = self.remaining_prefill_tokens[:] + return new_request + + def get_request_config(self) -> dict: + """Get all the fields necessary to create a request that would have the same configuration.""" + return { + "streaming": self.streaming, + "record_timestamps": self.record_timestamps, + "max_new_tokens": self.max_new_tokens, + "eos_token_id": self.eos_token_id, + "num_children": self.num_children, + "logit_processor_kwargs": deepcopy(self.logit_processor_kwargs), + } + + def create_equivalent_initial_request(self) -> "RequestState": + """Creates an equivalent new request by removing the generated tokens and adding them to the initial prompt. The + created request has THE SAME request_id. Notably, we can retrieve the original request from the created one with + the _true_initial_tokens attribute. The logprobs of the generated tokens are kept in the new request.""" + + request_config = self.get_request_config() + # If there is a number of max new tokens, we update it to account for the already generated tokens + if self.max_new_tokens is not None: + request_config["max_new_tokens"] = self.max_new_tokens - len(self.generated_tokens) + # Create new request state + new_state = RequestState( + request_id=self.request_id, + initial_tokens=self.initial_tokens + self.generated_tokens, + logprobs=self.logprobs[:], + _true_initial_tokens=self._true_initial_tokens + len(self.initial_tokens), + **request_config, + ) + # If the request has been soft reset once already, this stays the same + if self._true_initial_tokens: + new_state._true_initial_tokens = self._true_initial_tokens + # Otherwise, we set the true initial tokens to the number of initial tokens + else: + new_state._true_initial_tokens = len(self.initial_tokens) + return new_state + + +class FutureRequestState: + """Tracks the current state of a request and the relevant information to update it.""" + + # This makes instantiating this class faster + __slots__ = ("state", "has_new_token", "complete_blocks", "query_length") + + def __init__(self, state: RequestState, has_new_token: bool, complete_blocks: int, query_length: int) -> None: + self.state = state + self.has_new_token = has_new_token + self.complete_blocks = complete_blocks + self.query_length = query_length diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/scheduler.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/scheduler.py new file mode 100644 index 0000000000000000000000000000000000000000..fb3d46665feb784d8dd880441a25eff01a77c1e5 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/scheduler.py @@ -0,0 +1,431 @@ +# Copyright 2025 The HuggingFace Inc. team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import threading +from abc import ABC, abstractmethod +from collections import deque + +from ...utils.metrics import attach_tracer, traced +from .cache import PagedAttentionCache +from .requests import FutureRequestState, RequestState, RequestStatus, logger + + +class Scheduler(ABC): + """ + Abstract base class for scheduling requests in the continuous batch processor. Schedulers manage the lifecycle of + requests from when they are added to the waiting queue to when they are scheduled for processing. Different + schedulers implement different strategies for prioritizing and batching requests. + """ + + def __init__(self, cache: PagedAttentionCache): + self.cache = cache + self._cancellation_lock = threading.Lock() + # This is to compute the read cache used by a new request being scheduled + self.read_cache_limit = None if self.cache.num_full_attention_groups else self.cache.config.sliding_window + self.max_decode_fast_path_length = self.cache.max_blocks_per_request * self.cache.block_size + # Initialize mutable states via reset() + self.reset() + + def reset(self) -> None: + """Reset scheduler state for a new generation loop.""" + self.active_requests: dict[str, RequestState] = {} + self.waiting_requests: dict[str, RequestState] = {} + self.waiting_requests_order: deque[str] = deque() + self._requests_to_cancel: set[str] = set() + self._requests_to_fork: list[RequestState] = [] + self.block_new_requests = False + + @traced + def add_waiting_request(self, state: RequestState): + """Adds a request to the waiting list.""" + self.waiting_requests[state.request_id] = state + self.waiting_requests_order.append(state.request_id) + + @abstractmethod + def schedule_batch( + self, token_budget: int, cache_budget: int + ) -> tuple[list[FutureRequestState] | None, bool, int, int]: + """Schedules requests for the next batch based on available token and cache budgets. This method selects which + requests should be processed in the current batch, considering the budgets and the scheduler's prioritization + rules. The token_budget is the maximum number of tokens that can be processed in a batch, and the cache_budget + is the maximum number of KV cache entries that can be read in a batch. + Returns the list of scheduled requests in their "FutureRequestState" form, a boolean indicating if the decode + fast path can be used, the total number of query tokens and the maximum number of kv tokens read.""" + + @traced + def has_pending_requests(self) -> bool: + """Checks if there are requests ready to be processed.""" + return bool(len(self.active_requests) or len(self.waiting_requests)) + + @traced + def finish_request(self, request_id: str) -> None: + """Completes processing of a request and frees its allocated cache blocks. This method is called + when a request has finished generation or encountered an error. + """ + self.cache.free_blocks(request_id) + self.active_requests.pop(request_id, None) + + def pop_request_to_evict(self) -> tuple[str, RequestState]: + """Remove and return an active request chosen as the eviction victim for cache-pressure offload or soft reset. + Picks the newest active request when `block_new_requests` is set, else the oldest.""" + if self.block_new_requests: + return self.active_requests.popitem() + request_id = next(iter(self.active_requests)) + return request_id, self.active_requests.pop(request_id) + + @traced + def get_active_request_static_outputs(self, request_id: str) -> list[int]: + """Gets generated tokens for an active request.""" + if request_id in self.active_requests: + return self.active_requests[request_id].generated_tokens + return [] + + @traced + def set_request_cancellation(self, request_id: str): + """Marks a request for cancellation.""" + with self._cancellation_lock: + self._requests_to_cancel.add(request_id) + + @traced + def clear_cancelled_requests(self) -> list[RequestState]: + """Remove all cancelled requests from active and waiting queues.""" + cancelled_states = [] + with self._cancellation_lock: + for request_id in self._requests_to_cancel: + state_a = self.active_requests.pop(request_id, None) + state_w = self.waiting_requests.pop(request_id, None) + # Invariant: a request is never in both queues; state_a or state_w picks the one it was in + state = state_a or state_w + if state is not None: + cancelled_states.append(state) + if request_id in self.waiting_requests_order: + self.waiting_requests_order.remove(request_id) + self.cache.free_blocks(request_id) + self._requests_to_cancel = set() + return cancelled_states + + @traced + def request_is_cancelled(self, request_id: str) -> bool: + """Checks if a request has been cancelled or removed.""" + return request_id in self._requests_to_cancel or ( + request_id not in self.active_requests and request_id not in self.waiting_requests + ) + + @traced + def _allocate_blocks_if_needed(self, state: RequestState, len_next_tokens: int) -> bool: + """Allocate additional cache blocks for a request if the currently allocated blocks are insufficient to + accommodate the next tokens. It calculates how many blocks are needed based on the request's current + cache occupancy and the number of tokens to be processed. The allocation itself is done by the CacheAllocator + objects. Returns a boolean indicating if the allocation was successful or not. + """ + # First we check that the occupancy is less than the requested length, then we allocate enough blocks to cover + # the requested length. This is done using `current_len` so it also works for offloaded requests. + current_len = state.current_len() + occupancy = state.allocated_blocks * self.cache.block_size - current_len + if occupancy < len_next_tokens or state.allocated_blocks == 0: + blocks_needed = ((len_next_tokens - occupancy + 1) // self.cache.block_size) + 1 + allocated = self.cache.allocate_blocks(blocks_needed, state.request_id, state.allocated_blocks) + if allocated is None: + return False + state.allocated_blocks += allocated + return True + + def _infer_request_tokens(self, state: RequestState, request_ids_to_remove_from_waiting: set[str]) -> list[int]: + """Prepares a request for processing in the current batch. If prefix sharing is enabled, and the request was + pending, this is where we look for a prefix match and split the request if found.""" + # If prefix sharing is enabled, we look for a prefix match and split the request if found + if self.cache.use_prefix_sharing and state.status == RequestStatus.PENDING and not state.is_cpu_offloaded: + prefill_length = self.cache.search_prefix_match(state.request_id, state.remaining_prefill_tokens) + if prefill_length > 0: + self.active_requests[state.request_id] = state + request_ids_to_remove_from_waiting.add(state.request_id) + state.status = RequestStatus.PREFILLING + # We keep track of the number of allocated blocks to avoid double allocation + state.allocated_blocks += prefill_length // self.cache.block_size + # Even if we match the whole request, we keep at least 1 token to start decoding + prefill_length = min(prefill_length, len(state.remaining_prefill_tokens) - 1) + state.remaining_prefill_tokens = state.remaining_prefill_tokens[prefill_length:] + state.position_offset += prefill_length + + # If the request is decoding, the tokens to process are already set + if state.status == RequestStatus.DECODING: + request_tokens = state.tokens_to_process + # Otherwise, the tokens to process are the remaining prefill tokens + else: + request_tokens = state.remaining_prefill_tokens + return request_tokens + + def _schedule_request( + self, + state: RequestState, + request_tokens: list[int], + token_budget: int, + request_ids_to_remove_from_waiting: set[str], + ) -> None: + """Schedules a request for the current batch, updating the request's status according to the token budget left. + After a request is scheduled, it is part of the next batch unless there is an error. + If the request has children (for parallel decoding), it ensures at least one token remains before the request is + forked.""" + # If the request has one or more children we make sure not to prefill it entirely + # This does not check the request state, but DECODING request already have children set to 0. + if state.num_children > 0 and token_budget >= len(request_tokens) - 1: + token_budget = len(request_tokens) - 1 + self._requests_to_fork.append(state) + + # Case: we can process the entire prompt/remainder + if len(request_tokens) <= token_budget: + if state.status == RequestStatus.PENDING: + self.active_requests[state.request_id] = state + request_ids_to_remove_from_waiting.add(state.request_id) + if state.status <= RequestStatus.PREFILLING: + state.tokens_to_process = state.remaining_prefill_tokens + state.remaining_prefill_tokens = [] + # Although prefill will only be done after the batch being scheduled now, we set the status to DECODING + # to stay coherent when using asynchronous batching + state.status = RequestStatus.DECODING + + # Otherwise: we need to split the request + else: + if state.status == RequestStatus.PENDING: + self.active_requests[state.request_id] = state + state.status = RequestStatus.PREFILLING + request_ids_to_remove_from_waiting.add(state.request_id) + state.remaining_prefill_tokens = request_tokens[token_budget:] + state.tokens_to_process = request_tokens[:token_budget] + + def _process_candidates( + self, + candidates: list[RequestState], + token_budget: int, + cache_budget: int, + request_ids_to_remove_from_waiting: set[str], + safety_margin: float = 0.0, + ) -> tuple[list[FutureRequestState], bool, bool, int, int]: + """Schedules candidate requests for the current batch. + + This method contains the common logic shared by all schedulers: it checks token and cache budgets, allocates + cache blocks if needed, updates request states, and tracks which waiting requests should be removed from the + waiting queue. + """ + scheduled_requests = [] + one_allocation_failed = False + decode_fast_path = self.cache.max_blocks_per_request > 0 # best way to check if decode fast path availability + safety_margins = safety_margin * self.cache.num_blocks + original_token_budget, original_cache_budget = token_budget, cache_budget + + for state in candidates: + num_free_blocks = self.cache.get_num_free_blocks() + # If we are out the safety margin, we only accept decoding requests or the first prefill request + outside_safety_margin = num_free_blocks < safety_margins + if outside_safety_margin and scheduled_requests and state.status != RequestStatus.DECODING: + logger.info( + f"Outside safety margin, breaking out of scheduling loop. {num_free_blocks = } {safety_margins = }" + ) + break + + # Infer the tokens that will be present in the batch if token budget is enough + request_tokens = self._infer_request_tokens(state, request_ids_to_remove_from_waiting) + # Account for token budget + request_len = min(len(request_tokens), token_budget) + + # This block checks cache budget: decode batches have infinite budget, but varlen batches don't, because KV + # cache is read through a fixed-sized index tensor. We keep track of the current budget in case the batch + # goes from decode to varlen + is_decode_eligible = request_len == 1 and state.position_offset < self.max_decode_fast_path_length + read_cache_needed = state.current_len() + if self.read_cache_limit is not None: + read_cache_needed = min(read_cache_needed, self.read_cache_limit) + # A request that would change the batch from decode to varlen is rejected if the cache budget is too low + if not (decode_fast_path and is_decode_eligible) and cache_budget < read_cache_needed: + continue + + # Check there will be enough cache for the new tokens + allocation_successful = self._allocate_blocks_if_needed(state, request_len) + + # If the allocation would not be successful, we move on to the next request + if not allocation_successful: + one_allocation_failed = True + # If we reached a waiting request and the cache is full, all subsequent waiting requests will need + # allocation as well, so we can safely break out of the scheduling loop. + if num_free_blocks == 0 and state.request_id in self.waiting_requests: + logger.info(f"Breaking mid-loop for request {state.request_id} because the cache is full") + break + continue + + # If this point is reached, it means we can safely schedule the request + self._schedule_request(state, request_tokens, token_budget, request_ids_to_remove_from_waiting) + request_len = len(state.tokens_to_process) # it may change after scheduling + + # The decode fast path is only used if the request is a single token and its length is less than the max blocks per request + decode_fast_path &= request_len == 1 and state.position_offset < self.max_decode_fast_path_length + + # Update the token and cache budgets + token_budget -= request_len + cache_budget -= read_cache_needed + + # If using prefix sharing, we make note of the blocks that will be computed in the forward pass + if self.cache.allow_block_sharing: + tokens_in_current_block = state.current_len() % self.cache.block_size + tokens_after_forward = tokens_in_current_block + request_len + complete_blocks = tokens_after_forward // self.cache.block_size + else: + complete_blocks = 0 + + # Store the future request state + has_new_token = not state.remaining_prefill_tokens + scheduled_requests.append(FutureRequestState(state, has_new_token, complete_blocks, request_len)) + + # Remove the request from the waiting queue and mark it as removed + req_id = state.request_id + was_waiting = self.waiting_requests.pop(req_id, None) is not None + if was_waiting: + request_ids_to_remove_from_waiting.add(req_id) + + # Early exit of the loop if we have no budget left + if token_budget == 0 or (cache_budget <= 0 and not decode_fast_path): + break + + num_q_tokens = original_token_budget - token_budget + max_kv_read = original_cache_budget - cache_budget + return scheduled_requests, one_allocation_failed, decode_fast_path, num_q_tokens, max_kv_read + + def _get_waiting_candidates(self) -> list[RequestState]: + """Returns waiting requests in priority order. Since CPU-offloaded requests are cheaper to restore than fresh + requests, they get priority, but we interleave them with fresh request to not saturate new batches with only + offloaded requests.""" + offloaded: deque[RequestState] = deque() + fresh: deque[RequestState] = deque() + for req_id in self.waiting_requests_order: + state = self.waiting_requests[req_id] + (offloaded if state.is_cpu_offloaded else fresh).append(state) + ordered: list[RequestState] = [] + while offloaded or fresh: + if offloaded: + ordered.append(offloaded.popleft()) + if fresh: + ordered.append(fresh.popleft()) + return ordered + + def _cleanup_waiting_queue(self, request_ids_to_remove_from_waiting: set[str]) -> None: + """Removes processed requests from the waiting queue order.""" + self.waiting_requests_order = deque( + [req_id for req_id in self.waiting_requests_order if req_id not in request_ids_to_remove_from_waiting] + ) + + +# TODO: further common-ize the two classes +@attach_tracer() +class FIFOScheduler(Scheduler): + """This scheduler processes requests in the order they arrive, meaning decoding requests has priority over + prefilling requests. Additionally, it includes a safety margin mechanism to prevent cache exhaustion. By default, + when 80% of the cache is full, new requests will not be scheduled to prioritize decoding active requests.""" + + def __init__(self, cache: PagedAttentionCache, safety_margin: float = 0.2): + """Initializes the FIFO scheduler. The safety margin is the percentage of free blocks under which we stop + scheduling new prefill requests, so safety_margin = 0.1 means that when there is less than 10% of free blocks, + or equivalently when more than 90% of blocks are already allocated, we stop scheduling new prefill requests. + """ + super().__init__(cache) + self.safety_margin = safety_margin + + @traced + def schedule_batch( + self, token_budget: int, cache_budget: int + ) -> tuple[list[FutureRequestState] | None, bool, int, int]: + priority_states: list[RequestState] = [] + second_priority_states: list[RequestState] = [] + + for state in self.active_requests.values(): + if state.status == RequestStatus.DECODING: + priority_states.append(state) + elif state.status == RequestStatus.PREFILLING: + second_priority_states.append(state) + + # Add waiting requests to second priority, with CPU-offloaded requests first + if not self.block_new_requests: + second_priority_states.extend(self._get_waiting_candidates()) + + candidates = priority_states + second_priority_states + request_ids_to_remove_from_waiting = set() + scheduled_requests, one_allocation_failed, decode_fast_path, num_q_tokens, max_kv_read = ( + self._process_candidates( + candidates, + token_budget, + cache_budget, + request_ids_to_remove_from_waiting, + safety_margin=self.safety_margin, + ) + ) + + # We remove waiting requests before checking requests were scheduled, because there might have been prefill matches + self._cleanup_waiting_queue(request_ids_to_remove_from_waiting) + + # If no requests were scheduled and the cache is full, we signal it by returning None + if not scheduled_requests and one_allocation_failed: + return None, decode_fast_path, 0, 0 + + return scheduled_requests, decode_fast_path, num_q_tokens, max_kv_read + + +# FIXME: prioritize adding from waiting reqs before scheduling `RequestStatus.DECODING` when cache space allows it +# TODO: further consolidate the code by making more of it common. The reference Scheduler is FIFO, not this one. +@attach_tracer() +class PrefillFirstScheduler(Scheduler): + """Scheduler that prioritizes split prefill requests over decoding requests. This scheduler ensures that split + prefill requests (which are continuations of partially processed prompts) are completed before processing new + decoding requests.""" + + @traced + def schedule_batch( + self, token_budget: int, cache_budget: int + ) -> tuple[list[FutureRequestState] | None, bool, int, int]: + priority_states: list[RequestState] = [] + second_priority_states: list[RequestState] = [] + + for state in self.active_requests.values(): + # XXX: when cache is full, state can stay on `PREFILLING_SPLIT` so we need to take those into account + if state.status == RequestStatus.PREFILLING: + priority_states.append(state) + elif state.status == RequestStatus.DECODING: + second_priority_states.append(state) + + # Add waiting requests to second priority, with CPU-offloaded requests first + if not self.block_new_requests: + second_priority_states.extend(self._get_waiting_candidates()) + + candidates = priority_states + second_priority_states + request_ids_to_remove_from_waiting = set() + scheduled_requests, one_allocation_failed, decode_fast_path, num_q_tokens, max_kv_read = ( + self._process_candidates( + candidates, + token_budget, + cache_budget, + request_ids_to_remove_from_waiting, + safety_margin=0.0, + ) + ) + + # We remove waiting requests before checking requests were scheduled, because there might have been prefill matches + self._cleanup_waiting_queue(request_ids_to_remove_from_waiting) + + # If no requests were scheduled and the cache is full, we signal it by returning None + if not scheduled_requests and one_allocation_failed: + return None, decode_fast_path, 0, 0 + + return scheduled_requests, decode_fast_path, num_q_tokens, max_kv_read + + +SCHEDULER_MAPPING = { + "fifo": FIFOScheduler, + "prefill_first": PrefillFirstScheduler, +} diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/utils.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b97a54853ed17531c234b8ee29dcb1657f22599e --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/generation/continuous_batching/utils.py @@ -0,0 +1,217 @@ +# Copyright 2026 The HuggingFace Inc. team +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from collections import OrderedDict +from dataclasses import dataclass +from math import ceil, log2 +from typing import Any + +import torch + +from transformers.configuration_utils import PretrainedConfig +from transformers.generation.configuration_utils import ContinuousBatchingConfig + +from .requests import FutureRequestState, RequestState, RequestStatus, logger + + +class CudaGraphBuffer: + """A fixed-size dict for CUDA graphs with LRU eviction when full.""" + + def __init__(self, max_size: int) -> None: + if max_size <= 0: + raise ValueError(f"max_size must be positive, but got {max_size}") + self.max_size = max_size + self._storage: OrderedDict[tuple[int, ...], torch.cuda.CUDAGraph] = OrderedDict() + + def __del__(self) -> None: + original_max_size = self.max_size + self.max_size = 1 # 0 would cause an infinite loop, 1 is enough to clear all graphs + self.plan_for_new_graph(silent=True) + self.max_size = original_max_size + + def get_graph(self, key: tuple[int, ...]) -> torch.cuda.CUDAGraph | None: + graph = self._storage.get(key) + if graph is not None: + self._storage.move_to_end(key) + return graph + + def plan_for_new_graph(self, silent: bool = False) -> None: + while len(self._storage) >= self.max_size: + evicted_key, evicted_graph = self._storage.popitem(last=False) + if not silent: + logger.info(f"Evicting graph for {evicted_key = }") + evicted_graph.reset() + + def set_graph(self, key: tuple[int, ...], graph: torch.cuda.CUDAGraph) -> None: + # In our use case, this should not have any effect because we plan for a new graph before it is captured + self.plan_for_new_graph() + self._storage[key] = graph + + +@dataclass +class WorkloadHints: + """A tiny dataclass containing hints to help choose good continuous batching defaults""" + + max_prompt_length: int = 0 + max_generated_length: int = 0 + + # TODO: can this be fused with other resolve methods? + def resolve_using_hints(self, cb_config: "ContinuousBatchingConfig") -> None: + """Resolves the config using the given hints.""" + # The max number of block per request is an even number large enough to hold the max request length + if self.max_prompt_length and self.max_generated_length: + if cb_config.max_blocks_per_request is None: + max_sequence_length = self.max_prompt_length + self.max_generated_length + blocks_per_request = int(ceil(max_sequence_length / cb_config.block_size)) + 1 + cb_config.max_blocks_per_request = blocks_per_request + (blocks_per_request % 2) + + +def attn_mask_is_needed(config: PretrainedConfig) -> bool: + """Checks if attention mask is needed for the given (config).""" + return config._attn_implementation in ["paged|eager", "paged|sdpa"] + + +def pad_to_interval(size: int, interval_size: int, max_value: int) -> int: + """Return the smallest multiple of (interval_size) >= (size), capped at (max_value).""" + if interval_size <= 0: + return max_value + padded = ceil(size / interval_size) * interval_size if size > 0 else interval_size + return min(padded, max_value) + + +def pad_to_pow2(value: int, max_value: int, min_value: int = 0) -> int: + """Return the smallest power of 2 >= (value), capped at (max_value). If a minimum value is provided, the value is at + least padded to that value.""" + value = max(value, max(1, min_value)) + padded = 2 ** int(ceil(log2(value))) + return min(padded, max_value) + + +def aligned_divide(x: int, divide_by: int, align_to: int) -> int: + x = int(ceil(x / divide_by)) + if x % align_to: + x += align_to - (x % align_to) + return x + + +def build_attention_mask( + attention_mask: torch.Tensor, + cumulative_seqlens_q: list[int], + cumulative_seqlens_k: list[int], + sliding_window: int = 1, +) -> None: + """Builds an attention mask inplace using the cumulative seqlens of the query and key. If given a sliding window, it + will also apply a sliding window mask on top. The attention mask is not boolean, it uses zeroes and -inf (or its + equivalent) so it's more of an attention score bias tensor. + The attention mask is a block-diagonal matrix, with each block an attention mask for a single query-key pair. + Each of those block is built from a causal mask and, if there is a sliding window, a sliding window mask. + + An example is represented below, with seqlen_k = 8, seqlen_q = 4 and sliding_window = 6: + + CAUSAL MASK: + + █ █ █ █ █ ░ ░ ░ + █ █ █ █ █ █ ░ ░ + █ █ █ █ █ █ █ ░ + █ █ █ █ █ █ █ █ + + SLIDING WINDOW MASK: + ┌──────────────────────── seqlen_k - seqlen_q - sliding_window = 8 - 4 - 6 = -2 offset to the left + <─┴─> + ░ █ | █ █ █ █ █ █ █ █ + ░ ░ | █ █ █ █ █ █ █ █ + ░ ░ | ░ █ █ █ █ █ █ █ + ░ ░ | ░ ░ █ █ █ █ █ █ + + ATTENTION MASK (sum of causal and sliding window masks): + + █ █ █ █ █ ░ ░ ░ + █ █ █ █ █ █ ░ ░ + ░ █ █ █ █ █ █ ░ + ░ ░ █ █ █ █ █ █ + + Another example with seqlen_k = 5, seqlen_q = 3 and sliding_window = 2: + + CAUSAL MASK: + + █ █ █ ░ ░ + █ █ █ █ ░ + █ █ █ █ █ + + SLIDING WINDOW MASK: + ┌──────────────────────── seqlen_k - seqlen_q - sliding_window = 5 - 3 - 2 = 0 offset to the left + <┴> + | ░ █ █ █ █ + | ░ ░ █ █ █ + | ░ ░ ░ █ █ + + ATTENTION MASK (sum of causal and sliding window masks): + + ░ █ █ ░ ░ + ░ ░ █ █ ░ + ░ ░ ░ █ █ + + """ + min_value = torch.finfo(attention_mask.dtype).min + for i in range(len(cumulative_seqlens_q) - 1): + seqlen_q = cumulative_seqlens_q[i + 1] - cumulative_seqlens_q[i] + seqlen_k = cumulative_seqlens_k[i + 1] - cumulative_seqlens_k[i] + if seqlen_q < seqlen_k and seqlen_q >= 1: + causal_diagonal = seqlen_k - seqlen_q + 1 + else: + causal_diagonal = 1 + query_range = slice(cumulative_seqlens_q[i], cumulative_seqlens_q[i + 1]) + key_range = slice(cumulative_seqlens_k[i], cumulative_seqlens_k[i + 1]) + # Apply causal mask + minus_inf = torch.full( + attention_mask[..., query_range, key_range].shape, + min_value, + dtype=attention_mask.dtype, + device=attention_mask.device, + ) + masked = torch.triu(minus_inf, diagonal=causal_diagonal) + # Apply sliding window mask if needed + if sliding_window > 1: + sliding_diagonal = seqlen_k - seqlen_q - sliding_window + masked += torch.tril(minus_inf, diagonal=sliding_diagonal) + # Replace in attention mask + attention_mask[..., query_range, key_range] = masked + + +def create_warmup_future_states( + num: int, + status: RequestStatus, + num_query_tokens: int, + num_cache_tokens: int, + cache: Any, # not annotated to avoid circular import +) -> list[FutureRequestState]: + """An utility function to create a list of FutureRequestStates for the warmup of CB.""" + # Setup + request_ids = [f"__warmup_{status.name}_{i}__" for i in range(num)] + total_tokens = num_query_tokens + num_cache_tokens + blocks_needed = ceil(total_tokens / cache.block_size) + # Main loop + future_states = [] + for req_id in request_ids: + state = RequestState(request_id=req_id, initial_tokens=[0] * total_tokens, max_new_tokens=1) + state._status = status # bypass the property setter to avoid the lifecycle side effects + state.tokens_to_process = [0] * num_query_tokens + state.position_offset = num_cache_tokens + # Stop if allocation fails for any request + allocated = cache.allocate_blocks(blocks_needed, state.request_id, 0) + if allocated is None: + return future_states + future_states.append( + FutureRequestState(state, has_new_token=True, complete_blocks=0, query_length=num_query_tokens) + ) + return future_states diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a98d7e986cddd137d78b7cd93da8e873d80aecc4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/accelerate.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/accelerate.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71c79866b43d2d9a889d95973a65892de9b71769 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/accelerate.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/aqlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/aqlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c8efaf4ccdcdf940306b88a6c00501e3c7c6428 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/aqlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/awq.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/awq.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1eba0e4eb13131567fef562c38c253adfffcd4fd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/awq.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/bitnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/bitnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cb199b8b10ceb3e8ec0ac179df669f42da869b3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/bitnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/bitsandbytes.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/bitsandbytes.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8c4592ee04f8ede449a8385d66a21b58638419a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/bitsandbytes.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/deepspeed.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/deepspeed.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..769c702f03593a3e097f44f4129003ab4d5f634d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/deepspeed.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/eager_paged.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/eager_paged.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..33c4404603bc7689a8779f75a842e8e11666c076 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/eager_paged.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/eetq.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/eetq.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..872ec6622650c0e23760338e324798c79bb0d4b4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/eetq.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/executorch.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/executorch.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97c6a2b0a993b3f36249f24d5a669692495470e6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/executorch.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fbgemm_fp8.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fbgemm_fp8.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc7933fb9bf74bfbe0894cde651a3758afaeef29 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fbgemm_fp8.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/finegrained_fp8.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/finegrained_fp8.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf0ef0bebe0ec2b6f98edfd407e3eb3959769cda Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/finegrained_fp8.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flash_attention.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flash_attention.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9437f972a82633f5048b6842124a3569e936fe72 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flash_attention.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flash_paged.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flash_paged.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9cdb8adb05afbc9a7a37bb647f5a9e7a4de1808b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flash_paged.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flex_attention.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flex_attention.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be3fa7016b899e9c6e001da1596b1f418fd0efc2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/flex_attention.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fouroversix.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fouroversix.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d0915d938a2276b18c6e2d4990d82cb56aee0d2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fouroversix.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fp_quant.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fp_quant.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a04797b7dff2ed8c3357597c20d955983138e01 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fp_quant.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fsdp.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fsdp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8bffb3a45387b5df7c1034f29961eb5a39940773 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/fsdp.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/ggml.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/ggml.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fb4c78577be1c353243f3f7eaf07d040a8ced3c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/ggml.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/higgs.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/higgs.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..00c9b7cd8312050752ea7f55426ca76b0909e0d9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/higgs.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/hqq.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/hqq.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e8a50a7ff5d7cac5c8c47a1c54ab56d06156063 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/hqq.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/hub_kernels.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/hub_kernels.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2f457aa3eec38e434cbb4f3836099d24b54bdcf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/hub_kernels.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/liger.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/liger.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b2c71e044e47089821fcd02832ee8cace289233 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/liger.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/metal_quantization.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/metal_quantization.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba4d019b7da77c666d023bef53292f0c93301972 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/metal_quantization.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/mistral.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/mistral.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..475a2727c496dfc65dd44b999590b2736f88ff2b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/mistral.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf11cb1a214d3564525b586127448c29c5471661 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/mxfp4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/mxfp4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83790e41cb74d217b235a39316044c645e3876e6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/mxfp4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/neftune.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/neftune.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2c2277061b56b0a744e4b64a28c4f988875a63d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/neftune.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/npu_flash_attention.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/npu_flash_attention.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..91b33b4f0e50095d3f6bb26bcef339efd5646960 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/npu_flash_attention.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/peft.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/peft.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aca9bbe2b1c83e532f678a86a60d6a43d4f500a7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/peft.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/quanto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/quanto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..77f5cdb70c50d7c750a65a5615f4694ecf6e74ae Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/quanto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/quark.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/quark.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6ce2bde77ebc740451fc7dd88cd1375a84e68f6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/quark.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sdpa_attention.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sdpa_attention.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc260e9abcad0bdf15eabb4f7ee033b7d2fbea44 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sdpa_attention.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sdpa_paged.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sdpa_paged.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41da06fba720863481912b85658bec769c94acb7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sdpa_paged.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sinq.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sinq.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efa30156a5131b2578b0d7e7f980838c1ddc3b09 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sinq.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sonicmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sonicmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..839d61acd1529c3fce79e52cd7107086d1ddb7ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/sonicmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/spqr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/spqr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4244b31a2c3c7ed31635b1b68475ce916b493794 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/spqr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tensor_parallel.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tensor_parallel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..638c1eb0bf8bc356ac675e17eec3b810b66709ee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tensor_parallel.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tiktoken.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tiktoken.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b3f25a3ad522d8ff3fa841e66aef2cd41b8b9bb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tiktoken.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/torchao.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/torchao.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7cadd1f0dc07b2b00f310767968ea63f2af36eeb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/torchao.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tpu.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tpu.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..176dc24969a68f510cae80dc2c69174d32d92ae5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/tpu.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/vptq.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/vptq.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b13fe7fbe806fdacf3fcd5c96c0cce009b4c8326 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/integrations/__pycache__/vptq.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a42cbe3bd5f1ab552e8914aa6f007f5d9125af82 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_d_fine.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_d_fine.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c66275417c7b2ee50493abe7ed68244150e7121 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_d_fine.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_deformable_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_deformable_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15143ea45da33e474cf8ce9bbd22160526478497 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_deformable_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_deimv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_deimv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..164f36aa059e8a71702bfdfeb22efd6da60ac004 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_deimv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_for_object_detection.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_for_object_detection.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78886fdf12ece6f3428916b5b99ed67cd77fd593 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_for_object_detection.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_grounding_dino.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_grounding_dino.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65a4329f56e84878cf0fa0d8a490ef37f95ed6c1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_grounding_dino.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_lw_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_lw_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bbcd708164399c6129106d3eff7f4d5b6ac019df Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_lw_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_rt_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_rt_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4bdd7136ccc51d99b83638f74dd0f1773f03286 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_rt_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_utils.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45a1a1ac2117b125601f818ff33dec7e78018e14 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/loss/__pycache__/loss_utils.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6c7d3e9320b0644166bf4554efe2da85446ad8d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/configuration_afmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/configuration_afmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cfd0e185e51dbb3b5a1c2a67ef9e46c6c7a5a4d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/configuration_afmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/modeling_afmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/modeling_afmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48f46f4c9651c9b41ed636dc67eead9d6d5c3626 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/modeling_afmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/modular_afmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/modular_afmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dfa2054ea672ba98f66b0a8e823521a9ee6981f1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/afmoe/__pycache__/modular_afmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1e9e4fb8c7d82d186340665f26bd1847d155255 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/configuration_aimv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/configuration_aimv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a4ff690a420d9210a9442e5e90d940795ac803f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/configuration_aimv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/modeling_aimv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/modeling_aimv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cdea3422fb59cb8e98cafdc94ce82206542cb97e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/modeling_aimv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/modular_aimv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/modular_aimv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fc210881707e4ce2ee80ec031f63b43c2325f15 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aimv2/__pycache__/modular_aimv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10c7c171fd37fdb5b2f151de035c097788043279 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/configuration_albert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/configuration_albert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..565ca1e97ddfbe6b29894d6b58e1ad07e78facab Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/configuration_albert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/modeling_albert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/modeling_albert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..200083e7c7723a119832c192c96873703dc646e7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/modeling_albert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/tokenization_albert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/tokenization_albert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09a10e6f76d8f29d83399353f47aa2e7e42d19b8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/albert/__pycache__/tokenization_albert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c436814ddc78871e062feccf70f19b29c71a54b1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/configuration_align.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/configuration_align.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e96ac28ea4d85925ef987d7a8b450f15d5a43c87 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/configuration_align.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/modeling_align.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/modeling_align.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e433ad4385280c2e96c7568b8b338e64e5501e7d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/modeling_align.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/processing_align.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/processing_align.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72c6ab9c8c2a18df68ea56d5f638c6c6f25a3d3d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/align/__pycache__/processing_align.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ef4ed6b11abd713b2409876994f826f8eea66de Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/configuration_altclip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/configuration_altclip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34ca937ffafa9c865b7c4ceb4610c5213e3b260f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/configuration_altclip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/modeling_altclip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/modeling_altclip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ee4351ea92dcf32d7e654d98d41808124811505 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/modeling_altclip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/modular_altclip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/modular_altclip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..daa01098539495eef55ae553f520310938ac3f36 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/modular_altclip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/processing_altclip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/processing_altclip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7bd20031ce3d55d4d5e4ad77218bc2dbc8cd9333 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/altclip/__pycache__/processing_altclip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af4c8143b424bcb813d2778b0c29841a5f69b74e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/configuration_apertus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/configuration_apertus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15f2979eeda8cbf217c701dc99a49737bb5d5963 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/configuration_apertus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/modeling_apertus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/modeling_apertus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b402c89854ab6e84081aa09d1777c7a298bb0c25 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/modeling_apertus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/modular_apertus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/modular_apertus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc367ee26abd1815759c4fa1bb4697c48ccd9170 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/apertus/__pycache__/modular_apertus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5f96c9f0d7d5cebe25fe9d7098bd0aaf4e51ea3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/configuration_arcee.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/configuration_arcee.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d355874c14f5e7cfd86020220f7f8df9103993f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/configuration_arcee.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/modeling_arcee.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/modeling_arcee.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8de19d40362a5c7e3f29c22fe2b0b177058a5e5c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/modeling_arcee.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/modular_arcee.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/modular_arcee.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..276e23239921f720011915d45400086ab6dc73f0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/arcee/__pycache__/modular_arcee.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f1d475b5b642702d07a6ce2d95eebe9c37afed0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/configuration_aria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/configuration_aria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62a91831210d432355d33c27a42c9c8acc8883f9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/configuration_aria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/image_processing_aria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/image_processing_aria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8810f9be557266ecc7105622f87a0fb39093a0b2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/image_processing_aria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/image_processing_pil_aria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/image_processing_pil_aria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7704e9ea48081fd16cc43bfeca017880ea24f028 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/image_processing_pil_aria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/modeling_aria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/modeling_aria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2858ec3ae1b0bd27416914016a0557e80970f80f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/modeling_aria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/modular_aria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/modular_aria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd369dbfeaf1058bf5185e0741af1edc39a68948 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/modular_aria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/processing_aria.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/processing_aria.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a01c535a60db4dc862a775cde70fc61dcf045ff7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aria/__pycache__/processing_aria.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..948fa1f77e980ff32a1cbef0703d655915bc0577 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/configuration_audio_spectrogram_transformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/configuration_audio_spectrogram_transformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0c94627c7e1bec816d9dc8aa2bece18a94eae49 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/configuration_audio_spectrogram_transformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/feature_extraction_audio_spectrogram_transformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/feature_extraction_audio_spectrogram_transformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dfc4ed54e85db5c33d9be4068ee90bcf0b4b5f2c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/feature_extraction_audio_spectrogram_transformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/modeling_audio_spectrogram_transformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/modeling_audio_spectrogram_transformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..397b4d06890e75e8c259ace906c9b359e9cccf93 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audio_spectrogram_transformer/__pycache__/modeling_audio_spectrogram_transformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e54c6417f0e80c5eb3daa257a98950e4b3f3fe3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/configuration_audioflamingo3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/configuration_audioflamingo3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a93c227f79814153b44b97e15f5dc87e2d6fd3a2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/configuration_audioflamingo3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/modeling_audioflamingo3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/modeling_audioflamingo3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d8543b2f65486c2ce06d6671da982bbbb2d0fc0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/modeling_audioflamingo3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/modular_audioflamingo3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/modular_audioflamingo3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d319782ad4fddd97cd45fd4b4573fe4198409114 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/modular_audioflamingo3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/processing_audioflamingo3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/processing_audioflamingo3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cc580b93b7f6fde3703ea4ba38bec3f9f737f90 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/audioflamingo3/__pycache__/processing_audioflamingo3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f65f177ad625c8e3bcab4a6e2a6be9ceafc1e2ef Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/auto_factory.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/auto_factory.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46087611a45690f4f46c76f637044492633d4196 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/auto_factory.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/auto_mappings.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/auto_mappings.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..834076ba2cfc4c09dc4413b0c7e71f1a22a46261 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/auto_mappings.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/configuration_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/configuration_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e7549ad1e16d673a688de9248aeed3e0022eaf5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/configuration_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/feature_extraction_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/feature_extraction_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6991b845b4150e9df0bb6793fb234906e28a5fd2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/feature_extraction_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/image_processing_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/image_processing_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..319861ba92aef0581063fd07c542931a5779ad2f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/image_processing_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/modeling_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/modeling_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b9f7d6850089806ecdfe089016820a60920ddce Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/modeling_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/processing_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/processing_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cbf7f221cbf0f35fc96939b0222c25de679de29b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/processing_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/tokenization_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/tokenization_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68078a23fb069b18a2536a0ab346e89193cf67d3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/tokenization_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/video_processing_auto.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/video_processing_auto.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fa8fa0313c86467d5c381103ed9b342f1b9f035 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/auto/__pycache__/video_processing_auto.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/autoformer/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/autoformer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6bf093bf30ed21ea8c4afd01255091956f76b6f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/autoformer/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/autoformer/__pycache__/configuration_autoformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/autoformer/__pycache__/configuration_autoformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5abb93d5e63a8dd231ad7246bdf4d79d4d0e468 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/autoformer/__pycache__/configuration_autoformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29036b1f959f60338ec1d02440f9a079fd785c01 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/configuration_aya_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/configuration_aya_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5be7788936467381bb34d8e407f7127bbe6db27 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/configuration_aya_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/modeling_aya_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/modeling_aya_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c8adef4ecde0bed25d3b5bf6a90a1dadd11a5c71 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/modeling_aya_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/modular_aya_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/modular_aya_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc4961180a8707adcd812470e6301cc7baece7a2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/modular_aya_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/processing_aya_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/processing_aya_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e48542ad2f5261393fab6fe86175def5cd659e0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/aya_vision/__pycache__/processing_aya_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47e464a7e0b1a47882c616ffb93f6e3acc9a94c0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/configuration_bamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/configuration_bamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ee8337dbf7d17d4e742751bb7978f91c39e7949 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/configuration_bamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/modeling_bamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/modeling_bamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b36bfe59d83ec293f47b3c799ab767aebe2978f2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/modeling_bamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/modular_bamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/modular_bamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8652cfd78fdc4d617f7f08e94ba16e7242c7e5a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bamba/__pycache__/modular_bamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dbff1b65175c400db943e50c6d6d5b7e1b462afd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/configuration_bark.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/configuration_bark.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..197892caebb226badfd3c592866c752e12537ae0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/configuration_bark.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/generation_configuration_bark.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/generation_configuration_bark.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54f40fc615b2f6a2d459e17ca87b85d8a17f0634 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/generation_configuration_bark.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/modeling_bark.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/modeling_bark.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c7dda7cf3ce7f09e20a083e30cb3a481e88b841 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/modeling_bark.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/processing_bark.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/processing_bark.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e4765a955b20f1576aec7684e8bde3ab8467e5a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bark/__pycache__/processing_bark.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d349a7d44cf3ac81907beb678c74f0d5c1b408e1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/configuration_bart.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/configuration_bart.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b09842624e0cf8eaa9724d1828393c9fb970169 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/configuration_bart.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/modeling_bart.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/modeling_bart.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25cec57d1a17fad938093496428b89dcaed9485a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/modeling_bart.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/tokenization_bart.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/tokenization_bart.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45b7ce6c8b0f1c709c24001a206005995f82f0ab Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bart/__pycache__/tokenization_bart.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/barthez/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/barthez/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d887f0982b81339ea0382eff529ac7d0d1d96f57 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/barthez/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/barthez/__pycache__/tokenization_barthez.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/barthez/__pycache__/tokenization_barthez.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5986d59ac98e03001c73b4e1fb532e5bbd8f6f4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/barthez/__pycache__/tokenization_barthez.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bartpho/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bartpho/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe101e9d06b648ac97ee4d9b103c0c6e8ee1508f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bartpho/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bartpho/__pycache__/tokenization_bartpho.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bartpho/__pycache__/tokenization_bartpho.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2edfb9fb5879d23f21bb32ef2975a5b605d4fee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bartpho/__pycache__/tokenization_bartpho.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a881dc0de47ce9033ae95346c0ff7099ff4459e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/configuration_beit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/configuration_beit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..96b7509cdead50dd8cd8b406917a629dec116ec5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/configuration_beit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/image_processing_beit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/image_processing_beit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7244a61459417c1bead06807a63d526a68c8f15 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/image_processing_beit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/image_processing_pil_beit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/image_processing_pil_beit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..331f6920203c6e1a2cbf5bbfc3bc7ad47cf85e6e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/image_processing_pil_beit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/modeling_beit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/modeling_beit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b388add397512152cac979ba98d571d95dbc451 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/beit/__pycache__/modeling_beit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..850b2845dfe1651125c2819714f6660cc84f90ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/configuration_bert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/configuration_bert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5510890cde00c49de093e96edfb8b4b45f65478 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/configuration_bert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/modeling_bert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/modeling_bert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edc0552019a3d987335abcffcfc436c1195cd6ae Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/modeling_bert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/tokenization_bert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/tokenization_bert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0ff1147b8be7f0d7f50484db98799fb5b7c5aab Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/tokenization_bert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/tokenization_bert_legacy.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/tokenization_bert_legacy.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45dafb8237c2a379ade9b1b92986e0e9d7c6e50f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert/__pycache__/tokenization_bert_legacy.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5e72070b336f5bc6a5608cef905b2a92f4fcb68 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/configuration_bert_generation.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/configuration_bert_generation.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee55d4315efa2974710eb723e8de76f2fc97d0ed Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/configuration_bert_generation.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/modeling_bert_generation.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/modeling_bert_generation.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fc80ab521723b9627c3c9c60549a24bcdfbe39b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/modeling_bert_generation.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/tokenization_bert_generation.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/tokenization_bert_generation.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97124f678c57e6d8d39f0fcdeb38f7d5595fc186 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_generation/__pycache__/tokenization_bert_generation.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_japanese/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_japanese/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1e11f2d49e42ac93ec3c18bbc6f225060319872e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_japanese/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_japanese/__pycache__/tokenization_bert_japanese.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_japanese/__pycache__/tokenization_bert_japanese.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e36b2b06d052af7079896c5d7598bb4ad62ba222 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bert_japanese/__pycache__/tokenization_bert_japanese.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bertweet/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bertweet/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..677a114f3d8826d0a3115961e2e9234948c9338a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bertweet/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bertweet/__pycache__/tokenization_bertweet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bertweet/__pycache__/tokenization_bertweet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1854f5c16e64df89f4ddf34aa17ca5f513b648db Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bertweet/__pycache__/tokenization_bertweet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bedae47447d5abfe96e349f5092036addd0faa5c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/configuration_big_bird.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/configuration_big_bird.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9864a9738157bcb4a73fd7c0e279c465889a745 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/configuration_big_bird.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/tokenization_big_bird.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/tokenization_big_bird.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f762e2ba5d40624809d57d5312260c80f7d82b66 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/big_bird/__pycache__/tokenization_big_bird.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bigbird_pegasus/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bigbird_pegasus/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d69146320b75114e128001b5d88c61c683855a19 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bigbird_pegasus/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bigbird_pegasus/__pycache__/configuration_bigbird_pegasus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bigbird_pegasus/__pycache__/configuration_bigbird_pegasus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f6f0d16b223f1b0f0334c76277f321a709dd993 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bigbird_pegasus/__pycache__/configuration_bigbird_pegasus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5022334379ee2495655362c9d5fba9b1d7f4ce68 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/configuration_biogpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/configuration_biogpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2f9c128e80499c7aebde139f8c043cd5a59ce26 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/configuration_biogpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/modeling_biogpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/modeling_biogpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b1be33aa6a9dfbdc9834fdb9a135e843bf2bb6f0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/modeling_biogpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/modular_biogpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/modular_biogpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d99912fa504c19a9a028983d9e3b1f023a08d566 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/modular_biogpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/tokenization_biogpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/tokenization_biogpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f96d7c4b4cb6984c57531fbb5918bb38df9c51a9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/biogpt/__pycache__/tokenization_biogpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03ae374ca42428e1cfdeab5de245508f246694d9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/configuration_bit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/configuration_bit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0c3eace8e17639f1dc9aeb2833171c63969772f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/configuration_bit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/image_processing_bit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/image_processing_bit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3cc6a5df50b399cb8cbef222cd0a2d9663d3e29 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/image_processing_bit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/image_processing_pil_bit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/image_processing_pil_bit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba33e624c04bceb40cd1d0b8a7f682e1f8b3116b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/image_processing_pil_bit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/modeling_bit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/modeling_bit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebf48bb73901529f63211f92dd4fd2c6f9fe2334 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bit/__pycache__/modeling_bit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5dfc8d2c10c559004f57c2aee15a58eacaa47a6e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/configuration_bitnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/configuration_bitnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22c9c0e03e5b05f2aecd821182e982d558fc4d7d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/configuration_bitnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/modeling_bitnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/modeling_bitnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4b4bdb37725de00e8084b45b0cfd4b2854f20e2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/modeling_bitnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/modular_bitnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/modular_bitnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89d83690970d8021241e74a5e197cead56e5f3a4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bitnet/__pycache__/modular_bitnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d15ba1134fed5aa25b561798ba35c5687c39e5d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/configuration_blenderbot.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/configuration_blenderbot.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81675f58c0154cad17180a2866f05d496a6fb2da Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/configuration_blenderbot.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/modeling_blenderbot.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/modeling_blenderbot.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a2f16bfe7cca03aab792f5dbb9b8f98a27608fad Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/modeling_blenderbot.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/tokenization_blenderbot.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/tokenization_blenderbot.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..602ada9ffa6e11dbab356fbb1a8351e9f5ac0e34 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot/__pycache__/tokenization_blenderbot.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2f8a9df229f0987661a6e1e08b89504cd692a499 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/configuration_blenderbot_small.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/configuration_blenderbot_small.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b9d6920e281295512b7a449462b0c5bf453cec1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/configuration_blenderbot_small.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/modeling_blenderbot_small.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/modeling_blenderbot_small.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..979f0ad2baf410b0e0171667c9a0e2edf95f34a2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/modeling_blenderbot_small.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/tokenization_blenderbot_small.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/tokenization_blenderbot_small.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a89ee4a86fe0d3ede2314015f7bf8a30230b23e2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blenderbot_small/__pycache__/tokenization_blenderbot_small.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d50db0801e7bf51d937b36fc20d84fe5f23443cb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/configuration_blip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/configuration_blip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d661179a47ba1f0fce5d236759fad46c7c890948 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/configuration_blip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/image_processing_blip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/image_processing_blip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8a606db7f802065fb52a6b4187496495bd6d068 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/image_processing_blip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/image_processing_pil_blip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/image_processing_pil_blip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3dcf9fd57867c36be113408c8f4ba2746329a16c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/image_processing_pil_blip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/modeling_blip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/modeling_blip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..503c57654eb6c8836add8f4f05f41ba07ff4e507 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/modeling_blip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/modeling_blip_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/modeling_blip_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..115a118f752da4ed90aae776260a6e430d48c24a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/modeling_blip_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/processing_blip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/processing_blip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..20e5326e7d658781863a49a2e5a3ec3d362bba3a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip/__pycache__/processing_blip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db9f80b0817cb3e639cf3674181c43ce59f86bd8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/configuration_blip_2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/configuration_blip_2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c6cf8739d7a015b0a8fd6d43ad7449789efbe21 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/configuration_blip_2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/processing_blip_2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/processing_blip_2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6f14e6c9d55a443d268a90910768edb76355cdf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blip_2/__pycache__/processing_blip_2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fef727b49c779b5a627fc7b1ace73b2182be60f9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/configuration_bloom.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/configuration_bloom.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d93f0e32f0a3c9880c47b5ddb1386c82354a9437 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/configuration_bloom.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/modeling_bloom.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/modeling_bloom.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2a1f127b6ea6fa18513b1d4c5503257f9e1d69b9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bloom/__pycache__/modeling_bloom.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..873dac4ae62d6420b01128a30f2cc4c441c76b88 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/configuration_blt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/configuration_blt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22aff186482c51152e1b13ba46412b6206d6d072 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/configuration_blt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/modeling_blt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/modeling_blt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d8fb8b1fa1b6678824d3333895d9a9aeea219eb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/modeling_blt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/modular_blt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/modular_blt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef98e543c05d41e642f40188e2d620f726979d13 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/blt/__pycache__/modular_blt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..60334cc8ec0d9b62390058303148ce72b31eb241 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/configuration_bridgetower.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/configuration_bridgetower.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bb96839a5a4e1bb9f2af339e96b232d662d155d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/configuration_bridgetower.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/image_processing_bridgetower.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/image_processing_bridgetower.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02f2c7e6ee2ed54f61d9753947e348a4d5d46c96 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/image_processing_bridgetower.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/image_processing_pil_bridgetower.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/image_processing_pil_bridgetower.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bb7da3c4e268a06cbe1dd93cda00d7022726b627 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/image_processing_pil_bridgetower.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/modeling_bridgetower.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/modeling_bridgetower.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7341c9969bb4c1bc4dfa866672ef9456be61f49 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/modeling_bridgetower.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/processing_bridgetower.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/processing_bridgetower.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8271c057f15c05d30960bb3206fb5c65f64ec295 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bridgetower/__pycache__/processing_bridgetower.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aee90f29d01378e50267265d0d75d0443f17fd9a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/configuration_bros.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/configuration_bros.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..236a1d95018d89166b90d324ab7bc3868e832a5d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/configuration_bros.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/modeling_bros.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/modeling_bros.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26c9825df324e9dca76dacde054375e9d2cd49ee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/modeling_bros.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/processing_bros.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/processing_bros.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c09b3fb133fc244a61f5a6d95a550e261eec587 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/bros/__pycache__/processing_bros.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/byt5/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/byt5/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c87796f10598ed3bf7c6074267a52c36cae0c69a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/byt5/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/byt5/__pycache__/tokenization_byt5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/byt5/__pycache__/tokenization_byt5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..caf61e88465a1426211802ba770af16b3ed089c6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/byt5/__pycache__/tokenization_byt5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d068acaf0aa7654200079aaea68f5c999a11123 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/configuration_camembert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/configuration_camembert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b231b9522fc5799a7f0c9867758d71e3ba5443a0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/configuration_camembert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/modeling_camembert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/modeling_camembert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bab24cbade3a05d68f87347489d18ca68f25b50d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/modeling_camembert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/modular_camembert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/modular_camembert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db256d446ceec6a4f7d40d552a8141e4d9dab396 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/modular_camembert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/tokenization_camembert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/tokenization_camembert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fe0300e99c6208efa1b3a870553d74e548ff72e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/camembert/__pycache__/tokenization_camembert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e5b7cd29d49aedaf4a0602f39e33f24d19c0222 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/configuration_canine.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/configuration_canine.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be7073f9a9c2bd61543ebfc4d91db11e15345c72 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/configuration_canine.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/modeling_canine.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/modeling_canine.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f66c3b03c0f3a426c36cbf14f04c7fb9111b702e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/modeling_canine.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/tokenization_canine.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/tokenization_canine.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f48211d04024d3ee622ee23723a708698078a11 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/canine/__pycache__/tokenization_canine.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ddbc86802685720f791247f6880b23affb8c5849 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/configuration_chameleon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/configuration_chameleon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..608dc5e269ec9191ab246528bd0a2d1947c57c53 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/configuration_chameleon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/image_processing_chameleon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/image_processing_chameleon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e74e6e86dc57c47189e3064cdf0f541ff081e3cc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/image_processing_chameleon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/image_processing_pil_chameleon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/image_processing_pil_chameleon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1d3e6e27496b26c0ad3772d7e7021ee14361c5a7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/image_processing_pil_chameleon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/modeling_chameleon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/modeling_chameleon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65c83c2d9f4953401078b5f0b2dd00d93ce38b75 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/modeling_chameleon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/processing_chameleon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/processing_chameleon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83c58f917f749d2702e5be55ef75aeb15d56cf7e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chameleon/__pycache__/processing_chameleon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e12ed2fefc0b66235fe4f761f74221c1716a9d99 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/configuration_chinese_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/configuration_chinese_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..124d212e21f6d8d56c2f20ad286b3a6ff5a6ac43 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/configuration_chinese_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/image_processing_chinese_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/image_processing_chinese_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea6005c0b7fec98e281e7ab7414b5a788cd3bace Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/image_processing_chinese_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/image_processing_pil_chinese_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/image_processing_pil_chinese_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2e1e6747f4dffdfc8d2febc52cb48fa180a6436 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/image_processing_pil_chinese_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/modeling_chinese_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/modeling_chinese_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4cb5eed9a8d8d19d6d4e4cad538632f7cf26f8f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/modeling_chinese_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/modular_chinese_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/modular_chinese_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5aa5b151fc3399d77ab4138e6693f07ffc3e1ce8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/modular_chinese_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/processing_chinese_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/processing_chinese_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49646d0fa09c6b5d30ca4229f70ca241f5fd1430 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chinese_clip/__pycache__/processing_chinese_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1928f439b5a3237cbc74ebceba5aa6ea5b548be Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/configuration_chmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/configuration_chmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1d1001dbd7b4003dfcb3e2e10811c4fe144e2d5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/configuration_chmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/image_processing_chmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/image_processing_chmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78e78acb5de47056c717c87a44a6ace9a760e460 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/image_processing_chmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/modeling_chmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/modeling_chmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..916533fb037720f755058507d5ebeb31c52ebc8a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/modeling_chmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/modular_chmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/modular_chmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc78afc5d460d740389d6e56bae902d561e489fa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/chmv2/__pycache__/modular_chmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..262e9d61fce7f61ac3d7a5c7ee58026503d94609 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/configuration_clap.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/configuration_clap.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7a657304efabbff6e91aa40f31c5756a9e73135 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/configuration_clap.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/feature_extraction_clap.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/feature_extraction_clap.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9baf1042a768402b6c81ddb35b5f75ac6246812c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/feature_extraction_clap.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/modeling_clap.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/modeling_clap.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4886e8edc77b22be8c6a0d7a246cc76f4c55eacf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/modeling_clap.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/processing_clap.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/processing_clap.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0cbc2b2b6155ce2296861cfa5f59c9955938517 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clap/__pycache__/processing_clap.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b294303f73a29b31305ad23d0174a67138a11ec9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/configuration_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/configuration_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ffabaa02a8fc6858a59c0be102fc9042fd6d73f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/configuration_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/image_processing_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/image_processing_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7a5595bf4ff5de4e391016bc643a39a1fb423b05 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/image_processing_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/image_processing_pil_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/image_processing_pil_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8c4737f8a8a7b7e6a04770d02e9429b0f985e908 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/image_processing_pil_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/modeling_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/modeling_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfad5c8bac69deaea9957fd725bac98925042840 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/modeling_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/processing_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/processing_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49ca727e3b7ed932810f2134ebc02713478c07ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/processing_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/tokenization_clip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/tokenization_clip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4677e1e1de27adc82f6d570c9ec7ad377ea618b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clip/__pycache__/tokenization_clip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..60b44d782b35981a4b908679fde8e2ca8128a5f6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/configuration_clipseg.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/configuration_clipseg.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b311dc6fb9d7d762cc0299ef604df32f4f5d6395 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/configuration_clipseg.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/modeling_clipseg.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/modeling_clipseg.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68959310e2e3653e9a14ace24694dda5738fa5e8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/modeling_clipseg.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/modular_clipseg.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/modular_clipseg.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6775e7c67ca029b604675c775f18a57d1bd547b8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/modular_clipseg.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/processing_clipseg.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/processing_clipseg.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea2aee676192e0b51e25b458616fb9dd3a847dcc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clipseg/__pycache__/processing_clipseg.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2e5cadf6ed59ace3fb9f9296b0ae7008146118eb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/configuration_clvp.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/configuration_clvp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7780dbaf8dc33444577fc849220a4a445b36aab5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/configuration_clvp.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/feature_extraction_clvp.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/feature_extraction_clvp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d8e31c45ae62804622431e622d3c7caed1179ff Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/feature_extraction_clvp.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/modeling_clvp.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/modeling_clvp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c50112ec8dd058519650b3928ddc42a86dfad43 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/modeling_clvp.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/number_normalizer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/number_normalizer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..437a61f7037882408ae568e16538ae202f2353bb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/number_normalizer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/processing_clvp.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/processing_clvp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6ec5b0035f576ae38daca15adf78292e185bd6c6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/processing_clvp.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/tokenization_clvp.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/tokenization_clvp.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..81b4296c590e0d6061f09f09d7d10a6a8ce14f69 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/clvp/__pycache__/tokenization_clvp.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/code_llama/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/code_llama/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb24b48e9fdeb5d28b44b02e13f8e433e5eada43 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/code_llama/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/code_llama/__pycache__/tokenization_code_llama.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/code_llama/__pycache__/tokenization_code_llama.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..723f66ea28a829e147e2c315779ba21dc9acb23f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/code_llama/__pycache__/tokenization_code_llama.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f464235636edb42dc8c351ed1ffd5eba3bb6f4e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/configuration_codegen.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/configuration_codegen.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..313babba37fc4a113757370d03aff7997db40103 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/configuration_codegen.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/modeling_codegen.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/modeling_codegen.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ad9420d256b3ec142efa99aef6e45bb400d8f42 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/modeling_codegen.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/tokenization_codegen.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/tokenization_codegen.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1504c3e445816ce73d1775bf1a6792fa1fade532 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/codegen/__pycache__/tokenization_codegen.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3fda7a3ddfcf0fc1481bf4733be78e896b5b5207 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/configuration_cohere.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/configuration_cohere.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61eb1eeae4bd827b1a3dbc8df08136ea5c98c59b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/configuration_cohere.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/modeling_cohere.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/modeling_cohere.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7847aaa76403a96ab2e9c0fa13d9fcb3d7fd9aec Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/modeling_cohere.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/modular_cohere.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/modular_cohere.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..552ce64819c74c677d8e39c9360dfc8c2a1c1e4b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/modular_cohere.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/tokenization_cohere.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/tokenization_cohere.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..59994f8f782653e3daea1499e35c3f6e83fa46bf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere/__pycache__/tokenization_cohere.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e44f4b48cc8a8ca969de1e9e0826e29e03eca270 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/configuration_cohere2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/configuration_cohere2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..531857175630c7d907d2595831d16477678f4fab Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/configuration_cohere2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/modeling_cohere2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/modeling_cohere2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2f0cc1d837d7f37b4294d64772b57ee274934b1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/modeling_cohere2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/modular_cohere2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/modular_cohere2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39ab549cccd94ee7e107d49d0ee650b4db945add Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2/__pycache__/modular_cohere2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df3946a508b41ff229fc38ab9b0a85c3942cadf8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/configuration_cohere2_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/configuration_cohere2_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7882f36b2c8dcb497bcf63f88394e7ab5e9baa8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/configuration_cohere2_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/image_processing_cohere2_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/image_processing_cohere2_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..954b12abd073f6a2c9f2f37a5682a3ecc93ca2e1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/image_processing_cohere2_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/modeling_cohere2_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/modeling_cohere2_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ceae0a56aa65c90f62164280069a371e62e213ef Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/modeling_cohere2_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/modular_cohere2_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/modular_cohere2_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfc8541b06369c8ff831552a678302dfe420b9a3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/modular_cohere2_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/processing_cohere2_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/processing_cohere2_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b30c24c5faa38fe3efb336055e4bd6ac25816d4f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere2_vision/__pycache__/processing_cohere2_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d26eeebf82434a1c121a7b82305bd22f8cb0c575 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/configuration_cohere_asr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/configuration_cohere_asr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffb303a947c9304a4f4778d3618c363521e4fe81 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/configuration_cohere_asr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/feature_extraction_cohere_asr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/feature_extraction_cohere_asr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eda9dd96d48c155db7c18525facda35af42287b2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/feature_extraction_cohere_asr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/modeling_cohere_asr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/modeling_cohere_asr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4684ce8a2965f023ad6f58e46841c6d3f2fde130 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/modeling_cohere_asr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/modular_cohere_asr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/modular_cohere_asr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e52cc0498c103c37bda1e1a1cd3c3444ffa1c23 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/modular_cohere_asr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/processing_cohere_asr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/processing_cohere_asr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b70f216307b51f0210d57350643619e76604c3e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cohere_asr/__pycache__/processing_cohere_asr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d223e9301bbbdb836652f886e93ed8edb78e60a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/configuration_colmodernvbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/configuration_colmodernvbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..644336765afb70af5916f6bc8e8e770d71c664e9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/configuration_colmodernvbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/modeling_colmodernvbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/modeling_colmodernvbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e9b821d4f3addf2737fde1b71f2fbe1be5e99d5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/modeling_colmodernvbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/modular_colmodernvbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/modular_colmodernvbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8264b3b88b285cb1607ee6acac909dc1bce536fd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/modular_colmodernvbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/processing_colmodernvbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/processing_colmodernvbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..74a9556dc2fb4439628a0a1acb5290c196b8922a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colmodernvbert/__pycache__/processing_colmodernvbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7c80e7d2c1c2f4750f08c573effe0ccaf19eb8c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/configuration_colpali.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/configuration_colpali.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d2f5ca1fafd2839b41972f9ea8d40854b4f9d59 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/configuration_colpali.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/modeling_colpali.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/modeling_colpali.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..479c637f666596953dfaa4396692c82ebfd1ae18 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/modeling_colpali.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/modular_colpali.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/modular_colpali.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5bfa132af02297f66e3eede786ebc60815c6c8d8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/modular_colpali.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/processing_colpali.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/processing_colpali.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..850478b678e6e64d21b8b623f7b16d61d010f7f4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colpali/__pycache__/processing_colpali.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c40eeabf45a69a6b1670fca1469d1e68c5ed202e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/configuration_colqwen2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/configuration_colqwen2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c98b8dbe5231cb0670a789635974fa03c0220403 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/configuration_colqwen2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/modeling_colqwen2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/modeling_colqwen2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72578305c806f53a8b5eb64a199595685a7991e6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/modeling_colqwen2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/modular_colqwen2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/modular_colqwen2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab184dd410ca249748511d8d2efff2073b142fef Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/modular_colqwen2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/processing_colqwen2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/processing_colqwen2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..883b65d636213a993fa5640717f3822c4ff2ad93 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/colqwen2/__pycache__/processing_colqwen2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e57de2f301c8ee62047f38e432c76f5714a47ad9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/configuration_conditional_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/configuration_conditional_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..63d249f52aa998e8aefe6a4f2e7154df36453aad Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/configuration_conditional_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/image_processing_conditional_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/image_processing_conditional_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65aaf0479c821ec2bb8f864be340cc7281263686 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/image_processing_conditional_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/image_processing_pil_conditional_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/image_processing_pil_conditional_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6d15a61fa82189915b58819a4026033db47b42f5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/image_processing_pil_conditional_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/modular_conditional_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/modular_conditional_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d059da7b871a95ae0a56b71cbc8fb49c52afb99 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/conditional_detr/__pycache__/modular_conditional_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b024fbc581dad1f8a8d96c9d36246ec95cdafcb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/configuration_convbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/configuration_convbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0476f808354ec485cc528514356974de086a95ee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/configuration_convbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/modeling_convbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/modeling_convbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a8ad69fde97468a802ed97d792970010c39fabc4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/modeling_convbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/tokenization_convbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/tokenization_convbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c69a77819e55698f6b6ff6e5629fc0c82a2d8d6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convbert/__pycache__/tokenization_convbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7cdf9257ead2723203495a5a2a76a82629d5deaf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/configuration_convnext.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/configuration_convnext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..49415cfeef06e65d6a8655a86b7e4f868d871320 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/configuration_convnext.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/image_processing_convnext.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/image_processing_convnext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b93d6b27413965ea7b84be3bc809b6bcb2ad0aa1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/image_processing_convnext.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/image_processing_pil_convnext.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/image_processing_pil_convnext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80e566c76700874de5b31faab80b8df1fbce8fad Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/image_processing_pil_convnext.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/modeling_convnext.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/modeling_convnext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52896de32764e9d240048362c97aca032b31dec1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnext/__pycache__/modeling_convnext.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fad22662184820701fbc44f00834f93b7cb6b761 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/configuration_convnextv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/configuration_convnextv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5d8549005b7fd6a65a826d417a9917fa6751fe8e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/configuration_convnextv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/modeling_convnextv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/modeling_convnextv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b35144d61bb01906793057655d011f3f4baa03b7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/convnextv2/__pycache__/modeling_convnextv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7bccfae81d3db6799eb032b4d004e6a1d8b9e9d7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/tokenization_cpm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/tokenization_cpm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0a56f271cac53fe5bd56aaf9892b7b32eb9d605 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/tokenization_cpm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/tokenization_cpm_fast.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/tokenization_cpm_fast.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..421549cf629b8c33e1d01dfb05c1272a1033dcd1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpm/__pycache__/tokenization_cpm_fast.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4ce10d165f468b53cca6e8d55e810a34241c3f1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/configuration_cpmant.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/configuration_cpmant.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b579f45e550569c0c662bb5ebc412e6b98f6ecf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/configuration_cpmant.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/modeling_cpmant.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/modeling_cpmant.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4cd0c8a7c730fa2a610405232d18508c2938903 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/modeling_cpmant.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/tokenization_cpmant.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/tokenization_cpmant.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..508819875228a14f2a733111c854f0d615d9e5ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cpmant/__pycache__/tokenization_cpmant.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..06631112475857a26a698cf9a66879f114c6be06 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/configuration_csm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/configuration_csm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5daf553ccbff54fc05d73e95786ac4876a72596f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/configuration_csm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/generation_csm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/generation_csm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..039e6b1eda54ba2845834b475c133c0205c795ca Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/generation_csm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/modeling_csm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/modeling_csm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4a4c8e2910b66327604f2f0daf8ea1facdabf6e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/modeling_csm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/modular_csm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/modular_csm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65648f23932539a77ee18e0b6ef727aef3d37bb7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/modular_csm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/processing_csm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/processing_csm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3fe931baf545c1e1a73ba40ddd03e4b11459ee7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/csm/__pycache__/processing_csm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58fe945f3b709901fa4c95c70c0aa8f31c31c40b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/configuration_ctrl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/configuration_ctrl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee5bb065858f4d68b4446f1e2ef890bd7910494b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/configuration_ctrl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/modeling_ctrl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/modeling_ctrl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f541693f8b34c3d7320c038e7e053e37873f36d8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/modeling_ctrl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/tokenization_ctrl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/tokenization_ctrl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..716c43679cb36ad9ebe4f5dee1b070b2e4084d40 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ctrl/__pycache__/tokenization_ctrl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8901fb7cb0c143606c9beefec9835ca9d2ea3a09 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/configuration_cvt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/configuration_cvt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc2e88d4ac08e3f9b1f6af42786d458214524f0a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/configuration_cvt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/modeling_cvt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/modeling_cvt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a6c0c15421ed26f6c96b404b360f2b3885d5bd78 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cvt/__pycache__/modeling_cvt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f61e53fd123a616f9b3d92846799adfd974bb73 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/configuration_cwm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/configuration_cwm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..68878172a7ef41d2e399dd837157355d2d35c9b7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/configuration_cwm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/modeling_cwm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/modeling_cwm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..295444f7094bb6f9f93e4d2e42251073e981cfe7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/modeling_cwm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/modular_cwm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/modular_cwm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75622dc307eccd3556c395aef29b268c1b9f1a7a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/cwm/__pycache__/modular_cwm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a3c0e89457b1185af317873f7ebf3fbfb3884fd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/configuration_d_fine.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/configuration_d_fine.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97dd28c578ad914ff4a0f8446c2aa0b9f8cb36a0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/configuration_d_fine.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/modular_d_fine.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/modular_d_fine.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b81aa06b0e2b55631591ffdfb3c521a6e921f3bd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/d_fine/__pycache__/modular_d_fine.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e165b14ba958fd6cbd50faa6e4305ccb6bf4991 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/configuration_dab_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/configuration_dab_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..413af7e7837793ab92e5d89dbe1a652410e3cbb8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/configuration_dab_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/modeling_dab_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/modeling_dab_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bdefdcf9e2a79b3b5eefcc932ca068b2325648d1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dab_detr/__pycache__/modeling_dab_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6eed713f1c5457d583f8d233e18e22633f028e2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/configuration_dac.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/configuration_dac.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f782e3fa6684f9b0b600f3bfad3fbacfa9e7a7d9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/configuration_dac.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/feature_extraction_dac.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/feature_extraction_dac.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..696bfcc9140886747b1279fdea923581b69b5634 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/feature_extraction_dac.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/modeling_dac.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/modeling_dac.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e51cb3af94915f6670bd181c3c4819125087c6c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dac/__pycache__/modeling_dac.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e63f93be4d81e3b166e0a93814a383899b2f7538 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_audio.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_audio.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e70fcf1d7d7c4cc1169f12712fcfa9952116c7b8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_audio.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4011ffde9ca059a02b82e761f7d8e265edff71e4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b01c4965c8c0cc29e3ff4a3660d5cfc6f8ac4ef Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/configuration_data2vec_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_audio.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_audio.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82cdf47dff86039e509b5204f9c059bdf6a2d64b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_audio.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d5fc1f1a73ff3bc9f607a12470a96794eeb7c328 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c06f48f27a5c78242587cf3386d2bd9e69194cd4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modeling_data2vec_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modular_data2vec_audio.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modular_data2vec_audio.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..01f9f45c92a3595c7f9a3b8785ebb81151c8a816 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modular_data2vec_audio.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modular_data2vec_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modular_data2vec_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1e34b888f6f50714a86d7b6cf7d2b8b4e76b9a2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/data2vec/__pycache__/modular_data2vec_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd0c24cbea41ebe68573db0ef10bc81c484b2dcf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/configuration_dbrx.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/configuration_dbrx.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7fd910a98c189bdaea6b39b413c1e8debc5fc38 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/configuration_dbrx.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/modeling_dbrx.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/modeling_dbrx.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..820760a0dea92fa9102a5adc81df18841c840349 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/modeling_dbrx.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/modular_dbrx.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/modular_dbrx.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..155f181947f426baee6975dbd669dd6e71a10d4b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dbrx/__pycache__/modular_dbrx.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80a47a3e8de05360483bdf6e750ae8ef527a6e12 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/configuration_deberta.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/configuration_deberta.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48efb8c8dd72aef0134e9600c8673d71ed8037d4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/configuration_deberta.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/modeling_deberta.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/modeling_deberta.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..234ca7454474b6d8014ad6228081baa111eb5a51 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/modeling_deberta.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/tokenization_deberta.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/tokenization_deberta.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c00824a6415742496316f394be1fa239c514ccd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta/__pycache__/tokenization_deberta.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ebb61b4826063b2ecea096f693fe47ba41ed48b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/configuration_deberta_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/configuration_deberta_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39f7799d6b0b9b274d99520ad6a42e1e2e11933d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/configuration_deberta_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/modeling_deberta_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/modeling_deberta_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89c03f24b6a8ff26285dce16e1d47d90082fbb4f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/modeling_deberta_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/tokenization_deberta_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/tokenization_deberta_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6fc886cd4dc36efaab53ca6bc2688683f9168265 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deberta_v2/__pycache__/tokenization_deberta_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..905dfaf9ef8cd90a11541a7713643f04b1b8790c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/configuration_decision_transformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/configuration_decision_transformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82d5b30354e9f53814246efb474b8206490dfb52 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/configuration_decision_transformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/modeling_decision_transformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/modeling_decision_transformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ba7c6159536e4bcfec0dbef7b5c4ff5924d6beac Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/decision_transformer/__pycache__/modeling_decision_transformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d03d642cc2196a104f61edefd5835a36d7c0fdc2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/configuration_deepseek_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/configuration_deepseek_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bde220fcd0b128b7a614562cb6a689f0097bfcf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/configuration_deepseek_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/modeling_deepseek_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/modeling_deepseek_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..98ccd676752e02dc258e2de43b1068ffd7163814 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/modeling_deepseek_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/modular_deepseek_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/modular_deepseek_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03022f4a72ddd8a9083747a13e432f0894df7c1e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v2/__pycache__/modular_deepseek_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4309386b7b5726c835498740dc0ae9b6b9e55a1e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/configuration_deepseek_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/configuration_deepseek_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3f4e8282905323932ccf45f01316df88701a94e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/configuration_deepseek_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/modeling_deepseek_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/modeling_deepseek_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7611b4d82b47783d7ce06f97c40e5ec7477d3e21 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/modeling_deepseek_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/modular_deepseek_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/modular_deepseek_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..55cdddba596e9a6deed868232ea348ebc103e616 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v3/__pycache__/modular_deepseek_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..314a96974d5c7020c06c0fb4e08b3ffb90f4960a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/configuration_deepseek_v4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/configuration_deepseek_v4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bd86fb9adb4ad1a9fb270a599b453dd44ffb0cb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/configuration_deepseek_v4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/modeling_deepseek_v4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/modeling_deepseek_v4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce5f684a78fd2e5b6fbda1bfdf96ad5f89feb61d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/modeling_deepseek_v4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/modular_deepseek_v4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/modular_deepseek_v4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b01b20ebc4a6a62a2ec879fbec62b4ae8fed651f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_v4/__pycache__/modular_deepseek_v4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..438d50528a6e6ee1a025df50f23441b8dd07f470 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/configuration_deepseek_vl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/configuration_deepseek_vl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..626a906000f3d2e37aaf2a850a575985f72dc27d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/configuration_deepseek_vl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/image_processing_deepseek_vl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/image_processing_deepseek_vl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..daea03cc36616a573801939ff52285266f4d4d3e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/image_processing_deepseek_vl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/image_processing_pil_deepseek_vl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/image_processing_pil_deepseek_vl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..991ab43c11789a048faaf22163c1a4dc92702062 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/image_processing_pil_deepseek_vl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/modeling_deepseek_vl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/modeling_deepseek_vl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c62e0616bc6d7f31ec0a40b894140b67513a7cd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/modeling_deepseek_vl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/modular_deepseek_vl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/modular_deepseek_vl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..57a01eafb6bc87df3fb754b869b7b90976b0e859 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/modular_deepseek_vl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/processing_deepseek_vl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/processing_deepseek_vl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e48ee37730b2251469b2511830b4e0ca8be14da Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl/__pycache__/processing_deepseek_vl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..275fd0a22f5b49289b9603715f91dcb43d08a9dd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/configuration_deepseek_vl_hybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/configuration_deepseek_vl_hybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c20eb7071a5ee4d410e225c5e577825e02f09c5c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/configuration_deepseek_vl_hybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/image_processing_deepseek_vl_hybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/image_processing_deepseek_vl_hybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b2c8947a7ccb5dcd5f068ba9a4c9c0bd8f3f359 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/image_processing_deepseek_vl_hybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/image_processing_pil_deepseek_vl_hybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/image_processing_pil_deepseek_vl_hybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa2c21ddb760ecb967f769100521ee6fc1d3de7d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/image_processing_pil_deepseek_vl_hybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/modeling_deepseek_vl_hybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/modeling_deepseek_vl_hybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fd843b04c6075e14001235007cc789e96e716754 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/modeling_deepseek_vl_hybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/modular_deepseek_vl_hybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/modular_deepseek_vl_hybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ea21faa2792c9359463454f462dda99763e802d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/modular_deepseek_vl_hybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/processing_deepseek_vl_hybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/processing_deepseek_vl_hybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1e6a081f2591d6aa18527aa6cba36462c300ac64 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deepseek_vl_hybrid/__pycache__/processing_deepseek_vl_hybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..986356bafba747e06fe8e52d8778b486aabbff1c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/configuration_deformable_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/configuration_deformable_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f856de9d0b9077968c9ea69924047a0bef6cdc94 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/configuration_deformable_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..47239061770820972b581840d03a26b080807754 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_deformable_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_pil_deformable_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_pil_deformable_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a209eab61ab3ef263b72fd660bb8f1c86d0fea6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/image_processing_pil_deformable_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/modeling_deformable_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/modeling_deformable_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5085abfe45b196d47b5213457a5fe175fd8cf118 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/modeling_deformable_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/modular_deformable_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/modular_deformable_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..316b4025d2587e1489e8dfba5d6bce479a37eec3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deformable_detr/__pycache__/modular_deformable_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f57258c44328fe78832e0459743c19115e4f95bb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/configuration_deimv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/configuration_deimv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ebd5840320dc509bc1027c25ba8d218953a5b7c2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/configuration_deimv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/modular_deimv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/modular_deimv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0663ecdebb928be4aa6edd07df82b6e917e176e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deimv2/__pycache__/modular_deimv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..041210e9060819244ae428c41cf5c1674c71841d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/configuration_deit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/configuration_deit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a80da381044a5925d65d27c2916f4396217c535a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/configuration_deit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/image_processing_deit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/image_processing_deit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8637eebfd5e8b06efffd2e1b90da3d021b770a4a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/image_processing_deit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/image_processing_pil_deit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/image_processing_pil_deit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d93ba5922de153b170288a085ed573dc0e7cfc34 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/image_processing_pil_deit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/modeling_deit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/modeling_deit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8df4649e1b18d1af13d332336a73258310b4ae1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deit/__pycache__/modeling_deit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deprecated/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deprecated/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7f1e3f6324bfe556a1ffc8c33dd70157bc4edf28 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/deprecated/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eebac7a58e355381d66094804586f907b8de437d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/configuration_depth_anything.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/configuration_depth_anything.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af0fc8004b2cb50af7475fbe2e962bcb18235792 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/configuration_depth_anything.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/modeling_depth_anything.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/modeling_depth_anything.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97cce3c8b4d6fc46ebdf2c6d37a7d3276cda0e3d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_anything/__pycache__/modeling_depth_anything.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e62173e362957882134f6b1f30990f65f13adc5b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/configuration_depth_pro.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/configuration_depth_pro.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fafd38e8d274f3d7bbafd933c2f24e75ae6ceb82 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/configuration_depth_pro.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/image_processing_depth_pro.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/image_processing_depth_pro.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..05244050363c42127b54e1712af05bf2356f0b6a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/image_processing_depth_pro.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/modeling_depth_pro.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/modeling_depth_pro.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..23194207c41a048b181e619ff0fc26251845a639 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/depth_pro/__pycache__/modeling_depth_pro.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b578ffe572d37307c6a2d9e686e380005c7c4ee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/configuration_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/configuration_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d08e1fdd7e457da958951e1cf321e21ef5f781f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/configuration_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/image_processing_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/image_processing_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04295ed2774868160cc943231b765b6fd2670557 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/image_processing_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/image_processing_pil_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/image_processing_pil_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62559565e481a8bd191c2544c86df8c5d6119adb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/image_processing_pil_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/modeling_detr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/modeling_detr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b969443f52db0c110626a97f2dcfef339bf8147 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/detr/__pycache__/modeling_detr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa96877b1c99a9c359d3a3eb5a8ffda13ce7ea4f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/configuration_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/configuration_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c64cafe8688b801b9636ffbce59f8ac99a3f5265 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/configuration_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/feature_extraction_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/feature_extraction_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1e26dafe96acd1e9a162ac70e97d2a436a1d39f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/feature_extraction_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/generation_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/generation_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..207a9555ff22bd22a13cacdce532b5960522e42c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/generation_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/modeling_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/modeling_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..acacbcc9d00f57a4af808e6bf570b73624f5ec04 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/modeling_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/modular_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/modular_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..555f04e1c38536f9c234f382d4fb65aa54fd2a63 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/modular_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/processing_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/processing_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c919742d9c928b1e29912b8cd5642d8af2e56bc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/processing_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/tokenization_dia.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/tokenization_dia.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..22675246617f41bcb7c10ac2941f2f9bd28f303a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dia/__pycache__/tokenization_dia.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dialogpt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dialogpt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d970be92fc94d2bf5f87a2c05ca744aa619b843 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dialogpt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe921b6b7d094dfc2af3ecc315306b43f4a0a541 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/configuration_diffllama.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/configuration_diffllama.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e931c5c6b912943a4c77ffbb714a63cb1602900d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/configuration_diffllama.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/modeling_diffllama.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/modeling_diffllama.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..59a5bd3ef90a76c2c2f3e918d6eb26ba02cb3d8e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/modeling_diffllama.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/modular_diffllama.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/modular_diffllama.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..43f72e62a44458923fa8ebd8588e6f074c73eaaf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/diffllama/__pycache__/modular_diffllama.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ab4a8e58eac890464cd60e4fea8bb33fd8e7b08 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/configuration_dinat.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/configuration_dinat.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..65e87b0b9cce3582bab12ee4c85b06667d15ef97 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/configuration_dinat.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/modeling_dinat.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/modeling_dinat.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3c49cf7fddc0f89ccb50fcf4a834e3bd593d7f9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinat/__pycache__/modeling_dinat.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8199c59b26f53bff5274839e0b593b91b192356c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/configuration_dinov2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/configuration_dinov2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..13c7715c4cc5746ee0a062a30eaf4a86b0df9684 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/configuration_dinov2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/modeling_dinov2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/modeling_dinov2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aab6c03d5616454312e0d68d3b75dd9937a19c8a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2/__pycache__/modeling_dinov2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7dce849055e2905d1657b6d8d455221404cceeee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/configuration_dinov2_with_registers.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/configuration_dinov2_with_registers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..daf09ee75757b746a9eb3356d62388d6f1894525 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/configuration_dinov2_with_registers.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/modeling_dinov2_with_registers.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/modeling_dinov2_with_registers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82503829c6fabe0d0d931e97f7cd9a5c49d39597 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/modeling_dinov2_with_registers.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/modular_dinov2_with_registers.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/modular_dinov2_with_registers.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2ab4db420bbe12ba90175277d13bccbf54118fe Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov2_with_registers/__pycache__/modular_dinov2_with_registers.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5beb64d2ef0672bb93e32a32d05302d44f0308de Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/configuration_dinov3_convnext.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/configuration_dinov3_convnext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..333b6f90bdb25254ad108e6c1ee9f4687833f930 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/configuration_dinov3_convnext.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/modeling_dinov3_convnext.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/modeling_dinov3_convnext.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b633a0a81b25b51d1633e5f082ebb64cc784018 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_convnext/__pycache__/modeling_dinov3_convnext.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..44611883c95b8e50cd4fd31ba70b8d96f5590879 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/configuration_dinov3_vit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/configuration_dinov3_vit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3f76b073a87903b54fb398a0ff34db394e5115ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/configuration_dinov3_vit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/image_processing_dinov3_vit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/image_processing_dinov3_vit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6ad655b968e13cb9a73f7d15b51778de596e67a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/image_processing_dinov3_vit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/modeling_dinov3_vit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/modeling_dinov3_vit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b10820d790a9bb36c9c3752d3989952b92bf5d1b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/modeling_dinov3_vit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/modular_dinov3_vit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/modular_dinov3_vit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c008176a9e5810f995ce7a360ad6cad192de0837 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dinov3_vit/__pycache__/modular_dinov3_vit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..67a3e0a9900abef164800304692c02beb797fa6e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/configuration_distilbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/configuration_distilbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0aec07e7ee35be9a813005f7b5bc61eec83d27d0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/configuration_distilbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/modeling_distilbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/modeling_distilbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fdbc4583788ac10971428d598d7ae193fa603f8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/modeling_distilbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/tokenization_distilbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/tokenization_distilbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6059abd23361baec066d50a3972c136224dc339f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/distilbert/__pycache__/tokenization_distilbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dit/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dit/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7211745f79d553a148c6ab3f6397060c94375ceb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dit/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5d41d9b7b38ca7820b6e6a85350af345134e930 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/configuration_doge.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/configuration_doge.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54e443a4972790eb9e0f4d7465b7f1dafa45495f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/configuration_doge.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/modeling_doge.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/modeling_doge.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0db72da2ae38d12d25a842785257ee16fb90bcb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/modeling_doge.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/modular_doge.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/modular_doge.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f7969c476fb13422f83b2452dffd84f3680ee7f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/doge/__pycache__/modular_doge.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b239e638dac3c1dd80e01dfa1a4b58a34b927ab6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/configuration_donut_swin.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/configuration_donut_swin.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fb77977820c68e440055fe79d3ae93f676985b51 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/configuration_donut_swin.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/image_processing_donut.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/image_processing_donut.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4ac39bdbec57f8d59924b2780e8c7c10bcbd904 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/image_processing_donut.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/image_processing_pil_donut.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/image_processing_pil_donut.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cefab7d81efdbb6b13fa55cf0c0310f0a1718d2b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/image_processing_pil_donut.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/modeling_donut_swin.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/modeling_donut_swin.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecb595c802f9fc727d9f07f318966efcbc5e9153 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/modeling_donut_swin.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/processing_donut.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/processing_donut.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e0b32c0e331159213e55065f726c59bed4d1623 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/donut/__pycache__/processing_donut.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..45f21117d2dc67d7f9c0b863c4c16eea282ec3b4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/configuration_dots1.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/configuration_dots1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6cd71623bfc047677175409e3f5ec3e4278be0ff Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/configuration_dots1.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/modeling_dots1.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/modeling_dots1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..085634f64ed0692e4a387a164c811417cd077be7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/modeling_dots1.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/modular_dots1.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/modular_dots1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e07740fc64ac3666f9c8c7a9d80836cead260f7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dots1/__pycache__/modular_dots1.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c22441543f6dff44b54db1afc9584d1d5eb93091 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/configuration_dpr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/configuration_dpr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5e42c7ea5d18ebe5ed336070f81a25ede179f54 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/configuration_dpr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/modeling_dpr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/modeling_dpr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5796d37f6064d1527c5d4c217ca5b8f6735223fa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/modeling_dpr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/tokenization_dpr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/tokenization_dpr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf39668f97ab2ab21908c0ae48297b3e6ba30e88 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/tokenization_dpr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/tokenization_dpr_fast.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/tokenization_dpr_fast.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc1be2ee2388b880a88296fc4e158638f3b5881e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpr/__pycache__/tokenization_dpr_fast.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0149d45c6a76bcd36eb6c7086f8e2cc69f551f7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/configuration_dpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/configuration_dpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52ec62e18e075ec2448878840ff9585cf3e9ea1e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/configuration_dpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/image_processing_dpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/image_processing_dpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d0960006e4e26d900ef2bf6ab2c66d1fff046af Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/image_processing_dpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/image_processing_pil_dpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/image_processing_pil_dpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0a7fc1191ef58951f01f63a66c96a4817576b712 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/image_processing_pil_dpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/modeling_dpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/modeling_dpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..589d481491fa08993a6fb7ed755684b92756f58f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/modeling_dpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/modular_dpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/modular_dpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eac6f8be890384c878fdb326c9d5e3d0f8735aa3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/dpt/__pycache__/modular_dpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9394d1b17d389541175081ebbe7e791b4153360f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/configuration_edgetam.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/configuration_edgetam.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfbbce1961e8e40ba988ed1ac2155d124ed1134e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/configuration_edgetam.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/modeling_edgetam.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/modeling_edgetam.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..620caefdda43c3481230aaa4e5bccd3d8b9710d9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/modeling_edgetam.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/modular_edgetam.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/modular_edgetam.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e9470675a5bbe5059ed8d6e650aa02f2d763224 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam/__pycache__/modular_edgetam.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18bb2037f0341101b38a9834902e2bf598a7a64a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/configuration_edgetam_video.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/configuration_edgetam_video.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7482797c62763ab51249aef82d181ffa2dea5ee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/configuration_edgetam_video.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/modular_edgetam_video.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/modular_edgetam_video.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7541050bf164f25e445943e7d1d55436dcdd4386 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/edgetam_video/__pycache__/modular_edgetam_video.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e9d386e89ed4569cfa0bd985d7eabe797e372c4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/configuration_efficientloftr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/configuration_efficientloftr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fda31f5728782e55f787c1f066f033c0945de16b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/configuration_efficientloftr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/image_processing_efficientloftr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/image_processing_efficientloftr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd52577f8252bb86e695244a3a0dcdd041b2e612 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/image_processing_efficientloftr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/image_processing_pil_efficientloftr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/image_processing_pil_efficientloftr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..07c33047aebeb816fce502987e6a53a654b021cb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/image_processing_pil_efficientloftr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/modeling_efficientloftr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/modeling_efficientloftr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7f0d046cadc9ad22762af883e8c5b03c4aaef9f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/modeling_efficientloftr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/modular_efficientloftr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/modular_efficientloftr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bb53a36b920f49182f4f01b40289e7600cee365 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientloftr/__pycache__/modular_efficientloftr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7c0a0ae735c5c547ecbbb4816b0d5ccb17b9b0f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/configuration_efficientnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/configuration_efficientnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40290503fdb9c650f22e6532c4f7ecb1affba03f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/configuration_efficientnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/image_processing_efficientnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/image_processing_efficientnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d97a52efceb7b209e8f84e8de0b9ac0d8309b60 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/image_processing_efficientnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/image_processing_pil_efficientnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/image_processing_pil_efficientnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c2a37c5c899a1820b0f78d0182fb02bdc59889cf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/image_processing_pil_efficientnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/modeling_efficientnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/modeling_efficientnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..642337164d3a978d34ffd5e96b2e6e62e4d86a42 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/efficientnet/__pycache__/modeling_efficientnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af8ea86a2334d768300f5384935ed5eeb569c4bf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/configuration_electra.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/configuration_electra.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46bf96941276c5961e591f00d13e7462324a7ecb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/configuration_electra.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/modeling_electra.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/modeling_electra.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..beb0e18505cf053288e9b35ab2a2bac37fa5cdf7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/electra/__pycache__/modeling_electra.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..534fcf3fa0a667be64ae00275aafd71528a7df08 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/configuration_emu3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/configuration_emu3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c158b94d0188a274a2b8d66889c724b537f83f97 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/configuration_emu3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/image_processing_emu3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/image_processing_emu3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9cb59ab8bcc8fd0a7afed07c184c8769e2bc3da Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/image_processing_emu3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/modeling_emu3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/modeling_emu3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62c40926ce30d74b660ab5e50abb52d6e60c1cd7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/modeling_emu3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/modular_emu3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/modular_emu3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa40e0001cd6e67bb7e673d393141d4471b6a9cc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/modular_emu3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/processing_emu3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/processing_emu3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e9707a74ce54fdc32755b140558eff5eb2226167 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/emu3/__pycache__/processing_emu3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1e7bfb89270d402b58db92f83240ed4e8367d56 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/configuration_encodec.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/configuration_encodec.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e0d7240b0ff4ab607d0edf4c5641fccd77382be3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/configuration_encodec.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/feature_extraction_encodec.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/feature_extraction_encodec.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31655216c5b41d21fb46b8b24ba68b88e676640d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/feature_extraction_encodec.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/modeling_encodec.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/modeling_encodec.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8907595f0a5b857070ee0549f9d55da7cd51feec Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encodec/__pycache__/modeling_encodec.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..370871023f7ae33d79b438d5884f04de68eea58d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/configuration_encoder_decoder.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/configuration_encoder_decoder.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..092cc1520ceced4ec9a3a9ac76305c6d96917172 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/configuration_encoder_decoder.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/modeling_encoder_decoder.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/modeling_encoder_decoder.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03e4c2a9e7f10ba7acfb25b5fa06245a47811bf6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/encoder_decoder/__pycache__/modeling_encoder_decoder.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d90f365fb46d651a988f4c8a087776bb9003446b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/configuration_eomt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/configuration_eomt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e932164f0438165419d01c466093ce3d57ce79ab Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/configuration_eomt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/image_processing_eomt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/image_processing_eomt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f4449c7908fbf451ad334b6ee7c154d429ad2c33 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/image_processing_eomt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/image_processing_pil_eomt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/image_processing_pil_eomt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d96647ff809aa81a69526659626a203b2a936bd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/image_processing_pil_eomt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/modeling_eomt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/modeling_eomt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5440f8ce364660deb30e25cf62021c8455ac8bea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/modeling_eomt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/modular_eomt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/modular_eomt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1cd6ef2a45cb699ce47ec6ae453cbdc2925bfda Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt/__pycache__/modular_eomt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e7317f17f502d658578b35ded47a6c8aae4f91b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/configuration_eomt_dinov3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/configuration_eomt_dinov3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f4de155803575f2c150cef3b6d29a9e504d689f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/configuration_eomt_dinov3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/modeling_eomt_dinov3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/modeling_eomt_dinov3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..914348d43fc92851eb3052d0469bb7020a94bee5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/modeling_eomt_dinov3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/modular_eomt_dinov3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/modular_eomt_dinov3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e02979065320e3a6f47c4a2e3211b895217d5fcd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eomt_dinov3/__pycache__/modular_eomt_dinov3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5dcee9d45281a743bced79d5ecca2f559e57db46 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/configuration_ernie.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/configuration_ernie.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83967d0cbd35e23f02caef656f46381b61c0da97 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/configuration_ernie.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/modeling_ernie.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/modeling_ernie.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aff9f8fc1e36a799b0140f3c011867eab508d553 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/modeling_ernie.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/modular_ernie.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/modular_ernie.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9dd7bd3a8147277bb3e19001ef39d11d5a24470d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie/__pycache__/modular_ernie.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..93913b4b6a953e97013819c10c29b9f631391f82 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/configuration_ernie4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/configuration_ernie4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..87321bcea5ffd33cc9f84f34148cffb5dd942e79 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/configuration_ernie4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/modeling_ernie4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/modeling_ernie4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d44f65ec8b99f46cc8f51c0aef6f3df79efdd1df Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/modeling_ernie4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/modular_ernie4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/modular_ernie4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3212197d9b867aa32370f1d3e8415575d25661de Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5/__pycache__/modular_ernie4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..241a305e5779957d14d1e1fd0133f878b3de5468 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/configuration_ernie4_5_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/configuration_ernie4_5_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a5487a47c7f7933d7e13afc759d7391ae24d2241 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/configuration_ernie4_5_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/modeling_ernie4_5_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/modeling_ernie4_5_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ddb06aa5a8bafdc6568789ce4189c118b53fec3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/modeling_ernie4_5_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/modular_ernie4_5_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/modular_ernie4_5_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc0975fcf2f291e0884aa0c80e42ad89dcf30f77 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_moe/__pycache__/modular_ernie4_5_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d402f5e588edaf71e89f204ad89375f07d723cb0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/configuration_ernie4_5_vl_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/configuration_ernie4_5_vl_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2207fb9419d93d7f4174b31b4525bdd38d54c70 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/configuration_ernie4_5_vl_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/image_processing_ernie4_5_vl_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/image_processing_ernie4_5_vl_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cfd51563d4497eabf5bebabbd920087f5229021e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/image_processing_ernie4_5_vl_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/image_processing_pil_ernie4_5_vl_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/image_processing_pil_ernie4_5_vl_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..750f63e9de6ef82ef63c6cec54b86a0933ae69d1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/image_processing_pil_ernie4_5_vl_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/modular_ernie4_5_vl_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/modular_ernie4_5_vl_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b79a28fde81899b2d84a8761a489ebc840cd302d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/modular_ernie4_5_vl_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/processing_ernie4_5_vl_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/processing_ernie4_5_vl_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab5da5329308787733e25fe338a962d9e1e65992 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/processing_ernie4_5_vl_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/video_processing_ernie4_5_vl_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/video_processing_ernie4_5_vl_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6193389e5a357c472cbdfa13abae164eadc29656 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ernie4_5_vl_moe/__pycache__/video_processing_ernie4_5_vl_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37554f32467128f370b692e34b2cb87c4cad49e7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/configuration_esm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/configuration_esm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3b951d107e21ce37aea871179c83b7be5b777dba Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/configuration_esm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/modeling_esm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/modeling_esm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ae8a0ea848bea2b9631340768d31299c836a25b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/modeling_esm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/tokenization_esm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/tokenization_esm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ca203db1996c1ac3430d9845032485e1e5817be Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/__pycache__/tokenization_esm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__init__.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..02a8c149ae320dd9b045edc5df31760a4eebefd9 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__init__.py @@ -0,0 +1,8 @@ +from .chunk_utils import chunk_layer +from .data_transforms import make_atom14_masks +from .feats import atom14_to_atom37, frames_and_literature_positions_to_atom14_pos, torsion_angles_to_frames +from .loss import compute_predicted_aligned_error, compute_tm +from .protein import Protein as OFProtein +from .protein import to_pdb +from .rigid_utils import Rigid, Rotation +from .tensor_utils import dict_multimap, flatten_final_dims, permute_final_dims diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d1330877983d285a6dae302bcb3d8ca9a3d264e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/chunk_utils.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/chunk_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..503fcce45b877b9e5db2033f79ceb05becef04d8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/chunk_utils.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/data_transforms.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/data_transforms.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..71a8ac9804745daf15fc9be0e44911e8dc599ae4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/data_transforms.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/feats.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/feats.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50874b61374af5f67aba31f0ac46ef4bb3b5d042 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/feats.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/loss.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/loss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1b59223fcabcbf0b0aa022ade1da7b2816cdf751 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/loss.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/protein.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/protein.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0f154c26643ef69c0df2480430beb7f5dc31db6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/protein.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/residue_constants.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/residue_constants.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7fcebdb412eacbe82289ab41d851abb1374d90c0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/residue_constants.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/rigid_utils.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/rigid_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48116d93de7c6aceba6311d4e80b6d91d9d457a3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/rigid_utils.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/tensor_utils.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/tensor_utils.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2aa29020445ac99b39ab801be4a8dde7a180a09c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/__pycache__/tensor_utils.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/chunk_utils.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/chunk_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2146a481c8b8eec5f2d33da178eda10d506dcde9 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/chunk_utils.py @@ -0,0 +1,398 @@ +# Copyright 2021 AlQuraishi Laboratory +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +import logging +import math +from collections.abc import Callable, Iterable, Sequence +from functools import partial +from typing import Any + +import torch + +from .tensor_utils import tensor_tree_map, tree_map + + +def _fetch_dims(tree: dict | list | tuple | torch.Tensor) -> list[tuple[int, ...]]: + shapes = [] + if isinstance(tree, dict): + for v in tree.values(): + shapes.extend(_fetch_dims(v)) + elif isinstance(tree, (list, tuple)): + for t in tree: + shapes.extend(_fetch_dims(t)) + elif isinstance(tree, torch.Tensor): + shapes.append(tree.shape) + else: + raise TypeError("Not supported") + + return shapes + + +@torch.jit.ignore +def _flat_idx_to_idx(flat_idx: int, dims: tuple[int, ...]) -> tuple[int, ...]: + idx = [] + for d in reversed(dims): + idx.append(flat_idx % d) + flat_idx = flat_idx // d + + return tuple(reversed(idx)) + + +@torch.jit.ignore +def _get_minimal_slice_set( + start: Sequence[int], + end: Sequence[int], + dims: Sequence[int], + start_edges: Sequence[bool] | None = None, + end_edges: Sequence[bool] | None = None, +) -> list[tuple[slice, ...]]: + """ + Produces an ordered sequence of tensor slices that, when used in sequence on a tensor with shape dims, yields + tensors that contain every leaf in the contiguous range [start, end]. Care is taken to yield a short sequence of + slices, and perhaps even the shortest possible (I'm pretty sure it's the latter). + + end is INCLUSIVE. + """ + + # start_edges and end_edges both indicate whether, starting from any given + # dimension, the start/end index is at the top/bottom edge of the + # corresponding tensor, modeled as a tree + def reduce_edge_list(l: list[bool]) -> None: + tally = True + for i in range(len(l)): + reversed_idx = -1 * (i + 1) + l[reversed_idx] &= tally + tally = l[reversed_idx] + + if start_edges is None: + start_edges = [s == 0 for s in start] + reduce_edge_list(start_edges) + if end_edges is None: + end_edges = [e == (d - 1) for e, d in zip(end, dims)] + reduce_edge_list(end_edges) + + # Base cases. Either start/end are empty and we're done, or the final, + # one-dimensional tensor can be simply sliced + if len(start) == 0: + return [()] + elif len(start) == 1: + return [(slice(start[0], end[0] + 1),)] + + slices: list[tuple[slice, ...]] = [] + path_list: list[slice] = [] + + # Dimensions common to start and end can be selected directly + for s, e in zip(start, end): + if s == e: + path_list.append(slice(s, s + 1)) + else: + break + + path: tuple[slice, ...] = tuple(path_list) + divergence_idx = len(path) + + # start == end, and we're done + if divergence_idx == len(dims): + return [path] + + def upper() -> tuple[tuple[slice, ...], ...]: + assert start_edges is not None + assert end_edges is not None + + sdi = start[divergence_idx] + return tuple( + path + (slice(sdi, sdi + 1),) + s + for s in _get_minimal_slice_set( + start[divergence_idx + 1 :], + [d - 1 for d in dims[divergence_idx + 1 :]], + dims[divergence_idx + 1 :], + start_edges=start_edges[divergence_idx + 1 :], + end_edges=[True for _ in end_edges[divergence_idx + 1 :]], + ) + ) + + def lower() -> tuple[tuple[slice, ...], ...]: + assert start_edges is not None + assert end_edges is not None + + edi = end[divergence_idx] + return tuple( + path + (slice(edi, edi + 1),) + s + for s in _get_minimal_slice_set( + [0 for _ in start[divergence_idx + 1 :]], + end[divergence_idx + 1 :], + dims[divergence_idx + 1 :], + start_edges=[True for _ in start_edges[divergence_idx + 1 :]], + end_edges=end_edges[divergence_idx + 1 :], + ) + ) + + # If both start and end are at the edges of the subtree rooted at + # divergence_idx, we can just select the whole subtree at once + if start_edges[divergence_idx] and end_edges[divergence_idx]: + slices.append(path + (slice(start[divergence_idx], end[divergence_idx] + 1),)) + # If just start is at the edge, we can grab almost all of the subtree, + # treating only the ragged bottom edge as an edge case + elif start_edges[divergence_idx]: + slices.append(path + (slice(start[divergence_idx], end[divergence_idx]),)) + slices.extend(lower()) + # Analogous to the previous case, but the top is ragged this time + elif end_edges[divergence_idx]: + slices.extend(upper()) + slices.append(path + (slice(start[divergence_idx] + 1, end[divergence_idx] + 1),)) + # If both sides of the range are ragged, we need to handle both sides + # separately. If there's contiguous meat in between them, we can index it + # in one big chunk + else: + slices.extend(upper()) + middle_ground = end[divergence_idx] - start[divergence_idx] + if middle_ground > 1: + slices.append(path + (slice(start[divergence_idx] + 1, end[divergence_idx]),)) + slices.extend(lower()) + + return slices + + +@torch.jit.ignore +def _chunk_slice(t: torch.Tensor, flat_start: int, flat_end: int, no_batch_dims: int) -> torch.Tensor: + """ + Equivalent to + + t.reshape((-1,) + t.shape[no_batch_dims:])[flat_start:flat_end] + + but without the need for the initial reshape call, which can be memory-intensive in certain situations. The only + reshape operations in this function are performed on sub-tensors that scale with (flat_end - flat_start), the chunk + size. + """ + + batch_dims = t.shape[:no_batch_dims] + start_idx = list(_flat_idx_to_idx(flat_start, batch_dims)) + # _get_minimal_slice_set is inclusive + end_idx = list(_flat_idx_to_idx(flat_end - 1, batch_dims)) + + # Get an ordered list of slices to perform + slices = _get_minimal_slice_set( + start_idx, + end_idx, + batch_dims, + ) + + sliced_tensors = [t[s] for s in slices] + + return torch.cat([s.view((-1,) + t.shape[no_batch_dims:]) for s in sliced_tensors]) + + +def chunk_layer( + layer: Callable, + inputs: dict[str, Any], + chunk_size: int, + no_batch_dims: int, + low_mem: bool = False, + _out: Any = None, + _add_into_out: bool = False, +) -> Any: + """ + Implements the "chunking" procedure described in section 1.11.8. + + Layer outputs and inputs are assumed to be simple "pytrees," consisting only of (arbitrarily nested) lists, tuples, + and dicts with torch.Tensor leaves. + + Args: + layer: + The layer to be applied chunk-wise + inputs: + A (non-nested) dictionary of keyworded inputs. All leaves must be tensors and must share the same batch + dimensions. + chunk_size: + The number of sub-batches per chunk. If multiple batch dimensions are specified, a "sub-batch" is defined + as a single indexing of all batch dimensions simultaneously (s.t. the number of sub-batches is the product + of the batch dimensions). + no_batch_dims: + How many of the initial dimensions of each input tensor can be considered batch dimensions. + low_mem: + Avoids flattening potentially large input tensors. Unnecessary in most cases, and is ever so slightly + slower than the default setting. + Returns: + The reassembled output of the layer on the inputs. + """ + if not (len(inputs) > 0): + raise ValueError("Must provide at least one input") + + initial_dims = [shape[:no_batch_dims] for shape in _fetch_dims(inputs)] + orig_batch_dims = tuple(max(s) for s in zip(*initial_dims)) + + def _prep_inputs(t: torch.Tensor) -> torch.Tensor: + if not low_mem: + if sum(t.shape[:no_batch_dims]) != no_batch_dims: + t = t.expand(orig_batch_dims + t.shape[no_batch_dims:]) + t = t.reshape(-1, *t.shape[no_batch_dims:]) + else: + t = t.expand(orig_batch_dims + t.shape[no_batch_dims:]) + return t + + prepped_inputs: dict[str, Any] = tensor_tree_map(_prep_inputs, inputs) + prepped_outputs = None + if _out is not None: + prepped_outputs = tensor_tree_map(lambda t: t.view([-1] + list(t.shape[no_batch_dims:])), _out) + + flat_batch_dim = 1 + for d in orig_batch_dims: + flat_batch_dim *= d + + no_chunks = flat_batch_dim // chunk_size + (flat_batch_dim % chunk_size != 0) + + def _select_chunk(t: torch.Tensor) -> torch.Tensor: + return t[i : i + chunk_size] if t.shape[0] != 1 else t + + i = 0 + out = prepped_outputs + for _ in range(no_chunks): + # Chunk the input + if not low_mem: + select_chunk = _select_chunk + else: + select_chunk = partial( + _chunk_slice, + flat_start=i, + flat_end=min(flat_batch_dim, i + chunk_size), + no_batch_dims=len(orig_batch_dims), + ) + + chunks: dict[str, Any] = tensor_tree_map(select_chunk, prepped_inputs) + + # Run the layer on the chunk + output_chunk = layer(**chunks) + + # Allocate space for the output + if out is None: + out = tensor_tree_map(lambda t: t.new_zeros((flat_batch_dim,) + t.shape[1:]), output_chunk) + + # Put the chunk in its pre-allocated space + if isinstance(output_chunk, dict): + + def assign(d1: dict, d2: dict) -> None: + for k, v in d1.items(): + if isinstance(v, dict): + assign(v, d2[k]) + else: + if _add_into_out: + v[i : i + chunk_size] += d2[k] + else: + v[i : i + chunk_size] = d2[k] + + assign(out, output_chunk) + elif isinstance(output_chunk, tuple): + for x1, x2 in zip(out, output_chunk): + if _add_into_out: + x1[i : i + chunk_size] += x2 + else: + x1[i : i + chunk_size] = x2 + elif isinstance(output_chunk, torch.Tensor): + if _add_into_out: + out[i : i + chunk_size] += output_chunk + else: + out[i : i + chunk_size] = output_chunk + else: + raise TypeError("Not supported") + + i += chunk_size + + out = tensor_tree_map(lambda t: t.view(orig_batch_dims + t.shape[1:]), out) + + return out + + +class ChunkSizeTuner: + def __init__( + self, + # Heuristically, runtimes for most of the modules in the network + # plateau earlier than this on all GPUs I've run the model on. + max_chunk_size: int = 512, + ): + self.max_chunk_size = max_chunk_size + self.cached_chunk_size: int | None = None + self.cached_arg_data: tuple | None = None + + def _determine_favorable_chunk_size(self, fn: Callable, args: tuple, min_chunk_size: int) -> int: + logging.info("Tuning chunk size...") + + if min_chunk_size >= self.max_chunk_size: + return min_chunk_size + + candidates: list[int] = [2**l for l in range(int(math.log2(self.max_chunk_size)) + 1)] + candidates = [c for c in candidates if c > min_chunk_size] + candidates = [min_chunk_size] + candidates + candidates[-1] += 4 + + def test_chunk_size(chunk_size: int) -> bool: + try: + with torch.no_grad(): + fn(*args, chunk_size=chunk_size) + return True + except RuntimeError: + return False + + min_viable_chunk_size_index = 0 + i = len(candidates) - 1 + while i > min_viable_chunk_size_index: + viable = test_chunk_size(candidates[i]) + if not viable: + i = (min_viable_chunk_size_index + i) // 2 + else: + min_viable_chunk_size_index = i + i = (i + len(candidates) - 1) // 2 + + return candidates[min_viable_chunk_size_index] + + def _compare_arg_caches(self, ac1: Iterable, ac2: Iterable) -> bool: + consistent = True + for a1, a2 in zip(ac1, ac2): + assert type(ac1) is type(ac2) + if isinstance(ac1, (list, tuple)): + consistent &= self._compare_arg_caches(a1, a2) + elif isinstance(ac1, dict): + a1_items = [v for _, v in sorted(a1.items(), key=lambda x: x[0])] + a2_items = [v for _, v in sorted(a2.items(), key=lambda x: x[0])] + consistent &= self._compare_arg_caches(a1_items, a2_items) + else: + consistent &= a1 == a2 + + return consistent + + def tune_chunk_size( + self, + representative_fn: Callable, + args: tuple, + min_chunk_size: int, + ) -> int: + consistent = True + arg_data: tuple = tree_map(lambda a: a.shape if isinstance(a, torch.Tensor) else a, args, object) + if self.cached_arg_data is not None: + # If args have changed shape/value, we need to re-tune + assert len(self.cached_arg_data) == len(arg_data) + consistent = self._compare_arg_caches(self.cached_arg_data, arg_data) + else: + # Otherwise, we can reuse the precomputed value + consistent = False + + if not consistent: + self.cached_chunk_size = self._determine_favorable_chunk_size( + representative_fn, + args, + min_chunk_size, + ) + self.cached_arg_data = arg_data + + assert self.cached_chunk_size is not None + + return self.cached_chunk_size diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/data_transforms.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/data_transforms.py new file mode 100644 index 0000000000000000000000000000000000000000..bcd67aacab8e5ee6d141166d1ec7fa94cba84e6d --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/data_transforms.py @@ -0,0 +1,90 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import numpy as np +import torch + +from . import residue_constants as rc +from .tensor_utils import tensor_tree_map, tree_map + + +def make_atom14_masks(protein: dict[str, torch.Tensor]) -> dict[str, torch.Tensor]: + """Construct denser atom positions (14 dimensions instead of 37).""" + restype_atom14_to_atom37_list = [] + restype_atom37_to_atom14_list = [] + restype_atom14_mask_list = [] + + for rt in rc.restypes: + atom_names = rc.restype_name_to_atom14_names[rc.restype_1to3[rt]] + restype_atom14_to_atom37_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]) + atom_name_to_idx14 = {name: i for i, name in enumerate(atom_names)} + restype_atom37_to_atom14_list.append([(atom_name_to_idx14.get(name, 0)) for name in rc.atom_types]) + + restype_atom14_mask_list.append([(1.0 if name else 0.0) for name in atom_names]) + + # Add dummy mapping for restype 'UNK' + restype_atom14_to_atom37_list.append([0] * 14) + restype_atom37_to_atom14_list.append([0] * 37) + restype_atom14_mask_list.append([0.0] * 14) + + restype_atom14_to_atom37 = torch.tensor( + restype_atom14_to_atom37_list, + dtype=torch.int32, + device=protein["aatype"].device, + ) + restype_atom37_to_atom14 = torch.tensor( + restype_atom37_to_atom14_list, + dtype=torch.int32, + device=protein["aatype"].device, + ) + restype_atom14_mask = torch.tensor( + restype_atom14_mask_list, + dtype=torch.float32, + device=protein["aatype"].device, + ) + protein_aatype = protein["aatype"].to(torch.long) + + # create the mapping for (residx, atom14) --> atom37, i.e. an array + # with shape (num_res, 14) containing the atom37 indices for this protein + residx_atom14_to_atom37 = restype_atom14_to_atom37[protein_aatype] + residx_atom14_mask = restype_atom14_mask[protein_aatype] + + protein["atom14_atom_exists"] = residx_atom14_mask + protein["residx_atom14_to_atom37"] = residx_atom14_to_atom37.long() + + # create the gather indices for mapping back + residx_atom37_to_atom14 = restype_atom37_to_atom14[protein_aatype] + protein["residx_atom37_to_atom14"] = residx_atom37_to_atom14.long() + + # create the corresponding mask + restype_atom37_mask = torch.zeros([21, 37], dtype=torch.float32, device=protein["aatype"].device) + for restype, restype_letter in enumerate(rc.restypes): + restype_name = rc.restype_1to3[restype_letter] + atom_names = rc.residue_atoms[restype_name] + for atom_name in atom_names: + atom_type = rc.atom_order[atom_name] + restype_atom37_mask[restype, atom_type] = 1 + + residx_atom37_mask = restype_atom37_mask[protein_aatype] + protein["atom37_atom_exists"] = residx_atom37_mask + + return protein + + +def make_atom14_masks_np(batch: dict[str, torch.Tensor]) -> dict[str, np.ndarray]: + batch = tree_map(lambda n: torch.tensor(n, device=batch["aatype"].device), batch, np.ndarray) + out = tensor_tree_map(lambda t: np.array(t), make_atom14_masks(batch)) + return out diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/feats.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/feats.py new file mode 100644 index 0000000000000000000000000000000000000000..366f3c47d9466d0c5556b6eb7c365393785a82aa --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/feats.py @@ -0,0 +1,253 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT 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 overload + +import torch +import torch.types +from torch import nn + +from . import residue_constants as rc +from .rigid_utils import Rigid, Rotation +from .tensor_utils import batched_gather + + +@overload +def pseudo_beta_fn(aatype: torch.Tensor, all_atom_positions: torch.Tensor, all_atom_masks: None) -> torch.Tensor: ... + + +@overload +def pseudo_beta_fn( + aatype: torch.Tensor, all_atom_positions: torch.Tensor, all_atom_masks: torch.Tensor +) -> tuple[torch.Tensor, torch.Tensor]: ... + + +def pseudo_beta_fn(aatype, all_atom_positions, all_atom_masks): + is_gly = aatype == rc.restype_order["G"] + ca_idx = rc.atom_order["CA"] + cb_idx = rc.atom_order["CB"] + pseudo_beta = torch.where( + is_gly[..., None].expand(*((-1,) * len(is_gly.shape)), 3), + all_atom_positions[..., ca_idx, :], + all_atom_positions[..., cb_idx, :], + ) + + if all_atom_masks is not None: + pseudo_beta_mask = torch.where( + is_gly, + all_atom_masks[..., ca_idx], + all_atom_masks[..., cb_idx], + ) + return pseudo_beta, pseudo_beta_mask + else: + return pseudo_beta + + +def atom14_to_atom37(atom14: torch.Tensor, batch: dict[str, torch.Tensor]) -> torch.Tensor: + atom37_data = batched_gather( + atom14, + batch["residx_atom37_to_atom14"], + dim=-2, + no_batch_dims=len(atom14.shape[:-2]), + ) + + atom37_data = atom37_data * batch["atom37_atom_exists"][..., None] + + return atom37_data + + +def build_template_angle_feat(template_feats: dict[str, torch.Tensor]) -> torch.Tensor: + template_aatype = template_feats["template_aatype"] + torsion_angles_sin_cos = template_feats["template_torsion_angles_sin_cos"] + alt_torsion_angles_sin_cos = template_feats["template_alt_torsion_angles_sin_cos"] + torsion_angles_mask = template_feats["template_torsion_angles_mask"] + template_angle_feat = torch.cat( + [ + nn.functional.one_hot(template_aatype, 22), + torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2], 14), + alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2], 14), + torsion_angles_mask, + ], + dim=-1, + ) + + return template_angle_feat + + +def build_template_pair_feat( + batch: dict[str, torch.Tensor], + min_bin: torch.types.Number, + max_bin: torch.types.Number, + no_bins: int, + use_unit_vector: bool = False, + eps: float = 1e-20, + inf: float = 1e8, +) -> torch.Tensor: + template_mask = batch["template_pseudo_beta_mask"] + template_mask_2d = template_mask[..., None] * template_mask[..., None, :] + + # Compute distogram (this seems to differ slightly from Alg. 5) + tpb = batch["template_pseudo_beta"] + dgram = torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2, dim=-1, keepdim=True) + lower = torch.linspace(min_bin, max_bin, no_bins, device=tpb.device) ** 2 + upper = torch.cat([lower[1:], lower.new_tensor([inf])], dim=-1) + dgram = ((dgram > lower) * (dgram < upper)).type(dgram.dtype) + + to_concat = [dgram, template_mask_2d[..., None]] + + aatype_one_hot: torch.LongTensor = nn.functional.one_hot( + batch["template_aatype"], + rc.restype_num + 2, + ) + + n_res = batch["template_aatype"].shape[-1] + to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2], n_res, -1, -1)) + to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2], -1, n_res, -1)) + + n, ca, c = [rc.atom_order[a] for a in ["N", "CA", "C"]] + rigids = Rigid.make_transform_from_reference( + n_xyz=batch["template_all_atom_positions"][..., n, :], + ca_xyz=batch["template_all_atom_positions"][..., ca, :], + c_xyz=batch["template_all_atom_positions"][..., c, :], + eps=eps, + ) + points = rigids.get_trans()[..., None, :, :] + rigid_vec = rigids[..., None].invert_apply(points) + + inv_distance_scalar = torch.rsqrt(eps + torch.sum(rigid_vec**2, dim=-1)) + + t_aa_masks = batch["template_all_atom_mask"] + template_mask = t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c] + template_mask_2d = template_mask[..., None] * template_mask[..., None, :] + + inv_distance_scalar = inv_distance_scalar * template_mask_2d + unit_vector = rigid_vec * inv_distance_scalar[..., None] + + if not use_unit_vector: + unit_vector = unit_vector * 0.0 + + to_concat.extend(torch.unbind(unit_vector[..., None, :], dim=-1)) + to_concat.append(template_mask_2d[..., None]) + + act = torch.cat(to_concat, dim=-1) + act = act * template_mask_2d[..., None] + + return act + + +def build_extra_msa_feat(batch: dict[str, torch.Tensor]) -> torch.Tensor: + msa_1hot: torch.LongTensor = nn.functional.one_hot(batch["extra_msa"], 23) + msa_feat = [ + msa_1hot, + batch["extra_has_deletion"].unsqueeze(-1), + batch["extra_deletion_value"].unsqueeze(-1), + ] + return torch.cat(msa_feat, dim=-1) + + +def torsion_angles_to_frames( + r: Rigid, + alpha: torch.Tensor, + aatype: torch.Tensor, + rrgdf: torch.Tensor, +) -> Rigid: + # [*, N, 8, 4, 4] + default_4x4 = rrgdf[aatype, ...] + + # [*, N, 8] transformations, i.e. + # One [*, N, 8, 3, 3] rotation matrix and + # One [*, N, 8, 3] translation matrix + default_r = r.from_tensor_4x4(default_4x4) + + bb_rot = alpha.new_zeros((*((1,) * len(alpha.shape[:-1])), 2)) + bb_rot[..., 1] = 1 + + # [*, N, 8, 2] + alpha = torch.cat([bb_rot.expand(*alpha.shape[:-2], -1, -1), alpha], dim=-2) + + # [*, N, 8, 3, 3] + # Produces rotation matrices of the form: + # [ + # [1, 0 , 0 ], + # [0, a_2,-a_1], + # [0, a_1, a_2] + # ] + # This follows the original code rather than the supplement, which uses + # different indices. + + all_rots = alpha.new_zeros(default_r.get_rots().get_rot_mats().shape) + all_rots[..., 0, 0] = 1 + all_rots[..., 1, 1] = alpha[..., 1] + all_rots[..., 1, 2] = -alpha[..., 0] + all_rots[..., 2, 1:] = alpha + + all_frames = default_r.compose(Rigid(Rotation(rot_mats=all_rots), None)) + + chi2_frame_to_frame = all_frames[..., 5] + chi3_frame_to_frame = all_frames[..., 6] + chi4_frame_to_frame = all_frames[..., 7] + + chi1_frame_to_bb = all_frames[..., 4] + chi2_frame_to_bb = chi1_frame_to_bb.compose(chi2_frame_to_frame) + chi3_frame_to_bb = chi2_frame_to_bb.compose(chi3_frame_to_frame) + chi4_frame_to_bb = chi3_frame_to_bb.compose(chi4_frame_to_frame) + + all_frames_to_bb = Rigid.cat( + [ + all_frames[..., :5], + chi2_frame_to_bb.unsqueeze(-1), + chi3_frame_to_bb.unsqueeze(-1), + chi4_frame_to_bb.unsqueeze(-1), + ], + dim=-1, + ) + + all_frames_to_global = r[..., None].compose(all_frames_to_bb) + + return all_frames_to_global + + +def frames_and_literature_positions_to_atom14_pos( + r: Rigid, + aatype: torch.Tensor, + default_frames: torch.Tensor, + group_idx: torch.Tensor, + atom_mask: torch.Tensor, + lit_positions: torch.Tensor, +) -> torch.Tensor: + # [*, N, 14] + group_mask = group_idx[aatype, ...] + + # [*, N, 14, 8] + group_mask_one_hot: torch.LongTensor = nn.functional.one_hot( + group_mask, + num_classes=default_frames.shape[-3], + ) + + # [*, N, 14, 8] + t_atoms_to_global = r[..., None, :] * group_mask_one_hot + + # [*, N, 14] + t_atoms_to_global = t_atoms_to_global.map_tensor_fn(lambda x: torch.sum(x, dim=-1)) + + # [*, N, 14, 1] + atom_mask = atom_mask[aatype, ...].unsqueeze(-1) + + # [*, N, 14, 3] + lit_positions = lit_positions[aatype, ...] + pred_positions = t_atoms_to_global.apply(lit_positions) + pred_positions = pred_positions * atom_mask + + return pred_positions diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/loss.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/loss.py new file mode 100644 index 0000000000000000000000000000000000000000..1ca0e64306ba9ee0db0b10370e06b92c75451862 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/loss.py @@ -0,0 +1,104 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import torch + + +def _calculate_bin_centers(boundaries: torch.Tensor) -> torch.Tensor: + step = boundaries[1] - boundaries[0] + bin_centers = boundaries + step / 2 + bin_centers = torch.cat([bin_centers, (bin_centers[-1] + step).unsqueeze(-1)], dim=0) + return bin_centers + + +def _calculate_expected_aligned_error( + alignment_confidence_breaks: torch.Tensor, + aligned_distance_error_probs: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor]: + bin_centers = _calculate_bin_centers(alignment_confidence_breaks) + return ( + torch.sum(aligned_distance_error_probs * bin_centers, dim=-1), + bin_centers[-1], + ) + + +def compute_predicted_aligned_error( + logits: torch.Tensor, + max_bin: int = 31, + no_bins: int = 64, + **kwargs, +) -> dict[str, torch.Tensor]: + """Computes aligned confidence metrics from logits. + + Args: + logits: [*, num_res, num_res, num_bins] the logits output from + PredictedAlignedErrorHead. + max_bin: Maximum bin value + no_bins: Number of bins + Returns: + aligned_confidence_probs: [*, num_res, num_res, num_bins] the predicted + aligned error probabilities over bins for each residue pair. + predicted_aligned_error: [*, num_res, num_res] the expected aligned distance + error for each pair of residues. + max_predicted_aligned_error: [*] the maximum predicted error possible. + """ + boundaries = torch.linspace(0, max_bin, steps=(no_bins - 1), device=logits.device) + + aligned_confidence_probs = torch.nn.functional.softmax(logits, dim=-1) + predicted_aligned_error, max_predicted_aligned_error = _calculate_expected_aligned_error( + alignment_confidence_breaks=boundaries, + aligned_distance_error_probs=aligned_confidence_probs, + ) + + return { + "aligned_confidence_probs": aligned_confidence_probs, + "predicted_aligned_error": predicted_aligned_error, + "max_predicted_aligned_error": max_predicted_aligned_error, + } + + +def compute_tm( + logits: torch.Tensor, + residue_weights: torch.Tensor | None = None, + max_bin: int = 31, + no_bins: int = 64, + eps: float = 1e-8, + **kwargs, +) -> torch.Tensor: + if residue_weights is None: + residue_weights = logits.new_ones(logits.shape[-2]) + + boundaries = torch.linspace(0, max_bin, steps=(no_bins - 1), device=logits.device) + + bin_centers = _calculate_bin_centers(boundaries) + torch.sum(residue_weights) + n = logits.shape[-2] + clipped_n = max(n, 19) + + d0 = 1.24 * (clipped_n - 15) ** (1.0 / 3) - 1.8 + + probs = torch.nn.functional.softmax(logits, dim=-1) + + tm_per_bin = 1.0 / (1 + (bin_centers**2) / (d0**2)) + predicted_tm_term = torch.sum(probs * tm_per_bin, dim=-1) + + normed_residue_mask = residue_weights / (eps + residue_weights.sum()) + per_alignment = torch.sum(predicted_tm_term * normed_residue_mask, dim=-1) + + weighted = per_alignment * residue_weights + + argmax = (weighted == torch.max(weighted)).nonzero()[0] + return per_alignment[tuple(argmax)] diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/protein.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/protein.py new file mode 100644 index 0000000000000000000000000000000000000000..0c347119a49d227cf7f9e7e0572850e9d29a4200 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/protein.py @@ -0,0 +1,330 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Protein data type.""" + +import dataclasses +import re +import string +from collections.abc import Iterator, Mapping, Sequence +from typing import Any + +import numpy as np + +from . import residue_constants + + +FeatureDict = Mapping[str, np.ndarray] +ModelOutput = Mapping[str, Any] # Is a nested dict. +PICO_TO_ANGSTROM = 0.01 + + +@dataclasses.dataclass(frozen=True) +class Protein: + """Protein structure representation.""" + + # Cartesian coordinates of atoms in angstroms. The atom types correspond to + # residue_constants.atom_types, i.e. the first three are N, CA, CB. + atom_positions: np.ndarray # [num_res, num_atom_type, 3] + + # Amino-acid type for each residue represented as an integer between 0 and + # 20, where 20 is 'X'. + aatype: np.ndarray # [num_res] + + # Binary float mask to indicate presence of a particular atom. 1.0 if an atom + # is present and 0.0 if not. This should be used for loss masking. + atom_mask: np.ndarray # [num_res, num_atom_type] + + # Residue index as used in PDB. It is not necessarily continuous or 0-indexed. + residue_index: np.ndarray # [num_res] + + # B-factors, or temperature factors, of each residue (in sq. angstroms units), + # representing the displacement of the residue from its ground truth mean + # value. + b_factors: np.ndarray # [num_res, num_atom_type] + + # Chain indices for multi-chain predictions + chain_index: np.ndarray | None = None + + # Optional remark about the protein. Included as a comment in output PDB + # files + remark: str | None = None + + # Templates used to generate this protein (prediction-only) + parents: Sequence[str] | None = None + + # Chain corresponding to each parent + parents_chain_index: Sequence[int] | None = None + + +def from_proteinnet_string(proteinnet_str: str) -> Protein: + tag_re = r"(\[[A-Z]+\]\n)" + tags: list[str] = [tag.strip() for tag in re.split(tag_re, proteinnet_str) if len(tag) > 0] + groups: Iterator[tuple[str, list[str]]] = zip(tags[0::2], [l.split("\n") for l in tags[1::2]]) + + atoms: list[str] = ["N", "CA", "C"] + aatype = None + atom_positions = None + atom_mask = None + for g in groups: + if g[0] == "[PRIMARY]": + seq = g[1][0].strip() + # Replace unknown residues with "X" (strings are immutable, so convert to list first) + seq = [char if char in residue_constants.restypes else "X" for char in seq] + aatype = np.array( + [residue_constants.restype_order.get(res_symbol, residue_constants.restype_num) for res_symbol in seq] + ) + elif g[0] == "[TERTIARY]": + tertiary: list[list[float]] = [] + for axis in range(3): + tertiary.append(list(map(float, g[1][axis].split()))) + tertiary_np = np.array(tertiary) + atom_positions = np.zeros((len(tertiary[0]) // 3, residue_constants.atom_type_num, 3)).astype(np.float32) + for i, atom in enumerate(atoms): + atom_positions[:, residue_constants.atom_order[atom], :] = np.transpose(tertiary_np[:, i::3]) + atom_positions *= PICO_TO_ANGSTROM + elif g[0] == "[MASK]": + mask = np.array(list(map({"-": 0, "+": 1}.get, g[1][0].strip()))) + atom_mask = np.zeros( + ( + len(mask), + residue_constants.atom_type_num, + ) + ).astype(np.float32) + for i, atom in enumerate(atoms): + atom_mask[:, residue_constants.atom_order[atom]] = 1 + atom_mask *= mask[..., None] + + assert aatype is not None + + return Protein( + atom_positions=atom_positions, + atom_mask=atom_mask, + aatype=aatype, + residue_index=np.arange(len(aatype)), + b_factors=None, + ) + + +def get_pdb_headers(prot: Protein, chain_id: int = 0) -> list[str]: + pdb_headers: list[str] = [] + + remark = prot.remark + if remark is not None: + pdb_headers.append(f"REMARK {remark}") + + parents = prot.parents + parents_chain_index = prot.parents_chain_index + if parents is not None and parents_chain_index is not None: + parents = [p for i, p in zip(parents_chain_index, parents) if i == chain_id] + + if parents is None or len(parents) == 0: + parents = ["N/A"] + + pdb_headers.append(f"PARENT {' '.join(parents)}") + + return pdb_headers + + +def add_pdb_headers(prot: Protein, pdb_str: str) -> str: + """Add pdb headers to an existing PDB string. Useful during multi-chain + recycling + """ + out_pdb_lines: list[str] = [] + lines = pdb_str.split("\n") + + remark = prot.remark + if remark is not None: + out_pdb_lines.append(f"REMARK {remark}") + + parents_per_chain: list[list[str]] + if prot.parents is not None and len(prot.parents) > 0: + parents_per_chain = [] + if prot.parents_chain_index is not None: + parent_dict: dict[str, list[str]] = {} + for p, i in zip(prot.parents, prot.parents_chain_index): + parent_dict.setdefault(str(i), []) + parent_dict[str(i)].append(p) + + max_idx = max(int(chain_idx) for chain_idx in parent_dict) + for i in range(max_idx + 1): + chain_parents = parent_dict.get(str(i), ["N/A"]) + parents_per_chain.append(chain_parents) + else: + parents_per_chain.append(list(prot.parents)) + else: + parents_per_chain = [["N/A"]] + + def make_parent_line(p: Sequence[str]) -> str: + return f"PARENT {' '.join(p)}" + + out_pdb_lines.append(make_parent_line(parents_per_chain[0])) + + chain_counter = 0 + for i, l in enumerate(lines): + if "PARENT" not in l and "REMARK" not in l: + out_pdb_lines.append(l) + if "TER" in l and "END" not in lines[i + 1]: + chain_counter += 1 + if not chain_counter >= len(parents_per_chain): + chain_parents = parents_per_chain[chain_counter] + else: + chain_parents = ["N/A"] + + out_pdb_lines.append(make_parent_line(chain_parents)) + + return "\n".join(out_pdb_lines) + + +def to_pdb(prot: Protein) -> str: + """Converts a `Protein` instance to a PDB string. + + Args: + prot: The protein to convert to PDB. + + Returns: + PDB string. + """ + restypes = residue_constants.restypes + ["X"] + + def res_1to3(r: int) -> str: + return residue_constants.restype_1to3.get(restypes[r], "UNK") + + atom_types = residue_constants.atom_types + + pdb_lines: list[str] = [] + + atom_mask = prot.atom_mask + aatype = prot.aatype + atom_positions = prot.atom_positions + residue_index = prot.residue_index.astype(np.int32) + b_factors = prot.b_factors + chain_index = prot.chain_index + + if np.any(aatype > residue_constants.restype_num): + raise ValueError("Invalid aatypes.") + + headers = get_pdb_headers(prot) + if len(headers) > 0: + pdb_lines.extend(headers) + + n = aatype.shape[0] + atom_index = 1 + prev_chain_index = 0 + chain_tags = string.ascii_uppercase + chain_tag = None + # Add all atom sites. + for i in range(n): + res_name_3 = res_1to3(aatype[i]) + for atom_name, pos, mask, b_factor in zip(atom_types, atom_positions[i], atom_mask[i], b_factors[i]): + if mask < 0.5: + continue + + record_type = "ATOM" + name = atom_name if len(atom_name) == 4 else f" {atom_name}" + alt_loc = "" + insertion_code = "" + occupancy = 1.00 + element = atom_name[0] # Protein supports only C, N, O, S, this works. + charge = "" + + chain_tag = "A" + if chain_index is not None: + chain_tag = chain_tags[chain_index[i]] + + # PDB is a columnar format, every space matters here! + atom_line = ( + f"{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}" + f"{res_name_3:>3} {chain_tag:>1}" + f"{residue_index[i]:>4}{insertion_code:>1} " + f"{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}" + f"{occupancy:>6.2f}{b_factor:>6.2f} " + f"{element:>2}{charge:>2}" + ) + pdb_lines.append(atom_line) + atom_index += 1 + + should_terminate = i == n - 1 + if chain_index is not None: + if i != n - 1 and chain_index[i + 1] != prev_chain_index: + should_terminate = True + prev_chain_index = chain_index[i + 1] + + if should_terminate: + # Close the chain. + chain_end = "TER" + chain_termination_line = ( + f"{chain_end:<6}{atom_index:>5} {res_1to3(aatype[i]):>3} {chain_tag:>1}{residue_index[i]:>4}" + ) + pdb_lines.append(chain_termination_line) + atom_index += 1 + + if i != n - 1: + # "prev" is a misnomer here. This happens at the beginning of + # each new chain. + pdb_lines.extend(get_pdb_headers(prot, prev_chain_index)) + + pdb_lines.append("END") + pdb_lines.append("") + return "\n".join(pdb_lines) + + +def ideal_atom_mask(prot: Protein) -> np.ndarray: + """Computes an ideal atom mask. + + `Protein.atom_mask` typically is defined according to the atoms that are reported in the PDB. This function + computes a mask according to heavy atoms that should be present in the given sequence of amino acids. + + Args: + prot: `Protein` whose fields are `numpy.ndarray` objects. + + Returns: + An ideal atom mask. + """ + return residue_constants.STANDARD_ATOM_MASK[prot.aatype] + + +def from_prediction( + features: FeatureDict, + result: ModelOutput, + b_factors: np.ndarray | None = None, + chain_index: np.ndarray | None = None, + remark: str | None = None, + parents: Sequence[str] | None = None, + parents_chain_index: Sequence[int] | None = None, +) -> Protein: + """Assembles a protein from a prediction. + + Args: + features: Dictionary holding model inputs. + result: Dictionary holding model outputs. + b_factors: (Optional) B-factors to use for the protein. + chain_index: (Optional) Chain indices for multi-chain predictions + remark: (Optional) Remark about the prediction + parents: (Optional) List of template names + Returns: + A protein instance. + """ + return Protein( + aatype=features["aatype"], + atom_positions=result["final_atom_positions"], + atom_mask=result["final_atom_mask"], + residue_index=features["residue_index"] + 1, + b_factors=b_factors if b_factors is not None else np.zeros_like(result["final_atom_mask"]), + chain_index=chain_index, + remark=remark, + parents=parents, + parents_chain_index=parents_chain_index, + ) diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/residue_constants.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/residue_constants.py new file mode 100644 index 0000000000000000000000000000000000000000..e92e65d29bfb2e7a0ad640e71d983c1c467d3a54 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/residue_constants.py @@ -0,0 +1,979 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Constants used in AlphaFold.""" + +import collections +import copy +import functools +from collections.abc import Mapping, Sequence +from importlib import resources + +import numpy as np + + +# Internal import (35fd). + + +# Distance from one CA to next CA [trans configuration: omega = 180]. +ca_ca = 3.80209737096 + +# Format: The list for each AA type contains chi1, chi2, chi3, chi4 in +# this order (or a relevant subset from chi1 onwards). ALA and GLY don't have +# chi angles so their chi angle lists are empty. +chi_angles_atoms: dict[str, list[list[str]]] = { + "ALA": [], + # Chi5 in arginine is always 0 +- 5 degrees, so ignore it. + "ARG": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD"], ["CB", "CG", "CD", "NE"], ["CG", "CD", "NE", "CZ"]], + "ASN": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "OD1"]], + "ASP": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "OD1"]], + "CYS": [["N", "CA", "CB", "SG"]], + "GLN": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD"], ["CB", "CG", "CD", "OE1"]], + "GLU": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD"], ["CB", "CG", "CD", "OE1"]], + "GLY": [], + "HIS": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "ND1"]], + "ILE": [["N", "CA", "CB", "CG1"], ["CA", "CB", "CG1", "CD1"]], + "LEU": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]], + "LYS": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD"], ["CB", "CG", "CD", "CE"], ["CG", "CD", "CE", "NZ"]], + "MET": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "SD"], ["CB", "CG", "SD", "CE"]], + "PHE": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]], + "PRO": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD"]], + "SER": [["N", "CA", "CB", "OG"]], + "THR": [["N", "CA", "CB", "OG1"]], + "TRP": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]], + "TYR": [["N", "CA", "CB", "CG"], ["CA", "CB", "CG", "CD1"]], + "VAL": [["N", "CA", "CB", "CG1"]], +} + +# If chi angles given in fixed-length array, this matrix determines how to mask +# them for each AA type. The order is as per restype_order (see below). +chi_angles_mask: list[list[float]] = [ + [0.0, 0.0, 0.0, 0.0], # ALA + [1.0, 1.0, 1.0, 1.0], # ARG + [1.0, 1.0, 0.0, 0.0], # ASN + [1.0, 1.0, 0.0, 0.0], # ASP + [1.0, 0.0, 0.0, 0.0], # CYS + [1.0, 1.0, 1.0, 0.0], # GLN + [1.0, 1.0, 1.0, 0.0], # GLU + [0.0, 0.0, 0.0, 0.0], # GLY + [1.0, 1.0, 0.0, 0.0], # HIS + [1.0, 1.0, 0.0, 0.0], # ILE + [1.0, 1.0, 0.0, 0.0], # LEU + [1.0, 1.0, 1.0, 1.0], # LYS + [1.0, 1.0, 1.0, 0.0], # MET + [1.0, 1.0, 0.0, 0.0], # PHE + [1.0, 1.0, 0.0, 0.0], # PRO + [1.0, 0.0, 0.0, 0.0], # SER + [1.0, 0.0, 0.0, 0.0], # THR + [1.0, 1.0, 0.0, 0.0], # TRP + [1.0, 1.0, 0.0, 0.0], # TYR + [1.0, 0.0, 0.0, 0.0], # VAL +] + +# The following chi angles are pi periodic: they can be rotated by a multiple +# of pi without affecting the structure. +chi_pi_periodic: list[list[float]] = [ + [0.0, 0.0, 0.0, 0.0], # ALA + [0.0, 0.0, 0.0, 0.0], # ARG + [0.0, 0.0, 0.0, 0.0], # ASN + [0.0, 1.0, 0.0, 0.0], # ASP + [0.0, 0.0, 0.0, 0.0], # CYS + [0.0, 0.0, 0.0, 0.0], # GLN + [0.0, 0.0, 1.0, 0.0], # GLU + [0.0, 0.0, 0.0, 0.0], # GLY + [0.0, 0.0, 0.0, 0.0], # HIS + [0.0, 0.0, 0.0, 0.0], # ILE + [0.0, 0.0, 0.0, 0.0], # LEU + [0.0, 0.0, 0.0, 0.0], # LYS + [0.0, 0.0, 0.0, 0.0], # MET + [0.0, 1.0, 0.0, 0.0], # PHE + [0.0, 0.0, 0.0, 0.0], # PRO + [0.0, 0.0, 0.0, 0.0], # SER + [0.0, 0.0, 0.0, 0.0], # THR + [0.0, 0.0, 0.0, 0.0], # TRP + [0.0, 1.0, 0.0, 0.0], # TYR + [0.0, 0.0, 0.0, 0.0], # VAL + [0.0, 0.0, 0.0, 0.0], # UNK +] + +# Atoms positions relative to the 8 rigid groups, defined by the pre-omega, phi, +# psi and chi angles: +# 0: 'backbone group', +# 1: 'pre-omega-group', (empty) +# 2: 'phi-group', (currently empty, because it defines only hydrogens) +# 3: 'psi-group', +# 4,5,6,7: 'chi1,2,3,4-group' +# The atom positions are relative to the axis-end-atom of the corresponding +# rotation axis. The x-axis is in direction of the rotation axis, and the y-axis +# is defined such that the dihedral-angle-definiting atom (the last entry in +# chi_angles_atoms above) is in the xy-plane (with a positive y-coordinate). +# format: [atomname, group_idx, rel_position] +rigid_group_atom_positions: dict[str, list[tuple[str, int, tuple[float, float, float]]]] = { + "ALA": [ + ("N", 0, (-0.525, 1.363, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.526, -0.000, -0.000)), + ("CB", 0, (-0.529, -0.774, -1.205)), + ("O", 3, (0.627, 1.062, 0.000)), + ], + "ARG": [ + ("N", 0, (-0.524, 1.362, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.525, -0.000, -0.000)), + ("CB", 0, (-0.524, -0.778, -1.209)), + ("O", 3, (0.626, 1.062, 0.000)), + ("CG", 4, (0.616, 1.390, -0.000)), + ("CD", 5, (0.564, 1.414, 0.000)), + ("NE", 6, (0.539, 1.357, -0.000)), + ("NH1", 7, (0.206, 2.301, 0.000)), + ("NH2", 7, (2.078, 0.978, -0.000)), + ("CZ", 7, (0.758, 1.093, -0.000)), + ], + "ASN": [ + ("N", 0, (-0.536, 1.357, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.526, -0.000, -0.000)), + ("CB", 0, (-0.531, -0.787, -1.200)), + ("O", 3, (0.625, 1.062, 0.000)), + ("CG", 4, (0.584, 1.399, 0.000)), + ("ND2", 5, (0.593, -1.188, 0.001)), + ("OD1", 5, (0.633, 1.059, 0.000)), + ], + "ASP": [ + ("N", 0, (-0.525, 1.362, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.527, 0.000, -0.000)), + ("CB", 0, (-0.526, -0.778, -1.208)), + ("O", 3, (0.626, 1.062, -0.000)), + ("CG", 4, (0.593, 1.398, -0.000)), + ("OD1", 5, (0.610, 1.091, 0.000)), + ("OD2", 5, (0.592, -1.101, -0.003)), + ], + "CYS": [ + ("N", 0, (-0.522, 1.362, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.524, 0.000, 0.000)), + ("CB", 0, (-0.519, -0.773, -1.212)), + ("O", 3, (0.625, 1.062, -0.000)), + ("SG", 4, (0.728, 1.653, 0.000)), + ], + "GLN": [ + ("N", 0, (-0.526, 1.361, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.526, 0.000, 0.000)), + ("CB", 0, (-0.525, -0.779, -1.207)), + ("O", 3, (0.626, 1.062, -0.000)), + ("CG", 4, (0.615, 1.393, 0.000)), + ("CD", 5, (0.587, 1.399, -0.000)), + ("NE2", 6, (0.593, -1.189, -0.001)), + ("OE1", 6, (0.634, 1.060, 0.000)), + ], + "GLU": [ + ("N", 0, (-0.528, 1.361, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.526, -0.000, -0.000)), + ("CB", 0, (-0.526, -0.781, -1.207)), + ("O", 3, (0.626, 1.062, 0.000)), + ("CG", 4, (0.615, 1.392, 0.000)), + ("CD", 5, (0.600, 1.397, 0.000)), + ("OE1", 6, (0.607, 1.095, -0.000)), + ("OE2", 6, (0.589, -1.104, -0.001)), + ], + "GLY": [ + ("N", 0, (-0.572, 1.337, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.517, -0.000, -0.000)), + ("O", 3, (0.626, 1.062, -0.000)), + ], + "HIS": [ + ("N", 0, (-0.527, 1.360, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.525, 0.000, 0.000)), + ("CB", 0, (-0.525, -0.778, -1.208)), + ("O", 3, (0.625, 1.063, 0.000)), + ("CG", 4, (0.600, 1.370, -0.000)), + ("CD2", 5, (0.889, -1.021, 0.003)), + ("ND1", 5, (0.744, 1.160, -0.000)), + ("CE1", 5, (2.030, 0.851, 0.002)), + ("NE2", 5, (2.145, -0.466, 0.004)), + ], + "ILE": [ + ("N", 0, (-0.493, 1.373, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.527, -0.000, -0.000)), + ("CB", 0, (-0.536, -0.793, -1.213)), + ("O", 3, (0.627, 1.062, -0.000)), + ("CG1", 4, (0.534, 1.437, -0.000)), + ("CG2", 4, (0.540, -0.785, -1.199)), + ("CD1", 5, (0.619, 1.391, 0.000)), + ], + "LEU": [ + ("N", 0, (-0.520, 1.363, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.525, -0.000, -0.000)), + ("CB", 0, (-0.522, -0.773, -1.214)), + ("O", 3, (0.625, 1.063, -0.000)), + ("CG", 4, (0.678, 1.371, 0.000)), + ("CD1", 5, (0.530, 1.430, -0.000)), + ("CD2", 5, (0.535, -0.774, 1.200)), + ], + "LYS": [ + ("N", 0, (-0.526, 1.362, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.526, 0.000, 0.000)), + ("CB", 0, (-0.524, -0.778, -1.208)), + ("O", 3, (0.626, 1.062, -0.000)), + ("CG", 4, (0.619, 1.390, 0.000)), + ("CD", 5, (0.559, 1.417, 0.000)), + ("CE", 6, (0.560, 1.416, 0.000)), + ("NZ", 7, (0.554, 1.387, 0.000)), + ], + "MET": [ + ("N", 0, (-0.521, 1.364, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.525, 0.000, 0.000)), + ("CB", 0, (-0.523, -0.776, -1.210)), + ("O", 3, (0.625, 1.062, -0.000)), + ("CG", 4, (0.613, 1.391, -0.000)), + ("SD", 5, (0.703, 1.695, 0.000)), + ("CE", 6, (0.320, 1.786, -0.000)), + ], + "PHE": [ + ("N", 0, (-0.518, 1.363, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.524, 0.000, -0.000)), + ("CB", 0, (-0.525, -0.776, -1.212)), + ("O", 3, (0.626, 1.062, -0.000)), + ("CG", 4, (0.607, 1.377, 0.000)), + ("CD1", 5, (0.709, 1.195, -0.000)), + ("CD2", 5, (0.706, -1.196, 0.000)), + ("CE1", 5, (2.102, 1.198, -0.000)), + ("CE2", 5, (2.098, -1.201, -0.000)), + ("CZ", 5, (2.794, -0.003, -0.001)), + ], + "PRO": [ + ("N", 0, (-0.566, 1.351, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.527, -0.000, 0.000)), + ("CB", 0, (-0.546, -0.611, -1.293)), + ("O", 3, (0.621, 1.066, 0.000)), + ("CG", 4, (0.382, 1.445, 0.0)), + # ('CD', 5, (0.427, 1.440, 0.0)), + ("CD", 5, (0.477, 1.424, 0.0)), # manually made angle 2 degrees larger + ], + "SER": [ + ("N", 0, (-0.529, 1.360, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.525, -0.000, -0.000)), + ("CB", 0, (-0.518, -0.777, -1.211)), + ("O", 3, (0.626, 1.062, -0.000)), + ("OG", 4, (0.503, 1.325, 0.000)), + ], + "THR": [ + ("N", 0, (-0.517, 1.364, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.526, 0.000, -0.000)), + ("CB", 0, (-0.516, -0.793, -1.215)), + ("O", 3, (0.626, 1.062, 0.000)), + ("CG2", 4, (0.550, -0.718, -1.228)), + ("OG1", 4, (0.472, 1.353, 0.000)), + ], + "TRP": [ + ("N", 0, (-0.521, 1.363, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.525, -0.000, 0.000)), + ("CB", 0, (-0.523, -0.776, -1.212)), + ("O", 3, (0.627, 1.062, 0.000)), + ("CG", 4, (0.609, 1.370, -0.000)), + ("CD1", 5, (0.824, 1.091, 0.000)), + ("CD2", 5, (0.854, -1.148, -0.005)), + ("CE2", 5, (2.186, -0.678, -0.007)), + ("CE3", 5, (0.622, -2.530, -0.007)), + ("NE1", 5, (2.140, 0.690, -0.004)), + ("CH2", 5, (3.028, -2.890, -0.013)), + ("CZ2", 5, (3.283, -1.543, -0.011)), + ("CZ3", 5, (1.715, -3.389, -0.011)), + ], + "TYR": [ + ("N", 0, (-0.522, 1.362, 0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.524, -0.000, -0.000)), + ("CB", 0, (-0.522, -0.776, -1.213)), + ("O", 3, (0.627, 1.062, -0.000)), + ("CG", 4, (0.607, 1.382, -0.000)), + ("CD1", 5, (0.716, 1.195, -0.000)), + ("CD2", 5, (0.713, -1.194, -0.001)), + ("CE1", 5, (2.107, 1.200, -0.002)), + ("CE2", 5, (2.104, -1.201, -0.003)), + ("OH", 5, (4.168, -0.002, -0.005)), + ("CZ", 5, (2.791, -0.001, -0.003)), + ], + "VAL": [ + ("N", 0, (-0.494, 1.373, -0.000)), + ("CA", 0, (0.000, 0.000, 0.000)), + ("C", 0, (1.527, -0.000, -0.000)), + ("CB", 0, (-0.533, -0.795, -1.213)), + ("O", 3, (0.627, 1.062, -0.000)), + ("CG1", 4, (0.540, 1.429, -0.000)), + ("CG2", 4, (0.533, -0.776, 1.203)), + ], +} + +# A list of atoms (excluding hydrogen) for each AA type. PDB naming convention. +residue_atoms: dict[str, list[str]] = { + "ALA": ["C", "CA", "CB", "N", "O"], + "ARG": ["C", "CA", "CB", "CG", "CD", "CZ", "N", "NE", "O", "NH1", "NH2"], + "ASP": ["C", "CA", "CB", "CG", "N", "O", "OD1", "OD2"], + "ASN": ["C", "CA", "CB", "CG", "N", "ND2", "O", "OD1"], + "CYS": ["C", "CA", "CB", "N", "O", "SG"], + "GLU": ["C", "CA", "CB", "CG", "CD", "N", "O", "OE1", "OE2"], + "GLN": ["C", "CA", "CB", "CG", "CD", "N", "NE2", "O", "OE1"], + "GLY": ["C", "CA", "N", "O"], + "HIS": ["C", "CA", "CB", "CG", "CD2", "CE1", "N", "ND1", "NE2", "O"], + "ILE": ["C", "CA", "CB", "CG1", "CG2", "CD1", "N", "O"], + "LEU": ["C", "CA", "CB", "CG", "CD1", "CD2", "N", "O"], + "LYS": ["C", "CA", "CB", "CG", "CD", "CE", "N", "NZ", "O"], + "MET": ["C", "CA", "CB", "CG", "CE", "N", "O", "SD"], + "PHE": ["C", "CA", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "N", "O"], + "PRO": ["C", "CA", "CB", "CG", "CD", "N", "O"], + "SER": ["C", "CA", "CB", "N", "O", "OG"], + "THR": ["C", "CA", "CB", "CG2", "N", "O", "OG1"], + "TRP": ["C", "CA", "CB", "CG", "CD1", "CD2", "CE2", "CE3", "CZ2", "CZ3", "CH2", "N", "NE1", "O"], + "TYR": ["C", "CA", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "N", "O", "OH"], + "VAL": ["C", "CA", "CB", "CG1", "CG2", "N", "O"], +} + +# Naming swaps for ambiguous atom names. +# Due to symmetries in the amino acids the naming of atoms is ambiguous in +# 4 of the 20 amino acids. +# (The LDDT paper lists 7 amino acids as ambiguous, but the naming ambiguities +# in LEU, VAL and ARG can be resolved by using the 3d constellations of +# the 'ambiguous' atoms and their neighbours) +# TODO: ^ interpret this +residue_atom_renaming_swaps: dict[str, dict[str, str]] = { + "ASP": {"OD1": "OD2"}, + "GLU": {"OE1": "OE2"}, + "PHE": {"CD1": "CD2", "CE1": "CE2"}, + "TYR": {"CD1": "CD2", "CE1": "CE2"}, +} + +# Van der Waals radii [Angstroem] of the atoms (from Wikipedia) +van_der_waals_radius: dict[str, float] = { + "C": 1.7, + "N": 1.55, + "O": 1.52, + "S": 1.8, +} + +Bond = collections.namedtuple("Bond", ["atom1_name", "atom2_name", "length", "stddev"]) +BondAngle = collections.namedtuple( + "BondAngle", + ["atom1_name", "atom2_name", "atom3name", "angle_rad", "stddev"], +) + + +def map_structure_with_atom_order(in_list: list, first_call: bool = True) -> list: + # Maps strings in a nested list structure to their corresponding index in atom_order + if first_call: + in_list = copy.deepcopy(in_list) + for i in range(len(in_list)): + if isinstance(in_list[i], list): + in_list[i] = map_structure_with_atom_order(in_list[i], first_call=False) + elif isinstance(in_list[i], str): + in_list[i] = atom_order[in_list[i]] + else: + raise TypeError("Unexpected type when mapping nested lists!") + return in_list + + +@functools.cache +def load_stereo_chemical_props() -> tuple[ + Mapping[str, list[Bond]], + Mapping[str, list[Bond]], + Mapping[str, list[BondAngle]], +]: + """Load stereo_chemical_props.txt into a nice structure. + + Load literature values for bond lengths and bond angles and translate bond angles into the length of the opposite + edge of the triangle ("residue_virtual_bonds"). + + Returns: + residue_bonds: dict that maps resname --> list of Bond tuples residue_virtual_bonds: dict that maps resname --> + list of Bond tuples residue_bond_angles: dict that maps resname --> list of BondAngle tuples + """ + # TODO: this file should be downloaded in a setup script + stereo_chemical_props = resources.read_text("openfold.resources", "stereo_chemical_props.txt") + + lines_iter = iter(stereo_chemical_props.splitlines()) + # Load bond lengths. + residue_bonds: dict[str, list[Bond]] = {} + next(lines_iter) # Skip header line. + for line in lines_iter: + if line.strip() == "-": + break + bond, resname, bond_length, stddev = line.split() + atom1, atom2 = bond.split("-") + if resname not in residue_bonds: + residue_bonds[resname] = [] + residue_bonds[resname].append(Bond(atom1, atom2, float(bond_length), float(stddev))) + residue_bonds["UNK"] = [] + + # Load bond angles. + residue_bond_angles: dict[str, list[BondAngle]] = {} + next(lines_iter) # Skip empty line. + next(lines_iter) # Skip header line. + for line in lines_iter: + if line.strip() == "-": + break + bond, resname, angle_degree, stddev_degree = line.split() + atom1, atom2, atom3 = bond.split("-") + if resname not in residue_bond_angles: + residue_bond_angles[resname] = [] + residue_bond_angles[resname].append( + BondAngle( + atom1, + atom2, + atom3, + float(angle_degree) / 180.0 * np.pi, + float(stddev_degree) / 180.0 * np.pi, + ) + ) + residue_bond_angles["UNK"] = [] + + def make_bond_key(atom1_name: str, atom2_name: str) -> str: + """Unique key to lookup bonds.""" + return "-".join(sorted([atom1_name, atom2_name])) + + # Translate bond angles into distances ("virtual bonds"). + residue_virtual_bonds: dict[str, list[Bond]] = {} + for resname, bond_angles in residue_bond_angles.items(): + # Create a fast lookup dict for bond lengths. + bond_cache: dict[str, Bond] = {} + for b in residue_bonds[resname]: + bond_cache[make_bond_key(b.atom1_name, b.atom2_name)] = b + residue_virtual_bonds[resname] = [] + for ba in bond_angles: + bond1 = bond_cache[make_bond_key(ba.atom1_name, ba.atom2_name)] + bond2 = bond_cache[make_bond_key(ba.atom2_name, ba.atom3name)] + + # Compute distance between atom1 and atom3 using the law of cosines + # c^2 = a^2 + b^2 - 2ab*cos(gamma). + gamma = ba.angle_rad + length = np.sqrt(bond1.length**2 + bond2.length**2 - 2 * bond1.length * bond2.length * np.cos(gamma)) + + # Propagation of uncertainty assuming uncorrelated errors. + dl_outer = 0.5 / length + dl_dgamma = (2 * bond1.length * bond2.length * np.sin(gamma)) * dl_outer + dl_db1 = (2 * bond1.length - 2 * bond2.length * np.cos(gamma)) * dl_outer + dl_db2 = (2 * bond2.length - 2 * bond1.length * np.cos(gamma)) * dl_outer + stddev = np.sqrt( + (dl_dgamma * ba.stddev) ** 2 + (dl_db1 * bond1.stddev) ** 2 + (dl_db2 * bond2.stddev) ** 2 + ) + residue_virtual_bonds[resname].append(Bond(ba.atom1_name, ba.atom3name, length, stddev)) + + return (residue_bonds, residue_virtual_bonds, residue_bond_angles) + + +# Between-residue bond lengths for general bonds (first element) and for Proline +# (second element). +between_res_bond_length_c_n: tuple[float, float] = (1.329, 1.341) +between_res_bond_length_stddev_c_n: tuple[float, float] = (0.014, 0.016) + +# Between-residue cos_angles. +between_res_cos_angles_c_n_ca: tuple[float, float] = (-0.5203, 0.0353) # degrees: 121.352 +- 2.315 +between_res_cos_angles_ca_c_n: tuple[float, float] = (-0.4473, 0.0311) # degrees: 116.568 +- 1.995 + +# This mapping is used when we need to store atom data in a format that requires +# fixed atom data size for every residue (e.g. a numpy array). +atom_types: list[str] = [ + "N", + "CA", + "C", + "CB", + "O", + "CG", + "CG1", + "CG2", + "OG", + "OG1", + "SG", + "CD", + "CD1", + "CD2", + "ND1", + "ND2", + "OD1", + "OD2", + "SD", + "CE", + "CE1", + "CE2", + "CE3", + "NE", + "NE1", + "NE2", + "OE1", + "OE2", + "CH2", + "NH1", + "NH2", + "OH", + "CZ", + "CZ2", + "CZ3", + "NZ", + "OXT", +] +atom_order: dict[str, int] = {atom_type: i for i, atom_type in enumerate(atom_types)} +atom_type_num = len(atom_types) # := 37. + +# A compact atom encoding with 14 columns +# pylint: disable=line-too-long +restype_name_to_atom14_names: dict[str, list[str]] = { + "ALA": ["N", "CA", "C", "O", "CB", "", "", "", "", "", "", "", "", ""], + "ARG": ["N", "CA", "C", "O", "CB", "CG", "CD", "NE", "CZ", "NH1", "NH2", "", "", ""], + "ASN": ["N", "CA", "C", "O", "CB", "CG", "OD1", "ND2", "", "", "", "", "", ""], + "ASP": ["N", "CA", "C", "O", "CB", "CG", "OD1", "OD2", "", "", "", "", "", ""], + "CYS": ["N", "CA", "C", "O", "CB", "SG", "", "", "", "", "", "", "", ""], + "GLN": ["N", "CA", "C", "O", "CB", "CG", "CD", "OE1", "NE2", "", "", "", "", ""], + "GLU": ["N", "CA", "C", "O", "CB", "CG", "CD", "OE1", "OE2", "", "", "", "", ""], + "GLY": ["N", "CA", "C", "O", "", "", "", "", "", "", "", "", "", ""], + "HIS": ["N", "CA", "C", "O", "CB", "CG", "ND1", "CD2", "CE1", "NE2", "", "", "", ""], + "ILE": ["N", "CA", "C", "O", "CB", "CG1", "CG2", "CD1", "", "", "", "", "", ""], + "LEU": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "", "", "", "", "", ""], + "LYS": ["N", "CA", "C", "O", "CB", "CG", "CD", "CE", "NZ", "", "", "", "", ""], + "MET": ["N", "CA", "C", "O", "CB", "CG", "SD", "CE", "", "", "", "", "", ""], + "PHE": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "", "", ""], + "PRO": ["N", "CA", "C", "O", "CB", "CG", "CD", "", "", "", "", "", "", ""], + "SER": ["N", "CA", "C", "O", "CB", "OG", "", "", "", "", "", "", "", ""], + "THR": ["N", "CA", "C", "O", "CB", "OG1", "CG2", "", "", "", "", "", "", ""], + "TRP": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "NE1", "CE2", "CE3", "CZ2", "CZ3", "CH2"], + "TYR": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "OH", "", ""], + "VAL": ["N", "CA", "C", "O", "CB", "CG1", "CG2", "", "", "", "", "", "", ""], + "UNK": ["", "", "", "", "", "", "", "", "", "", "", "", "", ""], +} +# pylint: enable=line-too-long + + +# This is the standard residue order when coding AA type as a number. +# Reproduce it by taking 3-letter AA codes and sorting them alphabetically. +restypes: list[str] = [ + "A", + "R", + "N", + "D", + "C", + "Q", + "E", + "G", + "H", + "I", + "L", + "K", + "M", + "F", + "P", + "S", + "T", + "W", + "Y", + "V", +] +restype_order: dict[str, int] = {restype: i for i, restype in enumerate(restypes)} +restype_num = len(restypes) # := 20. +unk_restype_index = restype_num # Catch-all index for unknown restypes. + +restypes_with_x: list[str] = restypes + ["X"] +restype_order_with_x: dict[str, int] = {restype: i for i, restype in enumerate(restypes_with_x)} + + +def sequence_to_onehot(sequence: str, mapping: Mapping[str, int], map_unknown_to_x: bool = False) -> np.ndarray: + """Maps the given sequence into a one-hot encoded matrix. + + Args: + sequence: An amino acid sequence. + mapping: A dictionary mapping amino acids to integers. + map_unknown_to_x: If True, any amino acid that is not in the mapping will be + mapped to the unknown amino acid 'X'. If the mapping doesn't contain amino acid 'X', an error will be thrown. + If False, any amino acid not in the mapping will throw an error. + + Returns: + A numpy array of shape (seq_len, num_unique_aas) with one-hot encoding of the sequence. + + Raises: + ValueError: If the mapping doesn't contain values from 0 to + num_unique_aas - 1 without any gaps. + """ + num_entries = max(mapping.values()) + 1 + + if sorted(set(mapping.values())) != list(range(num_entries)): + raise ValueError( + "The mapping must have values from 0 to num_unique_aas-1 without any gaps. Got: %s" + % sorted(mapping.values()) + ) + + one_hot_arr = np.zeros((len(sequence), num_entries), dtype=np.int32) + + for aa_index, aa_type in enumerate(sequence): + if map_unknown_to_x: + if aa_type.isalpha() and aa_type.isupper(): + aa_id = mapping.get(aa_type, mapping["X"]) + else: + raise ValueError(f"Invalid character in the sequence: {aa_type}") + else: + aa_id = mapping[aa_type] + one_hot_arr[aa_index, aa_id] = 1 + + return one_hot_arr + + +restype_1to3: dict[str, str] = { + "A": "ALA", + "R": "ARG", + "N": "ASN", + "D": "ASP", + "C": "CYS", + "Q": "GLN", + "E": "GLU", + "G": "GLY", + "H": "HIS", + "I": "ILE", + "L": "LEU", + "K": "LYS", + "M": "MET", + "F": "PHE", + "P": "PRO", + "S": "SER", + "T": "THR", + "W": "TRP", + "Y": "TYR", + "V": "VAL", +} + + +# NB: restype_3to1 differs from Bio.PDB.protein_letters_3to1 by being a simple +# 1-to-1 mapping of 3 letter names to one letter names. The latter contains +# many more, and less common, three letter names as keys and maps many of these +# to the same one letter name (including 'X' and 'U' which we don't use here). +restype_3to1: dict[str, str] = {v: k for k, v in restype_1to3.items()} + +# Define a restype name for all unknown residues. +unk_restype = "UNK" + +resnames: list[str] = [restype_1to3[r] for r in restypes] + [unk_restype] +resname_to_idx: dict[str, int] = {resname: i for i, resname in enumerate(resnames)} + + +# The mapping here uses hhblits convention, so that B is mapped to D, J and O +# are mapped to X, U is mapped to C, and Z is mapped to E. Other than that the +# remaining 20 amino acids are kept in alphabetical order. +# There are 2 non-amino acid codes, X (representing any amino acid) and +# "-" representing a missing amino acid in an alignment. The id for these +# codes is put at the end (20 and 21) so that they can easily be ignored if +# desired. +HHBLITS_AA_TO_ID: dict[str, int] = { + "A": 0, + "B": 2, + "C": 1, + "D": 2, + "E": 3, + "F": 4, + "G": 5, + "H": 6, + "I": 7, + "J": 20, + "K": 8, + "L": 9, + "M": 10, + "N": 11, + "O": 20, + "P": 12, + "Q": 13, + "R": 14, + "S": 15, + "T": 16, + "U": 1, + "V": 17, + "W": 18, + "X": 20, + "Y": 19, + "Z": 3, + "-": 21, +} + +# Partial inversion of HHBLITS_AA_TO_ID. +ID_TO_HHBLITS_AA: dict[int, str] = { + 0: "A", + 1: "C", # Also U. + 2: "D", # Also B. + 3: "E", # Also Z. + 4: "F", + 5: "G", + 6: "H", + 7: "I", + 8: "K", + 9: "L", + 10: "M", + 11: "N", + 12: "P", + 13: "Q", + 14: "R", + 15: "S", + 16: "T", + 17: "V", + 18: "W", + 19: "Y", + 20: "X", # Includes J and O. + 21: "-", +} + +restypes_with_x_and_gap: list[str] = restypes + ["X", "-"] +MAP_HHBLITS_AATYPE_TO_OUR_AATYPE: tuple[int, ...] = tuple( + restypes_with_x_and_gap.index(ID_TO_HHBLITS_AA[i]) for i in range(len(restypes_with_x_and_gap)) +) + + +def _make_standard_atom_mask() -> np.ndarray: + """Returns [num_res_types, num_atom_types] mask array.""" + # +1 to account for unknown (all 0s). + mask = np.zeros([restype_num + 1, atom_type_num], dtype=np.int32) + for restype, restype_letter in enumerate(restypes): + restype_name = restype_1to3[restype_letter] + atom_names = residue_atoms[restype_name] + for atom_name in atom_names: + atom_type = atom_order[atom_name] + mask[restype, atom_type] = 1 + return mask + + +STANDARD_ATOM_MASK = _make_standard_atom_mask() + + +# A one hot representation for the first and second atoms defining the axis +# of rotation for each chi-angle in each residue. +def chi_angle_atom(atom_index: int) -> np.ndarray: + """Define chi-angle rigid groups via one-hot representations.""" + chi_angles_index = {} + one_hots = [] + + for k, v in chi_angles_atoms.items(): + indices = [atom_types.index(s[atom_index]) for s in v] + indices.extend([-1] * (4 - len(indices))) + chi_angles_index[k] = indices + + for r in restypes: + res3 = restype_1to3[r] + one_hot = np.eye(atom_type_num)[chi_angles_index[res3]] + one_hots.append(one_hot) + + one_hots.append(np.zeros([4, atom_type_num])) # Add zeros for residue `X`. + one_hot = np.stack(one_hots, axis=0) + one_hot = np.transpose(one_hot, [0, 2, 1]) + + return one_hot + + +chi_atom_1_one_hot = chi_angle_atom(1) +chi_atom_2_one_hot = chi_angle_atom(2) + +# An array like chi_angles_atoms but using indices rather than names. +chi_angles_atom_indices_list: list[list[list[str]]] = [chi_angles_atoms[restype_1to3[r]] for r in restypes] +chi_angles_atom_indices_ours: list = map_structure_with_atom_order(chi_angles_atom_indices_list) +chi_angles_atom_indices = np.array( + [chi_atoms + ([[0, 0, 0, 0]] * (4 - len(chi_atoms))) for chi_atoms in chi_angles_atom_indices_list] +) + +# Mapping from (res_name, atom_name) pairs to the atom's chi group index +# and atom index within that group. +chi_groups_for_atom: dict[tuple[str, str], list[tuple[int, int]]] = collections.defaultdict(list) +for res_name, chi_angle_atoms_for_res in chi_angles_atoms.items(): + for chi_group_i, chi_group in enumerate(chi_angle_atoms_for_res): + for atom_i, atom in enumerate(chi_group): + chi_groups_for_atom[(res_name, atom)].append((chi_group_i, atom_i)) +chi_groups_for_atom = dict(chi_groups_for_atom) + + +def _make_rigid_transformation_4x4(ex: np.ndarray, ey: np.ndarray, translation: np.ndarray) -> np.ndarray: + """Create a rigid 4x4 transformation matrix from two axes and transl.""" + # Normalize ex. + ex_normalized = ex / np.linalg.norm(ex) + + # make ey perpendicular to ex + ey_normalized = ey - np.dot(ey, ex_normalized) * ex_normalized + ey_normalized /= np.linalg.norm(ey_normalized) + + # compute ez as cross product + eznorm = np.cross(ex_normalized, ey_normalized) + m = np.stack([ex_normalized, ey_normalized, eznorm, translation]).transpose() + m = np.concatenate([m, [[0.0, 0.0, 0.0, 1.0]]], axis=0) + return m + + +# create an array with (restype, atomtype) --> rigid_group_idx +# and an array with (restype, atomtype, coord) for the atom positions +# and compute affine transformation matrices (4,4) from one rigid group to the +# previous group +restype_atom37_to_rigid_group = np.zeros([21, 37], dtype=int) +restype_atom37_mask = np.zeros([21, 37], dtype=np.float32) +restype_atom37_rigid_group_positions = np.zeros([21, 37, 3], dtype=np.float32) +restype_atom14_to_rigid_group = np.zeros([21, 14], dtype=int) +restype_atom14_mask = np.zeros([21, 14], dtype=np.float32) +restype_atom14_rigid_group_positions = np.zeros([21, 14, 3], dtype=np.float32) +restype_rigid_group_default_frame = np.zeros([21, 8, 4, 4], dtype=np.float32) + + +def _make_rigid_group_constants() -> None: + """Fill the arrays above.""" + for restype, restype_letter in enumerate(restypes): + resname = restype_1to3[restype_letter] + for atomname, group_idx, atom_position in rigid_group_atom_positions[resname]: + atomtype = atom_order[atomname] + restype_atom37_to_rigid_group[restype, atomtype] = group_idx + restype_atom37_mask[restype, atomtype] = 1 + restype_atom37_rigid_group_positions[restype, atomtype, :] = atom_position + + atom14idx = restype_name_to_atom14_names[resname].index(atomname) + restype_atom14_to_rigid_group[restype, atom14idx] = group_idx + restype_atom14_mask[restype, atom14idx] = 1 + restype_atom14_rigid_group_positions[restype, atom14idx, :] = atom_position + + for restype, restype_letter in enumerate(restypes): + resname = restype_1to3[restype_letter] + atom_positions: dict[str, np.ndarray] = { + name: np.array(pos) for name, _, pos in rigid_group_atom_positions[resname] + } + + # backbone to backbone is the identity transform + restype_rigid_group_default_frame[restype, 0, :, :] = np.eye(4) + + # pre-omega-frame to backbone (currently dummy identity matrix) + restype_rigid_group_default_frame[restype, 1, :, :] = np.eye(4) + + # phi-frame to backbone + mat = _make_rigid_transformation_4x4( + ex=atom_positions["N"] - atom_positions["CA"], + ey=np.array([1.0, 0.0, 0.0]), + translation=atom_positions["N"], + ) + restype_rigid_group_default_frame[restype, 2, :, :] = mat + + # psi-frame to backbone + mat = _make_rigid_transformation_4x4( + ex=atom_positions["C"] - atom_positions["CA"], + ey=atom_positions["CA"] - atom_positions["N"], + translation=atom_positions["C"], + ) + restype_rigid_group_default_frame[restype, 3, :, :] = mat + + # chi1-frame to backbone + if chi_angles_mask[restype][0]: + base_atom_names = chi_angles_atoms[resname][0] + base_atom_positions = [atom_positions[name] for name in base_atom_names] + mat = _make_rigid_transformation_4x4( + ex=base_atom_positions[2] - base_atom_positions[1], + ey=base_atom_positions[0] - base_atom_positions[1], + translation=base_atom_positions[2], + ) + restype_rigid_group_default_frame[restype, 4, :, :] = mat + + # chi2-frame to chi1-frame + # chi3-frame to chi2-frame + # chi4-frame to chi3-frame + # luckily all rotation axes for the next frame start at (0,0,0) of the + # previous frame + for chi_idx in range(1, 4): + if chi_angles_mask[restype][chi_idx]: + axis_end_atom_name = chi_angles_atoms[resname][chi_idx][2] + axis_end_atom_position = atom_positions[axis_end_atom_name] + mat = _make_rigid_transformation_4x4( + ex=axis_end_atom_position, + ey=np.array([-1.0, 0.0, 0.0]), + translation=axis_end_atom_position, + ) + restype_rigid_group_default_frame[restype, 4 + chi_idx, :, :] = mat + + +_make_rigid_group_constants() + + +def make_atom14_dists_bounds( + overlap_tolerance: float = 1.5, + bond_length_tolerance_factor: int = 15, +) -> dict[str, np.ndarray]: + """compute upper and lower bounds for bonds to assess violations.""" + restype_atom14_bond_lower_bound = np.zeros([21, 14, 14], np.float32) + restype_atom14_bond_upper_bound = np.zeros([21, 14, 14], np.float32) + restype_atom14_bond_stddev = np.zeros([21, 14, 14], np.float32) + residue_bonds, residue_virtual_bonds, _ = load_stereo_chemical_props() + for restype, restype_letter in enumerate(restypes): + resname = restype_1to3[restype_letter] + atom_list = restype_name_to_atom14_names[resname] + + # create lower and upper bounds for clashes + for atom1_idx, atom1_name in enumerate(atom_list): + if not atom1_name: + continue + atom1_radius = van_der_waals_radius[atom1_name[0]] + for atom2_idx, atom2_name in enumerate(atom_list): + if (not atom2_name) or atom1_idx == atom2_idx: + continue + atom2_radius = van_der_waals_radius[atom2_name[0]] + lower = atom1_radius + atom2_radius - overlap_tolerance + upper = 1e10 + restype_atom14_bond_lower_bound[restype, atom1_idx, atom2_idx] = lower + restype_atom14_bond_lower_bound[restype, atom2_idx, atom1_idx] = lower + restype_atom14_bond_upper_bound[restype, atom1_idx, atom2_idx] = upper + restype_atom14_bond_upper_bound[restype, atom2_idx, atom1_idx] = upper + + # overwrite lower and upper bounds for bonds and angles + for b in residue_bonds[resname] + residue_virtual_bonds[resname]: + atom1_idx = atom_list.index(b.atom1_name) + atom2_idx = atom_list.index(b.atom2_name) + lower = b.length - bond_length_tolerance_factor * b.stddev + upper = b.length + bond_length_tolerance_factor * b.stddev + restype_atom14_bond_lower_bound[restype, atom1_idx, atom2_idx] = lower + restype_atom14_bond_lower_bound[restype, atom2_idx, atom1_idx] = lower + restype_atom14_bond_upper_bound[restype, atom1_idx, atom2_idx] = upper + restype_atom14_bond_upper_bound[restype, atom2_idx, atom1_idx] = upper + restype_atom14_bond_stddev[restype, atom1_idx, atom2_idx] = b.stddev + restype_atom14_bond_stddev[restype, atom2_idx, atom1_idx] = b.stddev + return { + "lower_bound": restype_atom14_bond_lower_bound, # shape (21,14,14) + "upper_bound": restype_atom14_bond_upper_bound, # shape (21,14,14) + "stddev": restype_atom14_bond_stddev, # shape (21,14,14) + } + + +restype_atom14_ambiguous_atoms = np.zeros((21, 14), dtype=np.float32) +restype_atom14_ambiguous_atoms_swap_idx: np.ndarray = np.tile(np.arange(14, dtype=int), (21, 1)) + + +def _make_atom14_ambiguity_feats() -> None: + for res, pairs in residue_atom_renaming_swaps.items(): + res_idx = restype_order[restype_3to1[res]] + for atom1, atom2 in pairs.items(): + atom1_idx = restype_name_to_atom14_names[res].index(atom1) + atom2_idx = restype_name_to_atom14_names[res].index(atom2) + restype_atom14_ambiguous_atoms[res_idx, atom1_idx] = 1 + restype_atom14_ambiguous_atoms[res_idx, atom2_idx] = 1 + restype_atom14_ambiguous_atoms_swap_idx[res_idx, atom1_idx] = atom2_idx + restype_atom14_ambiguous_atoms_swap_idx[res_idx, atom2_idx] = atom1_idx + + +_make_atom14_ambiguity_feats() + + +def aatype_to_str_sequence(aatype: Sequence[int]) -> str: + return "".join([restypes_with_x[aatype[i]] for i in range(len(aatype))]) diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/rigid_utils.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/rigid_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..8f21ccfd1a34e57db4b2fcaff5d44b1665d971f0 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/rigid_utils.py @@ -0,0 +1,1243 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +from collections.abc import Callable, Sequence +from functools import cache +from typing import Any + +import numpy as np +import torch + + +def rot_matmul(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor: + """ + Performs matrix multiplication of two rotation matrix tensors. Written out by hand to avoid AMP downcasting. + + Args: + a: [*, 3, 3] left multiplicand + b: [*, 3, 3] right multiplicand + Returns: + The product ab + """ + + def row_mul(i: int) -> torch.Tensor: + return torch.stack( + [ + a[..., i, 0] * b[..., 0, 0] + a[..., i, 1] * b[..., 1, 0] + a[..., i, 2] * b[..., 2, 0], + a[..., i, 0] * b[..., 0, 1] + a[..., i, 1] * b[..., 1, 1] + a[..., i, 2] * b[..., 2, 1], + a[..., i, 0] * b[..., 0, 2] + a[..., i, 1] * b[..., 1, 2] + a[..., i, 2] * b[..., 2, 2], + ], + dim=-1, + ) + + return torch.stack( + [ + row_mul(0), + row_mul(1), + row_mul(2), + ], + dim=-2, + ) + + +def rot_vec_mul(r: torch.Tensor, t: torch.Tensor) -> torch.Tensor: + """ + Applies a rotation to a vector. Written out by hand to avoid transfer to avoid AMP downcasting. + + Args: + r: [*, 3, 3] rotation matrices + t: [*, 3] coordinate tensors + Returns: + [*, 3] rotated coordinates + """ + x, y, z = torch.unbind(t, dim=-1) + return torch.stack( + [ + r[..., 0, 0] * x + r[..., 0, 1] * y + r[..., 0, 2] * z, + r[..., 1, 0] * x + r[..., 1, 1] * y + r[..., 1, 2] * z, + r[..., 2, 0] * x + r[..., 2, 1] * y + r[..., 2, 2] * z, + ], + dim=-1, + ) + + +@cache +def identity_rot_mats( + batch_dims: tuple[int, ...], + dtype: torch.dtype | None = None, + device: torch.device | None = None, + requires_grad: bool = True, +) -> torch.Tensor: + rots = torch.eye(3, dtype=dtype, device=device, requires_grad=requires_grad) + rots = rots.view(*((1,) * len(batch_dims)), 3, 3) + rots = rots.expand(*batch_dims, -1, -1) + rots = rots.contiguous() + + return rots + + +@cache +def identity_trans( + batch_dims: tuple[int, ...], + dtype: torch.dtype | None = None, + device: torch.device | None = None, + requires_grad: bool = True, +) -> torch.Tensor: + trans = torch.zeros((*batch_dims, 3), dtype=dtype, device=device, requires_grad=requires_grad) + return trans + + +@cache +def identity_quats( + batch_dims: tuple[int, ...], + dtype: torch.dtype | None = None, + device: torch.device | None = None, + requires_grad: bool = True, +) -> torch.Tensor: + quat = torch.zeros((*batch_dims, 4), dtype=dtype, device=device, requires_grad=requires_grad) + + with torch.no_grad(): + quat[..., 0] = 1 + + return quat + + +_quat_elements: list[str] = ["a", "b", "c", "d"] +_qtr_keys: list[str] = [l1 + l2 for l1 in _quat_elements for l2 in _quat_elements] +_qtr_ind_dict: dict[str, int] = {key: ind for ind, key in enumerate(_qtr_keys)} + + +def _to_mat(pairs: list[tuple[str, int]]) -> np.ndarray: + mat = np.zeros((4, 4)) + for key, value in pairs: + ind = _qtr_ind_dict[key] + mat[ind // 4][ind % 4] = value + + return mat + + +_QTR_MAT = np.zeros((4, 4, 3, 3)) +_QTR_MAT[..., 0, 0] = _to_mat([("aa", 1), ("bb", 1), ("cc", -1), ("dd", -1)]) +_QTR_MAT[..., 0, 1] = _to_mat([("bc", 2), ("ad", -2)]) +_QTR_MAT[..., 0, 2] = _to_mat([("bd", 2), ("ac", 2)]) +_QTR_MAT[..., 1, 0] = _to_mat([("bc", 2), ("ad", 2)]) +_QTR_MAT[..., 1, 1] = _to_mat([("aa", 1), ("bb", -1), ("cc", 1), ("dd", -1)]) +_QTR_MAT[..., 1, 2] = _to_mat([("cd", 2), ("ab", -2)]) +_QTR_MAT[..., 2, 0] = _to_mat([("bd", 2), ("ac", -2)]) +_QTR_MAT[..., 2, 1] = _to_mat([("cd", 2), ("ab", 2)]) +_QTR_MAT[..., 2, 2] = _to_mat([("aa", 1), ("bb", -1), ("cc", -1), ("dd", 1)]) + + +def quat_to_rot(quat: torch.Tensor) -> torch.Tensor: + """ + Converts a quaternion to a rotation matrix. + + Args: + quat: [*, 4] quaternions + Returns: + [*, 3, 3] rotation matrices + """ + # [*, 4, 4] + quat = quat[..., None] * quat[..., None, :] + + # [4, 4, 3, 3] + mat = _get_quat("_QTR_MAT", dtype=quat.dtype, device=quat.device) + + # [*, 4, 4, 3, 3] + shaped_qtr_mat = mat.view((1,) * len(quat.shape[:-2]) + mat.shape) + quat = quat[..., None, None] * shaped_qtr_mat + + # [*, 3, 3] + return torch.sum(quat, dim=(-3, -4)) + + +def rot_to_quat(rot: torch.Tensor) -> torch.Tensor: + if rot.shape[-2:] != (3, 3): + raise ValueError("Input rotation is incorrectly shaped") + + [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = [[rot[..., i, j] for j in range(3)] for i in range(3)] + + k = [ + [ + xx + yy + zz, + zy - yz, + xz - zx, + yx - xy, + ], + [ + zy - yz, + xx - yy - zz, + xy + yx, + xz + zx, + ], + [ + xz - zx, + xy + yx, + yy - xx - zz, + yz + zy, + ], + [ + yx - xy, + xz + zx, + yz + zy, + zz - xx - yy, + ], + ] + + _, vectors = torch.linalg.eigh((1.0 / 3.0) * torch.stack([torch.stack(t, dim=-1) for t in k], dim=-2)) + return vectors[..., -1] + + +_QUAT_MULTIPLY = np.zeros((4, 4, 4)) +_QUAT_MULTIPLY[:, :, 0] = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]] + +_QUAT_MULTIPLY[:, :, 1] = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, -1, 0]] + +_QUAT_MULTIPLY[:, :, 2] = [[0, 0, 1, 0], [0, 0, 0, -1], [1, 0, 0, 0], [0, 1, 0, 0]] + +_QUAT_MULTIPLY[:, :, 3] = [[0, 0, 0, 1], [0, 0, 1, 0], [0, -1, 0, 0], [1, 0, 0, 0]] + +_QUAT_MULTIPLY_BY_VEC = _QUAT_MULTIPLY[:, 1:, :] + +_CACHED_QUATS: dict[str, np.ndarray] = { + "_QTR_MAT": _QTR_MAT, + "_QUAT_MULTIPLY": _QUAT_MULTIPLY, + "_QUAT_MULTIPLY_BY_VEC": _QUAT_MULTIPLY_BY_VEC, +} + + +@cache +def _get_quat(quat_key: str, dtype: torch.dtype, device: torch.device) -> torch.Tensor: + return torch.tensor(_CACHED_QUATS[quat_key], dtype=dtype, device=device) + + +def quat_multiply(quat1: torch.Tensor, quat2: torch.Tensor) -> torch.Tensor: + """Multiply a quaternion by another quaternion.""" + mat = _get_quat("_QUAT_MULTIPLY", dtype=quat1.dtype, device=quat1.device) + reshaped_mat = mat.view((1,) * len(quat1.shape[:-1]) + mat.shape) + return torch.sum(reshaped_mat * quat1[..., :, None, None] * quat2[..., None, :, None], dim=(-3, -2)) + + +def quat_multiply_by_vec(quat: torch.Tensor, vec: torch.Tensor) -> torch.Tensor: + """Multiply a quaternion by a pure-vector quaternion.""" + mat = _get_quat("_QUAT_MULTIPLY_BY_VEC", dtype=quat.dtype, device=quat.device) + reshaped_mat = mat.view((1,) * len(quat.shape[:-1]) + mat.shape) + return torch.sum(reshaped_mat * quat[..., :, None, None] * vec[..., None, :, None], dim=(-3, -2)) + + +def invert_rot_mat(rot_mat: torch.Tensor) -> torch.Tensor: + return rot_mat.transpose(-1, -2) + + +def invert_quat(quat: torch.Tensor) -> torch.Tensor: + quat_prime = quat.clone() + quat_prime[..., 1:] *= -1 + inv = quat_prime / torch.sum(quat**2, dim=-1, keepdim=True) + return inv + + +class Rotation: + """ + A 3D rotation. Depending on how the object is initialized, the rotation is represented by either a rotation matrix + or a quaternion, though both formats are made available by helper functions. To simplify gradient computation, the + underlying format of the rotation cannot be changed in-place. Like Rigid, the class is designed to mimic the + behavior of a torch Tensor, almost as if each Rotation object were a tensor of rotations, in one format or another. + """ + + def __init__( + self, + rot_mats: torch.Tensor | None = None, + quats: torch.Tensor | None = None, + normalize_quats: bool = True, + ): + """ + Args: + rot_mats: + A [*, 3, 3] rotation matrix tensor. Mutually exclusive with quats + quats: + A [*, 4] quaternion. Mutually exclusive with rot_mats. If normalize_quats is not True, must be a unit + quaternion + normalize_quats: + If quats is specified, whether to normalize quats + """ + if (rot_mats is None and quats is None) or (rot_mats is not None and quats is not None): + raise ValueError("Exactly one input argument must be specified") + + if (rot_mats is not None and rot_mats.shape[-2:] != (3, 3)) or (quats is not None and quats.shape[-1] != 4): + raise ValueError("Incorrectly shaped rotation matrix or quaternion") + + # Force full-precision + if quats is not None: + quats = quats.to(dtype=torch.float32) + if rot_mats is not None: + rot_mats = rot_mats.to(dtype=torch.float32) + + if quats is not None and normalize_quats: + quats = quats / torch.linalg.norm(quats, dim=-1, keepdim=True) + + self._rot_mats = rot_mats + self._quats = quats + + @staticmethod + def identity( + shape, + dtype: torch.dtype | None = None, + device: torch.device | None = None, + requires_grad: bool = True, + fmt: str = "quat", + ) -> Rotation: + """ + Returns an identity Rotation. + + Args: + shape: + The "shape" of the resulting Rotation object. See documentation for the shape property + dtype: + The torch dtype for the rotation + device: + The torch device for the new rotation + requires_grad: + Whether the underlying tensors in the new rotation object should require gradient computation + fmt: + One of "quat" or "rot_mat". Determines the underlying format of the new object's rotation + Returns: + A new identity rotation + """ + if fmt == "rot_mat": + rot_mats = identity_rot_mats( + shape, + dtype, + device, + requires_grad, + ) + return Rotation(rot_mats=rot_mats, quats=None) + elif fmt == "quat": + quats = identity_quats(shape, dtype, device, requires_grad) + return Rotation(rot_mats=None, quats=quats, normalize_quats=False) + else: + raise ValueError(f"Invalid format: f{fmt}") + + # Magic methods + + def __getitem__(self, index: Any) -> Rotation: + """ + Allows torch-style indexing over the virtual shape of the rotation object. See documentation for the shape + property. + + Args: + index: + A torch index. E.g. (1, 3, 2), or (slice(None,)) + Returns: + The indexed rotation + """ + if type(index) is not tuple: + index = (index,) + + if self._rot_mats is not None: + rot_mats = self._rot_mats[index + (slice(None), slice(None))] + return Rotation(rot_mats=rot_mats) + elif self._quats is not None: + quats = self._quats[index + (slice(None),)] + return Rotation(quats=quats, normalize_quats=False) + else: + raise ValueError("Both rotations are None") + + def __mul__(self, right: torch.Tensor) -> Rotation: + """ + Pointwise left multiplication of the rotation with a tensor. Can be used to e.g. mask the Rotation. + + Args: + right: + The tensor multiplicand + Returns: + The product + """ + if not (isinstance(right, torch.Tensor)): + raise TypeError("The other multiplicand must be a Tensor") + + if self._rot_mats is not None: + rot_mats = self._rot_mats * right[..., None, None] + return Rotation(rot_mats=rot_mats, quats=None) + elif self._quats is not None: + quats = self._quats * right[..., None] + return Rotation(rot_mats=None, quats=quats, normalize_quats=False) + else: + raise ValueError("Both rotations are None") + + def __rmul__(self, left: torch.Tensor) -> Rotation: + """ + Reverse pointwise multiplication of the rotation with a tensor. + + Args: + left: + The left multiplicand + Returns: + The product + """ + return self.__mul__(left) + + # Properties + + @property + def shape(self) -> torch.Size: + """ + Returns the virtual shape of the rotation object. This shape is defined as the batch dimensions of the + underlying rotation matrix or quaternion. If the Rotation was initialized with a [10, 3, 3] rotation matrix + tensor, for example, the resulting shape would be [10]. + + Returns: + The virtual shape of the rotation object + """ + if self._rot_mats is not None: + return self._rot_mats.shape[:-2] + elif self._quats is not None: + return self._quats.shape[:-1] + else: + raise ValueError("Both rotations are None") + + @property + def dtype(self) -> torch.dtype: + """ + Returns the dtype of the underlying rotation. + + Returns: + The dtype of the underlying rotation + """ + if self._rot_mats is not None: + return self._rot_mats.dtype + elif self._quats is not None: + return self._quats.dtype + else: + raise ValueError("Both rotations are None") + + @property + def device(self) -> torch.device: + """ + The device of the underlying rotation + + Returns: + The device of the underlying rotation + """ + if self._rot_mats is not None: + return self._rot_mats.device + elif self._quats is not None: + return self._quats.device + else: + raise ValueError("Both rotations are None") + + @property + def requires_grad(self) -> bool: + """ + Returns the requires_grad property of the underlying rotation + + Returns: + The requires_grad property of the underlying tensor + """ + if self._rot_mats is not None: + return self._rot_mats.requires_grad + elif self._quats is not None: + return self._quats.requires_grad + else: + raise ValueError("Both rotations are None") + + def get_rot_mats(self) -> torch.Tensor: + """ + Returns the underlying rotation as a rotation matrix tensor. + + Returns: + The rotation as a rotation matrix tensor + """ + if self._rot_mats is not None: + return self._rot_mats + elif self._quats is not None: + return quat_to_rot(self._quats) + else: + raise ValueError("Both rotations are None") + + def get_quats(self) -> torch.Tensor: + """ + Returns the underlying rotation as a quaternion tensor. + + Depending on whether the Rotation was initialized with a quaternion, this function may call torch.linalg.eigh. + + Returns: + The rotation as a quaternion tensor. + """ + if self._rot_mats is not None: + return rot_to_quat(self._rot_mats) + elif self._quats is not None: + return self._quats + else: + raise ValueError("Both rotations are None") + + def get_cur_rot(self) -> torch.Tensor: + """ + Return the underlying rotation in its current form + + Returns: + The stored rotation + """ + if self._rot_mats is not None: + return self._rot_mats + elif self._quats is not None: + return self._quats + else: + raise ValueError("Both rotations are None") + + # Rotation functions + + def compose_q_update_vec(self, q_update_vec: torch.Tensor, normalize_quats: bool = True) -> Rotation: + """ + Returns a new quaternion Rotation after updating the current object's underlying rotation with a quaternion + update, formatted as a [*, 3] tensor whose final three columns represent x, y, z such that (1, x, y, z) is the + desired (not necessarily unit) quaternion update. + + Args: + q_update_vec: + A [*, 3] quaternion update tensor + normalize_quats: + Whether to normalize the output quaternion + Returns: + An updated Rotation + """ + quats = self.get_quats() + new_quats = quats + quat_multiply_by_vec(quats, q_update_vec) + return Rotation( + rot_mats=None, + quats=new_quats, + normalize_quats=normalize_quats, + ) + + def compose_r(self, r: Rotation) -> Rotation: + """ + Compose the rotation matrices of the current Rotation object with those of another. + + Args: + r: + An update rotation object + Returns: + An updated rotation object + """ + r1 = self.get_rot_mats() + r2 = r.get_rot_mats() + new_rot_mats = rot_matmul(r1, r2) + return Rotation(rot_mats=new_rot_mats, quats=None) + + def compose_q(self, r: Rotation, normalize_quats: bool = True) -> Rotation: + """ + Compose the quaternions of the current Rotation object with those of another. + + Depending on whether either Rotation was initialized with quaternions, this function may call + torch.linalg.eigh. + + Args: + r: + An update rotation object + Returns: + An updated rotation object + """ + q1 = self.get_quats() + q2 = r.get_quats() + new_quats = quat_multiply(q1, q2) + return Rotation(rot_mats=None, quats=new_quats, normalize_quats=normalize_quats) + + def apply(self, pts: torch.Tensor) -> torch.Tensor: + """ + Apply the current Rotation as a rotation matrix to a set of 3D coordinates. + + Args: + pts: + A [*, 3] set of points + Returns: + [*, 3] rotated points + """ + rot_mats = self.get_rot_mats() + return rot_vec_mul(rot_mats, pts) + + def invert_apply(self, pts: torch.Tensor) -> torch.Tensor: + """ + The inverse of the apply() method. + + Args: + pts: + A [*, 3] set of points + Returns: + [*, 3] inverse-rotated points + """ + rot_mats = self.get_rot_mats() + inv_rot_mats = invert_rot_mat(rot_mats) + return rot_vec_mul(inv_rot_mats, pts) + + def invert(self) -> Rotation: + """ + Returns the inverse of the current Rotation. + + Returns: + The inverse of the current Rotation + """ + if self._rot_mats is not None: + return Rotation(rot_mats=invert_rot_mat(self._rot_mats), quats=None) + elif self._quats is not None: + return Rotation( + rot_mats=None, + quats=invert_quat(self._quats), + normalize_quats=False, + ) + else: + raise ValueError("Both rotations are None") + + # "Tensor" stuff + + def unsqueeze(self, dim: int) -> Rotation: + """ + Analogous to torch.unsqueeze. The dimension is relative to the shape of the Rotation object. + + Args: + dim: A positive or negative dimension index. + Returns: + The unsqueezed Rotation. + """ + if dim >= len(self.shape): + raise ValueError("Invalid dimension") + + if self._rot_mats is not None: + rot_mats = self._rot_mats.unsqueeze(dim if dim >= 0 else dim - 2) + return Rotation(rot_mats=rot_mats, quats=None) + elif self._quats is not None: + quats = self._quats.unsqueeze(dim if dim >= 0 else dim - 1) + return Rotation(rot_mats=None, quats=quats, normalize_quats=False) + else: + raise ValueError("Both rotations are None") + + @staticmethod + def cat(rs: Sequence[Rotation], dim: int) -> Rotation: + """ + Concatenates rotations along one of the batch dimensions. Analogous to torch.cat(). + + Note that the output of this operation is always a rotation matrix, regardless of the format of input + rotations. + + Args: + rs: + A list of rotation objects + dim: + The dimension along which the rotations should be concatenated + Returns: + A concatenated Rotation object in rotation matrix format + """ + rot_mats = torch.cat( + [r.get_rot_mats() for r in rs], + dim=dim if dim >= 0 else dim - 2, + ) + + return Rotation(rot_mats=rot_mats, quats=None) + + def map_tensor_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Rotation: + """ + Apply a Tensor -> Tensor function to underlying rotation tensors, mapping over the rotation dimension(s). Can + be used e.g. to sum out a one-hot batch dimension. + + Args: + fn: + A Tensor -> Tensor function to be mapped over the Rotation + Returns: + The transformed Rotation object + """ + if self._rot_mats is not None: + rot_mats = self._rot_mats.view(self._rot_mats.shape[:-2] + (9,)) + rot_mats = torch.stack(list(map(fn, torch.unbind(rot_mats, dim=-1))), dim=-1) + rot_mats = rot_mats.view(rot_mats.shape[:-1] + (3, 3)) + return Rotation(rot_mats=rot_mats, quats=None) + elif self._quats is not None: + quats = torch.stack(list(map(fn, torch.unbind(self._quats, dim=-1))), dim=-1) + return Rotation(rot_mats=None, quats=quats, normalize_quats=False) + else: + raise ValueError("Both rotations are None") + + def cuda(self) -> Rotation: + """ + Analogous to the cuda() method of torch Tensors + + Returns: + A copy of the Rotation in CUDA memory + """ + if self._rot_mats is not None: + return Rotation(rot_mats=self._rot_mats.cuda(), quats=None) + elif self._quats is not None: + return Rotation(rot_mats=None, quats=self._quats.cuda(), normalize_quats=False) + else: + raise ValueError("Both rotations are None") + + def to(self, device: torch.device | None, dtype: torch.dtype | None) -> Rotation: + """ + Analogous to the to() method of torch Tensors + + Args: + device: + A torch device + dtype: + A torch dtype + Returns: + A copy of the Rotation using the new device and dtype + """ + if self._rot_mats is not None: + return Rotation( + rot_mats=self._rot_mats.to(device=device, dtype=dtype), + quats=None, + ) + elif self._quats is not None: + return Rotation( + rot_mats=None, + quats=self._quats.to(device=device, dtype=dtype), + normalize_quats=False, + ) + else: + raise ValueError("Both rotations are None") + + def detach(self) -> Rotation: + """ + Returns a copy of the Rotation whose underlying Tensor has been detached from its torch graph. + + Returns: + A copy of the Rotation whose underlying Tensor has been detached from its torch graph + """ + if self._rot_mats is not None: + return Rotation(rot_mats=self._rot_mats.detach(), quats=None) + elif self._quats is not None: + return Rotation( + rot_mats=None, + quats=self._quats.detach(), + normalize_quats=False, + ) + else: + raise ValueError("Both rotations are None") + + +class Rigid: + """ + A class representing a rigid transformation. Little more than a wrapper around two objects: a Rotation object and a + [*, 3] translation Designed to behave approximately like a single torch tensor with the shape of the shared batch + dimensions of its component parts. + """ + + def __init__(self, rots: Rotation | None, trans: torch.Tensor | None): + """ + Args: + rots: A [*, 3, 3] rotation tensor + trans: A corresponding [*, 3] translation tensor + """ + # (we need device, dtype, etc. from at least one input) + + batch_dims, dtype, device, requires_grad = None, None, None, None + if trans is not None: + batch_dims = trans.shape[:-1] + dtype = trans.dtype + device = trans.device + requires_grad = trans.requires_grad + elif rots is not None: + batch_dims = rots.shape + dtype = rots.dtype + device = rots.device + requires_grad = rots.requires_grad + else: + raise ValueError("At least one input argument must be specified") + + if rots is None: + rots = Rotation.identity( + batch_dims, + dtype, + device, + requires_grad, + ) + elif trans is None: + trans = identity_trans( + batch_dims, + dtype, + device, + requires_grad, + ) + + assert rots is not None + assert trans is not None + + if (rots.shape != trans.shape[:-1]) or (rots.device != trans.device): + raise ValueError("Rots and trans incompatible") + + # Force full precision. Happens to the rotations automatically. + trans = trans.to(dtype=torch.float32) + + self._rots = rots + self._trans = trans + + @staticmethod + def identity( + shape: tuple[int, ...], + dtype: torch.dtype | None = None, + device: torch.device | None = None, + requires_grad: bool = True, + fmt: str = "quat", + ) -> Rigid: + """ + Constructs an identity transformation. + + Args: + shape: + The desired shape + dtype: + The dtype of both internal tensors + device: + The device of both internal tensors + requires_grad: + Whether grad should be enabled for the internal tensors + Returns: + The identity transformation + """ + return Rigid( + Rotation.identity(shape, dtype, device, requires_grad, fmt=fmt), + identity_trans(shape, dtype, device, requires_grad), + ) + + def __getitem__(self, index: Any) -> Rigid: + """ + Indexes the affine transformation with PyTorch-style indices. The index is applied to the shared dimensions of + both the rotation and the translation. + + E.g.:: + + r = Rotation(rot_mats=torch.rand(10, 10, 3, 3), quats=None) t = Rigid(r, torch.rand(10, 10, 3)) indexed = + t[3, 4:6] assert(indexed.shape == (2,)) assert(indexed.get_rots().shape == (2,)) + assert(indexed.get_trans().shape == (2, 3)) + + Args: + index: A standard torch tensor index. E.g. 8, (10, None, 3), + or (3, slice(0, 1, None)) + Returns: + The indexed tensor + """ + if type(index) is not tuple: + index = (index,) + + return Rigid( + self._rots[index], + self._trans[index + (slice(None),)], + ) + + def __mul__(self, right: torch.Tensor) -> Rigid: + """ + Pointwise left multiplication of the transformation with a tensor. Can be used to e.g. mask the Rigid. + + Args: + right: + The tensor multiplicand + Returns: + The product + """ + if not (isinstance(right, torch.Tensor)): + raise TypeError("The other multiplicand must be a Tensor") + + new_rots = self._rots * right + new_trans = self._trans * right[..., None] + + return Rigid(new_rots, new_trans) + + def __rmul__(self, left: torch.Tensor) -> Rigid: + """ + Reverse pointwise multiplication of the transformation with a tensor. + + Args: + left: + The left multiplicand + Returns: + The product + """ + return self.__mul__(left) + + @property + def shape(self) -> torch.Size: + """ + Returns the shape of the shared dimensions of the rotation and the translation. + + Returns: + The shape of the transformation + """ + return self._trans.shape[:-1] + + @property + def device(self) -> torch.device: + """ + Returns the device on which the Rigid's tensors are located. + + Returns: + The device on which the Rigid's tensors are located + """ + return self._trans.device + + def get_rots(self) -> Rotation: + """ + Getter for the rotation. + + Returns: + The rotation object + """ + return self._rots + + def get_trans(self) -> torch.Tensor: + """ + Getter for the translation. + + Returns: + The stored translation + """ + return self._trans + + def compose_q_update_vec(self, q_update_vec: torch.Tensor) -> Rigid: + """ + Composes the transformation with a quaternion update vector of shape [*, 6], where the final 6 columns + represent the x, y, and z values of a quaternion of form (1, x, y, z) followed by a 3D translation. + + Args: + q_vec: The quaternion update vector. + Returns: + The composed transformation. + """ + q_vec, t_vec = q_update_vec[..., :3], q_update_vec[..., 3:] + new_rots = self._rots.compose_q_update_vec(q_vec) + + trans_update = self._rots.apply(t_vec) + new_translation = self._trans + trans_update + + return Rigid(new_rots, new_translation) + + def compose(self, r: Rigid) -> Rigid: + """ + Composes the current rigid object with another. + + Args: + r: + Another Rigid object + Returns: + The composition of the two transformations + """ + new_rot = self._rots.compose_r(r._rots) + new_trans = self._rots.apply(r._trans) + self._trans + return Rigid(new_rot, new_trans) + + def apply(self, pts: torch.Tensor) -> torch.Tensor: + """ + Applies the transformation to a coordinate tensor. + + Args: + pts: A [*, 3] coordinate tensor. + Returns: + The transformed points. + """ + rotated = self._rots.apply(pts) + return rotated + self._trans + + def invert_apply(self, pts: torch.Tensor) -> torch.Tensor: + """ + Applies the inverse of the transformation to a coordinate tensor. + + Args: + pts: A [*, 3] coordinate tensor + Returns: + The transformed points. + """ + pts = pts - self._trans + return self._rots.invert_apply(pts) + + def invert(self) -> Rigid: + """ + Inverts the transformation. + + Returns: + The inverse transformation. + """ + rot_inv = self._rots.invert() + trn_inv = rot_inv.apply(self._trans) + + return Rigid(rot_inv, -1 * trn_inv) + + def map_tensor_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Rigid: + """ + Apply a Tensor -> Tensor function to underlying translation and rotation tensors, mapping over the + translation/rotation dimensions respectively. + + Args: + fn: + A Tensor -> Tensor function to be mapped over the Rigid + Returns: + The transformed Rigid object + """ + new_rots = self._rots.map_tensor_fn(fn) + new_trans = torch.stack(list(map(fn, torch.unbind(self._trans, dim=-1))), dim=-1) + + return Rigid(new_rots, new_trans) + + def to_tensor_4x4(self) -> torch.Tensor: + """ + Converts a transformation to a homogeneous transformation tensor. + + Returns: + A [*, 4, 4] homogeneous transformation tensor + """ + tensor = self._trans.new_zeros((*self.shape, 4, 4)) + tensor[..., :3, :3] = self._rots.get_rot_mats() + tensor[..., :3, 3] = self._trans + tensor[..., 3, 3] = 1 + return tensor + + @staticmethod + def from_tensor_4x4(t: torch.Tensor) -> Rigid: + """ + Constructs a transformation from a homogeneous transformation tensor. + + Args: + t: [*, 4, 4] homogeneous transformation tensor + Returns: + T object with shape [*] + """ + if t.shape[-2:] != (4, 4): + raise ValueError("Incorrectly shaped input tensor") + + rots = Rotation(rot_mats=t[..., :3, :3], quats=None) + trans = t[..., :3, 3] + + return Rigid(rots, trans) + + def to_tensor_7(self) -> torch.Tensor: + """ + Converts a transformation to a tensor with 7 final columns, four for the quaternion followed by three for the + translation. + + Returns: + A [*, 7] tensor representation of the transformation + """ + tensor = self._trans.new_zeros((*self.shape, 7)) + tensor[..., :4] = self._rots.get_quats() + tensor[..., 4:] = self._trans + + return tensor + + @staticmethod + def from_tensor_7(t: torch.Tensor, normalize_quats: bool = False) -> Rigid: + if t.shape[-1] != 7: + raise ValueError("Incorrectly shaped input tensor") + + quats, trans = t[..., :4], t[..., 4:] + + rots = Rotation(rot_mats=None, quats=quats, normalize_quats=normalize_quats) + + return Rigid(rots, trans) + + @staticmethod + def from_3_points( + p_neg_x_axis: torch.Tensor, origin: torch.Tensor, p_xy_plane: torch.Tensor, eps: float = 1e-8 + ) -> Rigid: + """ + Implements algorithm 21. Constructs transformations from sets of 3 points using the Gram-Schmidt algorithm. + + Args: + p_neg_x_axis: [*, 3] coordinates + origin: [*, 3] coordinates used as frame origins + p_xy_plane: [*, 3] coordinates + eps: Small epsilon value + Returns: + A transformation object of shape [*] + """ + p_neg_x_axis_unbound = torch.unbind(p_neg_x_axis, dim=-1) + origin_unbound = torch.unbind(origin, dim=-1) + p_xy_plane_unbound = torch.unbind(p_xy_plane, dim=-1) + + e0 = [c1 - c2 for c1, c2 in zip(origin_unbound, p_neg_x_axis_unbound)] + e1 = [c1 - c2 for c1, c2 in zip(p_xy_plane_unbound, origin_unbound)] + + denom = torch.sqrt(sum(c * c for c in e0) + eps * torch.ones_like(e0[0])) + e0 = [c / denom for c in e0] + dot = sum((c1 * c2 for c1, c2 in zip(e0, e1))) + e1 = [c2 - c1 * dot for c1, c2 in zip(e0, e1)] + denom = torch.sqrt(sum(c * c for c in e1) + eps * torch.ones_like(e1[0])) + e1 = [c / denom for c in e1] + e2 = [ + e0[1] * e1[2] - e0[2] * e1[1], + e0[2] * e1[0] - e0[0] * e1[2], + e0[0] * e1[1] - e0[1] * e1[0], + ] + + rots = torch.stack([c for tup in zip(e0, e1, e2) for c in tup], dim=-1) + rots = rots.reshape(rots.shape[:-1] + (3, 3)) + + rot_obj = Rotation(rot_mats=rots, quats=None) + + return Rigid(rot_obj, torch.stack(origin_unbound, dim=-1)) + + def unsqueeze(self, dim: int) -> Rigid: + """ + Analogous to torch.unsqueeze. The dimension is relative to the shared dimensions of the rotation/translation. + + Args: + dim: A positive or negative dimension index. + Returns: + The unsqueezed transformation. + """ + if dim >= len(self.shape): + raise ValueError("Invalid dimension") + rots = self._rots.unsqueeze(dim) + trans = self._trans.unsqueeze(dim if dim >= 0 else dim - 1) + + return Rigid(rots, trans) + + @staticmethod + def cat(ts: Sequence[Rigid], dim: int) -> Rigid: + """ + Concatenates transformations along a new dimension. + + Args: + ts: + A list of T objects + dim: + The dimension along which the transformations should be concatenated + Returns: + A concatenated transformation object + """ + rots = Rotation.cat([t._rots for t in ts], dim) + trans = torch.cat([t._trans for t in ts], dim=dim if dim >= 0 else dim - 1) + + return Rigid(rots, trans) + + def apply_rot_fn(self, fn: Callable[[Rotation], Rotation]) -> Rigid: + """ + Applies a Rotation -> Rotation function to the stored rotation object. + + Args: + fn: A function of type Rotation -> Rotation + Returns: + A transformation object with a transformed rotation. + """ + return Rigid(fn(self._rots), self._trans) + + def apply_trans_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> Rigid: + """ + Applies a Tensor -> Tensor function to the stored translation. + + Args: + fn: + A function of type Tensor -> Tensor to be applied to the translation + Returns: + A transformation object with a transformed translation. + """ + return Rigid(self._rots, fn(self._trans)) + + def scale_translation(self, trans_scale_factor: float) -> Rigid: + """ + Scales the translation by a constant factor. + + Args: + trans_scale_factor: + The constant factor + Returns: + A transformation object with a scaled translation. + """ + return self.apply_trans_fn(lambda t: t * trans_scale_factor) + + def stop_rot_gradient(self) -> Rigid: + """ + Detaches the underlying rotation object + + Returns: + A transformation object with detached rotations + """ + return self.apply_rot_fn(lambda r: r.detach()) + + @staticmethod + def make_transform_from_reference( + n_xyz: torch.Tensor, ca_xyz: torch.Tensor, c_xyz: torch.Tensor, eps: float = 1e-20 + ) -> Rigid: + """ + Returns a transformation object from reference coordinates. + + Note that this method does not take care of symmetries. If you provide the atom positions in the non-standard + way, the N atom will end up not at [-0.527250, 1.359329, 0.0] but instead at [-0.527250, -1.359329, 0.0]. You + need to take care of such cases in your code. + + Args: + n_xyz: A [*, 3] tensor of nitrogen xyz coordinates. + ca_xyz: A [*, 3] tensor of carbon alpha xyz coordinates. + c_xyz: A [*, 3] tensor of carbon xyz coordinates. + Returns: + A transformation object. After applying the translation and rotation to the reference backbone, the + coordinates will approximately equal to the input coordinates. + """ + translation = -1 * ca_xyz + n_xyz = n_xyz + translation + c_xyz = c_xyz + translation + + c_x, c_y, c_z = [c_xyz[..., i] for i in range(3)] + norm = torch.sqrt(eps + c_x**2 + c_y**2) + sin_c1 = -c_y / norm + cos_c1 = c_x / norm + + c1_rots = sin_c1.new_zeros((*sin_c1.shape, 3, 3)) + c1_rots[..., 0, 0] = cos_c1 + c1_rots[..., 0, 1] = -1 * sin_c1 + c1_rots[..., 1, 0] = sin_c1 + c1_rots[..., 1, 1] = cos_c1 + c1_rots[..., 2, 2] = 1 + + norm = torch.sqrt(eps + c_x**2 + c_y**2 + c_z**2) + sin_c2 = c_z / norm + cos_c2 = torch.sqrt(c_x**2 + c_y**2) / norm + + c2_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3)) + c2_rots[..., 0, 0] = cos_c2 + c2_rots[..., 0, 2] = sin_c2 + c2_rots[..., 1, 1] = 1 + c2_rots[..., 2, 0] = -1 * sin_c2 + c2_rots[..., 2, 2] = cos_c2 + + c_rots = rot_matmul(c2_rots, c1_rots) + n_xyz = rot_vec_mul(c_rots, n_xyz) + + _, n_y, n_z = [n_xyz[..., i] for i in range(3)] + norm = torch.sqrt(eps + n_y**2 + n_z**2) + sin_n = -n_z / norm + cos_n = n_y / norm + + n_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3)) + n_rots[..., 0, 0] = 1 + n_rots[..., 1, 1] = cos_n + n_rots[..., 1, 2] = -1 * sin_n + n_rots[..., 2, 1] = sin_n + n_rots[..., 2, 2] = cos_n + + rots = rot_matmul(n_rots, c_rots) + + rots = rots.transpose(-1, -2) + translation = -1 * translation + + rot_obj = Rotation(rot_mats=rots, quats=None) + + return Rigid(rot_obj, translation) + + def cuda(self) -> Rigid: + """ + Moves the transformation object to GPU memory + + Returns: + A version of the transformation on GPU + """ + return Rigid(self._rots.cuda(), self._trans.cuda()) diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/tensor_utils.py b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/tensor_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1362fa8de1c79a14f20501a551afa41145a39349 --- /dev/null +++ b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/esm/openfold_utils/tensor_utils.py @@ -0,0 +1,140 @@ +# Copyright 2021 AlQuraishi Laboratory +# Copyright 2021 DeepMind Technologies Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from collections.abc import Callable +from functools import partial +from typing import Any, TypeVar, overload + +import torch +import torch.nn as nn +import torch.types + + +def add(m1: torch.Tensor, m2: torch.Tensor, inplace: bool) -> torch.Tensor: + # The first operation in a checkpoint can't be in-place, but it's + # nice to have in-place addition during inference. Thus... + if not inplace: + m1 = m1 + m2 + else: + m1 += m2 + + return m1 + + +def permute_final_dims(tensor: torch.Tensor, inds: list[int]) -> torch.Tensor: + zero_index = -1 * len(inds) + first_inds = list(range(len(tensor.shape[:zero_index]))) + return tensor.permute(first_inds + [zero_index + i for i in inds]) + + +def flatten_final_dims(t: torch.Tensor, no_dims: int) -> torch.Tensor: + return t.reshape(t.shape[:-no_dims] + (-1,)) + + +def masked_mean(mask: torch.Tensor, value: torch.Tensor, dim: int, eps: float = 1e-4) -> torch.Tensor: + mask = mask.expand(*value.shape) + return torch.sum(mask * value, dim=dim) / (eps + torch.sum(mask, dim=dim)) + + +def pts_to_distogram( + pts: torch.Tensor, min_bin: torch.types.Number = 2.3125, max_bin: torch.types.Number = 21.6875, no_bins: int = 64 +) -> torch.Tensor: + boundaries = torch.linspace(min_bin, max_bin, no_bins - 1, device=pts.device) + dists = torch.sqrt(torch.sum((pts.unsqueeze(-2) - pts.unsqueeze(-3)) ** 2, dim=-1)) + return torch.bucketize(dists, boundaries) + + +def dict_multimap(fn: Callable[[list], Any], dicts: list[dict]) -> dict: + first = dicts[0] + new_dict = {} + for k, v in first.items(): + all_v = [d[k] for d in dicts] + if isinstance(v, dict): + new_dict[k] = dict_multimap(fn, all_v) + else: + new_dict[k] = fn(all_v) + + return new_dict + + +def one_hot(x: torch.Tensor, v_bins: torch.Tensor) -> torch.Tensor: + reshaped_bins = v_bins.view(((1,) * len(x.shape)) + (len(v_bins),)) + diffs = x[..., None] - reshaped_bins + am = torch.argmin(torch.abs(diffs), dim=-1) + return nn.functional.one_hot(am, num_classes=len(v_bins)).float() + + +def batched_gather(data: torch.Tensor, inds: torch.Tensor, dim: int = 0, no_batch_dims: int = 0) -> torch.Tensor: + ranges: list[slice | torch.Tensor] = [] + for i, s in enumerate(data.shape[:no_batch_dims]): + r = torch.arange(s) + r = r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape) - i - 1)))) + ranges.append(r) + + remaining_dims: list[slice | torch.Tensor] = [slice(None) for _ in range(len(data.shape) - no_batch_dims)] + remaining_dims[dim - no_batch_dims if dim >= 0 else dim] = inds + ranges.extend(remaining_dims) + # Matt note: Editing this to get around the behaviour of using a list as an array index changing + # in recent Numpy versions + return data[tuple(ranges)] + + +T = TypeVar("T") + + +def dict_map( + fn: Callable[[T], Any], dic: dict[Any, dict | list | tuple | T], leaf_type: type[T] +) -> dict[Any, dict | list | tuple | Any]: + new_dict: dict[Any, dict | list | tuple | Any] = {} + for k, v in dic.items(): + if isinstance(v, dict): + new_dict[k] = dict_map(fn, v, leaf_type) + else: + new_dict[k] = tree_map(fn, v, leaf_type) + + return new_dict + + +@overload +def tree_map(fn: Callable[[T], Any], tree: T, leaf_type: type[T]) -> Any: ... + + +@overload +def tree_map(fn: Callable[[T], Any], tree: dict, leaf_type: type[T]) -> dict: ... + + +@overload +def tree_map(fn: Callable[[T], Any], tree: list, leaf_type: type[T]) -> list: ... + + +@overload +def tree_map(fn: Callable[[T], Any], tree: tuple, leaf_type: type[T]) -> tuple: ... + + +def tree_map(fn, tree, leaf_type): + if isinstance(tree, dict): + return dict_map(fn, tree, leaf_type) + elif isinstance(tree, list): + return [tree_map(fn, x, leaf_type) for x in tree] + elif isinstance(tree, tuple): + return tuple(tree_map(fn, x, leaf_type) for x in tree) + elif isinstance(tree, leaf_type): + return fn(tree) + else: + print(type(tree)) + raise TypeError("Not supported") + + +tensor_tree_map = partial(tree_map, leaf_type=torch.Tensor) diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..efa4cc0f24271723ac0e6eadcedeec4d0c070076 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/configuration_eurobert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/configuration_eurobert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..440232f355aae34ff092a91858ef6a0519db9271 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/configuration_eurobert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/modeling_eurobert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/modeling_eurobert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..049e8a27feb01294aeff9e018d0fbe73490c6113 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/modeling_eurobert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/modular_eurobert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/modular_eurobert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03300bb82e6d16610dc8202477992c586c3a6ed8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/eurobert/__pycache__/modular_eurobert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1c31fd434ee21aab8f5eff503ae9b7c7da0e01c9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/configuration_evolla.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/configuration_evolla.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..088d15b9c39a31182b2f6da2c09ea2fb086371aa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/configuration_evolla.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/modeling_evolla.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/modeling_evolla.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ec99bda4bfef3af7a63274747d614d660e9551f8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/modeling_evolla.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/modular_evolla.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/modular_evolla.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..edae311cd096f8353d1e9ff5bbe61929cb517664 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/modular_evolla.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/processing_evolla.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/processing_evolla.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e384cdd7e534b126d713b71638838c225090e6a5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/evolla/__pycache__/processing_evolla.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bf056de5d6aad8183aa67cde3c7b9d251197057 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/configuration_exaone4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/configuration_exaone4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c9a3b491311af006016f4c00a11575bf1930451 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/configuration_exaone4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/modeling_exaone4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/modeling_exaone4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f979bdf2df1f11b76edab491b5071a7a988b23fe Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/modeling_exaone4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/modular_exaone4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/modular_exaone4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..87fe0e35e7f5f300de01ce3b4e3042c1e3d218cd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4/__pycache__/modular_exaone4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b5180161449eccb92c549d738ef95ebb2601010 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/configuration_exaone4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/configuration_exaone4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aabc880c46b7eebdd4678f7c25fc8fc6581d5ed1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/configuration_exaone4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/modeling_exaone4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/modeling_exaone4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..08e0872282c74a9aca674135fe12ff327d666d8b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/modeling_exaone4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/modular_exaone4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/modular_exaone4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..188077b88ad7fc28c8fbf71c667188489120b81b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/modular_exaone4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/processing_exaone4_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/processing_exaone4_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..39fb8165fe8ce22c6d344bc2cfba474f569f25ed Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone4_5/__pycache__/processing_exaone4_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9ddcdc18102ac1271edd0000493c56535ef7946 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/configuration_exaone_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/configuration_exaone_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..38194ead72e22f06a0d16ab4a011fd9fa7d4e933 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/configuration_exaone_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/modeling_exaone_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/modeling_exaone_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d93c45284c273c6f7e88f507434ad6eeb06393a0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/modeling_exaone_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/modular_exaone_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/modular_exaone_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..75345300dc75e7a22f96f32ed6e1679b35d5d4f4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/exaone_moe/__pycache__/modular_exaone_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2c146a8310159716731a8e3ce4fa9b11562df432 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/configuration_falcon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/configuration_falcon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b590d3e0ccbb957cef26b2aa01f989edd422d6b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/configuration_falcon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/modeling_falcon.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/modeling_falcon.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9bb213bd484c651c8ecf83d7a6f3843b5c37cb79 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon/__pycache__/modeling_falcon.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e10687d6766c92c365c518b4d6f75964b07d79c0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/configuration_falcon_h1.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/configuration_falcon_h1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..852af508318f592e9846625219d213d21b9325f8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/configuration_falcon_h1.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/modeling_falcon_h1.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/modeling_falcon_h1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90f6dcc6153bb5b78bfeb10e0eeb345be4e0c0ff Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/modeling_falcon_h1.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/modular_falcon_h1.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/modular_falcon_h1.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..363039cfa9e143c2e3301c4348bed3cc123b3e75 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_h1/__pycache__/modular_falcon_h1.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..625a4c039efc02598837e9482acaf921cf7c823d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/configuration_falcon_mamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/configuration_falcon_mamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..92488d001342806ce14db076ab2d8732f6ec1a37 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/configuration_falcon_mamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/modeling_falcon_mamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/modeling_falcon_mamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b4aa3e3b3c161703ff26138b2452f619fc3a4ef Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/modeling_falcon_mamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/modular_falcon_mamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/modular_falcon_mamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e42d5a377aa7284e1ca0be5ef28af61cdecf4b15 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/falcon_mamba/__pycache__/modular_falcon_mamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a62dbaf2c3c293bf804e806e7627c07b7e635fc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/configuration_fast_vlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/configuration_fast_vlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34949c9ecd43d7230a1a62811ef4cdc27fa1ddd3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/configuration_fast_vlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/modeling_fast_vlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/modeling_fast_vlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..14a35f4196e39da5c7dbb74531d941a58aa9c817 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/modeling_fast_vlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/modular_fast_vlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/modular_fast_vlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..073b8ae606b885160e05a34574d4305f038cb70d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fast_vlm/__pycache__/modular_fast_vlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae050de0f5fa181c2d5e2d876077c5ef6fc8fb2f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/configuration_fastspeech2_conformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/configuration_fastspeech2_conformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3aebb166c2249f454e5fec0ae5718e304ef7da47 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/configuration_fastspeech2_conformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/modeling_fastspeech2_conformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/modeling_fastspeech2_conformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..321ff36787d7dddf342e890d5846a216b1072e06 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/modeling_fastspeech2_conformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/tokenization_fastspeech2_conformer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/tokenization_fastspeech2_conformer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3117a9a56f884880f6894078ffbddb6e6ba69c20 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fastspeech2_conformer/__pycache__/tokenization_fastspeech2_conformer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf19d6a28e1454dc38ca04c5d49dcfade5e5c6a1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/configuration_flaubert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/configuration_flaubert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fac08b4d56aff621d725b127973f78b3b92e60b7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/configuration_flaubert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/modeling_flaubert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/modeling_flaubert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4de68dea8b78154a12bcf07853545d2d8a229c8b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/modeling_flaubert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/tokenization_flaubert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/tokenization_flaubert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..566a0c9640ad6b34f091045c508e32a31b3c87ae Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flaubert/__pycache__/tokenization_flaubert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..286f3ae12483622324239119234cfd3c53277fbb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/configuration_flava.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/configuration_flava.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dec2962ea11df46818e9313d2b0f8ddd2c91589e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/configuration_flava.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/image_processing_flava.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/image_processing_flava.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e873f2f92399151bc34486010f7cef9e2ab6bf66 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/image_processing_flava.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/image_processing_pil_flava.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/image_processing_pil_flava.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..23a0ab0ddff880ffb9c18dee7e7c43d922ff510d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/image_processing_pil_flava.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/processing_flava.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/processing_flava.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dec7e04dbaf0bc8ec36ce65abc1b4593dfe678da Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flava/__pycache__/processing_flava.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c5bc3803785576e8fdd6cbceb2d243c761905a0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/configuration_flex_olmo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/configuration_flex_olmo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f7a41e1948972d9f23ff90b6a4a76d5c0b792e7d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/configuration_flex_olmo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/modeling_flex_olmo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/modeling_flex_olmo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f3da1a400e1dbf5be8bb60db861a6c847604d1cb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/modeling_flex_olmo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/modular_flex_olmo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/modular_flex_olmo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a058575efdb59f2d067f6ce6fe6d6d85b74ad874 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/flex_olmo/__pycache__/modular_flex_olmo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..52dc16fcc80ef784f399398a49201b290f00f527 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/configuration_florence2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/configuration_florence2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1eb189cd8ba0fcc0db1b4a455e8bf33a4a690c3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/configuration_florence2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/modeling_florence2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/modeling_florence2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a042987fd2f58ffa8e207df177efbd1c5882018 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/modeling_florence2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/modular_florence2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/modular_florence2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..456d849287eb036ff10360038f822c6636e1df49 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/modular_florence2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/processing_florence2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/processing_florence2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1b79d5a822b30012d5ab7993655111e5a22a312 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/florence2/__pycache__/processing_florence2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..218ffa684c4ed1e298d53ef05dcf5e93f8e13035 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/configuration_fnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/configuration_fnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0fe37195f2f4980547332759619d56b8c005f122 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/configuration_fnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/modeling_fnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/modeling_fnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca82dc1779de5566b6b5817c5f2040bca04766d0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/modeling_fnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/tokenization_fnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/tokenization_fnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b0e98100bea7c5df776da7c996096e8407047ac1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fnet/__pycache__/tokenization_fnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e3ecba244410215079e568f37f3aba716728423e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/configuration_focalnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/configuration_focalnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8f633ea219735ed960faf7639f922b1dd57cdf28 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/configuration_focalnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/modeling_focalnet.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/modeling_focalnet.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d73f9fc7fd4eee561cc8c68b39aed6d5b608460f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/focalnet/__pycache__/modeling_focalnet.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e14dc49b19314daed7538939f0fe0883767056d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/configuration_fsmt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/configuration_fsmt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a8e69325293d727e26b7b28bc8662fda693aaee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/configuration_fsmt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/modeling_fsmt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/modeling_fsmt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c23642a17425e04a5800467fcd268065d372b10 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/modeling_fsmt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/tokenization_fsmt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/tokenization_fsmt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d3c39712965281b17263e2319677fcfad54c6447 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fsmt/__pycache__/tokenization_fsmt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfc200c6dfd1a4cde3214af2d66baa1dc2e28916 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/configuration_funnel.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/configuration_funnel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d4dd42d70265fbb877ac2c7207d0ac49e705424e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/configuration_funnel.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/modeling_funnel.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/modeling_funnel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..484c2ce30289ba8bf20339523f2558ae27ba4631 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/modeling_funnel.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/tokenization_funnel.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/tokenization_funnel.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..544f21d803613966049a861161ed0bf4f07a31a3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/funnel/__pycache__/tokenization_funnel.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7eecf3e197939f43481ab75d5e22124f66f5aef4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/configuration_fuyu.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/configuration_fuyu.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e861cbd49304d262d64725766630034ddf9b45aa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/configuration_fuyu.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/image_processing_fuyu.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/image_processing_fuyu.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4a451ca2804e18558623c0a8b3bdf73222b680f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/image_processing_fuyu.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/image_processing_pil_fuyu.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/image_processing_pil_fuyu.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d00bb5c1bedd2f8695596fcddc4d6b42e833e8c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/image_processing_pil_fuyu.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/modeling_fuyu.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/modeling_fuyu.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eda1c7eb685a62a04bc348578d1345ade94e1783 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/modeling_fuyu.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/processing_fuyu.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/processing_fuyu.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3184f885c0be8dcdc974d5fc76f402be435ceea9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/fuyu/__pycache__/processing_fuyu.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bdfbc1131f39478a7ca04ee330bc80eb12902e3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/configuration_gemma.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/configuration_gemma.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ea9bffcbe1e27b74ddb27c3c498f4986b2bf7a7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/configuration_gemma.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/modeling_gemma.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/modeling_gemma.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b51fdc0eb45d51316bd6ccd69d70766762cd072 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/modeling_gemma.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/modular_gemma.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/modular_gemma.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5006c9b4992757c0049f55b96921b20a861548b7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/modular_gemma.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/tokenization_gemma.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/tokenization_gemma.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1aa61d75f376ffe6aff95c91254586f54894685 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma/__pycache__/tokenization_gemma.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b49b21ca7c6582b8b18fc09fb816c66988bc0409 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/configuration_gemma2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/configuration_gemma2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf1e7dfee4a89323e2c4b4023f0d132cb75a2ad6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/configuration_gemma2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/modeling_gemma2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/modeling_gemma2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..30b26d33de197116b8f340d0f8406973746fc47c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/modeling_gemma2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/modular_gemma2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/modular_gemma2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66f530e02db13433e270e47aa3dcaa9a4f7b6a97 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma2/__pycache__/modular_gemma2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9780cb2cccd6a1737b1c9a5b76ca87d564279f8d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/configuration_gemma3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/configuration_gemma3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0c7f9b241bba909dbd512c98ed265c5f192c4726 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/configuration_gemma3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/image_processing_gemma3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/image_processing_gemma3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f2c7df1a5bc7a01bfcf5ec7afbb8a408565d5367 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/image_processing_gemma3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/image_processing_pil_gemma3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/image_processing_pil_gemma3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b38cf8bbf6b39dfdeaacc630e359acacf0cd4a9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/image_processing_pil_gemma3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/modeling_gemma3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/modeling_gemma3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf6a9a1b94ce6ba269abdc5b009668eccbe3bb0f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/modeling_gemma3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/modular_gemma3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/modular_gemma3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e51fa40fea4eac070d03babe662f6bcd0056e41b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/modular_gemma3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/processing_gemma3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/processing_gemma3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9febe4d5f8d4d3f4d3a0f85b17ee35f89a750449 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3/__pycache__/processing_gemma3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ab6544febd3062fa6fac39f2c02b30bd78629f8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/configuration_gemma3n.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/configuration_gemma3n.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ac014bab62b97761ed63e215170124042822896 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/configuration_gemma3n.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/feature_extraction_gemma3n.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/feature_extraction_gemma3n.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b063d6b7adc0beead863de128de4a44309948b0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/feature_extraction_gemma3n.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/processing_gemma3n.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/processing_gemma3n.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9d7c03016cc661adb2ec1b0efb09a0f4f70d466f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma3n/__pycache__/processing_gemma3n.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..418d64955fb1a371af099adda38e20d6a5093ef5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/configuration_gemma4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/configuration_gemma4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c0fbb3cd2b8c7e2e620d24acd02d545f4ab1c001 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/configuration_gemma4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/feature_extraction_gemma4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/feature_extraction_gemma4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1ac7c002c388790a8e3eaa25d8e9d33a3171eb6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/feature_extraction_gemma4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/image_processing_gemma4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/image_processing_gemma4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88faade81adc792650766c6e983474830eab287f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/image_processing_gemma4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/image_processing_pil_gemma4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/image_processing_pil_gemma4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a4c9c54eacf7b4d08fafad19ee682fae0c7be9a9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/image_processing_pil_gemma4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/processing_gemma4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/processing_gemma4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6a03fb91881d7aea593c6e16b5a75dc3407b82dc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/processing_gemma4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/video_processing_gemma4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/video_processing_gemma4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9c2b969bf9ea525714ef0e224f26af40350857f0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4/__pycache__/video_processing_gemma4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f0d553013c8ddbcbadfee64528b07d701a18989d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/configuration_gemma4_assistant.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/configuration_gemma4_assistant.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ee0beda8fabdad82fff018e75a59c8bbb2ed8f1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/configuration_gemma4_assistant.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/modeling_gemma4_assistant.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/modeling_gemma4_assistant.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d43476d658af6e8a5249e0066306701cdba0147e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gemma4_assistant/__pycache__/modeling_gemma4_assistant.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffad50774afb0953172bc42e0875d1880535dcd1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/configuration_git.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/configuration_git.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e27cb7663f29ea01b2d57857aa76576a03594f2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/configuration_git.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/modeling_git.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/modeling_git.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6e4d9b0e20d2ca42e372cd555328dda062e97148 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/modeling_git.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/processing_git.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/processing_git.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8cb09a0dd05d323294849bb99c10f2b8ed924e15 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/git/__pycache__/processing_git.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..448bfab6a57cc9f21354ec8b82323528d1b3d8f4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/configuration_glm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/configuration_glm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4569dfa5482986b7dd3e09f443a97254d60841c7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/configuration_glm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/modeling_glm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/modeling_glm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a40f6f12e378556515bb4bef6e8b291c60225414 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/modeling_glm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/modular_glm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/modular_glm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe5b12f93215fc35ba1721d9a6248a67d2b174cd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm/__pycache__/modular_glm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd485fadf319cd6859a938edf9b11048da3e0ad7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/configuration_glm4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/configuration_glm4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..48d02050332a85097d4f28e499ffd96f90e320dc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/configuration_glm4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/modeling_glm4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/modeling_glm4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e87685cc63b8c0cbf346beab10ac3c57b4ff784 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/modeling_glm4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/modular_glm4.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/modular_glm4.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8874c17b72c4d2b5df04cb1f3d16fb17c8c2aeca Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4/__pycache__/modular_glm4.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72dad95593986c3c841f4a2aa9805350b4ae9dec Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/configuration_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/configuration_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a1310740045cc79434e5d3589ed11bb9329d3be4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/configuration_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/image_processing_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/image_processing_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..de883bb1a2bdbde82a53c9e33c81eb0ffbbb43a8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/image_processing_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/image_processing_pil_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/image_processing_pil_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..274592da924a3145723a12c4115a84fbde45ad08 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/image_processing_pil_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/modeling_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/modeling_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..38d9486bb9bbf5711fefbef34947ae307bd855ee Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/modeling_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/modular_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/modular_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b06255a78af1f3813eeac733b642bc042dcc8ae Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/modular_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/processing_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/processing_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..281deed6b0797ac06cd96b2d0d0698994a473438 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/processing_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/video_processing_glm46v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/video_processing_glm46v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..328327c3f4f15b3bc0abe8160089df24893b66ef Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm46v/__pycache__/video_processing_glm46v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5ee20b605642a39e252c47ed9e61ffd7a3edc4e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/configuration_glm4_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/configuration_glm4_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6c59596ac3ebc5eaad712c2bed6d4b3e73473fcf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/configuration_glm4_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/modeling_glm4_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/modeling_glm4_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c664ad06784c839953b474d5fa40903ded9c12c8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/modeling_glm4_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/modular_glm4_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/modular_glm4_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af69dc436da629ba77f23f7aa239ccce6cc092d7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe/__pycache__/modular_glm4_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9fcbfad712d191d3fb4827819ed207f108f5916 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/configuration_glm4_moe_lite.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/configuration_glm4_moe_lite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50a536c662844ba2f61419c983cc1cd3e1e1aa66 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/configuration_glm4_moe_lite.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/modeling_glm4_moe_lite.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/modeling_glm4_moe_lite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eaecacec54a12f6072712a211fd288f8800c9d04 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/modeling_glm4_moe_lite.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/modular_glm4_moe_lite.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/modular_glm4_moe_lite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dcc409f5a96f77775c27be5d0d75dc78ddae9a5c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4_moe_lite/__pycache__/modular_glm4_moe_lite.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce6488182c4839e350f6300332a7476b369f12a4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/configuration_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/configuration_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ecc798f787be7e3947f1b4489965aee9119a34dc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/configuration_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/image_processing_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/image_processing_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82ee3168b043f94bcc2a952cde72f2690e43ac3a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/image_processing_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/image_processing_pil_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/image_processing_pil_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a834820b93a1248ab78ae23e186c17618341face Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/image_processing_pil_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/modeling_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/modeling_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a77bd6da4a46b6dc17dd6165302543c6bc22967d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/modeling_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/modular_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/modular_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..66c29f7576310e404c726a6ede2d162bc92a3912 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/modular_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/processing_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/processing_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..469d66ce1b35bb5bfa6714ce4a10aa57eb546c73 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/processing_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/video_processing_glm4v.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/video_processing_glm4v.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e9378816df9e6b083624e7518521152cf1b6fc7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v/__pycache__/video_processing_glm4v.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d0cbf7a0483c368b5bb4b7df4b6ef1cb5f12f5c3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/configuration_glm4v_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/configuration_glm4v_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..012c44ffb5f8837359bcd424128d4c398fde9ca8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/configuration_glm4v_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/modular_glm4v_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/modular_glm4v_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41e9f64a2a341bcf44cc7921857e5c349d679a1c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm4v_moe/__pycache__/modular_glm4v_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8a00a24544faf011894ad8f72417511050645fd4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/configuration_glm_image.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/configuration_glm_image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b8d43ac519e06380a7e3324e7f4150e22d55005b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/configuration_glm_image.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/image_processing_glm_image.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/image_processing_glm_image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..162c3e4b672c3ed59249b8b887da07c09d5893d4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/image_processing_glm_image.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/image_processing_pil_glm_image.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/image_processing_pil_glm_image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7b6b224a8f84c0e87645f51ba732861ef3ddd07a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/image_processing_pil_glm_image.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/modeling_glm_image.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/modeling_glm_image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e937706d0846eb0973dc2063de7e85d2e3e9c8a5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/modeling_glm_image.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/modular_glm_image.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/modular_glm_image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8cc3d587f67a35a92fa048f8461101605ecaf10 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/modular_glm_image.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/processing_glm_image.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/processing_glm_image.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3fd623b4975200c285ab7ae41bb29acac47d5bbe Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_image/__pycache__/processing_glm_image.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4361effbae6f2ec282f6fb9bd245eaef6cc6881f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/configuration_glm_moe_dsa.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/configuration_glm_moe_dsa.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bffbc775697b9bfd9b4c70c67dca839f72d6292e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/configuration_glm_moe_dsa.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/modeling_glm_moe_dsa.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/modeling_glm_moe_dsa.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2dae537906e25b219e0f2c262df5baf74ac34ee9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/modeling_glm_moe_dsa.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/modular_glm_moe_dsa.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/modular_glm_moe_dsa.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..796205912717f65a71bb019d623bb697f5b8aa74 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_moe_dsa/__pycache__/modular_glm_moe_dsa.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fed85a7ca63db315477292cda4c2145b43864baf Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/configuration_glm_ocr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/configuration_glm_ocr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8436a17d463b7cae0d01ea4e634fa6228379505d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/configuration_glm_ocr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/modeling_glm_ocr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/modeling_glm_ocr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc1647fbb909aa6aaddf0677e86a1da82e7a8f13 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/modeling_glm_ocr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/modular_glm_ocr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/modular_glm_ocr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e61f8c00b0196ee3de1a547f1502d6ac00af30a1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glm_ocr/__pycache__/modular_glm_ocr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d9159f892e912d917d4e8223677783ad2012f48a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/configuration_glmasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/configuration_glmasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5aba4848a6a53186c93e4e65c2ae05f0aab36caa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/configuration_glmasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/modeling_glmasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/modeling_glmasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..41c0119d9198c42f9b3420c0d9e846f1433a50e7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/modeling_glmasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/modular_glmasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/modular_glmasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54b89181488fba5c01bc0d0548c522660cb019a9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/modular_glmasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/processing_glmasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/processing_glmasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..32f53ecdcca9a5c71e1c5cd8a560f117d864b0ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glmasr/__pycache__/processing_glmasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee5116e38654ff3c948a93775f9f932199af9bfd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/configuration_glpn.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/configuration_glpn.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e91c87eee01873637770ea05a59a0d84a73db2c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/configuration_glpn.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/image_processing_glpn.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/image_processing_glpn.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7e7de31035eb0b23ccdbc60418a3c27447c6a6bb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/image_processing_glpn.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/image_processing_pil_glpn.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/image_processing_pil_glpn.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9ad4231615660f15725d3fcc209a8013d9f94037 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/image_processing_pil_glpn.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/modeling_glpn.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/modeling_glpn.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e37f43777cb4024269ef8ad7929f292c54696a0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/glpn/__pycache__/modeling_glpn.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c7141560c36b03b6621108577276a899eb0c80cb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/configuration_got_ocr2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/configuration_got_ocr2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..239827530c70099eb804286cf984df23c92a6ae7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/configuration_got_ocr2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/image_processing_got_ocr2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/image_processing_got_ocr2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..eccffbd31dbb3c7f32e5847ba67ed83980d1fdd2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/image_processing_got_ocr2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/image_processing_pil_got_ocr2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/image_processing_pil_got_ocr2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80f41469eee74a342b1b88ae6ac58ea7337bb474 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/image_processing_pil_got_ocr2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/modeling_got_ocr2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/modeling_got_ocr2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76522a7eeb05c71b3c89d6ceff9edc4df51eea78 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/modeling_got_ocr2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/modular_got_ocr2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/modular_got_ocr2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f09e044bd3f1a96ec37250b01f7a5a53fd266e0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/modular_got_ocr2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/processing_got_ocr2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/processing_got_ocr2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5f61bd4be06e7f38338f2d0b221dd30dd589a625 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/got_ocr2/__pycache__/processing_got_ocr2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..34d83c4f21c12c78151a789fe47fe43706a2b1fc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/configuration_gpt2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/configuration_gpt2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e4ef9edaa350d4d29b3bf26b1ad54df537341bd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/configuration_gpt2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/modeling_gpt2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/modeling_gpt2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4bdc66289629788ecc27375a5fc764ba41699084 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/modeling_gpt2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/tokenization_gpt2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/tokenization_gpt2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bd57e8f2ca7cbfe2a49e71ddf29e3a57dbb952dd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt2/__pycache__/tokenization_gpt2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae29f040deb8673cd126abc74916a8d40a5b251f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/configuration_gpt_bigcode.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/configuration_gpt_bigcode.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5505c323001253d19c8ae8952e02bb16b432dba Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/configuration_gpt_bigcode.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/modeling_gpt_bigcode.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/modeling_gpt_bigcode.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..29e2fd88077a8b391874660e69b76e9920898d7e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_bigcode/__pycache__/modeling_gpt_bigcode.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83fad7d4443d023818f68b5cfc44ce14db8d061e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/configuration_gpt_neo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/configuration_gpt_neo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..46ae8ac9b34db5667d19736f99de287a126f1f49 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/configuration_gpt_neo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/modeling_gpt_neo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/modeling_gpt_neo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bfb4bea215509573a29433b4fd2b7b367f3405a9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neo/__pycache__/modeling_gpt_neo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..687b9c4c1ae988020204a74f2bef70bb3cd31cd5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/configuration_gpt_neox.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/configuration_gpt_neox.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ff6ba6ede81f3cf3d13ab3fc71d678e14ed21fe6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/configuration_gpt_neox.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/modeling_gpt_neox.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/modeling_gpt_neox.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d8a76327a540228ea87e42c2e780021f0a3a9ff Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/modeling_gpt_neox.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/modular_gpt_neox.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/modular_gpt_neox.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d4c2b5582ea929595fbbe8dc1cd830b7acc040a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/modular_gpt_neox.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/tokenization_gpt_neox.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/tokenization_gpt_neox.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7785f1c899409c02c79924ab6eedc53fa1d2da1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox/__pycache__/tokenization_gpt_neox.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1566bd55e5d827e83a545bf8eb97894c355a050d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/configuration_gpt_neox_japanese.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/configuration_gpt_neox_japanese.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e627b1f23c28701dbfd5dc81a18bc9c2fd85bcf4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/configuration_gpt_neox_japanese.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/modeling_gpt_neox_japanese.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/modeling_gpt_neox_japanese.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e70ff11281c064bfa2f0c76f8cabc439b387aa6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/modeling_gpt_neox_japanese.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/tokenization_gpt_neox_japanese.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/tokenization_gpt_neox_japanese.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a23d8d99b7e88f79d260036fde959234d057810 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_neox_japanese/__pycache__/tokenization_gpt_neox_japanese.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..51377fc8d0ccc538736a0dddc3c208c367829f33 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/configuration_gpt_oss.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/configuration_gpt_oss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cac171b0e6c205b7d3e49cf2ec89eceab5260639 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/configuration_gpt_oss.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/modeling_gpt_oss.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/modeling_gpt_oss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e37d1a78592c164e59b3c529b9d4bb3723bccb1c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/modeling_gpt_oss.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/modular_gpt_oss.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/modular_gpt_oss.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..99c7326b8b7fd8463acffaa998a30da9748fb6e6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_oss/__pycache__/modular_gpt_oss.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_sw3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_sw3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dee7ae7ce92e99dafef9a8393dae2a8d7dd79125 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_sw3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_sw3/__pycache__/tokenization_gpt_sw3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_sw3/__pycache__/tokenization_gpt_sw3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4ee3c0cbdf20ec4a4f32df63eed0f4da2ef4e8a6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gpt_sw3/__pycache__/tokenization_gpt_sw3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..030a460d88bb9ed8d349a12fa69b0847310e0b6c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/configuration_gptj.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/configuration_gptj.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42a031c17d9c7ff78e2865fa2a489b1df5373b8a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/configuration_gptj.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/modeling_gptj.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/modeling_gptj.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e741f261b19947b2accadaa42c72a83f793dfacc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/gptj/__pycache__/modeling_gptj.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..959dafea53d14a6948c17e81a19c8142b02bfd56 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/configuration_granite.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/configuration_granite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..230ba2b33197fd812f4d68dd0e53a7ee52b86713 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/configuration_granite.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/modeling_granite.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/modeling_granite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d61eff185c0d3b9c44c6e3d6c1cddfdc7e83785 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/modeling_granite.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/modular_granite.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/modular_granite.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4099b56734167be3ad0c9f457432a1d123236569 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite/__pycache__/modular_granite.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2d53a79e3c398474484c819fe0d5ee8d87929e97 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/configuration_granite4_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/configuration_granite4_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..805b3568dc98f020ca50bd5fc9d4418a48a64231 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/configuration_granite4_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/modeling_granite4_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/modeling_granite4_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fb09920656a57c74ace1993def355e42636824b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/modeling_granite4_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/modular_granite4_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/modular_granite4_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..421b89b01115592b04e2258544188494cfc05938 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/modular_granite4_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/processing_granite4_vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/processing_granite4_vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3d2e59d6c0cf3a517da00c1d2878bb70ff612f1a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite4_vision/__pycache__/processing_granite4_vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e45cbec5aa07dcd3dce8962d53eeb9089b5691b3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/configuration_granite_speech.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/configuration_granite_speech.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8e7e6b15516c95b86c4f5fd71c4fccaeba8a6466 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/configuration_granite_speech.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/feature_extraction_granite_speech.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/feature_extraction_granite_speech.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6aa2502a66bac6610610fa47418cff8914bbd94e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/feature_extraction_granite_speech.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/modeling_granite_speech.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/modeling_granite_speech.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1ffb19cd005100206286f56dbdfa21a66de176f3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/modeling_granite_speech.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/processing_granite_speech.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/processing_granite_speech.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..719f440a9529f0c3a503b46bc000c69d5c593988 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech/__pycache__/processing_granite_speech.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9177e08cfa37b1678ea9a5ccf333c5d3729a1680 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/configuration_granite_speech_plus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/configuration_granite_speech_plus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ee7b78df6114e2debd2281077f907979dea53629 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/configuration_granite_speech_plus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/modeling_granite_speech_plus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/modeling_granite_speech_plus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b3f167b52fabbe1c83275bd6a7d1e7f8563a253b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/modeling_granite_speech_plus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/modular_granite_speech_plus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/modular_granite_speech_plus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aafe8ef3013bdc4747e021bea374e26380017a2f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granite_speech_plus/__pycache__/modular_granite_speech_plus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..738be23dafda363ce13eab86eb6fed324d1d2693 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/configuration_granitemoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/configuration_granitemoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4fa9cebd3318611e05ff91eb5b280ec4c7550499 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/configuration_granitemoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/modeling_granitemoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/modeling_granitemoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d0548789b288147e818094676e1ed0670e05417 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/modeling_granitemoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/modular_granitemoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/modular_granitemoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e93cd8a4bfe7fb3b66fae760bf743c5f98f6a103 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoe/__pycache__/modular_granitemoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2fe9c309cfa6b02f178254b3bcee0f87fb5466b1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/configuration_granitemoehybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/configuration_granitemoehybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..85c21b185a1ed5bab3d99dac5cefe79d4fee5122 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/configuration_granitemoehybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/modeling_granitemoehybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/modeling_granitemoehybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..496780afe1f117f39e44200e6b6dbceedf0be676 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/modeling_granitemoehybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/modular_granitemoehybrid.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/modular_granitemoehybrid.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50753e4e27f1693e73f6f869fcdfcdd1628efd1b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoehybrid/__pycache__/modular_granitemoehybrid.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c1d02f3b71d8f6f482fcf66a00d0a6d11dd790e7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/configuration_granitemoeshared.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/configuration_granitemoeshared.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6b546f9c4c59f8d0ca4eb55a6d0f4ca5b8437ae7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/configuration_granitemoeshared.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/modeling_granitemoeshared.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/modeling_granitemoeshared.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2d980f38f5ef763f7d7f19e281bac219289a538 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/modeling_granitemoeshared.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/modular_granitemoeshared.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/modular_granitemoeshared.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42812f5538e43d07386f876776b702dc017158a5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/granitemoeshared/__pycache__/modular_granitemoeshared.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe7912ce82f8fe9c0457b20cbe1cf0d882617edc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/configuration_grounding_dino.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/configuration_grounding_dino.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b820d4840477527b41750039e97c460c331ce65d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/configuration_grounding_dino.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/image_processing_grounding_dino.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/image_processing_grounding_dino.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83881d130d9c698dfc92955e26b0cbdbeeb4f1b2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/image_processing_grounding_dino.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/image_processing_pil_grounding_dino.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/image_processing_pil_grounding_dino.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0e8238a4289daed202afe3484f906f86af0a08cc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/image_processing_pil_grounding_dino.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/modular_grounding_dino.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/modular_grounding_dino.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..649c47a4ba884c5165cea2b6094e004ea9b10890 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/modular_grounding_dino.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/processing_grounding_dino.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/processing_grounding_dino.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f5c92af65a5c90521c22814ee6316a5e799cb23 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/grounding_dino/__pycache__/processing_grounding_dino.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c6f5018d3068cf98975f120f1909ecc5e137511b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/configuration_groupvit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/configuration_groupvit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09d24ef6986b4aa7ece7066dab478456fde7caa7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/configuration_groupvit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/modeling_groupvit.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/modeling_groupvit.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..868c779706ceec69945c64f412d91b0b0bedc295 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/groupvit/__pycache__/modeling_groupvit.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..97486c9dd8280af952373ba3c952d0a4bf33b674 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/configuration_helium.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/configuration_helium.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b80fcc99aa938c408e7a94ff4675187dc7ad0bd1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/configuration_helium.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/modeling_helium.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/modeling_helium.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a98c55465e25fdd174cdfc9f2700097d1c34e1a9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/modeling_helium.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/modular_helium.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/modular_helium.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dd902721eaed02de49065af926eea021ab812cf1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/helium/__pycache__/modular_helium.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/herbert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/herbert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3a0ace50e46fa26e0ec6a0d21e8bd9481ae13f8b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/herbert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/herbert/__pycache__/tokenization_herbert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/herbert/__pycache__/tokenization_herbert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..854845e8a88f2beda7d34f05ac17dec9c4d8a313 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/herbert/__pycache__/tokenization_herbert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e6e92edd0e80ff79f27d6936836933c597135f7d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/configuration_hgnet_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/configuration_hgnet_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e8ee1a192b7c9464ed7de1b9bdef149c861b0327 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/configuration_hgnet_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/modeling_hgnet_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/modeling_hgnet_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f66077f376e77248be5ed66cea583c80af2ff4e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/modeling_hgnet_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/modular_hgnet_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/modular_hgnet_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b42c661e924555fadfb4a707122c12fe82d29768 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hgnet_v2/__pycache__/modular_hgnet_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca2caead442287ee320ccac0141499013390c8be Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/configuration_hiera.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/configuration_hiera.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e36a67dd8548d5c8140b33e71abe0da0aed3649e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/configuration_hiera.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/modeling_hiera.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/modeling_hiera.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f93f148d419070c916c5791474731f329086f82 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hiera/__pycache__/modeling_hiera.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a1363f597a6542a6ef42f71b2c3809a2b9e5aac Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/configuration_higgs_audio_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/configuration_higgs_audio_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cb10b8ff8696efaf94e82128e72ee64012be3744 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/configuration_higgs_audio_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/generation_higgs_audio_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/generation_higgs_audio_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84734e4835074c88825ba3ce39db3ff8ea440f0d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/generation_higgs_audio_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/modeling_higgs_audio_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/modeling_higgs_audio_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fe3898033e01f90c33e135e01b8403cdec4c98f4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/modeling_higgs_audio_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/modular_higgs_audio_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/modular_higgs_audio_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f472658c5f117b815b13d49d9da9c352afe2f020 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/modular_higgs_audio_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/processing_higgs_audio_v2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/processing_higgs_audio_v2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ec0812a0127485a24b3782e373979435909242f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2/__pycache__/processing_higgs_audio_v2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..071907c16f44cf04a9845a27e0475b616c9650dd Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/configuration_higgs_audio_v2_tokenizer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/configuration_higgs_audio_v2_tokenizer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..707b93792d775c1780a636f1bcc5470e557bf561 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/configuration_higgs_audio_v2_tokenizer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/modeling_higgs_audio_v2_tokenizer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/modeling_higgs_audio_v2_tokenizer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24c66b05e73603bb34f9548c90f81327143b6554 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/modeling_higgs_audio_v2_tokenizer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/modular_higgs_audio_v2_tokenizer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/modular_higgs_audio_v2_tokenizer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8142ee54d65b8cac5e991c3ad86883ab96631ed0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/higgs_audio_v2_tokenizer/__pycache__/modular_higgs_audio_v2_tokenizer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e2097d0534662d4b47c188e68bc48f17c1441a79 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/configuration_hubert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/configuration_hubert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d32bf009c2e13a6022f98d8d0dc5b0dc92e86da5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/configuration_hubert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/modeling_hubert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/modeling_hubert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d518bb29916b7f48a953408cbc9527db13a263d0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/modeling_hubert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/modular_hubert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/modular_hubert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..54cae9e95b8f31255f2cb7bd301d8bed3e7e6e66 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hubert/__pycache__/modular_hubert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..42c5449e8bcdbfe56ca5d555b2761c3e17be7323 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/configuration_hunyuan_v1_dense.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/configuration_hunyuan_v1_dense.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dccf66c680e2f53ab8381cae81e093c7194a903b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/configuration_hunyuan_v1_dense.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/modeling_hunyuan_v1_dense.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/modeling_hunyuan_v1_dense.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..319c7c402d6579ff0e812fe554f168dc44c5ad54 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/modeling_hunyuan_v1_dense.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/modular_hunyuan_v1_dense.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/modular_hunyuan_v1_dense.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bbaa7c5e6c8e69fcaf3cec09fb1b94afe804dc38 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_dense/__pycache__/modular_hunyuan_v1_dense.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..392402a9c7e5fe83935b829886320f52e6a3680c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/configuration_hunyuan_v1_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/configuration_hunyuan_v1_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf3b26cdfe67eec0665e10a8b64c0fe334dc6ed8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/configuration_hunyuan_v1_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/modeling_hunyuan_v1_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/modeling_hunyuan_v1_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26c1756aede1b28824119eafe856d52edd4f9470 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/modeling_hunyuan_v1_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/modular_hunyuan_v1_moe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/modular_hunyuan_v1_moe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4a117e04e89d363dc8257dd36b52f1c698906f12 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hunyuan_v1_moe/__pycache__/modular_hunyuan_v1_moe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..376e1fbb605bf5f7ec6ea30745f6074376506776 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/configuration_hy_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/configuration_hy_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3e7465e7142ca1d197b1369b700c1ba13ed12a8d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/configuration_hy_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/modeling_hy_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/modeling_hy_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0edfec1e45e643db7288118e62fd54033e07e55e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/modeling_hy_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/modular_hy_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/modular_hy_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f10a30b0f250f6cf1a2b854058d411ec203e5681 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/hy_v3/__pycache__/modular_hy_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..defaa23bfc8b44b2effb083c6fd6a650f64052de Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/configuration_ibert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/configuration_ibert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7335eecbad56f9e4a1dcba84814621e592229ad4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/configuration_ibert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/modeling_ibert.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/modeling_ibert.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af25b1ba3766f1f8a424fbf47c6c311da68f5f26 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/modeling_ibert.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/quant_modules.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/quant_modules.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..78f12d5c4e8a7427046485044713b3aad3e3824b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ibert/__pycache__/quant_modules.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ca34ea0f6aba38812b9052b39821de3891143292 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/configuration_idefics.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/configuration_idefics.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..440b1c159eede63bfdf379354e26b3fb69aeb9f9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/configuration_idefics.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/image_processing_idefics.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/image_processing_idefics.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a19418f1968afc619f39f8b4a7fb6c03f298d400 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/image_processing_idefics.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/image_processing_pil_idefics.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/image_processing_pil_idefics.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f40657acd9bbb6b3d86ab606047f4de23c33ba2e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/image_processing_pil_idefics.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/modeling_idefics.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/modeling_idefics.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..221777933e841d651ceebd13b2a3fddcd05614ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/modeling_idefics.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/perceiver.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/perceiver.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a51c9d9ac55596c8a35e6f79015712406531993 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/perceiver.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/processing_idefics.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/processing_idefics.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c580f61f98cf7c60f7d28969b360e024b0726dc8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/processing_idefics.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/vision.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/vision.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7c57973628544a674c5ae2e75fb55ddb7e0cbd33 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics/__pycache__/vision.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8ca30614cd564b7f3de89ee880d267a46ef8ff8a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/configuration_idefics2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/configuration_idefics2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bf9e011826fa6f97737df5023f740a960f4c2f39 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/configuration_idefics2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/image_processing_idefics2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/image_processing_idefics2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aa0d7d5d5391fbf407944be0477e936444f0d66c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/image_processing_idefics2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/image_processing_pil_idefics2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/image_processing_pil_idefics2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..76914299a318aa16690094fd00e4ea251e1fcd6f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/image_processing_pil_idefics2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/modeling_idefics2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/modeling_idefics2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b7ea8f66bedec4e59d790232e466deb010bad6aa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/modeling_idefics2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/processing_idefics2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/processing_idefics2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21c53cfbc4aec2ac42a4410da8bfb12cb5950934 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics2/__pycache__/processing_idefics2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7ce3364548bee146324d3668bc825cb46c7c51a4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/configuration_idefics3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/configuration_idefics3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c22a7467024ac5b03b079e74914ba2ff6e29db01 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/configuration_idefics3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/image_processing_idefics3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/image_processing_idefics3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9810b37f0ee690c5bfca705c1e12e2fb80015ad9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/image_processing_idefics3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/image_processing_pil_idefics3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/image_processing_pil_idefics3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d8157ca2001266d4156ceb160ad51ea82e7346c5 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/image_processing_pil_idefics3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/modeling_idefics3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/modeling_idefics3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f385ecba253d903c843362931156750f0fead2b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/modeling_idefics3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/processing_idefics3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/processing_idefics3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0007e802986a0fe9b63ac51b6ce5c263734182f9 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/idefics3/__pycache__/processing_idefics3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..892265ad04850a133ebc64939639c4dabce4cae4 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/configuration_ijepa.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/configuration_ijepa.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4a8ac1a32aeedf2f6324e898a38baec5c90e6a3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/configuration_ijepa.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/modeling_ijepa.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/modeling_ijepa.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a668c5ec00329f3480593d6afc6206a4c8a4a2de Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/modeling_ijepa.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/modular_ijepa.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/modular_ijepa.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..061d4597a6e816b7ccb22fe9415db032df5a5e23 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/ijepa/__pycache__/modular_ijepa.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4f7040ea60b3564099d7077511da38f350e7612a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/configuration_imagegpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/configuration_imagegpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b9d9a0f071f84c5823639d66bcf8b4ad59264d65 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/configuration_imagegpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/image_processing_imagegpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/image_processing_imagegpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..28a15787d0cd9fa57bfa0f1f0fad3974ca3e1260 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/image_processing_imagegpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/image_processing_pil_imagegpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/image_processing_pil_imagegpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8dd9f1acd86e5169ab9a498dbbd537d2bd69d1ac Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/image_processing_pil_imagegpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/modeling_imagegpt.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/modeling_imagegpt.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..50c5c8c32dc11190154c0f807ead3f6217fb1418 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/imagegpt/__pycache__/modeling_imagegpt.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0ab2f85e39b61adc879b896f1e90423d19ababec Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/configuration_informer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/configuration_informer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d99e7c518b1e213cfa6998e8895dd648c7194e31 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/configuration_informer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/modeling_informer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/modeling_informer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8619ca3ff4b4349c2cb243e538eed2cb5a84d114 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/modeling_informer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/modular_informer.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/modular_informer.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25a1a3615694314d3a6dbe489d159f43ea012b86 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/informer/__pycache__/modular_informer.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..285e0a41ff08efbb995ee83ec27c968724665376 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/configuration_instructblip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/configuration_instructblip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9b984192362373a0290146d66a7bd1d46f6f258e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/configuration_instructblip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/modeling_instructblip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/modeling_instructblip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..26c8f60775c3bc84a5652af70d8107cf17a77d7e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/modeling_instructblip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/processing_instructblip.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/processing_instructblip.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80f7cba49da41446ae9e7ee84cb9cfcf9db094f6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblip/__pycache__/processing_instructblip.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..37022bccbb3fb60591dded1370e5b3e0795e121f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/configuration_instructblipvideo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/configuration_instructblipvideo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..564c396ce7889dda7851b584d49839c6d6087c70 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/configuration_instructblipvideo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/modeling_instructblipvideo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/modeling_instructblipvideo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6207e703dc6725d48c25623dcdf40c950e68697f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/modeling_instructblipvideo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/modular_instructblipvideo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/modular_instructblipvideo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15580cff959e0328c455c89af69065a0ffde3532 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/modular_instructblipvideo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/processing_instructblipvideo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/processing_instructblipvideo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c43566f913f2ec2bde0d548ed6de293ca9053bae Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/processing_instructblipvideo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/video_processing_instructblipvideo.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/video_processing_instructblipvideo.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..14097816e5a7b4981c272223bef5a313c747d330 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/instructblipvideo/__pycache__/video_processing_instructblipvideo.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..36d7a93aded050234d04a99eddedfc2d5577e501 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/configuration_internvl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/configuration_internvl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e4a819dd5bbcc2bcb3b32b4639c432ac24eba479 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/configuration_internvl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/modeling_internvl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/modeling_internvl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f14a08bccec2b960b3d94e5c12e5a82cffc7ed7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/modeling_internvl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/modular_internvl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/modular_internvl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..811fd1bc2ca9326a0ecc9be89c8807c83eabeeb8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/modular_internvl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/processing_internvl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/processing_internvl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c468e512a322e83becf9a43d54ad7e149bb8cdfc Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/processing_internvl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/video_processing_internvl.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/video_processing_internvl.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fc76fe530e6d2c0aed8840268e34d5460280cc6c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/internvl/__pycache__/video_processing_internvl.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7434839f3a4be2e70d6b57bbf1551150f409a241 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/configuration_jais2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/configuration_jais2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1dc0ec6f46a4c908b429319dd98b5f7d8055680c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/configuration_jais2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/modeling_jais2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/modeling_jais2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f1a24cf6739e66aa5652965c64264293badaa980 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/modeling_jais2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/modular_jais2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/modular_jais2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..540bc4daf1c7711698ed1966a2b0ad5350f21597 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jais2/__pycache__/modular_jais2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0b4ebe3566e8e350ca0501fac4775b26ff72e69a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/configuration_jamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/configuration_jamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e74270483dd59d563642082f89ab6487ce6baa16 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/configuration_jamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/modeling_jamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/modeling_jamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a128725424001e64f0e27b45768aa83f0d309f78 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/modeling_jamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/modular_jamba.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/modular_jamba.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e509d30bd3e496495ef4f13f8b4aa8752d867da8 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jamba/__pycache__/modular_jamba.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8d6bb363d93cea2b7f867aca145413bc4d47d88c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/configuration_janus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/configuration_janus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5dda7bdeb464f821115c135ceff96fc535ea99a1 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/configuration_janus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/image_processing_janus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/image_processing_janus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c94804e28d4563091b68f74bc3ed21446ffb4b7c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/image_processing_janus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/image_processing_pil_janus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/image_processing_pil_janus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..02945c2ecaa9e43f6678e65d110d9e036d242945 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/image_processing_pil_janus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/modeling_janus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/modeling_janus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ccb9803df3ab7b87ad155af6fb634619b5851792 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/modeling_janus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/modular_janus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/modular_janus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..add71095359c3b11e30e82b91995aa1e2b6be4a3 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/modular_janus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/processing_janus.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/processing_janus.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..672e45ea0c7474900b0f84ec91e46c1f1bf5bb4b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/janus/__pycache__/processing_janus.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dc67f2344a6fc284c87965b09647f28c92c12139 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/configuration_jetmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/configuration_jetmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2083c222b211a9cb23fcad2d54ca6fcbfc736e0f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/configuration_jetmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/modeling_jetmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/modeling_jetmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7fff3d6b526118d8f0490a40fd773f836f943693 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/modeling_jetmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/modular_jetmoe.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/modular_jetmoe.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..466756b59ab2374f0cdf4f507a7474b3c940958c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jetmoe/__pycache__/modular_jetmoe.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4475043cc694daa7ecc4180bd68b1b3e0bc082b2 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/configuration_jina_embeddings_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/configuration_jina_embeddings_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa737de04c6dd522c6aa798a9105efa5e8b98436 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/configuration_jina_embeddings_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/modeling_jina_embeddings_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/modeling_jina_embeddings_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db80f9bb4c60e04cb81f9402252765877951a62b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/modeling_jina_embeddings_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/modular_jina_embeddings_v3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/modular_jina_embeddings_v3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5cb21380684fc276021481c2081cba6acc0ff865 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/jina_embeddings_v3/__pycache__/modular_jina_embeddings_v3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..559bb1be82bb96a292cec316e5d39ab322be7689 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/configuration_kosmos2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/configuration_kosmos2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4e06c52b40c0aceff8ca899a982aa76b4ce9e498 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/configuration_kosmos2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/modeling_kosmos2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/modeling_kosmos2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..21d239505cad48c10b101848d99d1f97f7bc4e06 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/modeling_kosmos2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/processing_kosmos2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/processing_kosmos2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f96aa1c2316ff9232f372d945b5ce2f63adb9b05 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2/__pycache__/processing_kosmos2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be80f82dca10bfa1deb1d23eb0d9f31c0212d52f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/configuration_kosmos2_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/configuration_kosmos2_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d6f7ad5abf72a1c1751de3f2828f29340c6cdb82 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/configuration_kosmos2_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/image_processing_kosmos2_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/image_processing_kosmos2_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cd7fac9fc68c9fcf1ce9b9a3c8cfda159f8be48b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/image_processing_kosmos2_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/image_processing_pil_kosmos2_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/image_processing_pil_kosmos2_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aeac0f885fdecdba65bf351a4ba55c632d1b46c7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/image_processing_pil_kosmos2_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/modeling_kosmos2_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/modeling_kosmos2_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f5ea28fdfeaa20b4559b87045281a4339c3412ea Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/modeling_kosmos2_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/processing_kosmos2_5.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/processing_kosmos2_5.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8dd030ea5fdb91fba552db499e7f93ad0aefca02 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kosmos2_5/__pycache__/processing_kosmos2_5.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f549725009a8a1f6c332cbd39a3cee8a0cedd31d Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/configuration_kyutai_speech_to_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/configuration_kyutai_speech_to_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2889c6dac0969136dca44fd03ddc32e62f661119 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/configuration_kyutai_speech_to_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/feature_extraction_kyutai_speech_to_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/feature_extraction_kyutai_speech_to_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..466924ef48b94a87233a0da08d1cfac82aace043 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/feature_extraction_kyutai_speech_to_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/modeling_kyutai_speech_to_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/modeling_kyutai_speech_to_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..330291e161c8ab7e20b2e066800b5aec7f447824 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/modeling_kyutai_speech_to_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/modular_kyutai_speech_to_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/modular_kyutai_speech_to_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b214d9f46434a716e76265d61320d4249a6ba12 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/modular_kyutai_speech_to_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/processing_kyutai_speech_to_text.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/processing_kyutai_speech_to_text.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9e7c3507f6388d97981878248280aa1969e5a38a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/kyutai_speech_to_text/__pycache__/processing_kyutai_speech_to_text.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..020b3a8e2ce3ec7376a3e69c4aee985b41c9d722 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/configuration_laguna.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/configuration_laguna.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..72a3de0efd0fee21d7de2a35fca5383464433e6f Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/configuration_laguna.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/modeling_laguna.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/modeling_laguna.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc89a21f60768f64eaadb4716c8246efa210821c Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/modeling_laguna.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/modular_laguna.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/modular_laguna.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..452f77ce454b9754f25473d6d7aeee1923d8619e Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/laguna/__pycache__/modular_laguna.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..31703545b673495c274a6af4d6d388e6e85f424b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/configuration_lasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/configuration_lasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..629f01ce1a033f15681c6e1fd952721cc227eccb Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/configuration_lasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/feature_extraction_lasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/feature_extraction_lasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a7853a111fe78ea8c8e6e8745f3e19e0e0845a5b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/feature_extraction_lasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/modeling_lasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/modeling_lasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..18447095f4f372427a855b63f9bb2ab32b5bfbd0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/modeling_lasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/modular_lasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/modular_lasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a63b859cbd329de7fb00a207185c805316188689 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/modular_lasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/processing_lasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/processing_lasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d262104350fe8e47559c9b3179c9a2cdc47516aa Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/processing_lasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/tokenization_lasr.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/tokenization_lasr.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80dd91fe8df61b02e95dcc8cab982bcd44c6ef4b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/lasr/__pycache__/tokenization_lasr.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..154be5ca33477941382b87916d2e58bbdd54b992 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/configuration_layoutlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/configuration_layoutlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..768abba19206c94933880fb03da147fa1aa1d127 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/configuration_layoutlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/modeling_layoutlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/modeling_layoutlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6850809438d0698a9309a4cb6dcd47dafe6bbc68 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlm/__pycache__/modeling_layoutlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..224e21749615de010c809cc377541372b94e24e0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/configuration_layoutlmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/configuration_layoutlmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0bdd56b65ab975fa177a1146abc9eb32f2b6fde0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/configuration_layoutlmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/image_processing_layoutlmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/image_processing_layoutlmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..88da64af8640d4414ac23e324544a12a67f350c0 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/image_processing_layoutlmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/image_processing_pil_layoutlmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/image_processing_pil_layoutlmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ea4012970ab137a0146232bbac806054f88df809 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/image_processing_pil_layoutlmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/modeling_layoutlmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/modeling_layoutlmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da846c0fa7659d644298835625319a85af4ef415 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/modeling_layoutlmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/processing_layoutlmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/processing_layoutlmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d2d0b83ad009987135a7131c285733c244a206c7 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/processing_layoutlmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/tokenization_layoutlmv2.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/tokenization_layoutlmv2.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c8923d01f07b97c14345e3a6d739a24ca02cb53 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv2/__pycache__/tokenization_layoutlmv2.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ef88eb504da01da98f5409f135a0e9dc1d133e99 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/configuration_layoutlmv3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/configuration_layoutlmv3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c68136e0cc098adf44b6f0a7efe2c0688e40d756 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/configuration_layoutlmv3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/image_processing_layoutlmv3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/image_processing_layoutlmv3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ae35d713ac5c1431ee8fbc54fc4f2b00eab54567 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/image_processing_layoutlmv3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/image_processing_pil_layoutlmv3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/image_processing_pil_layoutlmv3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fcc7d0d78755cdc322a12eafb57aaec808b67d65 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/image_processing_pil_layoutlmv3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/modeling_layoutlmv3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/modeling_layoutlmv3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5ace09927662eb66251fb4dc41b08fbf1cbc815a Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/modeling_layoutlmv3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/processing_layoutlmv3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/processing_layoutlmv3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..83e3c30317ef43aa2c8761ac52f512e113153e84 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/processing_layoutlmv3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/tokenization_layoutlmv3.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/tokenization_layoutlmv3.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..40dcdc5f1947709316f3983158f772c517a0dc1b Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutlmv3/__pycache__/tokenization_layoutlmv3.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/__init__.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e79341403061aa77bb20836b4fe658756056e231 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/__init__.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/processing_layoutxlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/processing_layoutxlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..dca4429c3bc5e9fc03af7ca5e00b4e293c4404e6 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/processing_layoutxlm.cpython-311.pyc differ diff --git a/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/tokenization_layoutxlm.cpython-311.pyc b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/tokenization_layoutxlm.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..25b5e8b55f800c14e31c1ac1e5c661f878716993 Binary files /dev/null and b/micromamba_root/envs/pytorch_env/Lib/site-packages/transformers/models/layoutxlm/__pycache__/tokenization_layoutxlm.cpython-311.pyc differ