Transformers documentation
Florence-2
Ce modèle a été publié dans HF papers le 2023-11-10 et ajouté à Hugging Face Transformers le 2025-08-20.
Florence-2
Aperçu
Florence-2 est un modèle de vision avancé qui utilise une approche basée sur des invites pour traiter une large gamme de tâches de vision et de vision-langage. Florence-2 peut interpréter des invites textuelles simples pour effectuer des tâches telles que la légendation, la détection d'objets et la segmentation. Il exploite le jeu de données FLD-5B, contenant 5,4 milliards d'annotations sur 126 millions d'images, pour maîtriser l'apprentissage multi-tâches. L'architecture séquence-à-séquence du modèle lui permet d'exceller aussi bien en configuration zéro-shot qu'en configuration affinée, prouvant ainsi qu'il s'agit d'un modèle de vision de base compétitif.
Vous pouvez trouver tous les points de contrôle originaux de Florence-2 dans la collection Florence-2.
Ce modèle a été contribué par ducviet00. Cliquez sur les modèles Florence-2 dans la barre latérale droite pour plus d’exemples sur la façon d’appliquer Florence-2 à différentes tâches de vision et de langage.
L'exemple ci-dessous montre comment effectuer la détection d'objets avec Pipeline ou la classe AutoModel.
from transformers import pipeline
pipeline = pipeline(
"image-text-to-text",
model="florence-community/Florence-2-base",
device=0,
)
pipeline(
"https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true",
text="<OD>"
)import requests
from PIL import Image
from transformers import AutoProcessor, Florence2ForConditionalGeneration
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true"
image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-base", device_map="auto")
processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base")
task_prompt = "<OD>"
inputs = processor(text=task_prompt, images=image, return_tensors="pt").to(model.device)
generated_ids = model.generate(
**inputs,
max_new_tokens=1024,
num_beams=3,
)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
image_size = image.size
parsed_answer = processor.post_process_generation(generated_text, task=task_prompt, image_size=image_size)
print(parsed_answer)La quantification réduit la charge mémoire des grands modèles en représentant les poids avec une précision inférieure. Reportez-vous à l'aperçu de la Quantization pour plus d'informations sur les backends de quantification disponibles.
L'exemple ci-dessous utilise bitsandbytes pour quantifier le modèle en 4 bits.
# pip install bitsandbytes
import requests
import torch
from PIL import Image
from transformers import AutoProcessor, BitsAndBytesConfig, Florence2ForConditionalGeneration
quantization_config = BitsAndBytesConfig(load_in_4bit=True)
model = Florence2ForConditionalGeneration.from_pretrained(
"florence-community/Florence-2-base",
device_map="auto",
quantization_config=quantization_config
)
processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base")
url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg?download=true"
image = Image.open(requests.get(url, stream=True).raw).convert("RGB")
task_prompt = "<OD>"
inputs = processor(text=task_prompt, images=image, return_tensors="pt").to(model.device, torch.bfloat16)
generated_ids = model.generate(
**inputs,
max_new_tokens=1024,
num_beams=3,
)
generated_text = processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
image_size = image.size
parsed_answer = processor.post_process_generation(generated_text, task=task_prompt, image_size=image_size)
print(parsed_answer)Notes
- Florence-2 est un modèle basé sur des invites (prompts). Vous devez fournir une invite de tâche pour indiquer au modèle ce qu'il doit faire. Les tâches prises en charge sont les suivantes :
<OCR><OCR_WITH_REGION><CAPTION><DETAILED_CAPTION><MORE_DETAILED_CAPTION><OD><DENSE_REGION_CAPTION><CAPTION_TO_PHRASE_GROUNDING><REFERRING_EXPRESSION_SEGMENTATION><REGION_TO_SEGMENTATION><OPEN_VOCABULARY_DETECTION><REGION_TO_CATEGORY><REGION_TO_DESCRIPTION><REGION_TO_OCR><REGION_PROPOSAL>
- La sortie brute du modèle est une chaîne de caractères qui doit être analysée. Le Florence2Processor dispose d'une méthode
post_process_generation()qui permet d'analyser la chaîne pour la convertir dans un format plus exploitable, comme des boîtes englobantes et des étiquettes pour la détection d'objets.
Ressources
- Rapport technique de Florence-2
- Carnet Jupyter pour l'inférence et la visualisation du modèle Florence-2-large
Florence2VisionConfig
classe transformers.Florence2VisionConfig
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonein_channels: int = 3depths: list[int] | tuple[int, ...] = (1, 1, 9, 1)patch_size: list[int] | tuple[int, ...] = (7, 3, 3, 3)patch_stride: list[int] | tuple[int, ...] = (4, 2, 2, 2)patch_padding: list[int] | tuple[int, ...] = (3, 1, 1, 1)patch_prenorm: list[bool] | tuple[bool, ...] = (False, True, True, True)embed_dim: list[int] | tuple[int, ...] = (128, 256, 512, 1024)num_heads: list[int] | tuple[int, ...] = (4, 8, 16, 32)num_groups: list[int] | tuple[int, ...] = (4, 8, 16, 32)window_size: int = 12drop_path_rate: float | int = 0.1mlp_ratio: float = 4.0qkv_bias: bool = Trueactivation_function: str = 'gelu'projection_dim: int = 1024max_temporal_embeddings: int = 100max_position_embeddings: int = 50initializer_range: float = 0.02 )
Paramètres
- in_channels (
int, facultatif, par défaut3) — Le nombre de canaux d'entrée. - depths (
Tuple[int], facultatif, par défaut(1, 1, 9, 1)) — La profondeur du modèle. - patch_size (
Union[list[int], tuple[int, ...]], facultatif, par défaut(7, 3, 3, 3)) — La taille (résolution) de chaque patch. - patch_stride (
Tuple[int], facultatif, par défaut(4, 2, 2, 2)) — Le pas de patch de l'image. - patch_padding (
Tuple[int], facultatif, par défaut(3, 1, 1, 1)) — Le padding des patches de l'image. - patch_prenorm (
Tuple[bool], facultatif, par défaut(False, True, True, True)) — Indique s'il faut appliquer la normalisation de couche avant la couche d'incorporation de patch. - embed_dim (
Union[list[int], tuple[int, ...]], facultatif, par défaut(128, 256, 512, 1024)) — Dimension des embeddings et des états cachés. - num_heads (
Union[list[int], tuple[int, ...]], facultatif, par défaut(4, 8, 16, 32)) — Nombre de têtes d'attention pour chaque couche d'attention du décodeur Transformer. - num_groups (
Tuple[int], facultatif, par défaut(4, 8, 16, 32)) — Le nombre de groupes. - window_size (
int, facultatif, valeur par défaut 12) — La taille de la fenêtre du modèle. - drop_path_rate (
Union[float, int], facultatif, par défaut0.1) — Taux de drop path pour la fusion des patches. - mlp_ratio (
float, facultatif, par défaut4.0) — Ratio de la dimension cachée du MLP par rapport à la dimension d'embedding. - qkv_bias (
bool, facultatif, par défautTrue) — Indique s'il faut ajouter un biais aux requêtes, clés et valeurs. - activation_function (
str, facultatif, par défautgelu) — La fonction d'activation non linéaire (fonction ou chaîne de caractères) du décodeur. Par exemple,"gelu","relu","silu", etc. - projection_dim (
int, facultatif, par défaut1024) — Dimension des couches de projection du texte et de la vision. - max_temporal_embeddings (
int, facultatif, valeur par défaut 100) — La configuration de l'intégration temporelle visuelle. - max_position_embeddings (
int, facultatif, par défaut50) — La longueur de séquence maximale avec laquelle ce modèle pourrait être utilisé. - initializer_range (
float, facultatif, par défaut0.02) — L'écart-type de la truncated_normal_initializer utilisé pour initialiser toutes les matrices de poids.
Ceci est la classe de configuration destinée à stocker la configuration d'un Florence2Model. Elle est utilisée pour instancier un modèle Florence2 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de florence-community/Florence-2-base
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> from transformers import Florence2VisionConfig, Florence2VisionModel
>>> # Initializing a Florence2 Vision style configuration
>>> configuration = Florence2VisionConfig()
>>> # Initializing a model (with random weights)
>>> model = Florence2VisionModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configFlorence2Config
classe transformers.Florence2Config
< source >( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 51289tie_word_embeddings: bool = True )
Paramètres
- is_encoder_decoder (
bool, facultatif, valeur par défautTrue) — Indique si le modèle est utilisé comme encodeur/décodeur ou non. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte. - vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone visuel. - image_token_id (
int, facultatif, par défaut51289) — L’index du jeton d’image utilisé comme espace réservé pour les images d’entrée. - tie_word_embeddings (
bool, facultatif, par défautTrue) — Indique s'il faut lier les embeddings de poids selon la correspondancetied_weights_keysdu modèle.
Ceci est la classe de configuration destinée à stocker la configuration d'un Florence2Model. Elle est utilisée pour instancier un modèle Florence2 en fonction des arguments spécifiés, définissant ainsi l'architecture du modèle. L'instanciation d'une configuration avec les valeurs par défaut produira une configuration similaire à celle de florence-community/Florence-2-base
Les objets de configuration héritent de PreTrainedConfig et peuvent être utilisés pour contrôler les sorties du modèle. Consultez la documentation de PreTrainedConfig pour plus d’informations.
Exemple :
>>> from transformers import Florence2ForConditionalGeneration, Florence2Config, CLIPVisionConfig, BartConfig
>>> # Initializing a clip-like vision config
>>> vision_config = CLIPVisionConfig()
>>> # Initializing a Bart config
>>> text_config = BartConfig()
>>> # Initializing a Florence-2 configuration
>>> configuration = Florence2Config(vision_config, text_config)
>>> # Initializing a model from the florence-2 configuration
>>> model = Florence2ForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configFlorence2Processor
classe transformers.Florence2Processor
< source >( image_processor = Nonetokenizer = Nonenum_additional_image_tokens: int = 0post_processor_config: dict | None = None**kwargs )
Paramètres
- image_processor (
CLIPImageProcessor) — Le processeur d’images est une entrée obligatoire. - tokenizer (
BartTokenizer) — Le tokenizer est une entrée obligatoire. - num_additional_image_tokens (
int, facultatif, valeur par défaut 0) — Nombre de jetons supplémentaires ajoutés aux embeddings d’image, tels que CLS (+1). Si le backbone n’ajoute pas de CLS ni d’autres jetons supplémentaires, il n’est pas nécessaire de définir cet argument. - post_processor_config (
dict, facultatif, valeur par défaut 0) — Règles d’analyse spécifiques à la tâche pourFlorence2PostProcessor, par exemple des motifs regex, des seuils ou des jetons interdits.
Construit un Florence2Processor qui encapsule un processeur d’images et un tokeniseur en un seul processeur.
Florence2Processor offre toutes les fonctionnalités de CLIPImageProcessor et de BartTokenizer. Consultez ~CLIPImageProcessor et ~BartTokenizer pour plus d’informations.
__call__
< source >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = Noneaudio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor'], NoneType] = None**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> )
Paramètres
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], facultatif) — Image à prétraiter. S'attend à une image unique ou à un lot d'images dont les valeurs de pixels vont de 0 à 255. Si vous passez des images dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - text (
Union[str, list[str], list[list[str]]], facultatif) — La séquence ou le lot de séquences à encoder. Chaque séquence peut être une chaîne de caractères ou une liste de chaînes de caractères (chaînes pré-tokenisées). Si vous passez une entrée pré-tokenisée, définissezis_split_into_words=Truepour éviter toute ambiguïté avec les entrées en lot. - videos (
Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], facultatif) — Vidéo à prétraiter. S’attend à une vidéo unique ou à un lot de vidéos dont les valeurs de pixels vont de 0 à 255. Si vous passez des vidéos dont les valeurs de pixels sont comprises entre 0 et 1, définissezdo_rescale=False. - audio (
Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]], facultatif) — L’audio ou le lot d’audios à préparer. Chaque audio peut être un tableau NumPy ou un tenseur PyTorch. Dans le cas d’un tableau NumPy/tenseur PyTorch, chaque audio doit avoir la forme (C, T), où C est le nombre de canaux et T est la longueur d’échantillonnage de l’audio. - return_tensors (
strou TensorType, facultatif) — Si défini, renvoie des tenseurs d'un framework particulier. Les valeurs acceptées sont :'pt': Renvoie des objetstorch.Tensorde PyTorch.'np': Renvoie des objets NumPynp.ndarray.
- **kwargs (ProcessingKwargs, facultatif) — Options de traitement supplémentaires pour chaque modalité (texte, images, vidéos, audio). Les paramètres spécifiques au modèle sont répertoriés ci-dessus ; consultez la classe TypedDict pour la liste complète des arguments pris en charge.
Florence2Model
classe transformers.Florence2Model
< source >( config: Florence2Config )
Paramètres
- config (Florence2Config) — 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() pour charger les poids du modèle.
Florence-2 est un modèle de vision pour la légende, la détection et la segmentation.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_outputs: list[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs ) → Florence2Seq2SeqModelOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de CLIPImageProcessor. Voir CLIPImageProcessor.call() pour plus de détails (Florence2Processor utilise CLIPImageProcessor pour le traitement des images). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder que les entrées précédentes pour prédire le futur. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - encoder_outputs (
list[torch.Tensor], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values).
Retourne
Florence2Seq2SeqModelOutput ou tuple(torch.Tensor)
Un Florence2Seq2SeqModelOutput 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 (Florence2Config) et des entrées.
La méthode forward du modèle Florence2Model 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
Moduleplutô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.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du décodeur du modèle.Si
past_key_valuesest utilisé, seule la dernière hidden-state des séquences de forme(batch_size, 1, hidden_size)est renvoyée.past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties d'incorporation initiale facultatives.
decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties d'incorporation initiales facultatives.
encoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
image_hidden_states (
torch.Tensor, facultatif) — Untorch.Tensorde taille(batch_size, num_image_tokens, hidden_size). image_hidden_states du modèle produit par l’encodeur visuel et après projection de l’état caché final.
get_image_features
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, channels, height, width)) — Les tenseurs correspondant aux images d'entrée.
Retourne
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Un BaseModelOutputWithPooling 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 (Florence2Config) et des entrées.
Obtient les derniers états cachés de l'image depuis la tour de vision et applique la projection multimodale.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.pooler_output (
torch.Tensorde forme(batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, sequence_length, 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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Florence2ForConditionalGeneration
classe transformers.Florence2ForConditionalGeneration
< source >( config: Florence2Config )
Paramètres
- config (Florence2Config) — 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() pour charger les poids du modèle.
Florence-2 est un modèle de vision pour la légende, la détection et la segmentation.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: list[torch.Tensor] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Florence2Seq2SeqLMOutput or tuple(torch.Tensor)
Paramètres
- input_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des jetons de la séquence d'entrée dans le vocabulaire. Le bourrage (padding) sera ignoré par défaut.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size), facultatif) — Les tenseurs correspondant aux images d’entrée. Les valeurs de pixels peuvent être obtenues à l’aide de CLIPImageProcessor. Voir CLIPImageProcessor.call() pour plus de détails (Florence2Processor utilise CLIPImageProcessor pour le traitement des images). - attention_mask (
torch.Tensorde forme(batch_size, sequence_length), facultatif) — Masque pour éviter d'appliquer l'attention aux indices des jetons de bourrage. Les valeurs du masque sont choisies dans[0, 1]:- 1 pour les jetons qui ne sont pas masqués,
- 0 pour les jetons masqués.
- decoder_input_ids (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Indices des jetons de la séquence d'entrée du décodeur dans le vocabulaire.Les indices peuvent être obtenus à l'aide de AutoTokenizer. Consultez PreTrainedTokenizer.encode() et PreTrainedTokenizer.call() pour plus de détails.
- decoder_attention_mask (
torch.LongTensorde forme(batch_size, target_sequence_length), facultatif) — Masque pour éviter d’effectuer l’attention sur certains indices de jetons. Par défaut, un masque causal est utilisé afin de s’assurer que le modèle ne peut regarder que les entrées précédentes pour prédire le futur. - encoder_outputs (
list[torch.Tensor], facultatif) — Le tuple est composé de (last_hidden_state, facultatif :hidden_states, facultatif :attentions)last_hidden_statede forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence d’états cachés à la sortie de la dernière couche de l’encodeur. Utilisé dans l’attention croisée du décodeur. - past_key_values (
~cache_utils.Cache, facultatif) — États cachés précalculés (clés et valeurs dans les blocs d'auto-attention et d'attention croisée) qui peuvent être utilisés pour accélérer le décodage séquentiel. Cela consiste généralement en lapast_key_valuesretournée par le modèle à une étape antérieure du décodage, lorsqueuse_cache=Trueouconfig.use_cache=True.Seule une instance de Cache est autorisée en entrée, consultez notre guide du cache kv. Si aucun
past_key_valuesn'est transmis, DynamicCache sera initialisé par défaut.Le modèle produira le même format de cache qui est fourni en entrée.
Si
past_key_valuessont utilisés, l’utilisateur doit fournir uniquement lesinput_idsnon traités (ceux pour lesquels les états de clés et de valeurs passées n’ont pas été fournis à ce modèle) de forme(batch_size, unprocessed_length)au lieu de tous lesinput_idsde forme(batch_size, sequence_length). - inputs_embeds (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerinput_ids, vous pouvez choisir de passer directement une représentation intégrée. Cela est utile si vous souhaitez un meilleur contrôle sur la manière de convertir les indicesinput_idsen vecteurs associés que la matrice de recherche d’intégration interne du modèle. - decoder_inputs_embeds (
torch.Tensorde forme(batch_size, target_sequence_length, hidden_size), facultatif) — Facultativement, au lieu de passerdecoder_input_idsvous pouvez choisir de passer directement une représentation intégrée. Sipast_key_valuesest utilisé, facultativement, seules les dernièresdecoder_inputs_embedsdoivent être entrées (voirpast_key_values). Cela est utile si vous souhaitez un meilleur contrôle sur la conversion desdecoder_input_idsindices en vecteurs associés que la matrice de recherche d'intégration interne du modèle.Si
decoder_input_idsetdecoder_inputs_embedssont tous deux non définis,decoder_inputs_embedsprend la valeur deinputs_embeds. - labels (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Étiquettes pour le calcul de la perte de modélisation de langage masquée. Les indices doivent être dans[0, ..., config.vocab_size]ou -100 (voir la docstring deinput_ids). Les jetons dont l'indice est défini sur-100sont ignorés (masqués), la perte n'est calculée que pour les jetons dont l'étiquette est dans[0, ..., config.vocab_size]. - use_cache (
bool, facultatif) — Si défini surTrue, les états clé-valeurpast_key_valuessont renvoyés et peuvent être utilisés pour accélérer le décodage (voirpast_key_values). - logits_to_keep (
Union[int, torch.Tensor], facultatif, valeur par défaut0) — Si c'est unint, calcule les logits pour leslogits_to_keepderniers jetons. Si0, calcule les logits pour tous lesinput_ids(cas particulier). Seuls les logits du dernier jeton sont nécessaires pour la génération, et les calculer uniquement pour ce jeton peut économiser de la mémoire, ce qui devient assez significatif pour les séquences longues ou les tailles de vocabulaire importantes. Si c'est untorch.Tensor, il doit être 1D et correspondre aux indices à conserver dans la dimension de la longueur de la séquence. Cela est utile lors de l'utilisation du format de tenseurs empilés (une seule dimension pour le lot et la longueur de la séquence).
Retourne
Florence2Seq2SeqLMOutput ou tuple(torch.Tensor)
Un Florence2Seq2SeqLMOutput ou un tuple de
torch.Tensor (si return_dict=False est passé ou si config.return_dict=False) comprenant divers
éléments en fonction de la configuration (Florence2Config) et des entrées.
La méthode forward de Florence2ForConditionalGeneration 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
Moduleplutô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.Tensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.Tensorde forme(batch_size, sequence_length, config.vocab_size)) — Scores de prédiction de la tête de modélisation du langage (scores pour chaque jeton du vocabulaire avant SoftMax).past_key_values (
EncoderDecoderCache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de EncoderDecoderCache. Pour plus de détails, consultez notre guide sur le cache kv.Contient des états cachés précalculés (clés et valeurs dans les blocs d'auto-attention et dans les blocs d'attention croisée) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.decoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, sequence_length, hidden_size).États cachés du décodeur à la sortie de chaque couche, plus les sorties de l'intégration initiale.
decoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
cross_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de la couche d'attention croisée du décodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'attention croisée.
encoder_last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size), facultatif) — Séquence d'états cachés à la sortie de la dernière couche de l'encodeur du modèle.encoder_hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, sequence_length, hidden_size).États cachés de l'encodeur à la sortie de chaque couche, plus les sorties des embeddings initiaux.
encoder_attentions (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids d'attention de l'encodeur, après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
image_hidden_states (
torch.Tensor, facultatif) — Untorch.Tensorde taille(batch_size, num_image_tokens, hidden_size). image_hidden_states du modèle produit par l’encodeur visuel et après projection de l’état caché final.
Exemple :
>>> from PIL import Image
>>> from huggingface_hub.utils import httpx
>>> from io import BytesIO
>>> from transformers import AutoProcessor, Florence2ForConditionalGeneration
>>> model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-large")
>>> processor = AutoProcessor.from_pretrained("florence-community/Florence-2-large")
>>> prompt = "<CAPTION>"
>>> url = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/car.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = processor(text=prompt, images=image, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(**inputs, max_length=100)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"A green car parked in front of a yellow building."get_image_features
< source >( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Paramètres
- pixel_values (
torch.Tensorde forme(batch_size, num_channels, image_size, image_size)) — Les tenseurs correspondant aux images d'entrée. Les valeurs de pixels peuvent être obtenues à l'aide de CLIPImageProcessor. Voir CLIPImageProcessor.call() pour plus de détails (Florence2Processor utilise CLIPImageProcessor pour le traitement des images).
Retourne
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Un BaseModelOutputWithPooling 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 (Florence2Config) et des entrées.
last_hidden_state (
torch.Tensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche du modèle.pooler_output (
torch.Tensorde forme(batch_size, hidden_size)) — État caché de la dernière couche du premier jeton de la séquence (jeton de classification) après un traitement supplémentaire par les couches utilisées pour la tâche de pré-entraînement auxiliaire. Par exemple, pour les modèles de la famille BERT, cela renvoie le jeton de classification après traitement par une couche linéaire et une fonction d'activation tanh. Les poids de la couche linéaire sont entraînés à partir de l'objectif de prédiction de la phrase suivante (classification) pendant le pré-entraînement.hidden_states (
tuple(torch.Tensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.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, sequence_length, 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é lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.Tensor(un par couche) de forme(batch_size, num_heads, sequence_length, sequence_length).Poids des attentions après le softmax d'attention, utilisés pour calculer la moyenne pondérée dans les têtes d'auto-attention.
Exemple :
>>> from PIL import Image
>>> from transformers import AutoProcessor, Florence2ForConditionalGeneration
>>> model = Florence2ForConditionalGeneration.from_pretrained("florence-community/Florence-2-base")
>>> processor = AutoProcessor.from_pretrained("florence-community/Florence-2-base")
>>> messages = [
... {
... "role": "user", "content": [
... {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
... {"type": "text", "text": "Where is the cat standing?"},
... ]
... },
... ]
>>> inputs = processor.apply_chat_template(
... messages,
... tokenize=True,
... return_dict=True,
... return_tensors="pt",
... add_generation_prompt=True
... )
>>> # Generate
>>> generate_ids = model.generate(**inputs)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True)[0]Florence2VisionBackbone
classe transformers.Florence2VisionBackbone
< source >( config: Florence2VisionConfig )
Paramètres
- config (Florence2VisionConfig) — 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() pour charger les poids du modèle.
Le backbone de Florence2.
Ce modèle hérite de 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, la taille des têtes, etc.)
Ce modèle est également une sous-classe de 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
< source >( hidden_states: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )