# HGNet-V2

[HGNetV2](https://github.com/PaddlePaddle/PaddleClas/blob/v2.6.0/docs/zh_CN/models/ImageNet1k/PP-HGNetV2.md) — это convolutional neural network (CNN) backbone нового поколения, созданный для оптимального баланса между точностью и задержкой на GPU NVIDIA. Развивая идеи оригинального [HGNet](https://github.com/PaddlePaddle/PaddleClas/blob/v2.6.0/docs/en/models/PP-HGNet_en.md), HGNetV2 обеспечивает высокую точность при быстром выводе и демонстрирует отличные результаты в задачах классификации изображений, обнаружения объектов и сегментации, что делает его практичным выбором для приложений компьютерного зрения на базе GPU.

Все исходные модели HGNet V2 можно найти в организации [USTC](https://huggingface.co/ustc-community/models?search=hgnet).

> [!TIP]
> Эта модель была добавлена пользователем [VladOS95-cyber](https://github.com/VladOS95-cyber). Нажмите на модели HGNet V2 в правой боковой панели, чтобы увидеть больше примеров применения HGNet V2 к различным задачам компьютерного зрения.

Пример ниже демонстрирует, как классифицировать изображение с помощью [Pipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline) или класса [AutoModel](/docs/transformers/main/ru/model_doc/auto#transformers.AutoModel).

```python
from transformers import pipeline

pipeline = pipeline(
    task="image-classification",
    model="ustc-community/hgnet-v2",
    device=0
)
pipeline("http://images.cocodataset.org/val2017/000000039769.jpg")
```

```python
import requests
import torch
from PIL import Image

from transformers import AutoImageProcessor, HGNetV2ForImageClassification

url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

model = HGNetV2ForImageClassification.from_pretrained("ustc-community/hgnet-v2", device_map="auto")
processor = AutoImageProcessor.from_pretrained("ustc-community/hgnet-v2")

inputs = processor(images=image, return_tensors="pt").to(model.device)
with torch.no_grad():
    logits = model(**inputs).logits
predicted_class_id = logits.argmax(dim=-1).item()

class_labels = model.config.id2label
predicted_class_label = class_labels[predicted_class_id]
print(f"The predicted class label is: {predicted_class_label}")
```

## HGNetV2Config[[transformers.HGNetV2Config]]

#### transformers.HGNetV2Config[[transformers.HGNetV2Config]]

```python
transformers.HGNetV2Config(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, num_channels: int = 3, embedding_size: int = 64, depths: list[int] | tuple[int, ...] = (3, 4, 6, 3), hidden_sizes: list[int] | tuple[int, ...] = (256, 512, 1024, 2048), hidden_act: str = 'relu', _out_features: list[str] | None = None, _out_indices: list[int] | None = None, stem_channels: list[int] | tuple[int, ...] = (3, 32, 48), stem_strides: Sequence = (2, 1, 1, 2, 1), stage_in_channels: list[int] | tuple[int, ...] = (48, 128, 512, 1024), stage_mid_channels: list[int] | tuple[int, ...] = (48, 96, 192, 384), stage_out_channels: list[int] | tuple[int, ...] = (128, 512, 1024, 2048), stage_num_blocks: list[int] | tuple[int, ...] = (1, 1, 3, 1), stage_downsample: list[bool] | tuple[bool, ...] = (False, True, True, True), stage_downsample_strides: Sequence = (2, 2, 2, 2), stage_light_block: list[bool] | tuple[bool, ...] = (False, False, True, True), stage_kernel_size: list[int] | tuple[int, ...] = (3, 3, 5, 5), stage_numb_of_layers: list[int] | tuple[int, ...] = (6, 6, 6, 6), use_learnable_affine_block: bool = False, initializer_range: float = 0.02)
```

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

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

num_channels (`int`, *необязательный*, по умолчанию `3`) : Количество входных каналов.

embedding_size (`int`, *необязательный*, по умолчанию `64`) : Размерность эмбеддингов и скрытых состояний.

depths (`Union[list[int], tuple[int, ...]]`, *необязательный*, по умолчанию `(3, 4, 6, 3)`) : Глубина каждого слоя в Transformer.

hidden_sizes (`Union[list[int], tuple[int, ...]]`, *необязательный*, по умолчанию `(256, 512, 1024, 2048)`) : Размерность (скрытый размер) на каждом этапе модели.

hidden_act (`str`, *необязательный*, по умолчанию `relu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

stem_channels (`list[int]`, *optional*, по умолчанию `[3, 32, 48]`) : Размеры каналов для начальных слоёв: - Первое число (3) — количество каналов входного изображения - Второе число (32) — количество промежуточных каналов начальных слоёв - Третье число (48) — количество выходных каналов начальных слоёв

stem_strides (`Sequence[int | list[int] | tuple[int, ...]]`, *необязательный*, по умолчанию `(2, 1, 1, 2, 1)`) : Шаговые паттерны для стебельных слоев.

stage_in_channels (`list[int]`, *optional*, по умолчанию `[48, 128, 512, 1024]`) : Размеры входных каналов для каждого этапа backbone. Это определяет, сколько каналов будет иметь вход на каждом этапе.

stage_mid_channels (`list[int]`, *optional*, по умолчанию `[48, 96, 192, 384]`) : Размеры каналов на промежуточных этапах для каждой стадии бэкбона. Это определяет количество каналов, используемых в промежуточных слоях каждой стадии.

stage_out_channels (`list[int]`, *optional*, по умолчанию `[128, 512, 1024, 2048]`) : Размеры выходных каналов для каждого этапа backbone. Это определяет количество каналов в выводе каждого этапа.

stage_num_blocks (`list[int]`, *optional*, по умолчанию `[1, 1, 3, 1]`) : Количество блоков, используемых на каждом этапе backbone. Это определяет глубину каждого этапа, задавая, сколько свёрточных блоков нужно сложить.

stage_downsample (`list[bool]`, *необязательный*, по умолчанию `[False, True, True, True]`) : Указывает, следует ли выполнять даунсемплинг карт признаков на каждом этапе. Если `True`, пространственные размеры карт признаков будут уменьшены.

stage_downsample_strides (`Sequence[int | list[int] | tuple[int, ...]]`, *необязательный*, по умолчанию `(2, 2, 2, 2)`) : Шаговые паттерны для каждого слоя стадии.

stage_light_block (`list[bool]`, *необязательный*, по умолчанию `[False, False, True, True]`) : Указывает, следует ли использовать лёгкие блоки на каждом этапе. Лёгкие блоки — это вариант свёрточных блоков, который может содержать меньше параметров.

stage_kernel_size (`list[int]`, *необязательный*, по умолчанию `[3, 3, 5, 5]`) : Размеры ядер для свёрточных слоев на каждом этапе.

stage_numb_of_layers (`list[int]`, *необязательный*, по умолчанию `[6, 6, 6, 6]`) : Количество слоев, используемых в каждом блоке этапа.

use_learnable_affine_block (`bool`, *необязательный*, по умолчанию `False`) : Использовать ли Learnable Affine Blocks (LAB) в сети. LAB добавляет обучаемые параметры масштаба и смещения после определённых операций.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

Это класс конфигурации для хранения настроек HGNetV2Backbone. Он используется для создания модели Hgnet V2 в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации [ustc-community/dfine_x_coco](https://huggingface.co/ustc-community/dfine_x_coco)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/main/ru/main_classes/configuration#transformers.PreTrainedConfig).

## HGNetV2Backbone[[transformers.HGNetV2Backbone]]

#### transformers.HGNetV2Backbone[[transformers.HGNetV2Backbone]]

```python
transformers.HGNetV2Backbone(config: HGNetV2Config)
```

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

#### forward[[transformers.HGNetV2Backbone.forward]]

```python
forward(pixel_values: Tensor, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** `BackboneOutput` или `tuple(torch.Tensor)`

Объект `BackboneOutput` или кортеж из `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([HGNetV2Config](/docs/transformers/main/ru/model_doc/hgnet_v2#transformers.HGNetV2Config)) и входных данных.

Метод forward класса [HGNetV2Backbone](/docs/transformers/main/ru/model_doc/hgnet_v2#transformers.HGNetV2Backbone) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **feature_maps** (`tuple(torch.Tensor)` формы `(batch_size, num_channels, height, width)`) -- Карты признаков на каждом этапе.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода эмбеддингов + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)` или `(batch_size, num_channels, height, width)`, в зависимости от базовой модели.

  Скрытые состояния модели на выходе каждого этапа, а также выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) — Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Применимо только в том случае, если базовая модель использует механизм внимания.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Примеры:

```python
>>> from transformers import HGNetV2Config, HGNetV2Backbone
>>> import torch

>>> config = HGNetV2Config()
>>> model = HGNetV2Backbone(config)

>>> pixel_values = torch.randn(1, 3, 224, 224)

>>> with torch.no_grad():
...     outputs = model(pixel_values)

>>> feature_maps = outputs.feature_maps
>>> list(feature_maps[-1].shape)
[1, 2048, 7, 7]
```

## HGNetV2ForImageClassification[[transformers.HGNetV2ForImageClassification]]

#### transformers.HGNetV2ForImageClassification[[transformers.HGNetV2ForImageClassification]]

```python
transformers.HGNetV2ForImageClassification(config: HGNetV2Config)
```

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

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

config ([HGNetV2Config](/docs/transformers/main/ru/model_doc/hgnet_v2#transformers.HGNetV2Config)) : Класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель HGNetV2 с головой для классификации изображений (линейный слой поверх пуллинг-функций), например, для ImageNet.

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

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.HGNetV2ForImageClassification.forward]]

```python
forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

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

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

pixel_values (`torch.Tensor` формы `(batch_size, num_channels, image_size, image_size)`, *необязательный*) : Тензоры, соответствующие входным изображениям. Значения пикселей можно получить с помощью `image_processor_class`. Подробности см. в `image_processor_class.__call__` (`processor_class` использует `image_processor_class` для обработки изображений).

labels (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Метки для вычисления потерь классификации/регрессии изображений. Индексы должны находиться в диапазоне `[0, ..., config.num_labels - 1]`. Если `config.num_labels == 1`, вычисляется потеря регрессии (среднеквадратичная потеря), если `config.num_labels > 1`, вычисляется потеря классификации (кросс-энтропия).

output_hidden_states (`bool`, *необязательный*) : Нужно ли возвращать скрытые состояния всех слоёв. Подробнее о `hidden_states` в разделе возвращаемых тензоров.

return_dict (`bool`, *необязательный*) : Нужно ли возвращать [ModelOutput](/docs/transformers/main/ru/main_classes/output#transformers.utils.ModelOutput) вместо обычного кортежа.

**Возвращает:** [ImageClassifierOutputWithNoAttention](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) или `tuple(torch.Tensor)`

Объект [ImageClassifierOutputWithNoAttention](/docs/transformers/main/ru/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации ([HGNetV2Config](/docs/transformers/main/ru/model_doc/hgnet_v2#transformers.HGNetV2Config)) и входных данных.

Метод forward класса [HGNetV2ForImageClassification](/docs/transformers/main/ru/model_doc/hgnet_v2#transformers.HGNetV2ForImageClassification) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **loss** (`torch.Tensor` формы `(1,)`, *необязательный*, возвращается, если задан `labels`) -- Потери классификации (или регрессии, если config.num_labels==1).
- **logits** (`torch.Tensor` формы `(batch_size, config.num_labels)`) — Оценки классификации (или регрессии, если config.num_labels==1) до применения SoftMax.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого этапа) формы `(batch_size, num_channels, height, width)`. Скрытые состояния (также называемые картами признаков) модели на выходе каждого этапа.

Примеры:
```python
>>> import torch
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import HGNetV2ForImageClassification, AutoImageProcessor
>>> from PIL import Image

>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
...     image = Image.open(BytesIO(response.read()))

>>> model = HGNetV2ForImageClassification.from_pretrained("ustc-community/hgnet-v2")
>>> processor = AutoImageProcessor.from_pretrained("ustc-community/hgnet-v2")

>>> inputs = processor(images=image, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> outputs.logits.shape
torch.Size([1, 2])
```