Transformers documentation
ModernVBert
Este modelo se publicó en HF papers el 2025-10-01 y se contribuyó a Hugging Face Transformers el 2026-02-23.
ModernVBert
Resumen
ModernVBert es un codificador de visión-lenguaje que combina ModernBert con un codificador de visión SigLIP. Está optimizado para tareas de comprensión y recuperación de documentos visuales.
El modelo fue introducido en ModernVBERT: Towards Smaller Visual Document Retrievers.
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from transformers import AutoModelForMaskedLM, AutoProcessor
processor = AutoProcessor.from_pretrained("./mvb")
model = AutoModelForMaskedLM.from_pretrained("./mvb", device_map="auto")
image = Image.open(hf_hub_download("HuggingFaceTB/SmolVLM", "example_images/rococo.jpg", repo_type="space"))
text = "This [MASK] is on the wall."
# Create input messages
messages = [
{
"role": "user",
"content": [
{"type": "image"},
{"type": "text", "text": text}
]
},
]
# Prepare inputs
prompt = processor.apply_chat_template(messages)
inputs = processor(text=prompt, images=[image], return_tensors="pt").to(model.device)
# Inference
with torch.no_grad():
outputs = model(**inputs)
# To get predictions for the mask:
masked_index = inputs["input_ids"][0].tolist().index(processor.tokenizer.mask_token_id)
predicted_token_id = outputs.logits[0, masked_index].argmax(axis=-1)
predicted_token = processor.tokenizer.decode(predicted_token_id)
print("Predicted token:", predicted_token) # Predicted token: paintingModernVBertConfig
clase transformers.ModernVBertConfig
< 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 = Nonetext_config: transformers.configuration_utils.PreTrainedConfig | dict | None = Nonevision_config: transformers.configuration_utils.PreTrainedConfig | dict | None = Noneimage_token_id: int = 50407pixel_shuffle_factor: int = 4initializer_range: float = 0.02initializer_cutoff_factor: float = 2.0classifier_pooling: typing.Literal['cls', 'mean'] = 'cls'classifier_dropout: float | int = 0.0classifier_bias: bool = Falsetie_word_embeddings: bool = False )
Parámetros
- text_config (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — El objeto de configuración o el diccionario del backbone de texto. - vision_config (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — El objeto de configuración o el diccionario del backbone de visión. - image_token_id (
int, opcional, valor predeterminado50407) — El índice del token de imagen utilizado como marcador de posición para las imágenes de entrada. - pixel_shuffle_factor (
int | None, opcional, valor predeterminado 4) — Factor de escala utilizado por cualquier operación de pixel-shuffle / aumento de resolución en la cabeza visual. - initializer_range (
float, opcional, valor predeterminado0.02) — La desviación estándar del truncated_normal_initializer para inicializar todas las matrices de pesos. - initializer_cutoff_factor (
float | None, opcional, valor predeterminado 2.0) — El factor de corte para el truncated_normal_initializer utilizado para inicializar todas las matrices de pesos. - classifier_pooling (
Literal["cls", "mean"], opcional, valor predeterminado"cls") — La estrategia de agrupación (pooling) a utilizar para tareas de clasificación. - classifier_dropout (
Union[float, int], opcional, valor predeterminado0.0) — La proporción de dropout para el clasificador. - classifier_bias (
bool | None, opcional, valor predeterminadoFalse) — Si se debe añadir un término de sesgo a la cabeza de clasificación - tie_word_embeddings (
bool, opcional, valor predeterminadoFalse) — Si se deben vincular las matrices de pesos de embeddings según el mapeotied_weights_keysdel modelo.
Esta es la clase de configuración para almacenar la configuración de un ModernVBertModel. Se utiliza para instanciar un modelo Modernvbert según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de ModernVBERT/modernvbert
Los objetos de configuración heredan de PreTrainedConfig y se pueden usar para controlar las salidas del modelo. Lea la documentación de PreTrainedConfig para obtener más información.
Ejemplo:
>>> from transformers import ModernVBertConfig
>>> # Initializing configuration
>>> configuration = ModernVBertConfig()
>>> # Initializing a model from the configuration (model class is implemented in
>>> # `modernvbert.modeling_modernvbert`)
>>> from transformers import ModernVBertModel
>>> model = ModernVBertModel(configuration)
>>> # Accessing the model configuration
>>> cfg = model.configModernVBertModel
clase transformers.ModernVBertModel
< source >( config: ModernVBertConfig )
Parámetros
- config (ModernVBertConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
ModernVBertModel es un modelo que combina un codificador de visión (SigLIP) y un codificador de texto (ModernBert).
ModernVBert es el modelo base del recuperador visual ColModernVBert y se introdujo en el siguiente artículo: ModernVBERT: Towards Smaller Visual Document Retrievers.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: LongTensor = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.BoolTensor] = Noneimage_hidden_states: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ModernVBertBaseModelOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizandoimage_processor_class. Consulteimage_processor_class.__call__para más detalles (Idefics3Processor utilizaimage_processor_classpara procesar las imágenes). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar realizar atención en los índices de píxeles de relleno. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los estados ocultos del codificador de imagen después de la proyección de modalidad.
Devuelve
ModernVBertBaseModelOutput o tuple(torch.Tensor)
Un ModernVBertBaseModelOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ModernVBertConfig) y las entradas.
Las entradas que se proporcionan al modelo pueden tener un número arbitrario de imágenes. Para tener esto en cuenta, los pixel_values que se pasan al modelo tienen relleno de imágenes -> (batch_size, max_num_images, 3, max_heights, max_widths), donde max_num_images es el número máximo de imágenes entre las batch_size muestras del lote. No se necesitan imágenes de relleno más allá de rellenar los pixel_values en la entrada del modelo. Por eficiencia, solo pasamos las imágenes reales a través del forward del vision_model descartando las imágenes de relleno, es decir, pixel_values de tamaño (image_batch_size, 3, height, width), donde image_batch_size sería 7 cuando num_images_per_sample=[1, 3, 1, 2] y max_num_images sería 3.
- last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Secuencia de estados ocultos en la salida de la última capa del modelo. Si se usapast_key_values, solo se devuelve el último estado oculto de las secuencias, de forma(batch_size, 1, hidden_size). - hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size). Estados ocultos del modelo en la salida de cada capa más las salidas de embedding iniciales opcionales. - attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. - image_hidden_states (
tuple(torch.Tensor), opcional) — Tupla detorch.Tensor(uno para la salida de las incrustaciones de imagen,(batch_size, num_images, sequence_length, hidden_size). image_hidden_states del modelo producido por el codificador de visión
ModernVBertForMaskedLM
clase transformers.ModernVBertForMaskedLM
< source >( config: ModernVBertConfig )
Parámetros
- config (ModernVBertConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo Modernvbert con una cabeza de language modeling en la parte superior.”
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: LongTensor = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.BoolTensor] = Noneimage_hidden_states: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ModernVBertMaskedLMOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizandoimage_processor_class. Consulteimage_processor_class.__call__para más detalles (Idefics3Processor utilizaimage_processor_classpara procesar las imágenes). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar realizar atención en los índices de píxeles de relleno. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los estados ocultos del codificador de imagen después de la proyección de modalidad. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., text_config.]o enmodel.image_token_id. Los tokens con índices establecidos enmodel.image_token_idse ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., text_config.].
Devuelve
ModernVBertMaskedLMOutput o tuple(torch.Tensor)
Un ModernVBertMaskedLMOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ModernVBertConfig) y las entradas.
Las entradas que se proporcionan al modelo pueden tener un número arbitrario de imágenes. Para tener esto en cuenta, los pixel_values que se pasan al modelo tienen relleno de imágenes -> (batch_size, max_num_images, 3, max_heights, max_widths), donde max_num_images es el número máximo de imágenes entre las batch_size muestras del lote. No se necesitan imágenes de relleno más allá de rellenar los pixel_values en la entrada del modelo. Por eficiencia, solo pasamos las imágenes reales a través del forward del vision_model descartando las imágenes de relleno, es decir, pixel_values de tamaño (image_batch_size, 3, height, width), donde image_batch_size sería 7 cuando num_images_per_sample=[1, 3, 1, 2] y max_num_images sería 3.
- loss (
torch.Tensor, opcional, se devuelve cuando se proporcionalabels) — Pérdida de modelado de lenguaje enmascarado (MLM). - logits (
torch.Tensor) — Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax). - hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de los embeddings, si el modelo tiene una capa de embedding, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size). Estados ocultos del modelo en la salida de cada capa más las salidas de embedding iniciales opcionales. - attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(uno por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length). Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención. - image_hidden_states (
tuple(torch.Tensor), opcional) — Tupla detorch.Tensor(uno para la salida de las incrustaciones de imagen,(batch_size, num_images, sequence_length, hidden_size). image_hidden_states del modelo producido por el codificador de visión
Ejemplo:
>>> from transformers import AutoTokenizer, ModernVBertForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("ModernVBERT/modernvbert")
>>> model = ModernVBertForMaskedLM.from_pretrained("ModernVBERT/modernvbert")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
...
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
...ModernVBertForSequenceClassification
clase transformers.ModernVBertForSequenceClassification
< source >( config: ModernVBertConfig )
Parámetros
- config (ModernVBertConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo ModernVBert con una cabeza de clasificación de secuencias en la parte superior que realiza pooling.
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: LongTensor = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.BoolTensor] = Noneimage_hidden_states: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → SequenceClassifierOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizandoimage_processor_class. Consulteimage_processor_class.__call__para más detalles (Idefics3Processor utilizaimage_processor_classpara procesar las imágenes). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar realizar atención en los índices de píxeles de relleno. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los estados ocultos del codificador de imagen después de la proyección de modalidad. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., text_config.]o enmodel.image_token_id. Los tokens con índices establecidos enmodel.image_token_idse ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., text_config.].
Devuelve
SequenceClassifierOutput o tuple(torch.Tensor)
Un SequenceClassifierOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ModernVBertConfig) y las entradas.
Las entradas que se proporcionan al modelo pueden tener un número arbitrario de imágenes. Para tener esto en cuenta, los pixel_values que se pasan al modelo tienen relleno de imágenes -> (batch_size, max_num_images, 3, max_heights, max_widths), donde max_num_images es el número máximo de imágenes entre las batch_size muestras del lote. No se necesitan imágenes de relleno más allá de rellenar los pixel_values en la entrada del modelo. Por eficiencia, solo pasamos las imágenes reales a través del forward del vision_model descartando las imágenes de relleno, es decir, pixel_values de tamaño (image_batch_size, 3, height, width), donde image_batch_size sería 7 cuando num_images_per_sample=[1, 3, 1, 2] y max_num_images sería 3.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación (o de regresión si config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Puntuaciones de clasificación (o de regresión si config.num_labels==1) (antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo de clasificación de una sola etiqueta:
>>> import torch
>>> from transformers import AutoTokenizer, ModernVBertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("ModernVBERT/modernvbert")
>>> model = ModernVBertForSequenceClassification.from_pretrained("ModernVBERT/modernvbert")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ModernVBertForSequenceClassification.from_pretrained("ModernVBERT/modernvbert", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...Ejemplo de clasificación multietiqueta:
>>> import torch
>>> from transformers import AutoTokenizer, ModernVBertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("ModernVBERT/modernvbert")
>>> model = ModernVBertForSequenceClassification.from_pretrained("ModernVBERT/modernvbert", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ModernVBertForSequenceClassification.from_pretrained(
... "ModernVBERT/modernvbert", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossModernVBertForTokenClassification
clase transformers.ModernVBertForTokenClassification
< source >( config: ModernVBertConfig )
Parámetros
- config (ModernVBertConfig) — Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método from_pretrained() para cargar los pesos del modelo.
El modelo ModernVBert con una cabeza de clasificación de tokens en la parte superior, por ejemplo, para tareas de reconocimiento de entidades nombradas (NER).
Este modelo hereda de PreTrainedModel. Consulta la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).
Este modelo también es una subclase de torch.nn.Module de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.
forward
< source >( input_ids: LongTensor = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_attention_mask: typing.Optional[torch.BoolTensor] = Noneimage_hidden_states: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → TokenClassifierOutput or tuple(torch.Tensor)
Parámetros
- input_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada.Los índices se pueden obtener usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() y PreTrainedTokenizer.call() para más detalles.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de máscara seleccionados en[0, 1]:- 1 para los tokens que no están enmascarados,
- 0 para los tokens que están enmascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de las posiciones de los tokens de cada secuencia de entrada en los embeddings de posición. Seleccionados en el rango[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, en lugar de pasarinput_ids, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices deinput_idsen los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Los tensores correspondientes a las imágenes de entrada. Los valores de píxeles se pueden obtener utilizandoimage_processor_class. Consulteimage_processor_class.__call__para más detalles (Idefics3Processor utilizaimage_processor_classpara procesar las imágenes). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar realizar atención en los índices de píxeles de relleno. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Los estados ocultos del codificador de imagen después de la proyección de modalidad. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en[0, ..., text_config.]o enmodel.image_token_id. Los tokens con índices establecidos enmodel.image_token_idse ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en[0, ..., text_config.].
Devuelve
TokenClassifierOutput o tuple(torch.Tensor)
Un TokenClassifierOutput o una tupla de
torch.Tensor (si se pasa return_dict=False o cuando config.return_dict=False) que comprende varios
elementos según la configuración (ModernVBertConfig) y las entradas.
Las entradas que se proporcionan al modelo pueden tener un número arbitrario de imágenes. Para tener esto en cuenta, los pixel_values que se pasan al modelo tienen relleno de imágenes -> (batch_size, max_num_images, 3, max_heights, max_widths), donde max_num_images es el número máximo de imágenes entre las batch_size muestras del lote. No se necesitan imágenes de relleno más allá de rellenar los pixel_values en la entrada del modelo. Por eficiencia, solo pasamos las imágenes reales a través del forward del vision_model descartando las imágenes de relleno, es decir, pixel_values de tamaño (image_batch_size, 3, height, width), donde image_batch_size sería 7 cuando num_images_per_sample=[1, 3, 1, 2] y max_num_images sería 3.
loss (
torch.Tensorde forma(1,), opcional, se devuelve cuando se proporcionalabels) — Pérdida de clasificación.logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Puntuaciones de clasificación (antes de SoftMax).hidden_states (
tuple(torch.Tensor), opcional, devuelto cuando se pasaoutput_hidden_states=Trueo cuandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(una para la salida de las incrustaciones, si el modelo tiene una capa de incrustaciones, + una para la salida de cada capa) de forma(batch_size, sequence_length, hidden_size).Estados ocultos del modelo en la salida de cada capa más las salidas opcionales de la incrustación inicial.
attentions (
tuple(torch.Tensor), opcional, se devuelve cuando se pasaoutput_attentions=Trueo cuandoconfig.output_attentions=True) — Tupla detorch.Tensor(una por cada capa) de forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atención tras el softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
Ejemplo:
>>> from transformers import AutoTokenizer, ModernVBertForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("ModernVBERT/modernvbert")
>>> model = ModernVBertForTokenClassification.from_pretrained("ModernVBERT/modernvbert")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...