Transformers 4.37 中文文档（三十六）（3）

Transformers 4.37 中文文档（三十六）（2）https://developer.aliyun.com/article/1564719

GPTNeoXJapaneseForCausalLM

class transformers.GPTNeoXJapaneseForCausalLM

< source >

( config )

参数

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

GPTNeoXJapanese 模型在顶部具有用于分类模型微调的 语言建模 头。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

( input_ids: Optional = None attention_mask: Optional = None inputs_embeds: Optional = None head_mask: Optional = None past_key_values: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。
  可以使用 AutoTokenizer 获取索引。
  
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充令牌索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

• 1 用于 not masked 的令牌，
  
• 0 用于 masked 的令牌。
  

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落令牌索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

• 0 对应于 句子 A 令牌，
  
• 1 对应于 句子 B 令牌。
  

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部无效的掩码。在[0, 1]中选择的掩码值：

• 1 表示头部未被掩盖，
  
• 0 表示头部被掩盖。
  

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
  
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。当模型用作序列到序列模型中的解码器时，只有在需要时才需要这两个额外的张量。
  包含预先计算的隐藏状态（自注意力块中的键和值，可用于加速顺序解码（请参见past_key_values输入）。
  如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（这些没有将其过去的键值状态提供给此模型）的形状为(batch_size, 1)的张量，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
  
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]（请参见input_ids文档字符串）中。索引设置为-100的标记将被忽略（掩盖），仅对标签为[0, ..., config.vocab_size]的标记计算损失。
  
• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，可用于加速解码（请参见past_key_values）。
  

返回

transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包括根据配置（GPTNeoXJapaneseConfig）和输入的不同元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失（用于下一个标记预测）。
  
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）
  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有一个嵌入层，+ 一个用于每一层的输出）。
  模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

GPTNeoXJapaneseForCausalLM 的前向方法重写了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, GPTNeoXJapaneseForCausalLM, GPTNeoXJapaneseConfig
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("abeja/gpt-neox-japanese-2.7b")
>>> config = GPTNeoXJapaneseConfig.from_pretrained("abeja/gpt-neox-japanese-2.7b")
>>> config.is_decoder = True
>>> model = GPTNeoXJapaneseForCausalLM.from_pretrained("abeja/gpt-neox-japanese-2.7b", config=config)
>>> inputs = tokenizer("日本語のGPT-neoxがHugging Faceで使えます😀", return_tensors="pt")
>>> outputs = model(**inputs)
>>> prediction_logits = outputs.logits

GPT-J

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/gptj

概述

GPT-J 模型是由 Ben Wang 和 Aran Komatsuzaki 在kingoflolz/mesh-transformer-jax存储库中发布的。它是在Pile数据集上训练的类似 GPT-2 的因果语言模型。

此模型由Stella Biderman贡献。

使用提示

• 要在 float32 中加载GPT-J，至少需要 2 倍模型大小的 RAM：1 倍用于初始权重，另外 1 倍用于加载检查点。因此，对于 GPT-J，至少需要 48GB RAM 才能加载模型。为了减少 RAM 使用量，有几个选项。torch_dtype参数可用于在仅 CUDA 设备上以半精度初始化模型。还有一个存储 fp16 权重的 fp16 分支，可用于进一步最小化 RAM 使用量：

>>> from transformers import GPTJForCausalLM
>>> import torch
>>> device = "cuda"
>>> model = GPTJForCausalLM.from_pretrained(
...     "EleutherAI/gpt-j-6B",
...     revision="float16",
...     torch_dtype=torch.float16,
... ).to(device)

• 该模型应适合在 16GB GPU 上进行推断。对于训练/微调，将需要更多的 GPU RAM。例如，Adam  优化器会复制模型的四份副本：模型、梯度、平均梯度和梯度的平方平均值。因此，即使使用混合精度，梯度更新也是在 fp32 中，至少需要 4  倍模型大小的 GPU 内存。这还不包括激活和数据批次，这将再次需要更多的 GPU RAM。因此，应该探索解决方案，如  DeepSpeed，来训练/微调模型。另一个选项是使用原始代码库在 TPU 上训练/微调模型，然后将模型转换为 Transformers  格式进行推断。有关说明，请参阅此处。
  
• 尽管嵌入矩阵的大小为 50400，但 GPT-2 标记器仅使用 50257 个条目。这些额外的代币是为了提高 TPU 的效率而添加的。为了避免嵌入矩阵大小和 vocab 大小之间的不匹配，GPT-J的标记化器包含 143 个额外的令牌<|extratoken_1|>, ..., <|extratoken_143|>，因此tokenizer的vocab_size也变为 50400。
  

使用示例

generate() 方法可用于使用 GPT-J 模型生成文本。

>>> from transformers import AutoModelForCausalLM, AutoTokenizer
>>> model = AutoModelForCausalLM.from_pretrained("EleutherAI/gpt-j-6B")
>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> prompt = (
...     "In a shocking finding, scientists discovered a herd of unicorns living in a remote, "
...     "previously unexplored valley, in the Andes Mountains. Even more surprising to the "
...     "researchers was the fact that the unicorns spoke perfect English."
... )
>>> input_ids = tokenizer(prompt, return_tensors="pt").input_ids
>>> gen_tokens = model.generate(
...     input_ids,
...     do_sample=True,
...     temperature=0.9,
...     max_length=100,
... )
>>> gen_text = tokenizer.batch_decode(gen_tokens)[0]

…或者使用 float16 精度：

>>> from transformers import GPTJForCausalLM, AutoTokenizer
>>> import torch
>>> device = "cuda"
>>> model = GPTJForCausalLM.from_pretrained("EleutherAI/gpt-j-6B", torch_dtype=torch.float16).to(device)
>>> tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-j-6B")
>>> prompt = (
...     "In a shocking finding, scientists discovered a herd of unicorns living in a remote, "
...     "previously unexplored valley, in the Andes Mountains. Even more surprising to the "
...     "researchers was the fact that the unicorns spoke perfect English."
... )
>>> input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(device)
>>> gen_tokens = model.generate(
...     input_ids,
...     do_sample=True,
...     temperature=0.9,
...     max_length=100,
... )
>>> gen_text = tokenizer.batch_decode(gen_tokens)[0]

资源

一份官方 Hugging Face 和社区资源（由🌎表示），帮助您开始使用 GPT-J。如果您有兴趣提交资源以包含在此处，请随时提出拉取请求，我们将进行审查！资源应该最好展示一些新内容，而不是重复现有资源。

文本生成

• GPT-J的描述。
  
• 一篇关于如何使用 Hugging Face Transformers 和 Amazon SageMaker 部署 GPT-J 6B 进行推断的博客。
  
• 一篇关于如何使用 DeepSpeed-Inference 在 GPU 上加速 GPT-J 推断的博客。
  
• 一篇介绍GPT-J-6B：6B 基于 JAX 的 Transformer的博客。🌎
  
• 一个用于GPT-J-6B 推断演示的笔记本。🌎
  
• 另一个演示笔记本：使用 GPT-J-6B 进行推断。
  
• 🤗 Hugging Face 课程的因果语言建模章节。
  
• GPTJForCausalLM 可通过这个因果语言建模示例脚本、文本生成示例脚本和笔记本进行支持。
  
• TFGPTJForCausalLM 由这个因果语言建模示例脚本和笔记本支持。
  
• FlaxGPTJForCausalLM 由这个因果语言建模示例脚本和笔记本支持。
  

文档资源

• 文本分类任务指南
  
• 问答任务指南
  
• 因果语言建模任务指南
  

GPTJConfig

class transformers.GPTJConfig

<来源>

( vocab_size = 50400 n_positions = 2048 n_embd = 4096 n_layer = 28 n_head = 16 rotary_dim = 64 n_inner = None activation_function = 'gelu_new' resid_pdrop = 0.0 embd_pdrop = 0.0 attn_pdrop = 0.0 layer_norm_epsilon = 1e-05 initializer_range = 0.02 use_cache = True bos_token_id = 50256 eos_token_id = 50256 tie_word_embeddings = False **kwargs )

参数

• vocab_size (int, optional, 默认为 50400) — GPT-J 模型的词汇量。定义在调用 GPTJModel 时可以表示的不同标记数量。
  
• n_positions (int, optional, 默认为 2048) — 该模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
  
• n_embd (int, optional, 默认为 4096) — 嵌入和隐藏状态的维度。
  
• n_layer (int, optional, 默认为 28) — Transformer 编码器中的隐藏层数量。
  
• n_head (int, optional, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数量。
  
• rotary_dim (int, optional, 默认为 64) — 旋转位置嵌入应用的嵌入维度数量。
  
• n_inner (int, optional, 默认为 None) — 内部前馈层的维度。None将设置为 4 倍的 n_embd。
  
• activation_function (str, optional, 默认为"gelu_new") — 激活函数，可在列表["relu", "silu", "gelu", "tanh", "gelu_new"]中选择。
  
• resid_pdrop (float, optional, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
  
• embd_pdrop (int, optional, 默认为 0.1) — 嵌入的 dropout 比率。
  
• attn_pdrop (float, optional, 默认为 0.1) — 注意力的 dropout 比率。
  
• layer_norm_epsilon (float, optional, 默认为 1e-5) — 在层归一化层中使用的 epsilon。
  
• initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  
• use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
  

这是一个配置类，用于存储 GPTJModel 的配置。根据指定的参数实例化一个 GPT-J 模型，定义模型架构。使用默认值实例化配置将产生类似于 GPT-J EleutherAI/gpt-j-6B架构的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import GPTJModel, GPTJConfig
>>> # Initializing a GPT-J 6B configuration
>>> configuration = GPTJConfig()
>>> # Initializing a model from the configuration
>>> model = GPTJModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

PytorchHide Pytorch content

GPTJModel

class transformers.GPTJModel

<来源>

( config )

参数

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

裸 GPT-J 模型变压器，输出原始隐藏状态，没有特定的头部。这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

• 1 表示未被掩盖的标记，
  
• 0 表示被掩盖的标记。
  

• 什么是注意力掩码？
  
• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于句子 A标记，
  
• 1 对应于句子 B标记。
  

• 什么是标记类型 ID？
  
• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。
  什么是位置 ID？
  
• head_mask (torch.FloatTensor，形状为(num_attention_heads,)或(n_layer, num_attention_heads)，optional) — 用于使自注意力模块的特定头部失效的掩码。掩码值在[0, 1]中选择：

• 1 表示头部未被掩盖，
  
• 0 表示头部被掩盖。
  

• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_dim)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  
• output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（GPTJConfig）和输入的不同元素。

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层输出的隐藏状态序列。
  如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
  
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）- 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True，还有 2 个额外形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块中的键和值，以及如果config.is_encoder_decoder=True在交叉注意力块中）可用于加速顺序解码的（见past_key_values输入）。
  
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出的输出+每层的输出）。
  模型每一层输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

GPTJModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默忽略它们。

此示例使用一个随机模型，真实模型都非常庞大。为了获得正确的结果，应该使用 EleutherAI/gpt-j-6B 而不是 hf-internal-testing/tiny-random-gptj。如果加载该检查点时出现内存不足，可以尝试在from_pretrained调用中添加device_map="auto"。

示例：

>>> from transformers import AutoTokenizer, GPTJModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gptj")
>>> model = GPTJModel.from_pretrained("hf-internal-testing/tiny-random-gptj")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

GPTJForCausalLM

class transformers.GPTJForCausalLM

<来源>

( config )

参数

• config（GPTJConfig）- 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

在顶部具有语言建模头的 GPT-J 模型变换器。

该模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or 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标记。
  

• 什么是标记类型 ID？
  
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记的位置索引。在范围[0, config.n_positions - 1]中选择。
  什么是位置 ID？
  
• head_mask（形状为(num_attention_heads,)或(n_layer, num_attention_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部无效的蒙版。蒙版值选择在[0, 1]中：

• 1 表示头部“未屏蔽”，
  
• 0 表示头部“已屏蔽”。
  

• inputs_embeds（形状为(batch_size, sequence_length, hidden_dim)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
  
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
  
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids。索引选择在[-100, 0, ..., config.vocab_size]中，所有设置为-100的标签都将被忽略（屏蔽），损失仅计算标签在[0, ..., config.vocab_size]中的标签
  

返回

transformers.modeling_outputs.CausalLMOutputWithPast 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（GPTJConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 语言建模损失（用于下一个标记预测）。
  
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• past_key_values (tuple(tuple(torch.FloatTensor)), optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。
  包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
  
• hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 + 每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。
  模型在每个层的输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。
  在注意力 SoftMax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

GPTJForCausalLM 的前向方法重写了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用Module实例而不是此函数，因为前者会处理运行前后处理步骤，而后者会默默忽略它们。

此示例使用随机模型，真实模型都非常庞大。为了获得正确的结果，应该使用 EleutherAI/gpt-j-6B 而不是 hf-internal-testing/tiny-random-gptj。如果加载该检查点时出现内存不足，可以尝试在from_pretrained调用中添加device_map="auto"。

示例：

>>> import torch
>>> from transformers import AutoTokenizer, GPTJForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gptj")
>>> model = GPTJForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gptj")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

Transformers 4.37 中文文档（三十六）（4）https://developer.aliyun.com/article/1564721