Transformers documentation
ModernVBert
Este modelo foi publicado no HF papers em 2025-10-01 e contribuído para o Hugging Face Transformers em 2026-02-23.
ModernVBert
Visão geral
ModernVBert é um codificador de visão-linguagem que combina ModernBert com um codificador de visão SigLIP. Ele é otimizado para tarefas de compreensão e recuperação de documentos visuais.
O modelo foi introduzido em 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
classe 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) — O objeto de configuração ou dicionário do backbone de texto. - vision_config (
Union[~configuration_utils.PreTrainedConfig, dict], opcional) — O objeto de configuração ou dicionário do backbone de visão. - image_token_id (
int, opcional, padrão50407) — O índice do token de imagem usado como marcador de posição para as imagens de entrada. - pixel_shuffle_factor (
int | None, opcional, padrão 4) — Fator de escala usado por qualquer operação de pixel-shuffle / upsampling na cabeça de visão. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - initializer_cutoff_factor (
float | None, opcional, padrão 2.0) — Fator de corte para o truncated_normal_initializer usado na inicialização de todas as matrizes de pesos. - classifier_pooling (
Literal["cls", "mean"], opcional, padrão"cls") — A estratégia de pooling a ser usada para tarefas de classificação. - classifier_dropout (
Union[float, int], opcional, padrão0.0) — A taxa de dropout para o classificador. - classifier_bias (
bool | None, opcional, padrãoFalse) — Indica se um termo de viés deve ser adicionado à cabeça de classificação - tie_word_embeddings (
bool, opcional, padrãoFalse) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo.
Esta é a classe de configuração para armazenar a configuração de um ModernVBertModel. Ela é usada para instanciar um modelo Modernvbert de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do ModernVBERT/modernvbert
Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.
Exemplo:
>>> 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
classe transformers.ModernVBertModel
< source >( config: ModernVBertConfig )
Parâmetros
- config (ModernVBertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
ModernVBertModel é um modelo que combina um codificador de visão (SigLIP) e um codificador de texto (ModernBert).
ModernVBert é o modelo base do recuperador visual ColModernVBert e foi introduzido no seguinte artigo: ModernVBERT: Towards Smaller Visual Document Retrievers.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (Idefics3Processor usaimage_processor_classpara processar as imagens). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar a execução de atenção nos índices de pixels de preenchimento. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os estados ocultos do codificador de imagem após a projeção de modalidade.
Retorna
ModernVBertBaseModelOutput ou tuple(torch.Tensor)
Um ModernVBertBaseModelOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (ModernVBertConfig) e das entradas.
As entradas fornecidas ao modelo podem ter um número arbitrário de imagens. Para lidar com isso, os pixel_values fornecidos ao modelo possuem padding de imagens -> (batch_size, max_num_images, 3, max_heights, max_widths), onde max_num_images é o número máximo de imagens entre as batch_size amostras do lote. Imagens de padding não são necessárias além do padding dos pixel_values na entrada do modelo. Para eficiência, passamos apenas as imagens reais pelo forward do vision_model, descartando as imagens de padding, ou seja, pixel_values de tamanho (image_batch_size, 3, height, width), onde image_batch_size seria 7 quando num_images_per_sample=[1, 3, 1, 2] e max_num_images seria 3.
- last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de hidden-states na saída da última camada do modelo. Sepast_key_valuesfor usado, apenas o último hidden-state das sequências, de forma(batch_size, 1, hidden_size), é retornado. - hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma(batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. - attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com a forma(batch_size, num_heads, sequence_length, sequence_length). Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. - image_hidden_states (
tuple(torch.Tensor), opcional) — Tupla detorch.Tensor(um para a saída dos embeddings de imagem,(batch_size, num_images, sequence_length, hidden_size). image_hidden_states do modelo produzido pelo codificador de visão
ModernVBertForMaskedLM
classe transformers.ModernVBertForMaskedLM
< source >( config: ModernVBertConfig )
Parâmetros
- config (ModernVBertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo Modernvbert com uma cabeça de language modeling no topo.”
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (Idefics3Processor usaimage_processor_classpara processar as imagens). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar a execução de atenção nos índices de pixels de preenchimento. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os estados ocultos do codificador de imagem após a projeção de modalidade. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., text_config.]oumodel.image_token_id. Os tokens com índices definidos comomodel.image_token_idsão ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., text_config.].
Retorna
ModernVBertMaskedLMOutput ou tuple(torch.Tensor)
Um ModernVBertMaskedLMOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (ModernVBertConfig) e das entradas.
As entradas fornecidas ao modelo podem ter um número arbitrário de imagens. Para lidar com isso, os pixel_values fornecidos ao modelo possuem padding de imagens -> (batch_size, max_num_images, 3, max_heights, max_widths), onde max_num_images é o número máximo de imagens entre as batch_size amostras do lote. Imagens de padding não são necessárias além do padding dos pixel_values na entrada do modelo. Para eficiência, passamos apenas as imagens reais pelo forward do vision_model, descartando as imagens de padding, ou seja, pixel_values de tamanho (image_batch_size, 3, height, width), onde image_batch_size seria 7 quando num_images_per_sample=[1, 3, 1, 2] e max_num_images seria 3.
- loss (
torch.Tensor, opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem mascarada (MLM). - logits (
torch.Tensor) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax). - hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) com a forma(batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings. - attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com a forma(batch_size, num_heads, sequence_length, sequence_length). Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção. - image_hidden_states (
tuple(torch.Tensor), opcional) — Tupla detorch.Tensor(um para a saída dos embeddings de imagem,(batch_size, num_images, sequence_length, hidden_size). image_hidden_states do modelo produzido pelo codificador de visão
Exemplo:
>>> 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
classe transformers.ModernVBertForSequenceClassification
< source >( config: ModernVBertConfig )
Parâmetros
- config (ModernVBertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo ModernVBert com uma cabeça de classificação de sequência no topo que realiza pooling.
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (Idefics3Processor usaimage_processor_classpara processar as imagens). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar a execução de atenção nos índices de pixels de preenchimento. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os estados ocultos do codificador de imagem após a projeção de modalidade. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., text_config.]oumodel.image_token_id. Os tokens com índices definidos comomodel.image_token_idsão ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., text_config.].
Retorna
SequenceClassifierOutput ou tuple(torch.Tensor)
Um SequenceClassifierOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (ModernVBertConfig) e das entradas.
As entradas fornecidas ao modelo podem ter um número arbitrário de imagens. Para lidar com isso, os pixel_values fornecidos ao modelo possuem padding de imagens -> (batch_size, max_num_images, 3, max_heights, max_widths), onde max_num_images é o número máximo de imagens entre as batch_size amostras do lote. Imagens de padding não são necessárias além do padding dos pixel_values na entrada do modelo. Para eficiência, passamos apenas as imagens reais pelo forward do vision_model, descartando as imagens de padding, ou seja, pixel_values de tamanho (image_batch_size, 3, height, width), onde image_batch_size seria 7 quando num_images_per_sample=[1, 3, 1, 2] e max_num_images seria 3.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação (ou regressão se config.num_labels==1).logits (
torch.Tensorde forma(batch_size, config.num_labels)) — Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo de classificação de rótulo único:
>>> 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)
...Exemplo de classificação multirótulo:
>>> 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
classe transformers.ModernVBertForTokenClassification
< source >( config: ModernVBertConfig )
Parâmetros
- config (ModernVBertConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.
O modelo ModernVBert com uma cabeça de classificação de tokens no topo, por exemplo, para tarefas de Reconhecimento de Entidades Nomeadas (NER).
Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)
Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.
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 dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.
- attention_mask (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em[0, 1]:- 1 para tokens que não estão mascarados,
- 0 para tokens que estão mascarados.
- position_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo[0, config.n_positions - 1]. - inputs_embeds (
torch.Tensorde forma(batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passarinput_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices deinput_idsnos vetores associados do que a matriz de busca de incorporação interna do modelo. - pixel_values (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usandoimage_processor_class. Consulteimage_processor_class.__call__para mais detalhes (Idefics3Processor usaimage_processor_classpara processar as imagens). - pixel_attention_mask (
torch.Tensorde forma(batch_size, image_size, image_size), opcional) — Máscara para evitar a execução de atenção nos índices de pixels de preenchimento. - image_hidden_states (
torch.Tensorde forma(batch_size, num_channels, image_size, image_size)) — Os estados ocultos do codificador de imagem após a projeção de modalidade. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em[0, ..., text_config.]oumodel.image_token_id. Os tokens com índices definidos comomodel.image_token_idsão ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., text_config.].
Retorna
TokenClassifierOutput ou tuple(torch.Tensor)
Um TokenClassifierOutput ou uma tupla de
torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários
elementos, dependendo da configuração (ModernVBertConfig) e das entradas.
As entradas fornecidas ao modelo podem ter um número arbitrário de imagens. Para lidar com isso, os pixel_values fornecidos ao modelo possuem padding de imagens -> (batch_size, max_num_images, 3, max_heights, max_widths), onde max_num_images é o número máximo de imagens entre as batch_size amostras do lote. Imagens de padding não são necessárias além do padding dos pixel_values na entrada do modelo. Para eficiência, passamos apenas as imagens reais pelo forward do vision_model, descartando as imagens de padding, ou seja, pixel_values de tamanho (image_batch_size, 3, height, width), onde image_batch_size seria 7 quando num_images_per_sample=[1, 3, 1, 2] e max_num_images seria 3.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de classificação.logits (
torch.Tensorde forma(batch_size, sequence_length, config.num_labels)) — Pontuações de classificação (antes do SoftMax).hidden_states (
tuple(torch.Tensor), opcional, retornado quandooutput_hidden_states=Trueé passado ou quandoconfig.output_hidden_states=True) — Tupla detorch.Tensor(um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma(batch_size, sequence_length, hidden_size).Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.
attentions (
tuple(torch.Tensor), opcional, retornado quandooutput_attentions=Trueé passado ou quandoconfig.output_attentions=True) — Tupla detorch.Tensor(um para cada camada) com forma(batch_size, num_heads, sequence_length, sequence_length).Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.
Exemplo:
>>> 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)
...