Transformers documentation
JinaEmbeddingsV3
Este modelo foi publicado no HF papers em 2024-09-16 e contribuído para o Hugging Face Transformers em 2026-03-19.
JinaEmbeddingsV3
O Jina-Embeddings-v3 é um modelo de incorporação de texto multilíngue e multitarefa, projetado para uma variedade de aplicações de PLN. Baseado na arquitetura XLM-RoBERTa, este modelo suporta Rotary Position Embeddings (RoPE), substituindo as incorporações de posição absolutas para suportar sequências de entrada longas de até 8192 tokens. Além disso, ele possui 5 Task-Specific LoRA Adapters integrados, que permitem ao modelo gerar incorporações específicas para cada tarefa (por exemplo, para recuperação vs. classificação) sem aumentar significativamente a latência de inferência.
Você pode encontrar os checkpoints originais do Jina Embeddings v3 na organização Jina AI.
Clique nos modelos Jina Embeddings v3 na barra lateral à direita para ver mais exemplos de como aplicar o modelo a diferentes tarefas de linguagem.
O exemplo abaixo demonstra como extrair recursos (embeddings) com Pipeline, AutoModel e pela linha de comando.
from transformers import pipeline
pipeline = pipeline(
task="feature-extraction",
model="jinaai/jina-embeddings-v3-hf",
)
# Returns a list of lists containing the embeddings for each token
embeddings = pipeline("Jina Embeddings V3 is great for semantic search.")import torch
from transformers import AutoModel, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
model = AutoModel.from_pretrained("jinaai/jina-embeddings-v3-hf", device_map="auto")
prompt = "Jina Embeddings V3 is great for semantic search."
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
with torch.no_grad():
outputs = model(**inputs)
# The base AutoModel returns the raw hidden states for all tokens
last_hidden_states = outputs.last_hidden_state
print(f"Features shape: {last_hidden_states.shape}")Adaptadores LoRA Específicos para Tarefas
Um recurso importante do JinaEmbeddingsV3 são seus adaptadores LoRA, que permitem ajustar os embeddings de saída a casos de uso específicos e úteis, sem a sobrecarga de carregar modelos completamente diferentes.
As seguintes tarefas são suportadas:
retrieval.query: Usado para embeddings de consulta em tarefas de recuperação assimétrica (por exemplo, consultas de busca).retrieval.passage: Usado para embeddings de trechos em tarefas de recuperação assimétrica (por exemplo, os documentos pesquisados).separation: Usado para embeddings em aplicações de clustering e re-ranking.classification: Usado para embeddings em tarefas de classificação.text-matching: Usado para embeddings em tarefas que quantificam a similaridade entre dois textos, como Similaridade Semântica de Texto (STS) ou tarefas de recuperação simétrica.
Para gerar embeddings de sentenças ou parágrafos de alta qualidade, é necessário aplicar mean pooling aos embeddings de tokens do modelo. O mean pooling pega todos os embeddings de tokens da saída do modelo e calcula a média deles, ignorando os tokens de padding.
Aqui está como você pode gerar embeddings de frases adaptados para uma tarefa de consulta de recuperação usando a API AutoModel.
import torch
import torch.nn.functional as F
from transformers import AutoModel, AutoTokenizer
def mean_pooling(model_output, attention_mask):
# First element of model_output contains all token embeddings
token_embeddings = model_output[0]
input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
# Sum the embeddings and divide by the number of non-padding tokens
sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)
sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
return sum_embeddings / sum_mask
sentences = [
"How is the weather today?",
"What is the current weather like today?"
]
tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
model = AutoModel.from_pretrained("jinaai/jina-embeddings-v3-hf", device_map="auto")
encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors="pt").to(model.device)
# Set up the adapter mask for your specific task
task = 'retrieval_query' # Can be any of (retrieval_passage, separation, classification, text_matching) depending on the use-case.
model.load_adapter("jinaai/jina-embeddings-v3-hf", adapter_name=task, adapter_kwargs={"subfolder": task})
model.set_adapter(task)
with torch.no_grad():
model_output = model(**encoded_input)
embeddings = mean_pooling(model_output, encoded_input["attention_mask"])
embeddings = F.normalize(embeddings, p=2, dim=1)
print(embeddings.shape)
# Output: torch.Size([2, 1024])JinaEmbeddingsV3Config
classe transformers.JinaEmbeddingsV3Config
< 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 = Nonevocab_size: int = 250002hidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 16intermediate_size: int = 4096hidden_act: str = 'gelu'hidden_dropout_prob: float | int = 0.1attention_probs_dropout_prob: float | int = 0.1max_position_embeddings: int = 8194type_vocab_size: int = 1initializer_range: float = 0.02layer_norm_eps: float = 1e-05pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2use_cache: bool = Trueclassifier_dropout: float | int | None = Nonetie_word_embeddings: bool = Truerope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None )
Parâmetros
- vocab_size (
int, opcional, padrão250002) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelosinput_ids. - hidden_size (
int, opcional, padrão1024) — Dimensão das representações ocultas. - num_hidden_layers (
int, opcional, padrão24) — Número de camadas ocultas no decodificador do Transformer. - num_attention_heads (
int, opcional, padrão16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer. - intermediate_size (
int, opcional, padrão4096) — Dimensão das representações do MLP. - hidden_act (
str, opcional, padrãogelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo,"gelu","relu","silu", etc. - hidden_dropout_prob (
Union[float, int], opcional, padrão0.1) — A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, no codificador e no pooler. - attention_probs_dropout_prob (
Union[float, int], opcional, padrão0.1) — A taxa de dropout para as probabilidades de atenção. - max_position_embeddings (
int, opcional, padrão8194) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado. - type_vocab_size (
int, opcional, padrão1) — O tamanho do vocabulário dostoken_type_ids. - initializer_range (
float, opcional, padrão0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. - layer_norm_eps (
float, opcional, padrão1e-05) — O epsilon usado pelas camadas de normalização de camada. - pad_token_id (
int, opcional, padrão1) — ID do token usado para preenchimento no vocabulário. - bos_token_id (
int, opcional, padrão0) — ID do token usado para o início do fluxo no vocabulário. - eos_token_id (
Union[int, list[int]], opcional, padrão2) — ID do token usado para o fim do fluxo no vocabulário. - use_cache (
bool, opcional, padrãoTrue) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas seconfig.is_decoder=Trueou quando o modelo for um modelo generativo somente decodificador. - classifier_dropout (
Union[float, int], opcional) — A taxa de dropout para o classificador. - tie_word_embeddings (
bool, opcional, padrãoTrue) — Se deve vincular as embeddings de pesos de acordo com o mapeamentotied_weights_keysdo modelo. - rope_parameters (
Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor pararope_thetae, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE commax_position_embeddingsmaiores.
Esta é a classe de configuração para armazenar a configuração de um JinaEmbeddingsV3Model. Ela é usada para instanciar um modelo Jina Embeddings V3 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 jinaai/jina-embeddings-v3-hf
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.
Exemplos:
>>> from transformers import JinaEmbeddingsV3Config, JinaEmbeddingsV3Model
>>> # Initializing a Jina-Embeddings-V3 jinaai/jina-embeddings-v3-hf style configuration
>>> configuration = JinaEmbeddingsV3Config()
>>> # Initializing a model (with random weights) from the jinaai/jina-embeddings-v3-hf style configuration
>>> model = JinaEmbeddingsV3Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configJinaEmbeddingsV3Model
classe transformers.JinaEmbeddingsV3Model
< source >( config: JinaEmbeddingsV3Configadd_pooling_layer = True )
Parâmetros
- config (JinaEmbeddingsV3Config) — 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.
- add_pooling_layer (
bool, opcional, padrãoTrue) — Se deve adicionar uma camada de pooling
O modelo Jina Embeddings V3 puro, que gera estados ocultos brutos sem nenhum cabeçalho específico 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: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)
Parâmetros
- input_ids (
torch.Tensorde formato(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.
- token_type_ids (
torch.Tensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0, 1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token de sentence B.
- position_ids (
torch.Tensorde 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.
Retorna
BaseModelOutputWithPooling ou tuple(torch.Tensor)
Um BaseModelOutputWithPooling 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 (JinaEmbeddingsV3Config) e das entradas.
O método forward do JinaEmbeddingsV3Model substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
last_hidden_state (
torch.Tensorde forma(batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.pooler_output (
torch.Tensorde forma(batch_size, hidden_size)) — Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional através das camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para a família de modelos BERT, isso retorna o token de classificação após o processamento através de uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento.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.
JinaEmbeddingsV3ForMaskedLM
classe transformers.JinaEmbeddingsV3ForMaskedLM
< source >( config: JinaEmbeddingsV3Config )
Parâmetros
- config (JinaEmbeddingsV3Config) — 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 Jina Embeddings V3 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: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MaskedLMOutput 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.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0,1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token da frase B .
Este parâmetro só pode ser usado quando o modelo é inicializado com o
type_vocab_sizeparâmetro com o valor= 2. Todos os valores deste tensor devem ser sempre < type_vocab_size.
- 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. - 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[-100, 0, ..., config.vocab_size](veja a docstring deinput_ids). Tokens com índices definidos como-100são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em[0, ..., config.vocab_size].
Retorna
MaskedLMOutput ou tuple(torch.Tensor)
Um MaskedLMOutput 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 (JinaEmbeddingsV3Config) e das entradas.
O método forward de JinaEmbeddingsV3ForMaskedLM sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — Perda de modelagem de linguagem mascarada (MLM).logits (
torch.Tensorde forma(batch_size, sequence_length, config.vocab_size)) — 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) 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, JinaEmbeddingsV3ForMaskedLM
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> model = JinaEmbeddingsV3ForMaskedLM.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> 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)
...JinaEmbeddingsV3ForSequenceClassification
classe transformers.JinaEmbeddingsV3ForSequenceClassification
< source >( config: JinaEmbeddingsV3Config )
Parâmetros
- config (JinaEmbeddingsV3Config) — 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.
Modelo transformer XLM-RoBERTa com uma cabeça de classificação/regressão de sequência no topo (uma camada linear sobre a saída agregada), por exemplo, para tarefas GLUE.
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: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: 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.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0,1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token da frase B .
Este parâmetro só pode ser usado quando o modelo é inicializado com o
type_vocab_sizeparâmetro com o valor= 2. Todos os valores deste tensor devem ser sempre < type_vocab_size.
- 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. - labels (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em[0, ..., config.num_labels - 1]. Seconfig.num_labels == 1, uma perda de regressão é calculada (perda de erro quadrático médio). Seconfig.num_labels > 1, uma perda de classificação é calculada (entropia cruzada).
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 (JinaEmbeddingsV3Config) e das entradas.
O método forward de JinaEmbeddingsV3ForSequenceClassification substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
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, JinaEmbeddingsV3ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> model = JinaEmbeddingsV3ForSequenceClassification.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> 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 = JinaEmbeddingsV3ForSequenceClassification.from_pretrained("jinaai/jina-embeddings-v3-hf", 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, JinaEmbeddingsV3ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> model = JinaEmbeddingsV3ForSequenceClassification.from_pretrained("jinaai/jina-embeddings-v3-hf", 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 = JinaEmbeddingsV3ForSequenceClassification.from_pretrained(
... "jinaai/jina-embeddings-v3-hf", 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).lossJinaEmbeddingsV3ForTokenClassification
classe transformers.JinaEmbeddingsV3ForTokenClassification
< source >( config: JinaEmbeddingsV3Config )
Parâmetros
- config (JinaEmbeddingsV3Config) — 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 transformer Jina Embeddings V3 com uma cabeça de classificação de tokens no topo (uma camada linear sobre a saída dos hidden-states), 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: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: 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.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0,1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token da frase B .
Este parâmetro só pode ser usado quando o modelo é inicializado com o
type_vocab_sizeparâmetro com o valor= 2. Todos os valores deste tensor devem ser sempre < type_vocab_size.
- 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. - labels (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de classificação de tokens. Os índices devem estar em[0, ..., config.num_labels - 1].
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 (JinaEmbeddingsV3Config) e das entradas.
O método forward de JinaEmbeddingsV3ForTokenClassification sobrescreve o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
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, JinaEmbeddingsV3ForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> model = JinaEmbeddingsV3ForTokenClassification.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> 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)
...JinaEmbeddingsV3ForQuestionAnswering
classe transformers.JinaEmbeddingsV3ForQuestionAnswering
< source >( config: JinaEmbeddingsV3Config )
Parâmetros
- config (JinaEmbeddingsV3Config) — 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 transformer Jina Embeddings V3 com uma cabeça de classificação de intervalos no topo para tarefas de resposta a perguntas extrativas, como
SQuAD (uma camada linear no topo da saída dos estados ocultos para calcular span start logits e span end logits).
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: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.LongTensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → QuestionAnsweringModelOutput 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.
- token_type_ids (
torch.LongTensorde forma(batch_size, sequence_length), opcional) — Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em[0,1]:- 0 corresponde a um token de sentence A,
- 1 corresponde a um token da frase B .
Este parâmetro só pode ser usado quando o modelo é inicializado com o
type_vocab_sizeparâmetro com o valor= 2. Todos os valores deste tensor devem ser sempre < type_vocab_size.
- 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. - start_positions (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda. - end_positions (
torch.LongTensorde forma(batch_size,), opcional) — Rótulos para a posição (índice) do final do trecho rotulado, para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (sequence_length). Posições fora da sequência não são consideradas no cálculo da perda.
Retorna
QuestionAnsweringModelOutput ou tuple(torch.Tensor)
Um QuestionAnsweringModelOutput 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 (JinaEmbeddingsV3Config) e das entradas.
O método forward de JinaEmbeddingsV3ForQuestionAnswering substitui o método especial __call__.
Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de
Moduleem seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.
loss (
torch.Tensorde forma(1,), opcional, retornado quandolabelsé fornecido) — A perda total de extração de span é a soma de uma Cross-Entropy para as posições de início e fim.start_logits (
torch.Tensorde forma(batch_size, sequence_length)) — Pontuações de início de trecho (antes do SoftMax).end_logits (
torch.Tensorde forma(batch_size, sequence_length)) — Pontuações de fim de trecho (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, JinaEmbeddingsV3ForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> model = JinaEmbeddingsV3ForQuestionAnswering.from_pretrained("jinaai/jina-embeddings-v3-hf")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...