# Модели

Базовый класс [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel) реализует общие методы для загрузки/сохранения модели из локального файла или каталога, а также из конфигурации предобученной модели, предоставляемой библиотекой (скачанной с HuggingFace Hub).

[PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel) также реализует несколько методов, общих для всех моделей:

- изменить размер встраиваний входных токенов при добавлении новых токенов в словарь

Остальные методы, общие для каждой модели, определены в [ModuleUtilsMixin](/docs/transformers/main/ru/main_classes/model#transformers.modeling_utils.ModuleUtilsMixin) и [GenerationMixin](/docs/transformers/main/ru/main_classes/text_generation#transformers.GenerationMixin).

## PreTrainedModel[[transformers.PreTrainedModel]]

#### transformers.PreTrainedModel[[transformers.PreTrainedModel]]

```python
transformers.PreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1068)

Базовый класс для всех моделей.

Класс [PreTrainedModel](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel) отвечает за хранение конфигурации моделей, а также за методы загрузки, скачивания и сохранения моделей, а также за несколько методов, общих для всех моделей:

- изменить размер входных эмбеддингов

Атрибуты класса (переопределяются производными классами):

- **config_class** ([PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig)) — подкласс [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig), используемый в качестве класса конфигурации для данной архитектуры модели.
- **base_model_prefix** (`str`) — строка, указывающая на атрибут, связанный с базовой моделью в производных классах той же архитектуры, которые добавляют модули поверх базовой модели.
- **main_input_name** (`str`) — имя основного входа модели (часто `input_ids` для NLP-моделей, `pixel_values` для моделей компьютерного зрения и `input_values` для моделей обработки речи).
- **can_record_outputs** (dict):

#### push_to_hub[[transformers.PreTrainedModel.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Параметры:**

repo_id (`str`) : Имя репозитория, в который вы хотите загрузить модель. При загрузке в определённую организацию это имя должно включать название вашей организации.

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию используется `"Upload model"`.

commit_description (`str`, *необязательный*) : Описание коммита, который будет создан

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`bool` или `str`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если `True` (по умолчанию), будет использован токен, сгенерированный при выполнении `hf auth login` (хранится в `~/.huggingface`).

revision (`str`, *необязательный*) : Ветка, в которую будут отправлены загруженные файлы.

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"50GB"`) : Применимо только к моделям. Максимальный размер контрольной точки до её разбивки на части. Каждая часть контрольной точки будет иметь размер, меньший этого значения. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, `"5MB"`).

tags (`list[str]`, *необязательный*) : Список тегов для загрузки на Hub.

Загрузите файл модели в 🤗 Model Hub.

Примеры:

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

# Push the model to your namespace with the name "my-finetuned-bert".
model.push_to_hub("my-finetuned-bert")

# Push the model to an organization with the name "my-finetuned-bert".
model.push_to_hub("huggingface/my-finetuned-bert")
```

#### activation_checkpointing_disable[[transformers.PreTrainedModel.activation_checkpointing_disable]]

```python
activation_checkpointing_disable()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3249)

Отключает контрольную точку активации для текущей модели.

#### activation_checkpointing_enable[[transformers.PreTrainedModel.activation_checkpointing_enable]]

```python
activation_checkpointing_enable(activation_checkpointing_kwargs = None, every_n_layers: int = 1, offload: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3110)

**Параметры:**

every_n_layers (`int`, *optional*, по умолчанию 1) : Создавать контрольные точки только для каждого `every_n_layers`-го слоя декодера, оставляя остальные слои с сохранёнными активациями. Значение `1` означает создание контрольных точек для каждого слоя, что соответствует стандартному поведению «всё или ничего». Большие значения позволяют сэкономить память в ущерб скорости, что оправдано, если память, высвобождаемая при полном контрольном точковании, остаётся неиспользованной.

offload (`bool`, *необязательный*, по умолчанию `False`) : Хранить активации, сохранённые для пересчёта, в закреплённой памяти хоста, а не на ускорителе. Это освобождает `layers x sequence x hidden` байт памяти устройства, что является доминирующим фактором при больших длинах последовательностей, но требует копирования с устройства на хост в прямом проходе и с хоста на устройство в обратном. Оба копирования выполняются в вычислительном потоке, из-за чего шаг становится медленнее.

activation_checkpointing_kwargs (dict, *необязательный*) : Дополнительные именованные аргументы, передаваемые в функцию `torch.utils.checkpoint.checkpoint`.

Включает контрольную точку активации для текущей модели.

Мы передаём метод `__call__` модулей, а не `forward`, потому что `__call__` подключает все хуки модуля. https://discuss.pytorch.org/t/any-different-between-model-input-and-model-forward-input/3690/2

#### add_model_tags[[transformers.PreTrainedModel.add_model_tags]]

```python
add_model_tags(tags: list[str] | str)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1360)

**Параметры:**

tags (`Union[list[str], str]`) : Теги, которые необходимо внедрить в модель

Добавляет пользовательские теги в модель, которая будет загружена на Hugging Face Hub. Существующие теги модели не будут перезаписаны.

Примеры:

```python
from transformers import AutoModel

model = AutoModel.from_pretrained("google-bert/bert-base-cased")

model.add_model_tags(["custom", "custom-bert"])

# Push the model to your namespace with the name "my-custom-bert".
model.push_to_hub("my-custom-bert")
```

#### can_generate[[transformers.PreTrainedModel.can_generate]]

```python
can_generate()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1474)

**Возвращает:** `bool`

Может ли эта модель генерировать последовательности с помощью `.generate()`.

Возвращает, может ли эта модель генерировать последовательности с помощью `.generate()`, из `GenerationMixin` или из класса с похожим интерфейсом.

Внутренне, для классов, для которых эта функция возвращает True, запускаются изменения, специфичные для генерации: например, у экземпляра модели будет заполнен атрибут `generation_config`.

#### cuda[[transformers.PreTrainedModel.cuda]]

```python
cuda(*args, **kwargs)
```

Мок-значение для пути с точками (например, `torch.float32`): цепочки доступа к атрибутам и вызовы работают как пропускные декораторы, `repr` возвращает путь с точками, а использование в качестве базового класса подменяет его обычным базовым классом `type` (PEP 560 `__mro_entries__`), благодаря чему реальные дочерние классы сохраняют обычный метакласс, а `inspect.signature` читает их реальный `__init__`, а не мок.

#### dequantize[[transformers.PreTrainedModel.dequantize]]

```python
dequantize(dtype = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1342)

При необходимости декуантизуйте модель, если она была квантована методом, поддерживающим декуантизацию.

#### disable_input_require_grads[[transformers.PreTrainedModel.disable_input_require_grads]]

```python
disable_input_require_grads()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2181)

Удаляет `_require_grads_hook`.

#### enable_input_require_grads[[transformers.PreTrainedModel.enable_input_require_grads]]

```python
enable_input_require_grads()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2137)

Включает градиенты для входных эмбеддингов. Это полезно при дообучении весов адаптеров с фиксированными весами модели.

#### from_pretrained[[transformers.PreTrainedModel.from_pretrained]]

```python
from_pretrained(pretrained_model_name_or_path: str | os.PathLike | None, *model_args, config: transformers.configuration_utils.PreTrainedConfig | str | os.PathLike | None = None, cache_dir: str | os.PathLike | None = None, ignore_mismatched_sizes: bool = False, force_download: bool = False, local_files_only: bool = False, token: str | bool | None = None, revision: str = 'main', use_safetensors: bool | None = None, weights_only: bool = True, fusion_config: dict[str, bool | dict[str, typing.Any]] | None = None, disable_mmap: bool | None = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3892)

**Параметры:**

pretrained_model_name_or_path (`str` или `os.PathLike`, *необязательный*) : Может быть одним из следующих:  - Строка, *model id* предобученной модели, размещенной в репозитории моделей на huggingface.co. - Путь к *каталогу*, содержащему веса модели, сохраненные с помощью [save_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.save_pretrained), например, `./my_model_directory/`. Каталоги, сохраненные с помощью `save_pretrained(..., distributed_checkpoint=True)`, обнаруживаются и загружаются с использованием распределенного чекпоинтинга (DCP), сохраняя текущую сетку и размещения модели. Для этого требуется `torch>=2.7`, и загрузка выполняется строго: каждый ключ модели должен присутствовать в чекпоинте. - `None`, если вы предоставляете и конфигурацию, и словарь состояний (соответственно, с аргументами по имени `config` и `state_dict`).

model_args (последовательность позиционных аргументов, *необязательный*) : Все оставшиеся позиционные аргументы будут переданы в метод `__init__` базовой модели.

config (`Union[PreTrainedConfig, str, os.PathLike]`, *необязательный*) : Может быть одним из:  - экземпляр класса, производного от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig), - строка или путь, допустимые в качестве входных данных для [from_pretrained()](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained).  Конфигурация модели, используемая вместо автоматически загружаемой конфигурации. Конфигурация может быть загружена автоматически, если:  - модель является моделью, предоставляемой библиотекой (загружается с помощью строки *model id* предобученной модели). - модель была сохранена с помощью [save_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.save_pretrained) и перезагружается путем указания каталога сохранения. - модель загружается путем указания локального каталога в качестве `pretrained_model_name_or_path` и в каталоге находится файл конфигурации JSON с именем *config.json*.

state_dict (`dict[str, torch.Tensor]`, *необязательный*) : Словарь состояния, который используется вместо словаря состояния, загруженного из сохранённого файла весов. Этот параметр можно использовать, если вы хотите создать модель на основе предобученной конфигурации, но загрузить собственные веса. В таком случае, однако, стоит проверить, не является ли использование [save_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.save_pretrained) и [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) более простым вариантом.

cache_dir (`Union[str, os.PathLike]`, *необязательный*) : Путь к каталогу, в котором должен кэшироваться загруженный конфигурационный файл предобученной модели, если стандартный кэш не используется.

ignore_mismatched_sizes (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли вызывать ошибку, если размеры некоторых весов из контрольной точки не совпадают с размерами весов модели (например, при инициализации модели с 10 метками из контрольной точки с 3 метками).

force_download (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли принудительно (пере)загружать веса модели и файлы конфигурации, игнорируя кэшированные версии, если они существуют.

proxies (`dict[str, str]`, *необязательный*) : Словарь прокси-серверов, используемых по протоколу или конечной точке, например, `{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}`. Прокси-серверы применяются при каждой отправке запроса.

output_loading_info(`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли также возвращать словарь, содержащий отсутствующие ключи, неожиданные ключи и сообщения об ошибках.

local_files_only(`bool`, *необязательный*, по умолчанию `False`) : Использовать только локальные файлы (т. е. не пытаться скачать модель).

token (`str` или `bool`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если указано значение `True` или параметр не задан, будет использован токен, сгенерированный при выполнении `hf auth login` (хранится в `~/.huggingface`).

revision (`str`, *необязательный*, по умолчанию `"main"`) : Конкретная версия модели, которую следует использовать. Это может быть имя ветки, имя тега или идентификатор коммита, поскольку для хранения моделей и других артефактов на huggingface.co используется система на базе git, поэтому `revision` может быть любым идентификатором, разрешённым git.    Чтобы протестировать pull request, который вы создали на Hub, можно передать `revision="refs/pr/<pr_number>"`.

attn_implementation (`str`, *необязательный*) : Реализация механизма внимания, используемая в модели (если применимо). Допустимые значения: - `"eager"` (ручная реализация внимания) - `"sdpa"` (использование [`F.scaled_dot_product_attention`](https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention.html)) - `"flash_attention_2"` (использование [Dao-AILab/flash-attention](https://github.com/Dao-AILab/flash-attention)) - `"flash_attention_3"` (использование [Dao-AILab/flash-attention/hopper](https://github.com/Dao-AILab/flash-attention/tree/main/hopper)) - `"flash_attention_4"` (использование [Dao-AILab/flash-attention/flash_attn/cute](https://github.com/Dao-AILab/flash-attention/tree/main/flash_attn/cute)). По умолчанию, если доступно, используется SDPA. В противном случае по умолчанию применяется ручная реализация `"eager"`.  Принимаются ссылки на ядра HF в формате: /[@][:]  -  и  — любые последовательности, не содержащие "/" и ":". - "@" является необязательным (ветка, тег или commit-ish), например "@main", "@v1.2.0", "@abc123". - ":" является необязательным и указывает на функцию внутри репозитория ядра. - Оба варианта могут использоваться вместе только в следующем порядке: сначала @revision, затем :kernel_name. - Мы намеренно допускаем префикс "|" в начале (например, "flash|..."), так как код удаляет его перед загрузкой; символ '|' не исключен в классах символов здесь.  Примеры, соответствующие формату: "org/model" "org/model@main" "org/model:custom_kernel" "org/model@v1.2.3:custom_kernel"

experts_implementation (`str`, *optional*) : Реализация экспертов, используемая в модели (если применимо). Допустимые значения:  - `"eager"` (последовательная реализация матричных умножений для экспертов). - `"batched_mm"` (использует [`torch.bmm`](https://pytorch.org/docs/stable/generated/torch.bmm.html)). - `"grouped_mm"` (использует [`torch.nn.functional.grouped_mm`](https://docs.pytorch.org/docs/main/generated/torch.nn.functional.grouped_mm.html)).  По умолчанию, если модель это поддерживает, используется `"grouped_mm"`. В противном случае по умолчанию применяется ручная реализация `"eager"`.

**Параметры для инференса больших моделей:**

dtype (`str` или `torch.dtype`, *необязательный*, по умолчанию `"auto"`) : Переопределяет значение по умолчанию `torch_dtype` и загружает модель в указанном `dtype`. Доступные варианты:  1. `torch.float16` или `torch.bfloat16` или `torch.float`: загрузка в указанном `dtype`, при этом `config.dtype` модели (если он существует) игнорируется. Если значение не указано, модель будет загружена в `torch.float` (fp32).  2. `"auto"` — будет предпринята попытка использовать запись `dtype` или `torch_dtype` из файла `config.json` модели. Если такая запись не найдена, будет проверен `dtype` первого веса в контрольной точке, имеющего тип с плавающей точкой, и он будет использован в качестве `dtype`. В этом случае модель будет загружена в том `dtype`, в котором она была сохранена в конце обучения. Это значение нельзя использовать как индикатор того, в каком режиме обучалась модель, поскольку она могла быть обучена в одном из dtypes с половинной точностью, но сохранена в fp32.  3. Строка, являющаяся допустимым `torch.dtype`. Например, "float32" загружает модель в `torch.float32`, "float16" — в `torch.float16` и т. д.    Для некоторых моделей неизвестен `dtype`, в котором они были обучены. Вы можете попробовать проверить статью о модели или связаться с её авторами и попросить их добавить эту информацию в карточку модели и вставить запись `dtype` или `torch_dtype` в `config.json` на хаб.

device_map (`str` или `dict[str, Union[int, str, torch.device]]` или `int` или `torch.device`, *необязательный*) : Карта, указывающая, на какое устройство следует поместить каждый подмодуль. Не обязательно указывать имя каждого параметра/буфера: как только имя модуля указано, все его подмодули будут перемещены на то же устройство. Если передано только устройство (*напр.*, `"cpu"`, `"cuda:1"`, `"mps"` или порядковый номер GPU, например `1`), на котором будет размещена модель, карта устройств отобразит всю модель на это устройство. Передача `device_map = 0` означает, что вся модель будет размещена на GPU 0. Чтобы Accelerate автоматически вычислила наиболее оптимизированную `device_map`, установите `device_map="auto"`. Подробнее о каждом варианте см. [проектирование карты устройств](https://hf.co/docs/accelerate/main/en/usage_guides/big_modeling#designing-a-device-map).

max_memory (`Dict`, *необязательный*) : Словарь, сопоставляющий идентификатор устройства с максимальным объемом памяти, если используется `device_map`. Если не задан, по умолчанию устанавливается максимальный доступный объем памяти для каждого GPU и доступная оперативная память CPU.

distributed_config ([DistributedConfig](/docs/transformers/main/ru/expert_parallelism#transformers.DistributedConfig), *необязательный*) : Настройки для нативной распределённой загрузки с использованием tensor parallelism или FSDP2. Передайте `DistributedConfig(tp_size=N)`, чтобы использовать предопределённый план tensor parallelism модели, `DistributedConfig(tp_plan=...)`, чтобы указать план tensor parallelism, или `DistributedConfig(fsdp_size=N)` для FSDP2. Требует `torchrun` и инициализированную группу процессов, если `tp_size > 1` или `fsdp_size > 1`. Взаимоисключаем с `device_map`.

device_mesh (`torch.distributed.DeviceMesh`, *необязательный*) : Сетка устройств torch. Если не указано, по умолчанию используется world size. В настоящее время используется только для tensor parallel. Если указано, то в случае размерности > 1 она должна содержать измерение с именем `"tp"`, которое будет использоваться для tensor parallelism.

offload_folder (`str` или `os.PathLike`, *необязательный*) : если в `device_map` есть значение `"disk"`, то это папка, куда будут выгружаться веса.

offload_buffers (`bool`, *необязательный*) : Нужно ли выгружать буферы с параметрами модели.

quantization_config (`Union[QuantizationConfigMixin,Dict]`, *необязательный*) : Словарь параметров конфигурации или объект QuantizationConfigMixin для квантования (например, bitsandbytes, gptq).

subfolder (`str`, *необязательный*, по умолчанию `""`) : Если соответствующие файлы находятся в подпапке репозитория модели на huggingface.co, здесь можно указать имя папки.

variant (`str`, *необязательный*) : если указано, загружает веса из файла `variant`, *например* pytorch_model..bin.

use_safetensors (`bool`, *необязательный*, по умолчанию `None`) : Использовать ли контрольные точки `safetensors`. По умолчанию `None`. Если значение не указано и `safetensors` не установлен, оно будет установлено в `False`.

weights_only (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли ограничивать unpickler загрузкой только тензоров, примитивных типов, словарей и любых типов, добавленных через torch.serialization.add_safe_globals(). Если установлено в False, можно загрузить веса подклассов тензоров-обёрток.

disable_mmap (`bool`, *необязательный*) : Указывает, следует ли отключать отображение памяти при загрузке контрольных точек safetensors. Если значение равно `None` (по умолчанию), параметр автоматически устанавливается в `True`, если контрольная точка находится на файловой системе FUSE `hf-mount` (используется в HF Spaces/Endpoints), где комбинация mmap и параллельных page-faults может привести к взаимной блокировке. Если значение равно `True`, файлы полностью загружаются в память и обрабатываются с помощью `safetensors.torch.load`. Если значение равно `False`, всегда используется загрузчик с отображением памяти по умолчанию.

fusion_config (`dict[str, bool | dict[str, Any]]`, *необязательный*) : Необязательная конфигурация слияния, применяемая до создания экземпляра модели. Каждый ключ активирует семейство слияний, а его значение может быть `True` для включения данного слияния с параметрами по умолчанию или словарем с параметрами, специфичными для конкретного семейства. Например, `{"patch_embeddings": True}` включает слияние встраиваний патчей. Использовать это следует только как оптимизацию для инференса, поскольку это может незначительно изменить выходные данные. Если параметр не указан, `from_pretrained()` обращается к `config.fusion_config`, если он доступен. Дополнительные сведения см. в руководстве по отображению слияний в `docs/source/en/fusion_mapping.md`.

key_mapping (`dict[str, str], *optional*) : Возможное сопоставление имён весов, если используется модель с Hub, совместимая с архитектурой Transformers, но не преобразованная в соответствии с ней.

kwargs (остаточный словарь именованных аргументов, *необязательный*) : может использоваться для обновления объекта конфигурации (после его загрузки) и инициализации модели (например, `output_attentions=True`). Поведение зависит от того, предоставлена ли `config` или она загружается автоматически:  - Если конфигурация предоставлена через `config`, `**kwargs` передаются непосредственно в метод `__init__` базовой модели (предполагается, что все необходимые обновления конфигурации уже выполнены) - Если конфигурация не предоставлена, `kwargs` сначала передаются в функцию инициализации класса конфигурации ([from_pretrained()](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig.from_pretrained)). Каждый ключ `kwargs`, соответствующий атрибуту конфигурации, используется для переопределения этого атрибута переданным значением из `kwargs`. Оставшиеся ключи, не соответствующие ни одному атрибуту конфигурации, передаются в функцию `__init__` базовой модели.

Создайте предобученную модель PyTorch на основе конфигурации предобученной модели.

По умолчанию модель переводится в режим оценки с помощью `model.eval()` (модули Dropout отключаются). Для обучения модели сначала необходимо вернуть её в режим обучения с помощью `model.train()`.

The warning *Weights from XXX not initialized from pretrained model* means that the weights of XXX do not come pretrained with the rest of the model. It is up to you to train those weights with a downstream fine-tuning task.

Предупреждение *Weights from XXX not used in YYY* означает, что слой XXX не используется в YYY, поэтому соответствующие веса отбрасываются.

Активируйте специальный режим ["offline-mode"](https://huggingface.co/transformers/installation.html#offline-mode), чтобы использовать этот метод в среде с файрволом.

Примеры:

```python
>>> from transformers import BertConfig, BertModel

>>> # Download model and configuration from huggingface.co and cache.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased")
>>> # Model was saved using *save_pretrained('./test/saved_model/')* (for example purposes, not runnable).
>>> model = BertModel.from_pretrained("./test/saved_model/")
>>> # Update configuration during loading.
>>> model = BertModel.from_pretrained("google-bert/bert-base-uncased", output_attentions=True)
>>> assert model.config.output_attentions == True
```

#### get_compiled_call[[transformers.PreTrainedModel.get_compiled_call]]

```python
get_compiled_call(compile_config: transformers.generation.configuration_utils.CompileConfig | None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4799)

Возвращает версию `torch.compile` для `self.__call__`. Это полезно для динамического выбора между нескомпилированной и скомпилированной версией `forward` во время инференса, особенно для переключения между prefill (где мы не хотим использовать скомпилированную версию, чтобы избежать пересчёта графа с новыми формами) и итеративным декодированием (где нам нужны ускорения скомпилированной версии со статическими формами).

#### get_decoder[[transformers.PreTrainedModel.get_decoder]]

```python
get_decoder()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2254)

Попытка поиска модуля *decoder* в режиме best-effort.

Порядок попыток (покрывает ~85 % текущих случаев использования):

1. `self.decoder/self.language_model/self.text_model`
2. `self.base_model`                  (многие обёртки хранят декодер здесь)
3. `self.base_model.get_decoder()`    (вложенные обёртки)
4. fallback: raise для нескольких экзотических моделей, которым требуется индивидуальное правило

#### get_encoder[[transformers.PreTrainedModel.get_encoder]]

```python
get_encoder(modality: str | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2196)

Поиск модуля *encoder* в режиме best-effort. Если указан аргумент `modality`, функция ищет специфичный для модальности энкодер в мультимодальных моделях (например, "image_encoder"). По умолчанию функция возвращает текстовый энкодер модели, если он есть, а в противном случае возвращает `self`.

Возможные значения `modality`: "image", "video" и "audio".

#### get_expanded_tied_weights_keys[[transformers.PreTrainedModel.get_expanded_tied_weights_keys]]

```python
get_expanded_tied_weights_keys(all_submodels: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2416)

Возвращает расширенные ключи связанных весов (если они содержат модули или регулярные выражения) только для текущей модели или рекурсивно для всех подмоделей, если `all_submodels=True` (то есть значения конфигурации будут повторно проверены для всех подмоделей).

Для подавляющего большинства моделей достаточно связать эмбеддинги, поэтому у модели есть внутреннее свойство `_tied_weights_keys = {"lm_head.weight": "model.embed_tokens.weight"}`. В этом случае отображение уже «развёрнуто», то есть содержит полные параметры, и данная функция просто вернёт копию этого свойства. Для более сложных схем, например для `DFineForObjectDetection`, у нас есть следующее атрибут

```
_tied_weights_keys = {
    r"bbox_embed.(?![0])\d+": "bbox_embed.0",
    r"class_embed.(?![0])\d+": "class_embed.0",
    "model.decoder.class_embed": "class_embed",
    "model.decoder.bbox_embed": "bbox_embed",
}
```

В этом случае функция находит все параметры и буферы модели и сопоставляет все параметры,

возвращает следующее:
```
{
    'bbox_embed.1.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.1.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'bbox_embed.1.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'bbox_embed.1.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    'bbox_embed.1.layers.2.bias': 'bbox_embed.0.layers.2.bias',
    'bbox_embed.1.layers.2.weight': 'bbox_embed.0.layers.2.weight',
    'bbox_embed.2.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'bbox_embed.2.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    ...
    'class_embed.1.bias': 'class_embed.0.bias',
    'class_embed.1.weight': 'class_embed.0.weight',
    'class_embed.2.bias': 'class_embed.0.bias',
    'class_embed.2.weight': 'class_embed.0.weight',
    ...
    'model.decoder.class_embed.0.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.0.weight': 'class_embed.0.weight',
    'model.decoder.class_embed.1.bias': 'class_embed.0.bias',
    'model.decoder.class_embed.1.weight': 'class_embed.0.weight',
    ...
    'model.decoder.bbox_embed.0.layers.0.bias': 'bbox_embed.0.layers.0.bias',
    'model.decoder.bbox_embed.0.layers.0.weight': 'bbox_embed.0.layers.0.weight',
    'model.decoder.bbox_embed.0.layers.1.bias': 'bbox_embed.0.layers.1.bias',
    'model.decoder.bbox_embed.0.layers.1.weight': 'bbox_embed.0.layers.1.weight',
    ...
}
```

т. е. все параметры, соответствующие регулярным выражениям и шаблонам модулей в `_tied_weights_keys`

#### get_experts_implementation[[transformers.PreTrainedModel.get_experts_implementation]]

```python
get_experts_implementation()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2064)

Возвращает реализацию экспертов для этой модели и её подмоделей в виде `dict` в формате, принимаемом `set_experts_implementation` (`""` для этой модели и одна запись для каждого sub_config). Это обратная операция для `set_experts_implementation`, например, для создания снимка текущей реализации и последующего её восстановления.

#### get_memory_footprint[[transformers.PreTrainedModel.get_memory_footprint]]

```python
get_memory_footprint(return_buffers = True)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3676)

**Параметры:**

return_buffers (`bool`, *optional*, по умолчанию `True`) : Указывает, следует ли учитывать размер тензоров буферов при вычислении объёма занимаемой памяти. Буферы — это тензоры, для которых не требуется вычисление градиентов и которые не зарегистрированы как параметры. Например, среднее значение и стандартное отклонение в слоях batch norm. Подробности: https://discuss.pytorch.org/t/what-pytorch-means-by-buffers/120266/2

Получить объём памяти, занимаемый моделью. Этот метод возвращает объём памяти текущей модели в байтах. Полезно для оценки потребления памяти текущей модели и разработки соответствующих тестов. Решение вдохновлено обсуждением в сообществе PyTorch: https://discuss.pytorch.org/t/gpu-memory-that-model-uses/56822/2

#### get_parameter_or_buffer[[transformers.PreTrainedModel.get_parameter_or_buffer]]

```python
get_parameter_or_buffer(target: str)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4966)

Возвращает параметр или буфер, указанный в `target`, если он существует, иначе выбрасывает ошибку. Эта функция объединяет `get_parameter()` и `get_buffer()` в одну удобную функцию. Если целевой объект является атрибутом `_extra_state`, будет возвращено дополнительное состояние, предоставленное модулем. Обратите внимание, что это работает только в том случае, если `target` является листом модели.

#### gradient_checkpointing_disable[[transformers.PreTrainedModel.gradient_checkpointing_disable]]

```python
gradient_checkpointing_disable()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3276)

Устаревший псевдоним для [activation_checkpointing_disable()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_disable), будет удалён в v6.

#### gradient_checkpointing_enable[[transformers.PreTrainedModel.gradient_checkpointing_enable]]

```python
gradient_checkpointing_enable(gradient_checkpointing_kwargs = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3191)

Устаревший псевдоним для [activation_checkpointing_enable()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.activation_checkpointing_enable), будет удалён в v6.

#### init_weights[[transformers.PreTrainedModel.init_weights]]

```python
init_weights()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3098)

Инициализируйте и свяжите веса при необходимости. Если вы используете собственную `PreTrainedModel`, вам нужно реализовать логику инициализации в `_init_weights`.

#### initialize_weights[[transformers.PreTrainedModel.initialize_weights]]

```python
initialize_weights()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2386)

Это эквивалентно вызову `self.apply(self._initialize_weights)`, но корректно обрабатывает составные модели. Эта функция динамически вызывает правильную функцию `init_weights` для модулей по мере продвижения по графу модулей в процессе рекурсии. Она может обрабатывать произвольное количество подмоделей. Без неё каждая составная модель была бы вынуждена явно выполнять вторую рекурсию по всем подмоделям во внешнем `_init_weights`, что крайне подвержено ошибкам и неэффективно.

#### is_custom_code[[transformers.PreTrainedModel.is_custom_code]]

```python
is_custom_code()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L5020)

Возвращает, является ли текущая модель кастомным кодом, то есть загруженным с хабом или определённым в пользовательском модуле/сессии.

#### is_remote_code[[transformers.PreTrainedModel.is_remote_code]]

```python
is_remote_code()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L5014)

Возвращает, является ли текущая модель кастомным кодом, то есть кодом, загруженным из хабa, или классом, который мы только что зарегистрировали с помощью `register_for_auto_class`.

#### mark_tied_weights_as_initialized[[transformers.PreTrainedModel.mark_tied_weights_as_initialized]]

```python
mark_tied_weights_as_initialized(loading_info)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4938)

Добавляет флаг `_is_hf_initialized` на параметры, которые будут связаны, чтобы избежать их последующей инициализации, поскольку они всё равно будут связаны (перезаписаны). Это очень важно, так как большинство эмбеддингов связаны, и это огромные параметры (размер словаря часто составляет 256k), поэтому выполнение инициализации для них обходится очень дорого.

#### named_non_persistent_buffers[[transformers.PreTrainedModel.named_non_persistent_buffers]]

```python
named_non_persistent_buffers(recurse: bool = True, remove_duplicate: bool = True)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4990)

Аналогично `named_buffers`, но возвращает только непостоянные буферы. Это удобно, так как не всегда очевидно, являются ли буферы постоянными или нет.

#### post_init[[transformers.PreTrainedModel.post_init]]

```python
post_init()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1289)

Метод, вызываемый в конце инициализации каждой модели Transformers, для выполнения кода, требующего корректной инициализации модулей модели (например, инициализации весов). Он также используется для получения всех корректных статических свойств (parallelism plans, tied_weights_keys, _keep_in_fp32_modules и т. д.) в случае составных моделей (то есть верхнеуровневая модель должна знать о свойствах, определённых в её дочерних компонентах).

#### register_for_auto_class[[transformers.PreTrainedModel.register_for_auto_class]]

```python
register_for_auto_class(auto_class = 'AutoModel')
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4645)

**Параметры:**

auto_class (`str` или `type`, *необязательный*, по умолчанию `"AutoModel"`) : Автоматический класс, с которым будет зарегистрирована эта новая модель.

Зарегистрируйте этот класс с указанным автоклассом. Это следует использовать только для пользовательских моделей, так как модели из библиотеки уже сопоставлены с автоклассами.

#### resize_token_embeddings[[transformers.PreTrainedModel.resize_token_embeddings]]

```python
resize_token_embeddings(new_num_tokens: int | None = None, pad_to_multiple_of: int | None = None, mean_resizing: bool = True)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2633)

**Параметры:**

new_num_tokens (`int`, *optional*) : Новое количество токенов в матрице эмбеддингов. Увеличение размера добавит новые инициализированные векторы в конец. Уменьшение размера удалит векторы с конца. Если значение не указано или равно `None`, просто возвращается указатель на входной модуль `torch.nn.Embedding` модели без каких-либо действий.

pad_to_multiple_of (`int`, *optional*) : Если задано, матрица эмбеддингов будет дополнена (padding) до кратного указанного значения. Если `new_num_tokens` установлено в `None`, эмбеддинги будут дополнены до кратного `pad_to_multiple_of`. Это особенно полезно для использования Tensor Cores на аппаратных средствах NVIDIA с вычислительной мощностью `>= 7.5` (Volta) или на TPU, где производительность повышается при длине последовательности, кратной 128. Дополнительные сведения об этом, а также рекомендации по выбору правильного значения для изменения размера, см. в этом руководстве: https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc

mean_resizing (`bool`) : Инициализировать добавленные эмбеддинги из многомерного нормального распределения, имеющего среднее и ковариацию старых эмбеддингов, или инициализировать их нормальным распределением со средним, равным нулю, и стандартным отклонением, равным `config.initializer_range`. Установка `mean_resizing` в `True` полезна при увеличении размера эмбеддингов в каузальных языковых моделях, где вероятности сгенерированных токенов не будут затронуты добавленными эмбеддингами, поскольку инициализация новых эмбеддингов средним значением старых эмбеддингов уменьшает KL-расхождение между вероятностями следующего токена до и после добавления новых эмбеддингов. Подробнее в этой статье: https://nlp.stanford.edu/~johnhew/vocab-expansion.html

**Возвращает:** `torch.nn.Embedding`

Указатель на модуль эмбеддингов входных токенов модели.

Изменяет размер матрицы эмбеддингов входных токенов модели, если `new_num_tokens != config.vocab_size`.

После этого привязывает веса эмбеддингов, если класс модели имеет метод `tie_weights()`.

#### save_pretrained[[transformers.PreTrainedModel.save_pretrained]]

```python
save_pretrained(save_directory: str | os.PathLike, is_main_process: bool = True, state_dict: dict | None = None, push_to_hub: bool = False, max_shard_size: int | str = '50GB', variant: str | None = None, token: str | bool | None = None, save_peft_format: bool = True, save_original_format: bool = True, distributed_checkpoint: bool = False, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3310)

**Параметры:**

save_directory (`str` или `os.PathLike`) : Каталог для сохранения. Будет создан, если не существует.

is_main_process (`bool`, *необязательный*, по умолчанию `True`) : Указывает, является ли процесс, вызывающий данный метод, основным. Полезно при распределённом обучении, например на TPU, когда необходимо вызвать эту функцию во всех процессах. В этом случае установите `is_main_process=True` только в основном процессе, чтобы избежать гонок.

state_dict (вложенный словарь `torch.Tensor`) : Словарь состояния модели, который нужно сохранить. По умолчанию используется `self.state_dict()`, но этот параметр позволяет сохранять только части модели или применять особые меры предосторожности при восстановлении словаря состояния модели (например, при использовании параллелизма моделей).

push_to_hub (`bool`, *необязательный*, по умолчанию `False`) : Указывает, следует ли после сохранения модели загрузить её в Hugging Face model hub. Репозиторий, в который нужно загрузить модель, можно указать с помощью `repo_id` (по умолчанию используется имя `save_directory` в вашем пространстве имён).

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"50GB"`) : Максимальный размер контрольной точки до её разбивки на части. Каждая часть контрольной точки будет иметь размер, меньший этого значения. Если значение указано строкой, оно должно состоять из цифр, за которыми следует единица измерения (например, `"5MB"`).    Если вес модели превышает `max_shard_size`, он будет вынесен в отдельную часть контрольной точки, размер которой превысит `max_shard_size`.

variant (`str`, *необязательный*) : Если указано, веса сохраняются в формате model..safetensors.

token (`str` или `bool`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если указано значение `True` или параметр не задан, будет использован токен, сгенерированный при выполнении `hf auth login` (хранится в `~/.huggingface`).

save_peft_format (`bool`, *необязательный*, по умолчанию `True`) : Для обратной совместимости с библиотекой PEFT, если к модели подключены веса адаптеров, все ключи state dict адаптеров должны быть префиксированы строкой `base_model.model`. Продвинутые пользователи могут отключить это поведение, установив `save_peft_format` в `False`.

save_original_format (`bool`, *необязательный*, по умолчанию `True`) : Для обратной совместимости с предыдущими версиями `transformers` вы можете сохранить контрольную точку с её обратным отображением. Обратное отображение должно существовать, даже если модель была загружена из контрольной точки None legacy.

distributed_checkpoint (`bool`, *необязательный*, по умолчанию `False`) : При сохранении модели, разбитой на шарды FSDP или TP, записывать safetensors с использованием распределённого чекпоинтинга (DCP), а не сначала собирать веса на CPU. Этот метод должен вызываться на каждом ранке. Если `False`, веса сначала собираются на CPU на ранке 0 с помощью `gather_full_state_dict`, а затем записываются. Параметр предназначен только для сохранения и возобновления обучения; установите `False`, если вам нужны все возможности `save_pretrained`. При `push_to_hub=True` ранк 0 консолидирует чекпоинт в подкаталоге `consolidated/` и загружает этот каталог. Требуется `torch>=2.7`.

kwargs (`dict[str, Any]`, *необязательный*) : Дополнительные именованные аргументы, передаваемые в метод [push_to_hub()](/docs/transformers/main/ru/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub).

Сохраните модель и файл её конфигурации в каталог, чтобы её можно было загрузить снова с помощью метода класса [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained).

#### set_attn_implementation[[transformers.PreTrainedModel.set_attn_implementation]]

```python
set_attn_implementation(attn_implementation: str | dict, allow_all_kernels: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L1960)

**Параметры:**

attn_implementation (`str` или `dict`) : Реализация механизма внимания, которую следует установить для этой модели. Это может быть `str`, в этом случае значение будет передано всем подмоделям, если это применимо, или `dict`, где ключами являются имена sub_configs, в этом случае каждая подмодель передаст соответствующее значение (себе и всем вложенным в неё подмоделям). Само значение может быть `dict` в том же формате, чтобы указать sub_configs данной подмодели (как при инициализации конфигурации с вложенным `attn_implementation` dict).

allow_all_kernels (`bool`, optional) : Загружать ли ядра из непроверенных репозиториев хабa, если `attn_implementation` является пользовательским ядром, не входящим в репозиторий хаба `kernels-community`.

Установите требуемое значение `attn_implementation` для этой модели.

#### set_decoder[[transformers.PreTrainedModel.set_decoder]]

```python
set_decoder(decoder)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2277)

Симметричный setter. Повторяет логику поиска, используемую в `get_decoder`.

#### set_encoder[[transformers.PreTrainedModel.set_encoder]]

```python
set_encoder(encoder, modality: str | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2228)

Симметричный setter. Повторяет логику поиска, используемую в `get_encoder`.

#### set_experts_implementation[[transformers.PreTrainedModel.set_experts_implementation]]

```python
set_experts_implementation(experts_implementation: str | dict)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2077)

**Параметры:**

experts_implementation (`str` или `dict`) : Реализация экспертов, которую следует установить для этой модели. Это может быть `str`, в этом случае значение будет передано во все подмодели, если это применимо, или `dict`, где ключами являются имена sub_configs, в этом случае каждая подмодель получит соответствующее значение.

Установите требуемое значение `experts_implementation` для этой модели.

#### set_use_kernels[[transformers.PreTrainedModel.set_use_kernels]]

```python
set_use_kernels(use_kernels, kernel_config: transformers.utils.kernel_config.KernelConfig | None = None, mode: Mode | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L3850)

**Параметры:**

use_kernels (`bool`) : Использовать ли библиотеку `kernels` для применения kernelization к некоторым слоям модели.

kernel_config (`KernelConfig`, *необязательный*) : Конфигурация ядра, используемая для кернелизации модели. Если `None`, будет использоваться сопоставление ядер по умолчанию.

mode (`Mode`, *необязательный*) : Режим, который должен применяться во время `kernelize`. Необязательный параметр, по умолчанию устанавливается в режим обучения или вывода в зависимости от внутреннего флага `training`.

Определяет, следует ли использовать библиотеку `kernels` для ядровой обработки некоторых слоёв модели.

#### tie_weights[[transformers.PreTrainedModel.tie_weights]]

```python
tie_weights(missing_keys: set[str] | None = None, recompute_mapping: bool = True)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L2530)

Свяжите веса модели. Если `recompute_mapping=False` (значение по умолчанию при внутреннем вызове), будет использоваться атрибут `model.all_tied_weights_keys`, содержащий отображение `{target: source}` для связанных параметров. Если `recompute_mapping=True`, будет повторно проверяться все внутренние подмодели и их конфигурация, чтобы определить параметры, которые необходимо связать. Это значение по умолчанию, когда `model.tie_weights()` вызывается самостоятельно, вне `__init__` и `from_pretrained`, на случай, если значения конфигурации были изменены где-либо.

Обратите внимание, что при вызове `from_pretrained` связывание является *симметричным*: если в маппинге указано «target -> source», но `source` отсутствует в чекпоинте, а `target` присутствует, мы *меняем* source и target местами, чтобы всё равно связать всё с параметром, который действительно существует.

#### к[[transformers.PreTrainedModel.to]]

```python
to(*args, **kwargs)
```

Мок-значение для пути с точками (например, `torch.float32`): цепочки доступа к атрибутам и вызовы работают как пропускные декораторы, `repr` возвращает путь с точками, а использование в качестве базового класса подменяет его обычным базовым классом `type` (PEP 560 `__mro_entries__`), благодаря чему реальные дочерние классы сохраняют обычный метакласс, а `inspect.signature` читает их реальный `__init__`, а не мок.

#### warn_if_padding_and_no_attention_mask[[transformers.PreTrainedModel.warn_if_padding_and_no_attention_mask]]

```python
warn_if_padding_and_no_attention_mask(input_ids, attention_mask)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L4667)

Показывает одноразовое предупреждение, если input_ids, по-видимому, содержат padding, а attention mask не была передана.

Пользовательские модели также должны включать `_supports_assign_param_buffer`, который определяет, можно ли применить superfast init к данной модели. Признак того, что вашей модели это необходимо, — если `test_save_and_load_from_pretrained` завершается с ошибкой. В этом случае установите значение `False`.

## ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

#### transformers.modeling_utils.ModuleUtilsMixin[[transformers.modeling_utils.ModuleUtilsMixin]]

```python
transformers.modeling_utils.ModuleUtilsMixin()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L894)

Несколько утилит для `torch.nn.Modules`, предназначенных для использования в качестве миксина.

#### num_parameters[[transformers.modeling_utils.ModuleUtilsMixin.num_parameters]]

```python
num_parameters(only_trainable: bool = False, exclude_embeddings: bool = False)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/modeling_utils.py#L914)

**Параметры:**

only_trainable (`bool`, *необязательный*, по умолчанию `False`) : Возвращать ли только количество обучаемых параметров

exclude_embeddings (`bool`, *необязательный*, по умолчанию `False`) : Возвращать ли только количество параметров, не являющихся эмбеддингами

**Возвращает:** `int`

Количество параметров.

Получить количество (опционально, обучаемых или не являющихся эмбеддингами) параметров в модуле.

## Загрузка в Hub[[transformers.utils.PushToHubMixin]]

#### transformers.utils.PushToHubMixin[[transformers.utils.PushToHubMixin]]

```python
transformers.utils.PushToHubMixin()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L728)

Миксин, содержащий функциональность для загрузки модели или токенизатора на хаб.

#### push_to_hub[[transformers.utils.PushToHubMixin.push_to_hub]]

```python
push_to_hub(repo_id: str, commit_message: str | None = None, commit_description: str | None = None, private: bool | None = None, token: bool | str | None = None, revision: str | None = None, create_pr: bool = False, max_shard_size: int | str | None = '50GB', tags: list[str] | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/utils/hub.py#L822)

**Параметры:**

repo_id (`str`) : Имя репозитория, в который вы хотите отправить {object}. При отправке в конкретную организацию здесь должно указываться имя вашей организации.

commit_message (`str`, *необязательный*) : Сообщение для коммита при выполнении push. По умолчанию используется `"Upload {object}"`.

commit_description (`str`, *необязательный*) : Описание коммита, который будет создан

private (`bool`, *optional*) : Указывает, нужно ли сделать репозиторий приватным. Если `None` (по умолчанию), репозиторий будет публичным, если только по умолчанию для организации не задан приватный режим. Это значение игнорируется, если репозиторий уже существует.

token (`bool` или `str`, *необязательный*) : Токен, используемый в качестве HTTP bearer-авторизации для удалённых файлов. Если `True` (по умолчанию), будет использован токен, сгенерированный при выполнении `hf auth login` (хранится в `~/.huggingface`).

revision (`str`, *необязательный*) : Ветка, в которую будут отправлены загруженные файлы.

create_pr (`bool`, *необязательный*, по умолчанию `False`) : Создавать ли PR с загруженными файлами или коммитить изменения напрямую.

max_shard_size (`int` или `str`, *необязательный*, по умолчанию `"50GB"`) : Применимо только к моделям. Максимальный размер контрольной точки до её разбивки на части. Каждая часть контрольной точки будет иметь размер, меньший этого значения. Если значение указано в виде строки, оно должно состоять из цифр, за которыми следует единица измерения (например, `"5MB"`).

tags (`list[str]`, *необязательный*) : Список тегов для загрузки на Hub.

Загрузите {object_files} в 🤗 Model Hub.

Примеры:

```python
from transformers import {object_class}

{object} = {object_class}.from_pretrained("google-bert/bert-base-cased")

# Push the {object} to your namespace with the name "my-finetuned-bert".
{object}.push_to_hub("my-finetuned-bert")

# Push the {object} to an organization with the name "my-finetuned-bert".
{object}.push_to_hub("huggingface/my-finetuned-bert")
```