Transformers 文档

JinaEmbeddingsV3

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

在模型、数据集和 Spaces 上进行协作

通过加速推理获得更快的示例

切换文档主题

开始使用

该模型于 2024 年 9 月 16 日发布在 HF papers 上，并于 2026 年 3 月 19 日贡献给 Hugging Face Transformers。

JinaEmbeddingsV3

Jina-Embeddings-v3 是一款多语言、多任务文本嵌入模型，专为各种 NLP 应用而设计。该模型基于 XLM-RoBERTa 架构，支持旋转位置嵌入 (RoPE) 来替代绝对位置嵌入，从而支持高达 8192 个 token 的长输入序列。此外，它还内置了 5 个特定任务的 LoRA 适配器，使模型无需显著增加推理延迟即可生成特定任务的嵌入（例如用于检索与分类）。

你可以在 Jina AI 组织下找到原始的 Jina Embeddings v3 检查点。

点击右侧边栏中的 Jina Embeddings v3 模型，获取更多关于如何将该模型应用于不同语言任务的示例。

下面的示例演示了如何使用 Pipeline、AutoModel 以及命令行来提取特征（嵌入）。

流水线

自动模型

特定任务的 LoRA 适配器

JinaEmbeddingsV3 的一个关键特性是其 LoRA 适配器，它允许你根据特定的用例定制输出嵌入，而无需加载完全不同的模型，从而避免了额外的开销。

支持以下任务：

retrieval.query：用于非对称检索任务中的查询嵌入（例如搜索查询）。
retrieval.passage：用于非对称检索任务中的段落嵌入（例如被搜索的文档）。
separation：用于聚类和重排序应用中的嵌入。
classification：用于分类任务中的嵌入。
text-matching：用于量化两个文本之间相似性的任务中的嵌入，例如语义文本相似度 (STS) 或对称检索任务。

要生成高质量的句子或段落嵌入，你需要对模型的 token 嵌入应用平均池化 (mean pooling)。平均池化会获取模型输出的所有 token 嵌入并计算它们的平均值，同时遮蔽掉填充 (padding) token。

以下是如何使用 AutoModel API 为检索查询任务生成句子嵌入的方法。

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

class transformers.JinaEmbeddingsV3Config

< 源码 >

( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 is_encoder_decoder: bool = False id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None vocab_size: int = 250002 hidden_size: int = 1024 num_hidden_layers: int = 24 num_attention_heads: int = 16 intermediate_size: int = 4096 hidden_act: str = 'gelu' hidden_dropout_prob: float | int = 0.1 attention_probs_dropout_prob: float | int = 0.1 max_position_embeddings: int = 8194 type_vocab_size: int = 1 initializer_range: float = 0.02 layer_norm_eps: float = 1e-05 pad_token_id: int | None = 1 bos_token_id: int | None = 0 eos_token_id: int | list[int] | None = 2 use_cache: bool = True classifier_dropout: float | int | None = None tie_word_embeddings: bool = True rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None )

参数

vocab_size (int, 可选, 默认值为 250002) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 的数量。
hidden_size (int, 可选, 默认值为 1024) — 隐藏层表示的维度。
num_hidden_layers (int, 可选, 默认值为 24) — Transformer 解码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认值为 16) — Transformer 解码器中每个注意力层的注意力头数量。
intermediate_size (int, 可选, 默认值为 4096) — MLP 表示的维度。
hidden_act (str, 可选, 默认值为 gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu", "relu", "silu" 等。
hidden_dropout_prob (Union[float, int], 可选, 默认值为 0.1) — 嵌入、编码器和池化层中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (Union[float, int], 可选, 默认值为 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, 可选, 默认值为 8194) — 该模型可能使用的最大序列长度。
type_vocab_size (int, 可选, 默认值为 1) — token_type_ids 的词汇表大小。
initializer_range (float, 可选, 默认值为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认值为 1e-05) — 层归一化层使用的 epsilon 值。
pad_token_id (int, 可选, 默认值为 1) — 词汇表中用于填充的 token id。
bos_token_id (int, 可选, 默认值为 0) — 词汇表中用于流起始的 token id。
eos_token_id (Union[int, list[int]], 可选, 默认值为 2) — 词汇表中用于流结束的 token id。
use_cache (bool, 可选, 默认值为 True) — 模型是否应该返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 或模型为仅解码器的生成模型时相关。
classifier_dropout (Union[float, int], 可选) — 分类器的 dropout 比率。
tie_word_embeddings (bool, 可选, 默认值为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。
rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值，以及在你想使用更长的 max_position_embeddings 时用于缩放的可选参数。

这是用于存储 JinaEmbeddingsV3Model 配置的配置类。它根据指定的参数实例化 Jina Embeddings V3 模型，定义了模型架构。使用默认值实例化配置将产生与 jinaai/jina-embeddings-v3-hf 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。

示例

>>> 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.config

JinaEmbeddingsV3Model

class transformers.JinaEmbeddingsV3Model

< 源码 >

( config: JinaEmbeddingsV3Config add_pooling_layer = True )

参数

config (JinaEmbeddingsV3Config) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
add_pooling_layer (bool, 可选, 默认为 True) — 是否添加池化层。

不带任何特定顶层结构的 Jina Embeddings V3 模型，输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

( input_ids: torch.Tensor | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → BaseModelOutputWithPooling 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 词表中输入序列标记的索引。默认情况下，填充将被忽略。

可以通过 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 [0, 1]：
- 对于未被掩码的标记，值为 1，
- 对于被掩码的标记，值为 0。
什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于指示输入的第一部分和第二部分的片段标记索引。索引选自 [0, 1]：
- 0 对应于句子 A 的标记，
- 1 对应于句子 B 的标记。
什么是标记类型 ID？
position_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可选) — 作为一个选项，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望比模型内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为相关向量，这会非常有用。

BaseModelOutputWithPooling or tuple(torch.FloatTensor)

一个 BaseModelOutputWithPooling 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置 (JinaEmbeddingsV3Config) 和输入包含各种元素。

JinaEmbeddingsV3Model 的前向传播方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
pooler_output (torch.FloatTensor，形状为 (batch_size, hidden_size)) — 序列第一个 token（分类 token）在进一步通过用于辅助预训练任务的层后的最后一个隐藏状态。例如，对于 BERT 系列模型，这会返回经过线性层和 tanh 激活函数处理后的分类 token。线性层的权重是通过预训练期间的下一句预测（分类）目标来训练的。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

JinaEmbeddingsV3ForMaskedLM

class transformers.JinaEmbeddingsV3ForMaskedLM

< 源代码 >

( config model_args: ~utils.generic.ModelArgs | None = None adapter_args: ~utils.generic.AdapterArgs | None = None lora_args: ~utils.generic.LoRAArgs | None = None tokenizer_args: ~utils.generic.TokenizerArgs | None = None dataset_args: ~utils.generic.DatasetArgs | None = None data_args: ~utils.generic.DataArgs | None = None training_args: ~utils.generic.TrainingArgs | None = None generation_args: ~utils.generic.GenerationArgs | None = None vision_tower_args: ~utils.generic.VisionTowerArgs | None = None qlora_args: ~utils.generic.QLoRAArgs | None = None vision_tower_template_args: ~utils.generic.VisionTowerTemplateArgs | None = None video_tower_args: ~utils.generic.VideoTowerArgs | None = None vision_config: ~utils.generic.VisionConfig | None = None video_config: ~utils.generic.VideoConfig | None = None load_dataset: bool | None = None load_data_collator: bool | None = None load_processor: bool | None = None load_lora_adapter: bool | None = None load_adapter: bool | None = None load_qlora_adapter: bool | None = None **kwargs: typing_extensions.Unpack[transformers.modeling_utils.PreTrainedModelKwargs] )

参数

config (JinaEmbeddingsV3ForMaskedLM) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

带有 语言建模 顶层结构的 Jina Embeddings V3 模型。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None token_type_ids: torch.LongTensor | None = None position_ids: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 词表中输入序列标记的索引。默认情况下，填充将被忽略。

可以通过 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, 可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 [0, 1]：
- 对于未被掩码的标记，值为 1，
- 对于被掩码的标记，值为 0。
什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 用于指示输入的第一部分和第二部分的片段标记索引。索引选自 [0, 1]：
- 0 对应于句子 A 的标记，
- 1 对应于句子 B 的标记。此参数仅在模型使用值为
  
  = 2 的 type_vocab_size 参数初始化时才可用。此张量中的所有值都应始终小于 type_vocab_size。
什么是标记类型 ID？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 每个输入序列标记在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — 作为一个选项，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望比模型内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为相关向量，这会非常有用。
labels (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 范围内的标记进行计算。

MaskedLMOutput 或 tuple(torch.FloatTensor)

一个 MaskedLMOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置 (JinaEmbeddingsV3Config) 和输入包含各种元素。

JinaEmbeddingsV3ForMaskedLM 的前向传播方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> 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

class transformers.JinaEmbeddingsV3ForSequenceClassification

< 源代码 >

参数

config (JinaEmbeddingsV3ForSequenceClassification) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

带有序列分类/回归顶层结构（池化输出之上的线性层）的 XLM-RoBERTa 模型转换器，例如用于 GLUE 任务。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 词表中输入序列标记的索引。默认情况下，填充将被忽略。

可以通过 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor, 可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 [0, 1]：
- 对于未被掩码的标记，值为 1，
- 对于被掩码的标记，值为 0。
什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 用于指示输入的第一部分和第二部分的段 token 索引。索引选自 [0, 1]：
- 0 对应于 句子 A 的 token，
- 1 对应于 句子 B 的 token。此参数仅在模型初始化时使用了 type_vocab_size 参数且其值
  
  = 2 时才可使用。此张量中的所有值都应始终 < type_vocab_size。
什么是 token 类型 ID？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这非常有用。
labels (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。

SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），根据配置（JinaEmbeddingsV3Config）和输入，包含各种元素。

JinaEmbeddingsV3ForSequenceClassification 的 forward 方法，重写了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

单标签分类示例

>>> 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)
...

多标签分类示例

>>> 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).loss

JinaEmbeddingsV3ForTokenClassification

class transformers.JinaEmbeddingsV3ForTokenClassification

< 源代码 >

参数

config (JinaEmbeddingsV3ForTokenClassification) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

Jina Embeddings V3 transformer，顶部带有 token 分类头（隐藏状态输出上方的线性层），例如用于命名实体识别 (NER) 任务。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 词汇表中输入序列 token 的索引。默认情况下将忽略填充（padding）。

索引可以使用 AutoTokenizer 获取。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值选自 [0, 1]：
- 1 表示未屏蔽的 token，
- 0 表示已屏蔽的 token。
什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 用于指示输入的第一部分和第二部分的段 token 索引。索引选自 [0, 1]：
- 0 对应于 句子 A 的 token，
- 1 对应于 句子 B 的 token。此参数仅在模型初始化时使用了 type_vocab_size 参数且其值
  
  = 2 时才可使用。此张量中的所有值都应始终 < type_vocab_size。
什么是 token 类型 ID？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这非常有用。
labels (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 用于计算 token 分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。

TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 TokenClassifierOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），根据配置（JinaEmbeddingsV3Config）和输入，包含各种元素。

JinaEmbeddingsV3ForTokenClassification 的 forward 方法，重写了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失。
logits (形状为 (batch_size, sequence_length, config.num_labels) 的 torch.FloatTensor) — 分类分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> 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

class transformers.JinaEmbeddingsV3ForQuestionAnswering

< 源代码 >

参数

config (JinaEmbeddingsV3ForQuestionAnswering) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

Jina Embeddings V3 transformer，顶部带有用于提取式问答任务（如 SQuAD）的跨度（span）分类头（在隐藏状态输出上方添加线性层以计算 span start logits 和 span end logits）。

该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< 源代码 >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None token_type_ids: torch.LongTensor | None = None position_ids: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None start_positions: torch.LongTensor | None = None end_positions: torch.LongTensor | None = None **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 词汇表中输入序列 token 的索引。默认情况下将忽略填充（padding）。

索引可以使用 AutoTokenizer 获取。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值选自 [0, 1]：
- 1 表示未屏蔽的 token，
- 0 表示已屏蔽的 token。
什么是注意力掩码？
token_type_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 用于指示输入的第一部分和第二部分的段 token 索引。索引选自 [0, 1]：
- 0 对应于 句子 A 的 token，
- 1 对应于 句子 B 的 token。此参数仅在模型初始化时使用了 type_vocab_size 参数且其值
  
  = 2 时才可使用。此张量中的所有值都应始终 < type_vocab_size。
什么是 token 类型 ID？
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这非常有用。
start_positions (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于标记跨度起始位置（索引）的标签，用于计算词元分类损失。位置会被截断至序列长度 (sequence_length)。序列之外的位置不会被计入损失计算。
end_positions (形状为 (batch_size,) 的 torch.LongTensor，可选) — 用于标记跨度结束位置（索引）的标签，用于计算词元分类损失。位置会被截断至序列长度 (sequence_length)。序列之外的位置不会被计入损失计算。

QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

一个 QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），根据配置（JinaEmbeddingsV3Config）和输入的不同，包含各种元素。

JinaEmbeddingsV3ForQuestionAnswering 的 forward 方法，重写了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。
start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。
end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围结束分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

>>> 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)
...

在 GitHub 上更新

←JetMoe Laguna→