# MobileNet V2 [MobileNet V2](https://huggingface.co/papers/1801.04381) améliore les performances sur les appareils mobiles grâce à une architecture plus efficace. Il utilise des blocs résiduels inversés et des goulets d’étranglement linéaires pour démarrer avec une représentation plus petite des données, l’élargir pour le traitement, puis la réduire à nouveau afin de diminuer le nombre de calculs. Le modèle supprime également les non-linéarités pour maintenir la précision malgré sa conception simplifiée. Comme [MobileNet V1](./mobilenet_v1), il utilise des convolutions séparables en profondeur pour l’efficacité. Vous pouvez trouver tous les points de contrôle MobileNet d'origine sous l'organisation [Google](https://huggingface.co/google?search_models=mobilenet). > [!TIP] > Cliquez sur les modèles MobileNet V2 dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer MobileNet à différentes tâches de vision. Les exemples ci-dessous montrent comment classifier une image avec [Pipeline](/docs/transformers/main/fr/main_classes/pipelines#transformers.Pipeline) ou la classe [AutoModel](/docs/transformers/main/fr/model_doc/auto#transformers.AutoModel). ```python from transformers import pipeline pipeline = pipeline( task="image-classification", model="google/mobilenet_v2_1.4_224", device=0 ) pipeline("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg") ``` ```python import requests import torch from PIL import Image from transformers import AutoImageProcessor, AutoModelForImageClassification image_processor = AutoImageProcessor.from_pretrained( "google/mobilenet_v2_1.4_224", ) model = AutoModelForImageClassification.from_pretrained( "google/mobilenet_v2_1.4_224", device_map="auto", ) url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg" image = Image.open(requests.get(url, stream=True).raw) inputs = image_processor(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}") ``` ## Notes - Les noms de points de contrôle de classification suivent le motif `mobilenet_v2_{depth_multiplier}_{resolution}`, comme `mobilenet_v2_1.4_224`. `1.4` est le multiplicateur de profondeur et `224` est la résolution de l’image. Les noms de points de contrôle de segmentation suivent le motif `deeplabv3_mobilenet_v2_{depth_multiplier}_{resolution}`. - Bien que le modèle soit entraîné sur des images d'une taille spécifique, son architecture fonctionne avec des images de différentes tailles (32x32 minimum). Le [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor) gère le prétraitement nécessaire. - MobileNet est pré-entraîné sur [ImageNet-1k](https://huggingface.co/datasets/ILSVRC/imagenet-1k), un jeu de données comportant 1000 classes. Cependant, le modèle prédit en réalité 1001 classes. La classe supplémentaire est une classe « fond » (index 0). - Les modèles de segmentation utilisent une tête [DeepLabV3+](https://huggingface.co/papers/1802.02611) qui est souvent pré-entraînée sur des jeux de données comme [PASCAL VOC](https://huggingface.co/datasets/merve/pascal-voc). - Les points de contrôle TensorFlow d’origine déterminent la quantité de bourrage lors de l’inférence, car elle dépend de la taille de l’image d’entrée. Pour utiliser le comportement de bourrage natif de PyTorch, définissez `tf_padding=False` dans [MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config). ```python from transformers import MobileNetV2Config config = MobileNetV2Config.from_pretrained("google/mobilenet_v2_1.4_224", tf_padding=True) ``` - L'implémentation de Transformers ne prend pas en charge les fonctionnalités suivantes. - Utilise le pooling moyen global au lieu du pooling moyen 7x7 optionnel avec un pas de 2. Pour des entrées plus grandes, cela produit une sortie poolée plus grande qu'un pixel 1x1. - `output_hidden_states=True` renvoie *tous* les états cachés intermédiaires. Il n’est pas possible d’extraire la sortie de couches spécifiques pour d’autres usages en aval. - N'inclut pas les modèles quantifiés des points de contrôle d'origine, car ils contiennent des opérations « FakeQuantization » pour déquantiser les poids. - Pour les modèles de segmentation, la dernière couche de convolution du backbone est calculée, même si la tête DeepLabV3+ ne l'utilise pas. ## MobileNetV2Config[[transformers.MobileNetV2Config]] #### transformers.MobileNetV2Config[[transformers.MobileNetV2Config]] ```python transformers.MobileNetV2Config(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, image_size: int | list[int] | tuple[int, int] = 224, depth_multiplier: float | int = 1.0, depth_divisible_by: int = 8, min_depth: int = 8, expand_ratio: float | int = 6.0, output_stride: int = 32, first_layer_is_expansion: bool = True, finegrained_output: bool = True, hidden_act: str = 'relu6', tf_padding: bool = True, classifier_dropout_prob: float | int = 0.8, initializer_range: float = 0.02, layer_norm_eps: float = 0.001, semantic_loss_ignore_index: int = 255) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/configuration_mobilenet_v2.py#L24) **Paramètres :** num_channels (`int`, *facultatif*, par défaut `3`) : Le nombre de canaux d'entrée. image_size (`Union[int, list[int], tuple[int, int]]`, *facultatif*, valeur par défaut `224`) : La taille (résolution) de chaque image. depth_multiplier (`Union[float, int]`, *facultatif*, valeur par défaut `1.0`) : Réduit ou augmente le nombre de canaux dans chaque couche. Ce paramètre est parfois également appelé « alpha » ou « multiplicateur de largeur ». depth_divisible_by (`int`, *facultatif*, valeur par défaut : 8) : Le nombre de canaux de chaque couche sera toujours un multiple de ce nombre. min_depth (`int`, *facultatif*, valeur par défaut : 8) : Toutes les couches auront au moins ce nombre de canaux. expand_ratio (`float`, *facultatif*, valeur par défaut 6.0) : Le nombre de canaux de sortie de la première couche de chaque bloc est égal au nombre de canaux d'entrée multiplié par le ratio d'expansion. output_stride (`int`, *facultatif*, valeur par défaut 32) : Le ratio entre la résolution spatiale des cartes de caractéristiques d'entrée et de sortie. Par défaut, le modèle réduit les dimensions d'entrée d'un facteur 32. Si `output_stride` est 8 ou 16, le modèle utilise des convolutions dilatées sur les couches depthwise au lieu de convolutions régulières, afin que les cartes de caractéristiques ne deviennent jamais plus de 8x ou 16x plus petites que l'image d'entrée. first_layer_is_expansion (`bool`, *facultatif*, par défaut `True`) : True si la toute première couche de convolution est également la couche d'expansion du premier bloc d'expansion. finegrained_output (`bool`, *facultatif*, valeur par défaut `True`) : Si la valeur est true, le nombre de canaux de sortie de la couche de convolution finale restera élevé (1280), même si `depth_multiplier` est inférieur à 1. hidden_act (`str`, *facultatif*, par défaut `relu6`) : La fonction d'activation non linéaire (fonction ou chaîne de caractères) dans le décodeur. Par exemple, `"gelu"`, `"relu"`, `"silu"`, etc. tf_padding (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut utiliser les règles de remplissage TensorFlow sur les couches de convolution. classifier_dropout_prob (`Union[float, int]`, *facultatif*, valeur par défaut `0.8`) : Le taux de dropout pour le classifieur. initializer_range (`float`, *facultatif*, valeur par défaut `0.02`) : L'écart-type de la truncated_normal_initializer utilisé pour l'initialisation de toutes les matrices de poids. layer_norm_eps (`float`, *facultatif*, par défaut `0.001`) : L'épsilon utilisé par les couches de normalisation de couche. semantic_loss_ignore_index (`int`, *facultatif*, valeur par défaut `255`) : L'index ignoré par la fonction de perte du modèle de segmentation sémantique. Ceci est la classe de configuration destinée à stocker la configuration d'un MobileNetV2Model. Elle est utilisée pour instancier un modèle Mobilenet V2 en fonction des arguments spécifiés, en définissant l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de [google/mobilenet_v2_1.0_224](https://huggingface.co/google/mobilenet_v2_1.0_224) Les objets de configuration héritent de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de [PreTrainedConfig](/docs/transformers/main/fr/main_classes/configuration#transformers.PreTrainedConfig) pour plus d’informations. Exemple : ```python >>> from transformers import MobileNetV2Config, MobileNetV2Model >>> # Initializing a "mobilenet_v2_1.0_224" style configuration >>> configuration = MobileNetV2Config() >>> # Initializing a model from the "mobilenet_v2_1.0_224" style configuration >>> model = MobileNetV2Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## MobileNetV2ImageProcessor[[transformers.MobileNetV2ImageProcessor]] #### transformers.MobileNetV2ImageProcessor[[transformers.MobileNetV2ImageProcessor]] ```python transformers.MobileNetV2ImageProcessor(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/image_processing_mobilenet_v2.py#L49) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'shortest_edge' : 256}`) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par 255. Construit un processeur d’images MobileNetV2ImageProcessor. #### prétraiter[[transformers.MobileNetV2ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/image_processing_mobilenet_v2.py#L69) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. segmentation_maps (`ImageInput`, *facultatif*) : Les cartes de segmentation à prétraiter. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par 255. **Retourne :** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.). - **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation. #### post_process_semantic_segmentation[[transformers.MobileNetV2ImageProcessor.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/image_processing_mobilenet_v2.py#L184) **Paramètres :** outputs ([MobileNetV2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ForSemanticSegmentation)) : Sorties brutes du modèle. target_sizes (`list[tuple[int, int]]`, *facultatif*) : Liste de tuples correspondant à la taille finale demandée (hauteur, largeur) de chaque prédiction. return_segmentation_scores (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. Si `True`, chaque élément de la liste retournée est un `SemanticSegmentationPostProcessorOutput` avec les champs `segmentation` (identifiants de classes, forme `(height, width)`) et `segmentation_scores` (forme `(num_classes, height, width)`). **Retourne :** `list[torch.Tensor]` ou `list[SemanticSegmentationPostProcessorOutput]` Lorsque `return_segmentation_scores=False` (par défaut), une liste de longueur `batch_size` où chaque élément est une carte de segmentation de forme `(height, width)` avec des identifiants de classes. Lorsque `return_segmentation_scores=True`, une liste de `SemanticSegmentationPostProcessorOutput` avec les champs `segmentation` (identifiants de classes, forme `(height, width)`) et `segmentation_scores` (forme `(num_classes, height, width)`). Dans les deux cas, `(height, width)` correspond à la taille cible (si `target_sizes` est spécifiée). Convertit la sortie de [MobileNetV2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ForSemanticSegmentation) en cartes de segmentation sémantique. ## MobileNetV2ImageProcessorPil[[transformers.MobileNetV2ImageProcessorPil]] #### transformers.MobileNetV2ImageProcessorPil[[transformers.MobileNetV2ImageProcessorPil]] ```python transformers.MobileNetV2ImageProcessorPil(**kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/image_processing_pil_mobilenet_v2.py#L57) **Paramètres :** do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'shortest_edge' : 256}`) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*, valeur par défaut `False`) : Indique s'il faut par défaut redimensionner l'image en un carré si la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*, par défaut `{'height' : 224, 'width': 224}`) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, par défaut `2`) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*, valeur par défaut `0.00392156862745098`) : Facteur de remise à l'échelle appliqué à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*, valeur par défaut `[0.5, 0.5, 0.5]`) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*, valeur par défaut `True`) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par 255. Construit un processeur d’images MobileNetV2ImageProcessor. #### prétraiter[[transformers.MobileNetV2ImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], segmentation_maps: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = None, **kwargs: *) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/image_processing_pil_mobilenet_v2.py#L77) **Paramètres :** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Image à prétraiter. Attend une image unique ou un lot d'images dont les valeurs de pixels sont comprises entre 0 et 255. Si vous transmettez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissez `do_rescale=False`. segmentation_maps (`ImageInput`, *facultatif*) : Les cartes de segmentation à prétraiter. do_convert_rgb (`bool`, *kwargs*, *facultatif*) : Indique s'il faut convertir l'image en RGB. do_resize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut redimensionner l'image. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Décrit les dimensions d'entrée maximales du modèle. default_to_square (`bool`, *kwargs*, *facultatif*) : Indique s'il faut par défaut redimensionner l'image en un carré lorsque la taille est un entier. crop_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Taille de l'image de sortie après application de `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*) : Filtre de rééchantillonnage à utiliser lors du redimensionnement de l'image. Il peut s'agir d'une des valeurs de l'énumération `PILImageResampling`. N'a un effet que si `do_resize` est défini sur `True`. do_rescale (`bool`, *kwargs*, *facultatif*) : Indique s'il faut rééchelonner l'image. rescale_factor (`float`, *kwargs*, *facultatif*) : Facteur de redimensionnement à appliquer à l'image si `do_rescale` est défini sur `True`. do_normalize (`bool`, *kwargs*, *facultatif*) : Indique s'il faut normaliser l'image. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Moyenne de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. image_std (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *facultatif*) : Écart-type de l'image à utiliser pour la normalisation. N'a un effet que si `do_normalize` est défini sur `True`. do_pad (`bool`, *kwargs*, *facultatif*) : Indique s'il faut ajouter un rembourrage à l'image. Le rembourrage est effectué soit jusqu'à la plus grande taille du lot, soit jusqu'à une taille carrée fixe par image. La stratégie de rembourrage exacte dépend du modèle. pad_size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : La taille au format `{"height": int, "width" int}` à laquelle rembourrer les images. Elle doit être supérieure à la taille de n'importe quelle image fournie pour le prétraitement. Si `pad_size` n'est pas fourni, les images seront rembourrées à la hauteur et à la largeur maximales du lot. Appliqué uniquement lorsque `do_pad=True.` do_center_crop (`bool`, *kwargs*, *facultatif*) : Indique s'il faut effectuer un recadrage centré de l'image. data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Seul `ChannelDimension.FIRST` est pris en charge. Ajouté pour assurer la compatibilité avec les processeurs lents. input_data_format (`Union[str, ~image_utils.ChannelDimension]`, *kwargs*, *facultatif*) : Le format de la dimension des canaux pour l'image d'entrée. Si non défini, le format de la dimension des canaux est déduit de l'image d'entrée. Peut être l'un des éléments suivants : - `"channels_first"` ou `ChannelDimension.FIRST` : image au format (num_channels, height, width). - `"channels_last"` ou `ChannelDimension.LAST` : image au format (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE` : image au format (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : L'appareil sur lequel traiter les vidéos. Si non défini, l'appareil est déduit des vidéos d'entrée. return_tensors (`Annotated[str | ~utils.generic.TensorType | None, None]`, *kwargs*) : Renvoie des tenseurs empilés si la valeur est `'pt'`, sinon renvoie une liste de tenseurs. disable_grouping (`bool`, *kwargs*, *facultatif*) : Indique s'il faut désactiver le regroupement des images par taille afin de les traiter individuellement plutôt que par lots. Si la valeur est None, elle sera définie sur True si les images sont sur CPU, et sur False dans le cas contraire. Ce choix repose sur des observations empiriques, comme détaillé ici : https://github.com/huggingface/transformers/pull/38157 image_seq_length (`int`, *kwargs*, *facultatif*) : Le nombre de jetons d'image à utiliser pour chaque image de l'entrée. Ajouté pour la compatibilité ascendante, mais cela devrait être défini comme un attribut du processeur dans les futurs modèles. do_reduce_labels (`bool`, *kwargs*, *facultatif*, valeur par défaut `self.do_reduce_labels`) : Indique s'il faut réduire de 1 toutes les valeurs d'étiquettes des cartes de segmentation. Utilisé généralement pour les jeux de données où 0 est utilisé pour l'arrière-plan, et où l'arrière-plan lui-même n'est pas inclus dans toutes les classes d'un jeu de données (par ex. ADE20k). L'étiquette d'arrière-plan sera remplacée par 255. **Retourne :** `~image_processing_base.BatchFeature` - **data** (`dict`) -- Dictionnaire de listes/tableaux/tenseurs renvoyé par la méthode __call__ (« pixel_values », etc.). - **tensor_type** (`Union[None, str, TensorType]`, *facultatif*) -- Vous pouvez spécifier un tensor_type ici pour convertir les listes d'entiers en tenseurs PyTorch/Numpy lors de l'initialisation. #### post_process_semantic_segmentation[[transformers.MobileNetV2ImageProcessorPil.post_process_semantic_segmentation]] ```python post_process_semantic_segmentation(outputs, target_sizes: list[tuple[int, int]] | None = None, return_segmentation_scores: bool = False) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/image_processing_pil_mobilenet_v2.py#L180) **Paramètres :** outputs ([MobileNetV2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ForSemanticSegmentation)) : Sorties brutes du modèle. target_sizes (`list[tuple[int, int]]`, *facultatif*) : Liste de tuples correspondant à la taille finale demandée (hauteur, largeur) de chaque prédiction. return_segmentation_scores (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner les scores de segmentation en plus de la carte de segmentation. Si `True`, chaque élément de la liste retournée est un `SemanticSegmentationPostProcessorOutput` avec les champs `segmentation` (identifiants de classes, forme `(height, width)`) et `segmentation_scores` (forme `(num_classes, height, width)`). **Retourne :** `list[torch.Tensor]` ou `list[SemanticSegmentationPostProcessorOutput]` Lorsque `return_segmentation_scores=False` (par défaut), une liste de longueur `batch_size` où chaque élément est une carte de segmentation de forme `(height, width)` avec des identifiants de classes. Lorsque `return_segmentation_scores=True`, une liste de `SemanticSegmentationPostProcessorOutput` avec les champs `segmentation` (identifiants de classes, forme `(height, width)`) et `segmentation_scores` (forme `(num_classes, height, width)`). Dans les deux cas, `(height, width)` correspond à la taille cible (si `target_sizes` est spécifiée). Convertit la sortie de [MobileNetV2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ForSemanticSegmentation) en cartes de segmentation sémantique. ## MobileNetV2Model[[transformers.MobileNetV2Model]] #### transformers.MobileNetV2Model[[transformers.MobileNetV2Model]] ```python transformers.MobileNetV2Model(config: MobileNetV2Config, add_pooling_layer: bool = True) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py#L260) **Paramètres :** config ([MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. add_pooling_layer (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ajouter une couche de pooling Le modèle Mobilenet V2 brut, qui produit des états cachés bruts sans aucune tête spécifique au sommet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MobileNetV2Model.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py#L325) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor). Voir [MobileNetV2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor) pour le traitement des images). output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** `BaseModelOutputWithPoolingAndNoAttention` ou `tuple(torch.Tensor)` Un `BaseModelOutputWithPoolingAndNoAttention` ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments en fonction de la configuration ([MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config)) et des entrées. La méthode forward du modèle [MobileNetV2Model](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Model) surcharge la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **last_hidden_state** (`torch.Tensor` de forme `(batch_size, num_channels, height, width)`) -- Séquence d'états cachés à la sortie de la dernière couche du modèle. - **pooler_output** (`torch.Tensor` de forme `(batch_size, hidden_size)`) -- État caché de la dernière couche après une opération de pooling sur les dimensions spatiales. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, num_channels, height, width)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. Exemple : ```python ``` ## MobileNetV2ForImageClassification[[transformers.MobileNetV2ForImageClassification]] #### transformers.MobileNetV2ForImageClassification[[transformers.MobileNetV2ForImageClassification]] ```python transformers.MobileNetV2ForImageClassification(config: MobileNetV2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py#L374) **Paramètres :** config ([MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle MobileNetV2 avec une tête de classification d’images au sommet (une couche linéaire au-dessus des fonctionnalités agrégées), par exemple pour ImageNet. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MobileNetV2ForImageClassification.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, labels: typing.Optional[torch.Tensor] = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py#L390) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor). Voir [MobileNetV2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor) pour le traitement des images). output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. labels (`torch.LongTensor` de forme `(batch_size,)`, *facultatif*) : Étiquettes pour le calcul de la perte de classification/régression d'image. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. Si `config.num_labels == 1`, une perte de régression est calculée (perte quadratique moyenne). Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée). return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [ImageClassifierOutputWithNoAttention](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) ou `tuple(torch.Tensor)` Un [ImageClassifierOutputWithNoAttention](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.ImageClassifierOutputWithNoAttention) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config)) et les entrées. La méthode forward de [MobileNetV2ForImageClassification](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ForImageClassification) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1). - **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels)`) -- Scores de classification (ou de régression si config.num_labels==1) (avant SoftMax). - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d’embedding, + un pour la sortie de chaque étape) de forme `(batch_size, num_channels, height, width)`. États cachés (également appelés cartes de caractéristiques) du modèle à la sortie de chaque étape. Exemple : ```python >>> from transformers import AutoImageProcessor, MobileNetV2ForImageClassification >>> import torch >>> from datasets import load_dataset >>> dataset = load_dataset("huggingface/cats-image") >>> image = dataset["test"]["image"][0] >>> image_processor = AutoImageProcessor.from_pretrained("google/mobilenet_v2_1.0_224") >>> model = MobileNetV2ForImageClassification.from_pretrained("google/mobilenet_v2_1.0_224") >>> inputs = image_processor(image, return_tensors="pt") >>> with torch.no_grad(): ... logits = model(**inputs).logits >>> # model predicts one of the 1000 ImageNet classes >>> predicted_label = logits.argmax(-1).item() >>> print(model.config.id2label[predicted_label]) ... ``` ## MobileNetV2ForSemanticSegmentation[[transformers.MobileNetV2ForSemanticSegmentation]] #### transformers.MobileNetV2ForSemanticSegmentation[[transformers.MobileNetV2ForSemanticSegmentation]] ```python transformers.MobileNetV2ForSemanticSegmentation(config: MobileNetV2Config) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py#L508) **Paramètres :** config ([MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config)) : Classe de configuration du modèle contenant tous les paramètres du modèle. L’initialisation à partir d’un fichier de configuration ne charge pas les poids associés au modèle, uniquement la configuration. Consultez la méthode [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained) pour charger les poids du modèle. Modèle MobileNetV2 avec une tête de segmentation sémantique au sommet, par exemple pour Pascal VOC. Ce modèle hérite de [PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel). Consultez la documentation de la classe parente pour les méthodes génériques que la bibliothèque implémente pour tous ses modèles (tels que le téléchargement ou l'enregistrement, le redimensionnement des embeddings d'entrée, l'élagage des têtes, etc.). Ce modèle est également une sous-classe de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Utilisez-le comme un module PyTorch standard et consultez la documentation de PyTorch pour tout ce qui concerne l’utilisation et le comportement généraux. #### forward[[transformers.MobileNetV2ForSemanticSegmentation.forward]] ```python forward(pixel_values: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs) ``` [Source](https://github.com/huggingface/transformers/blob/main/src/transformers/models/mobilenet_v2/modeling_mobilenet_v2.py#L519) **Paramètres :** pixel_values (`torch.Tensor` de forme `(batch_size, num_channels, image_size, image_size)`, *facultatif*) : Les tenseurs correspondant aux images d'entrée. Les valeurs des pixels peuvent être obtenues à l'aide de [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor). Voir [MobileNetV2ImageProcessor.__call__()](/docs/transformers/main/fr/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) pour plus de détails (`processor_class` utilise [MobileNetV2ImageProcessor](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ImageProcessor) pour le traitement des images). labels (`torch.LongTensor` de forme `(batch_size, height, width)`, *facultatif*) : Cartes de segmentation sémantique de référence pour le calcul de la perte. Les indices doivent être dans `[0, ..., config.num_labels - 1]`. Si `config.num_labels > 1`, une perte de classification est calculée (entropie croisée). output_hidden_states (`bool`, *facultatif*) : Indique s'il faut retourner les états cachés de toutes les couches. Voir `hidden_states` dans les tenseurs retournés pour plus de détails. return_dict (`bool`, *facultatif*) : Indique s'il faut retourner un [ModelOutput](/docs/transformers/main/fr/main_classes/output#transformers.utils.ModelOutput) plutôt qu'un simple tuple. **Retourne :** [SemanticSegmenterOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) ou `tuple(torch.Tensor)` Un [SemanticSegmenterOutput](/docs/transformers/main/fr/main_classes/output#transformers.modeling_outputs.SemanticSegmenterOutput) ou un tuple de `torch.Tensor` (si `return_dict=False` est passé ou lorsque `config.return_dict=False`) comprenant divers éléments selon la configuration ([MobileNetV2Config](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2Config)) et les entrées. La méthode forward de [MobileNetV2ForSemanticSegmentation](/docs/transformers/main/fr/model_doc/mobilenet_v2#transformers.MobileNetV2ForSemanticSegmentation) redéfinit la méthode spéciale `__call__`. Bien que la recette de la passe avant doive être définie dans cette fonction, il faut ensuite appeler l'instance `Module` plutôt que celle-ci, car la première gère l'exécution des étapes de prétraitement et de post-traitement, tandis que la seconde les ignore silencieusement. - **loss** (`torch.Tensor` de forme `(1,)`, *facultatif*, renvoyé lorsque `labels` est fourni) -- Perte de classification (ou de régression si config.num_labels==1). - **logits** (`torch.Tensor` de forme `(batch_size, config.num_labels, logits_height, logits_width)`) -- Scores de classification pour chaque pixel. Les logits retournés n'ont pas nécessairement la même taille que les `pixel_values` passés en entrée. Cela permet d'éviter de réaliser deux interpolations et de perdre en qualité lorsqu'un utilisateur doit redimensionner les logits à la taille de l'image d'origine en post-traitement. Vous devez toujours vérifier la forme de vos logits et les redimensionner au besoin. - **hidden_states** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_hidden_states=True` est passé ou lorsque `config.output_hidden_states=True`) -- Tuple de `torch.Tensor` (un pour la sortie des embeddings, si le modèle possède une couche d'embedding, + un pour la sortie de chaque couche) de forme `(batch_size, patch_size, hidden_size)`. États cachés du modèle à la sortie de chaque couche, ainsi que les sorties d'incorporation initiales facultatives. - **attentions** (`tuple(torch.Tensor)`, *facultatif*, renvoyé lorsque `output_attentions=True` est passé ou lorsque `config.output_attentions=True`) -- Tuple de `torch.Tensor` (un par couche) de forme `(batch_size, num_heads, patch_size, sequence_length)`. Pondérations des attentions après le softmax d'attention, utilisées pour calculer la moyenne pondérée dans les têtes d'auto-attention. Exemples : ```python >>> from transformers import AutoImageProcessor, MobileNetV2ForSemanticSegmentation >>> from PIL import Image >>> from huggingface_hub.utils import httpx >>> from io import BytesIO >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg" >>> with httpx.stream("GET", url) as response: ... image = Image.open(BytesIO(response.read())) >>> image_processor = AutoImageProcessor.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513") >>> model = MobileNetV2ForSemanticSegmentation.from_pretrained("google/deeplabv3_mobilenet_v2_1.0_513") >>> inputs = image_processor(images=image, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> # logits are of shape (batch_size, num_labels, height, width) >>> logits = outputs.logits ```