Transformers 4.37 中文文档（九十七）（2）-阿里云开发者社区

Transformers 4.37 中文文档（九十七）（1）https://developer.aliyun.com/article/1564054

XCLIPTextModel

`class transformers.XCLIPTextModel`

( config: XCLIPTextConfig )

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。默认情况下，如果提供填充，则将被忽略。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
输入 ID 是什么？
attention_mask（torch.Tensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

1 用于“未被掩盖”的标记，
0 用于“被掩盖”的标记。

注意力掩码是什么？
position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
位置 ID 是什么？
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

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

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

last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)） — 模型最后一层的隐藏状态序列的输出。
pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)） — 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, XCLIPTextModel
>>> model = XCLIPTextModel.from_pretrained("microsoft/xclip-base-patch32")
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/xclip-base-patch32")
>>> inputs = tokenizer(["a photo of a cat", "a photo of a dog"], padding=True, return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_state = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_output  # pooled (EOS token) states

XCLIPVisionModel

`class transformers.XCLIPVisionModel`

<来源>

( config: XCLIPVisionConfig )

`forward`

<来源>

( pixel_values: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPooling or tuple(torch.FloatTensor)

参数

pixel_values (torch.FloatTensor，形状为(batch_size, num_channels, height, width)） — 像素值。默认情况下将忽略填充，如果您提供的话。像素值可以使用 AutoImageProcessor 获取。有关详细信息，请参阅 CLIPImageProcessor.call()。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。

transformers.modeling_outputs.BaseModelOutputWithPooling 或torch.FloatTensor元组

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

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层输出的隐藏状态序列。
pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）- 经过用于辅助预训练任务的层进一步处理后，序列的第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回通过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

示例：

>>> import av
>>> import torch
>>> import numpy as np
>>> from transformers import AutoProcessor, XCLIPVisionModel
>>> from huggingface_hub import hf_hub_download
>>> np.random.seed(0)
>>> def read_video_pyav(container, indices):
...     '''
...     Decode the video with PyAV decoder.
...     Args:
...         container (`av.container.input.InputContainer`): PyAV container.
...         indices (`List[int]`): List of frame indices to decode.
...     Returns:
...         result (np.ndarray): np array of decoded frames of shape (num_frames, height, width, 3).
...     '''
...     frames = []
...     container.seek(0)
...     start_index = indices[0]
...     end_index = indices[-1]
...     for i, frame in enumerate(container.decode(video=0)):
...         if i > end_index:
...             break
...         if i >= start_index and i in indices:
...             frames.append(frame)
...     return np.stack([x.to_ndarray(format="rgb24") for x in frames])
>>> def sample_frame_indices(clip_len, frame_sample_rate, seg_len):
...     '''
...     Sample a given number of frame indices from the video.
...     Args:
...         clip_len (`int`): Total number of frames to sample.
...         frame_sample_rate (`int`): Sample every n-th frame.
...         seg_len (`int`): Maximum allowed index of sample's last frame.
...     Returns:
...         indices (`List[int]`): List of sampled frame indices
...     '''
...     converted_len = int(clip_len * frame_sample_rate)
...     end_idx = np.random.randint(converted_len, seg_len)
...     start_idx = end_idx - converted_len
...     indices = np.linspace(start_idx, end_idx, num=clip_len)
...     indices = np.clip(indices, start_idx, end_idx - 1).astype(np.int64)
...     return indices
>>> # video clip consists of 300 frames (10 seconds at 30 FPS)
>>> file_path = hf_hub_download(
...     repo_id="nielsr/video-demo", filename="eating_spaghetti.mp4", repo_type="dataset"
... )
>>> container = av.open(file_path)
>>> # sample 16 frames
>>> indices = sample_frame_indices(clip_len=8, frame_sample_rate=1, seg_len=container.streams.video[0].frames)
>>> video = read_video_pyav(container, indices)
>>> processor = AutoProcessor.from_pretrained("microsoft/xclip-base-patch32")
>>> model = XCLIPVisionModel.from_pretrained("microsoft/xclip-base-patch32")
>>> pixel_values = processor(videos=list(video), return_tensors="pt").pixel_values
>>> batch_size, num_frames, num_channels, height, width = pixel_values.shape
>>> pixel_values = pixel_values.reshape(-1, num_channels, height, width)
>>> outputs = model(pixel_values)
>>> last_hidden_state = outputs.last_hidden_state

强化学习模型

Decision Transformer

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

概述

Decision Transformer 模型提出于Decision Transformer: Reinforcement Learning via Sequence Modeling

作者为 Lili Chen, Kevin Lu, Aravind Rajeswaran, Kimin Lee, Aditya Grover, Michael Laskin, Pieter Abbeel, Aravind Srinivas, Igor Mordatch。

该论文的摘要如下：

我们引入了一个将强化学习（RL）抽象为序列建模问题的框架。这使我们能够利用 Transformer 架构的简单性和可扩展性，以及与语言建模相关的进展，如 GPT-x 和 BERT。特别是，我们提出了 Decision Transformer，这是一个将 RL 问题转化为条件序列建模的架构。与先前拟合值函数或计算策略梯度的 RL 方法不同，Decision Transformer 通过利用因果屏蔽的 Transformer 简单地输出最佳动作。通过将自回归模型条件于期望的回报（奖励）、过去状态和动作，我们的 Decision Transformer 模型可以生成实现期望回报的未来动作。尽管简单，Decision Transformer 在 Atari、OpenAI Gym 和 Key-to-Door 任务上与最先进的无模型离线 RL 基线模型的性能相匹配或超越。

该模型版本适用于状态为向量的任务。

该模型由edbeeching贡献。原始代码可在此处找到。

DecisionTransformerConfig

`class transformers.DecisionTransformerConfig`

< source >

( state_dim = 17 act_dim = 4 hidden_size = 128 max_ep_len = 4096 action_tanh = True vocab_size = 1 n_positions = 1024 n_layer = 3 n_head = 1 n_inner = None activation_function = 'relu' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 scale_attn_weights = True use_cache = True bos_token_id = 50256 eos_token_id = 50256 scale_attn_by_inverse_layer_idx = False reorder_and_upcast_attn = False **kwargs )

参数

state_dim (int, optional, 默认为 17) — RL 环境的状态大小
act_dim (int, optional, 默认为 4) — 输出动作空间的大小
hidden_size (int, optional, 默认为 128) — 隐藏层的大小
max_ep_len (int, optional, 默认为 4096) — 环境中一个 episode 的最大长度
action_tanh (bool, optional, 默认为 True) — 是否在动作预测上使用 tanh 激活
vocab_size (int, optional, 默认为 50257) — GPT-2 模型的词汇大小。定义了在调用 DecisionTransformerModel 时可以表示的不同标记数量。
n_positions (int, optional, 默认为 1024) — 该模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
n_layer (int, optional, 默认为 3) — Transformer 编码器中隐藏层的数量。
n_head (int, optional, 默认为 1) — Transformer 编码器中每个注意力层的注意力头数。
n_inner (int, optional) — 内部前馈层的维度。如果未设置，将默认为n_embd的 4 倍。
activation_function (str, optional, 默认为"gelu") — 激活函数，可在列表["relu", "silu", "gelu", "tanh", "gelu_new"]中选择。
resid_pdrop (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
embd_pdrop (int, optional, 默认为 0.1) — 嵌入的丢失比例。
attn_pdrop (float, optional, 默认为 0.1) — 注意力的丢失比例。
layer_norm_epsilon (float, optional, 默认为 1e-5) — 在层归一化层中使用的 epsilon 值。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
scale_attn_weights (bool, 可选, 默认为 True) — 通过除以 sqrt(hidden_size)来缩放注意力权重。
use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
scale_attn_by_inverse_layer_idx (bool, 可选, 默认为 False) — 是否通过1 / layer_idx + 1额外缩放注意力权重。
reorder_and_upcast_attn (bool, 可选, 默认为 False) — 是否在计算注意力（点积）之前缩放键（K），并在使用混合精度训练时将注意力点积/softmax 向上转换为 float()。

这是用于存储 DecisionTransformerModel 配置的配置类。它用于根据指定的参数实例化一个决策变换器模型，定义模型架构。使用默认值实例化配置将产生类似于标准 DecisionTransformer 架构的配置。许多配置选项用于实例化作为架构一部分使用的 GPT2 模型。

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

示例：

>>> from transformers import DecisionTransformerConfig, DecisionTransformerModel
>>> # Initializing a DecisionTransformer configuration
>>> configuration = DecisionTransformerConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = DecisionTransformerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

DecisionTransformerGPT2Model

`class transformers.DecisionTransformerGPT2Model`

<来源>

( config )

`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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

DecisionTransformerModel

`class transformers.DecisionTransformerModel`

<来源>

( config )

参数

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

决策变换器模型这个模型是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

该模型基于 GPT2 架构，在离线 RL 设置中执行动作的自回归预测。更多细节请参考论文：arxiv.org/abs/2106.01345

`forward`

<来源>

( states: Optional = None actions: Optional = None rewards: Optional = None returns_to_go: Optional = None timesteps: Optional = None attention_mask: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.decision_transformer.modeling_decision_transformer.DecisionTransformerOutput or tuple(torch.FloatTensor)

参数

states (torch.FloatTensor，形状为(batch_size, episode_length, state_dim)) — 轨迹中每个步骤的状态
actions (torch.FloatTensor，形状为(batch_size, episode_length, act_dim)) — “专家”策略对当前状态采取的动作，这些动作用于自回归预测
rewards (torch.FloatTensor，形状为(batch_size, episode_length, 1)) — 每个状态、动作的奖励
returns_to_go（形状为(batch_size, episode_length, 1)的torch.FloatTensor）- 轨迹中每个状态的回报
timesteps（形状为(batch_size, episode_length)的torch.LongTensor）- 轨迹中每一步的时间步长
attention_mask（形状为(batch_size, episode_length)的torch.FloatTensor）- 掩码，用于在执行自回归预测时屏蔽动作

transformers.models.decision_transformer.modeling_decision_transformer.DecisionTransformerOutput或tuple(torch.FloatTensor)

一个transformers.models.decision_transformer.modeling_decision_transformer.DecisionTransformerOutput或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含各种元素，取决于配置（DecisionTransformerConfig）和输入。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）- 模型最后一层的隐藏状态序列。
state_preds（形状为(batch_size, sequence_length, state_dim)的torch.FloatTensor）- 环境状态预测
action_preds（形状为(batch_size, sequence_length, action_dim)的torch.FloatTensor）- 模型动作预测
return_preds（形状为(batch_size, sequence_length, 1)的torch.FloatTensor）- 每个状态的预测回报
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 后的注意力权重，用于计算自注意力头中的加权平均值。

DecisionTransformerModel的forward方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import DecisionTransformerModel
>>> import torch
>>> model = DecisionTransformerModel.from_pretrained("edbeeching/decision-transformer-gym-hopper-medium")
>>> # evaluation
>>> model = model.to(device)
>>> model.eval()
>>> env = gym.make("Hopper-v3")
>>> state_dim = env.observation_space.shape[0]
>>> act_dim = env.action_space.shape[0]
>>> state = env.reset()
>>> states = torch.from_numpy(state).reshape(1, 1, state_dim).to(device=device, dtype=torch.float32)
>>> actions = torch.zeros((1, 1, act_dim), device=device, dtype=torch.float32)
>>> rewards = torch.zeros(1, 1, device=device, dtype=torch.float32)
>>> target_return = torch.tensor(TARGET_RETURN, dtype=torch.float32).reshape(1, 1)
>>> timesteps = torch.tensor(0, device=device, dtype=torch.long).reshape(1, 1)
>>> attention_mask = torch.zeros(1, 1, device=device, dtype=torch.float32)
>>> # forward pass
>>> with torch.no_grad():
...     state_preds, action_preds, return_preds = model(
...         states=states,
...         actions=actions,
...         rewards=rewards,
...         returns_to_go=target_return,
...         timesteps=timesteps,
...         attention_mask=attention_mask,
...         return_dict=False,
...     )

Transformers 4.37 中文文档（九十七）（3）https://developer.aliyun.com/article/1564056

Transformers 4.37 中文文档（九十七）（2）

XCLIPTextModel

`class transformers.XCLIPTextModel`

`forward`

XCLIPVisionModel

`class transformers.XCLIPVisionModel`

`forward`

强化学习模型

Decision Transformer

概述

DecisionTransformerConfig

`class transformers.DecisionTransformerConfig`

DecisionTransformerGPT2Model

`class transformers.DecisionTransformerGPT2Model`

`forward`

DecisionTransformerModel

`class transformers.DecisionTransformerModel`

`forward`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（九十七）（2）

XCLIPTextModel

class transformers.XCLIPTextModel

forward

XCLIPVisionModel

class transformers.XCLIPVisionModel

forward

强化学习模型

Decision Transformer

概述

DecisionTransformerConfig

class transformers.DecisionTransformerConfig

DecisionTransformerGPT2Model

class transformers.DecisionTransformerGPT2Model

forward

DecisionTransformerModel

class transformers.DecisionTransformerModel

forward

热门文章

最新文章

相关课程

相关电子书

`class transformers.XCLIPTextModel`

`forward`

`class transformers.XCLIPVisionModel`

`forward`

`class transformers.DecisionTransformerConfig`

`class transformers.DecisionTransformerGPT2Model`

`forward`

`class transformers.DecisionTransformerModel`

`forward`