Transformers documentation
LightOnOcr
Ce modèle a été contribué à Hugging Face Transformers le 2026-01-14.
LightOnOcr
LightOnOcr est un modèle compact de vision-langage de bout en bout destiné à la reconnaissance optique de caractères (OCR) et à la compréhension de documents. Il atteint une précision de pointe dans sa catégorie de poids, tout en étant plusieurs fois plus rapide et moins coûteux que les VLM généralistes plus volumineux.
📝 Lire le billet de blog complet | 📓 Carnet de finetuning
Aperçu du modèle
LightOnOcr combine un encodeur Vision Transformer (basé sur Pixtral) avec un décodeur de texte léger (basé sur Qwen3) distillé à partir de VLM ouverts de haute qualité. Il est optimisé pour les tâches d’analyse de documents, produisant une extraction de texte précise et sensible à la mise en page à partir de pages haute résolution.
Utilisation
from transformers import LightOnOcrForConditionalGeneration, LightOnOcrProcessor
model = LightOnOcrForConditionalGeneration.from_pretrained("lightonai/LightOnOCR-1B-1025", device_map="auto")
processor = LightOnOcrProcessor.from_pretrained("lightonai/LightOnOCR-1B-1025")
url = "https://huggingface.co/datasets/hf-internal-testing/fixtures_ocr/resolve/main/SROIE-receipt.jpeg"
conversation = [{"role": "user", "content": [{"type": "image", "url": url}]}]
inputs = processor.apply_chat_template(
conversation,
add_generation_prompt=True,
tokenize=True,
return_dict=True,
return_tensors="pt",
).to(model.device)
output_ids = model.generate(**inputs, max_new_tokens=1024)
generated_ids = output_ids[0, inputs["input_ids"].shape[1] :]
output_text = processor.decode(generated_ids, skip_special_tokens=True)
print(output_text)LightOnOcrConfig
classe transformers.LightOnOcrConfig
< 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 = Nonespatial_merge_size: int = 2image_token_id: int = 151655tie_word_embeddings: bool = Truevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )
Paramètres
- spatial_merge_size (
int, facultatif, par défaut2) — La taille de la fenêtre de fusion spatiale utilisée pour réduire le nombre de jetons visuels en fusionnant les patches voisins. - image_token_id (
int, facultatif, par défaut151655) — 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. - vision_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone visuel. - text_config (
Union[dict, ~configuration_utils.PreTrainedConfig], facultatif) — L'objet de configuration ou le dictionnaire du backbone de texte.
Ceci est la classe de configuration destinée à stocker la configuration d'un LightOnOcrModel. Elle est utilisée pour instancier un modèle Lighton Ocr 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 du lightonai/LightOnOCR-1B-1025
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 LightOnOcrConfig, LightOnOcrForConditionalGeneration
>>> # Initializing a LightOnOcr configuration
>>> configuration = LightOnOcrConfig()
>>> # Initializing a model from the configuration
>>> model = LightOnOcrForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLightOnOcrProcessor
classe transformers.LightOnOcrProcessor
< source >( image_processor = Nonetokenizer = Nonepatch_size: int = 14spatial_merge_size: int = 2chat_template = None**kwargs )
__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.
LightOnOcrModel
classe transformers.LightOnOcrModel
< source >( config: LightOnOcrConfig )
Paramètres
- config (LightOnOcrConfig) — 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 modèle LightOnOcr, qui se compose d'un backbone visuel et d'un modèle de langage, sans tête de modélisation du langage.
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.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneuse_cache: bool | None = Noneimage_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LightOnOcrModelOutputWithPast or tuple(torch.FloatTensor)
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.FloatTensorde 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 PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (LightOnOcrProcessor utilise PixtralImageProcessor 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.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - 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.FloatTensorde 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). - image_sizes (
torch.Tensorde forme(batch_size, 2), facultatif) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], facultatif) — Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (pooler_output, facultatif :last_hidden_states, facultatif :hidden_states, facultatif :attentions)pooler_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
LightOnOcrModelOutputWithPast ou tuple(torch.FloatTensor)
Un LightOnOcrModelOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LightOnOcrConfig) et des entrées.
La méthode forward du modèle LightOnOcrModel 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.FloatTensorde forme(batch_size, sequence_length, hidden_size)) — Séquence d'états cachés à la sortie de la dernière couche 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 (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. 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) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple(torch.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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.
image_hidden_states (
torch.FloatTensor, facultatif) — Untorch.FloatTensorde taille(batch_size, num_images, sequence_length, 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: Tensorimage_sizes: typing.Union[torch.Tensor, list]**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
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 PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (LightOnOcrProcessor utilise PixtralImageProcessor pour le traitement des images). - image_sizes (
Union[torch.Tensor, list]de forme(batch_size, 2)) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
Retourne
BaseModelOutputWithPooling ou tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LightOnOcrConfig) et des entrées.
last_hidden_state (
torch.FloatTensorde 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.FloatTensorde 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 à travers 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.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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.
LightOnOcrForConditionalGeneration
classe transformers.LightOnOcrForConditionalGeneration
< source >( config: LightOnOcrConfig )
Paramètres
- config (LightOnOcrConfig) — 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 modèle LIGHTON_OCR, qui se compose d'un backbone visuel et d'un modèle de langage.
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.FloatTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0image_sizes: typing.Optional[torch.Tensor] = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → LightOnOcrCausalLMOutputWithPast or tuple(torch.FloatTensor)
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.FloatTensorde 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 PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (LightOnOcrProcessor utilise PixtralImageProcessor 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.
- position_ids (
torch.LongTensorde forme(batch_size, sequence_length), facultatif) — Indices des positions des jetons de chaque séquence d'entrée dans les embeddings de position. Sélectionnés dans l'intervalle[0, config.n_positions - 1]. - 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.FloatTensorde 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. - 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). - image_sizes (
torch.Tensorde forme(batch_size, 2), facultatif) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image. - mm_encoder_outputs (
dict[str, ~modeling_outputs.BaseModelOutputWithPooling], facultatif) — Dictionnaire dont les clés sont les modalités prises en charge et les valeurs sont les sorties encodées pour cette modalité. Chaque sortie encodée est un tuple composé de (pooler_output, facultatif :last_hidden_states, facultatif :hidden_states, facultatif :attentions)pooler_outputde forme(batch_size, sequence_length, hidden_size), facultatif) est une séquence de fonctions multimodales de l'encodeur fusionnées dans les embeddings de texte.
Retourne
LightOnOcrCausalLMOutputWithPast ou tuple(torch.FloatTensor)
Un LightOnOcrCausalLMOutputWithPast ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LightOnOcrConfig) et des entrées.
La méthode forward de LightOnOcrForConditionalGeneration 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.FloatTensorde forme(1,), facultatif, renvoyé lorsquelabelsest fourni) — Perte de modélisation du langage (pour la prédiction du jeton suivant).logits (
torch.FloatTensorde 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 (
Cache, facultatif, renvoyé lorsqueuse_cache=Trueest passé ou lorsqueconfig.use_cache=True) — Il s’agit d’une instance de Cache. 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) qui peuvent être utilisés (voir l'entrée
past_key_values) pour accélérer le décodage séquentiel.hidden_states (
tuple[torch.FloatTensor], facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor], facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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.
image_hidden_states (
torch.FloatTensor, facultatif) — Untorch.FloatTensorde taille(batch_size, num_images, sequence_length, 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, LightOnOcrForConditionalGeneration
>>> model = LightOnOcrForConditionalGeneration.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> processor = AutoProcessor.from_pretrained("mistralai/Mistral-Small-3.1-24B-Instruct-2503")
>>> prompt = "<s>[INST][IMG]What is the image?[/INST]"
>>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
>>> with httpx.stream("GET", url) as response:
... image = Image.open(BytesIO(response.read()))
>>> inputs = processor(images=image, text=prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=15)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"What is the image?The image depicts two cats lying on a pink blanket."get_image_features
< source >( pixel_values: FloatTensorimage_sizes: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.FloatTensor)
Paramètres
- pixel_values (
torch.FloatTensorde 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 PixtralImageProcessor. Voir PixtralImageProcessor.call() pour plus de détails (LightOnOcrProcessor utilise PixtralImageProcessor pour le traitement des images). - image_sizes (
torch.Tensorde forme(batch_size, 2)) — Les dimensions des images du lot, sous la forme (hauteur, largeur) pour chaque image.
Retourne
BaseModelOutputWithPooling ou tuple(torch.FloatTensor)
Un BaseModelOutputWithPooling ou un tuple de
torch.FloatTensor (si return_dict=False est passé ou lorsque config.return_dict=False) comprenant divers
éléments en fonction de la configuration (LightOnOcrConfig) et des entrées.
last_hidden_state (
torch.FloatTensorde 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.FloatTensorde 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 à travers 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.FloatTensor), facultatif, renvoyé lorsqueoutput_hidden_states=Trueest passé ou lorsqueconfig.output_hidden_states=True) — Tuple detorch.FloatTensor(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.FloatTensor), facultatif, renvoyé lorsqueoutput_attentions=Trueest passé ou lorsqueconfig.output_attentions=True) — Tuple detorch.FloatTensor(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, LightOnOcrForConditionalGeneration
>>> model = LightOnOcrForConditionalGeneration.from_pretrained("lightonai/LightOnOCR-1B-1025")
>>> processor = AutoProcessor.from_pretrained("lightonai/LightOnOCR-1B-1025")
>>> 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]