Hugging Face 的标志

Transformers.js 文档

utils/张量

您正在查看 main 版本，该版本需要从源代码安装. 如果您想要常规 npm 安装，请查看最新的稳定版本 (v3.0.0)。
Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

utils/tensor

用于 Tensor 处理的辅助模块。

这些函数和类仅在内部使用，意味着最终用户无需访问此处的任何内容。

utils/tensor.Tensor

类型：utils/tensor 的静态类

new Tensor(...args)

创建一个新的 Tensor 或复制现有的 Tensor。

参数类型
...args*

tensor.dims : <code> 数组. < number > </code>

张量的维度。

类型：Tensor 的实例属性

tensor.type : <code> DataType </code>

张量的类型。

类型：Tensor 的实例属性

tensor.data : <code> DataArray </code>

存储在张量中的数据。

类型：Tensor 的实例属性

tensor.size : <code> number </code>

张量中元素的数量。

类型：Tensor 的实例属性

tensor.location : <code> string </code>

张量数据的位置。

类型：Tensor 的实例属性

tensor.Symbol.iterator() ⇒ <code> 迭代器 </code>

返回一个迭代器对象，用于按行优先顺序迭代张量数据。如果张量具有多个维度，则迭代器将产生子数组。

类型：Tensor 的实例方法
返回: Iterator - 一个迭代器对象，用于按行优先顺序迭代张量数据。

tensor._getitem(index) ⇒ <code> Tensor </code>

索引到 Tensor 对象中。

类型：Tensor 的实例方法
返回: Tensor - 指定索引处的数据。

参数类型描述
index数字

要访问的索引。

tensor.indexOf(item) ⇒ <code> number </code>

类型：Tensor 的实例方法
返回: number - 项目在张量数据中首次出现的索引。

参数类型描述
itemnumber | bigint

要在张量中搜索的项目

tensor._subarray(index, iterSize, iterDims) ⇒ <code> Tensor </code>

类型：Tensor 的实例方法

参数类型
index数字
iterSize数字
iterDimsany

tensor.item() ⇒ <code> number </code> | <code> bigint </code>

以标准 JavaScript Number 形式返回此张量的值。这仅适用于具有一个元素的张量。对于其他情况，请参阅 Tensor.tolist()。

类型：Tensor 的实例方法
返回: number | bigint - 此张量作为标准 JavaScript Number 的值。
抛出:

  • Error 如果张量有多个元素。

tensor.tolist() ⇒ <code> 数组 </code>

将张量数据转换为 n 维 JS 列表

类型：Tensor 的实例方法

tensor.sigmoid() ⇒ <code> Tensor </code>

返回一个新 Tensor，其中 sigmoid 函数应用于每个元素。

类型：Tensor 的实例方法
返回: Tensor - 应用了 sigmoid 函数的张量。

tensor.sigmoid_() ⇒ <code> Tensor </code>

就地将 sigmoid 函数应用于张量。

类型：Tensor 的实例方法
返回: Tensor - 返回 this。

tensor.map(callback) ⇒ <code> Tensor </code>

返回一个新 Tensor，其中回调函数应用于每个元素。

类型：Tensor 的实例方法
返回: Tensor - 一个新 Tensor，其中回调函数应用于每个元素。

参数类型描述
callback函数

要应用于每个元素的函数。它应接受三个参数：当前元素、其索引和张量的数据数组。

tensor.map_(callback) ⇒ <code> Tensor </code>

就地将回调函数应用于张量的每个元素。

类型：Tensor 的实例方法
返回: Tensor - 返回 this。

参数类型描述
callback函数

要应用于每个元素的函数。它应接受三个参数：当前元素、其索引和张量的数据数组。

tensor.mul(val) ⇒ <code> Tensor </code>

返回一个新 Tensor，其每个元素都乘以一个常数。

类型：Tensor 的实例方法
返回值: Tensor - 新的张量。

参数类型描述
val数字

要乘的值。

tensor.mul_(val) ⇒ <code> Tensor </code>

将张量乘以一个常数，原地操作。

类型：Tensor 的实例方法
返回: Tensor - 返回 this。

参数类型描述
val数字

要乘的值。

tensor.div(val) ⇒ <code> Tensor </code>

返回一个新 Tensor，其每个元素都除以一个常数。

类型：Tensor 的实例方法
返回值: Tensor - 新的张量。

参数类型描述
val数字

要除以的值。

tensor.div_(val) ⇒ <code> Tensor </code>

将张量除以一个常数，原地操作。

类型：Tensor 的实例方法
返回: Tensor - 返回 this。

参数类型描述
val数字

要除以的值。

tensor.add(val) ⇒ <code> Tensor </code>

返回一个新 Tensor，其每个元素都加上一个常数。

类型：Tensor 的实例方法
返回值: Tensor - 新的张量。

参数类型描述
val数字

要加上的值。

tensor.add_(val) ⇒ <code> Tensor </code>

将张量加上一个常数，原地操作。

类型：Tensor 的实例方法
返回: Tensor - 返回 this。

参数类型描述
val数字

要加上的值。

tensor.sub(val) ⇒ <code> Tensor </code>

返回一个新 Tensor，其每个元素都减去一个常数。

类型：Tensor 的实例方法
返回值: Tensor - 新的张量。

参数类型描述
val数字

要减去的值。

tensor.sub_(val) ⇒ <code> Tensor </code>

将张量减去一个常数，原地操作。

类型：Tensor 的实例方法
返回: Tensor - 返回 this。

参数类型描述
val数字

要减去的值。

tensor.clone() ⇒ <code> Tensor </code>

创建当前 Tensor 的深拷贝。

类型：Tensor 的实例方法
返回值: Tensor - 一个新的 Tensor，具有与原始张量相同的类型、数据和维度。

tensor.slice(...slices) ⇒ <code> Tensor </code>

对 Tensor 沿指定维度执行切片操作。

考虑一个维度为 [4, 7] 的 Tensor

[ 1,  2,  3,  4,  5,  6,  7]
[ 8,  9, 10, 11, 12, 13, 14]
[15, 16, 17, 18, 19, 20, 21]
[22, 23, 24, 25, 26, 27, 28]

我们可以对行和列这两个维度进行切片，例如在本例中，我们可以从第二个元素开始，返回到倒数第二个元素，像这样

tensor.slice([1, -1], [1, -1]);

这将返回

[  9, 10, 11, 12, 13 ]
[ 16, 17, 18, 19, 20 ]

类型：Tensor 的实例方法
返回值: Tensor - 包含所选元素的新 Tensor。
抛出:

  • Error 如果切片输入无效。
参数类型描述
...slicesnumber | Array<number> | null

每个维度的切片规范。

  • 如果给定一个数字，则选择单个元素。
  • 如果给定两个数字的数组，则选择元素范围 [开始，结束（不包含）]。
  • 如果给定 null，则选择整个维度。

tensor.permute(...dims) ⇒ <code> Tensor </code>

返回此 Tensor 的置换版本，根据提供的维度。

类型：Tensor 的实例方法
返回值: Tensor - 置换后的张量。

参数类型描述
...dims数字

要置换的维度。

tensor.sum([dim], keepdim) ⇒

返回给定维度 dim 中输入张量每行的总和。

类型：Tensor 的实例方法
返回值: 求和后的张量

参数类型默认值描述
[dim]数字

要缩减的维度。如果为 null，则缩减所有维度。
keepdimbooleanfalse

输出张量是否保留 dim。

tensor.norm([p], [dim], [keepdim]) ⇒ <code> Tensor </code>

返回给定张量的矩阵范数或向量范数。

类型：Tensor 的实例方法
返回值: Tensor - 张量的范数。

参数类型默认值描述
[p]number | string'fro'

范数的阶数
[dim]数字

指定计算范数时要跨越的张量维度。如果 dim 为 None，则将在输入的所有维度上计算范数。
[keepdim]booleanfalse

输出张量是否保留 dim。

tensor.normalize_([p], [dim]) ⇒ <code> Tensor </code>

对指定维度上的输入执行 L_p 归一化。原地操作。

类型：Tensor 的实例方法
返回值: Tensor - this 用于操作链式调用。

参数类型默认值描述
[p]数字2

范数公式中的指数值
[dim]数字1

要缩减的维度

tensor.normalize([p], [dim]) ⇒ <code> Tensor </code>

对指定维度上的输入执行 L_p 归一化。

类型：Tensor 的实例方法
返回值: Tensor - 归一化后的张量。

参数类型默认值描述
[p]数字2

范数公式中的指数值
[dim]数字1

要缩减的维度

tensor.stride() ⇒ <code> Array. < number > </code>

计算并返回此张量的步幅。步幅是从指定维度 dim 中的一个元素移动到下一个元素所需的跳跃。

类型：Tensor 的实例方法
返回值: Array.<number> - 此张量的步幅。

tensor.squeeze([dim]) ⇒ <code> Tensor </code>

返回一个张量，其中移除了输入中所有指定的大小为 1 的维度。

注意：返回的张量与输入张量共享存储空间，因此更改其中一个的内容将更改另一个的内容。如果需要副本，请在挤压之前使用 tensor.clone()。

类型：Tensor 的实例方法
返回值: Tensor - 挤压后的张量

参数类型默认值描述
[dim]number | Array<number>

如果给定，则仅在指定的维度中挤压输入。

tensor.squeeze_()

@see Tensor.squeeze 的原地版本

类型：Tensor 的实例方法

tensor.unsqueeze(dim) ⇒ <code> Tensor </code>

返回一个新的张量，在指定位置插入大小为 1 的维度。

注意：返回的张量与此张量共享相同的底层数据。

类型：Tensor 的实例方法
返回值: Tensor - 扩维后的张量

参数类型默认值描述
dim数字

插入单例维度的索引

tensor.unsqueeze_()

@see Tensor.unsqueeze 的原地版本

类型：Tensor 的实例方法

tensor.flatten_()

@see Tensor.flatten 的原地版本

类型：Tensor 的实例方法

tensor.flatten(start_dim, end_dim) ⇒ <code> Tensor </code>

通过将输入重塑为一维张量来展平输入。如果传递了 start_dim 或 end_dim，则仅展平以 start_dim 开头并以 end_dim 结尾的维度。输入中元素的顺序不变。

类型：Tensor 的实例方法
返回值: Tensor - 展平后的张量。

参数类型默认值描述
start_dim数字0

要展平的第一个维度
end_dim数字

要展平的最后一个维度

tensor.view(...dims) ⇒ <code> Tensor </code>

返回一个新张量，其数据与 self 张量相同，但 shape 不同。

类型：Tensor 的实例方法
返回值: Tensor - 具有相同数据但形状不同的张量

参数类型描述
...dims数字

期望的大小

tensor.gt(val) ⇒ <code> Tensor </code>

逐元素计算 input > val。

类型：Tensor 的实例方法
返回值: Tensor - 一个布尔张量，当输入大于 other 时为 true，否则为 false。

参数类型描述
val数字

要比较的值。

tensor.lt(val) ⇒ <code> Tensor </code>

逐元素计算 input < val。

类型：Tensor 的实例方法
返回值: Tensor - 一个布尔张量，当输入小于 other 时为 true，否则为 false。

参数类型描述
val数字

要比较的值。

tensor.clamp_()

@see Tensor.clamp 的原地版本

类型：Tensor 的实例方法

tensor.clamp(min, max) ⇒ <code> Tensor </code>

将输入张量中的所有元素夹紧到范围 [ min, max ] 内

类型：Tensor 的实例方法
返回: Tensor - 输出张量。

参数类型描述
min数字

要夹紧到的范围的下界
max数字

要夹紧到的范围的上界

tensor.round_()

@see Tensor.round 的原地版本

类型：Tensor 的实例方法

tensor.round() ⇒ <code> Tensor </code>

将输入张量的元素四舍五入到最接近的整数。

类型：Tensor 的实例方法
返回: Tensor - 输出张量。

tensor.to(type) ⇒ <code> Tensor </code>

执行张量数据类型转换。

类型：Tensor 的实例方法
返回: Tensor - 转换后的张量。

参数类型描述
typeDataType

期望的数据类型。

utils/tensor.permute(tensor, axes) ⇒ <code> Tensor </code>

根据提供的轴置换张量。

类型: utils/tensor 的静态方法
返回值: Tensor - 置换后的张量。

参数类型描述
tensorany

要置换的输入张量。
axesArray

用于置换张量的轴。

utils/tensor.interpolate(input, size, mode, align_corners) ⇒ <code> Tensor </code>

将张量插值到给定大小。

类型: utils/tensor 的静态方法
返回: Tensor - 插值后的张量。

参数类型描述
inputTensor

要插值的输入张量。数据必须是通道优先的 (即，[c, h, w])
sizeArray.<number>

图像的输出大小
modestring

插值模式
align_cornersboolean

是否对齐角点。

utils/tensor.interpolate_4d(input, options) ⇒ <code> Promise. < Tensor > </code>

对输入进行下采样/上采样。灵感来源于 https://pytorch.ac.cn/docs/stable/generated/torch.nn.functional.interpolate.html。

类型: utils/tensor 的静态方法
返回: Promise.<Tensor> - 插值后的张量。

参数类型默认值描述
inputTensor

输入张量
optionsObject

插值的选项
[options.size]*

输出空间大小。
[options.mode]"nearest" | "bilinear" | "bicubic"'bilinear'

用于上采样的算法

utils/tensor.matmul(a, b) ⇒ <code> Promise. < Tensor > </code>

两个张量的矩阵乘积。灵感来源于 https://pytorch.ac.cn/docs/stable/generated/torch.matmul.html

类型: utils/tensor 的静态方法
返回: Promise.<Tensor> - 两个张量的矩阵乘积。

参数类型描述
aTensor

要相乘的第一个张量
bTensor

要相乘的第二个张量

utils/tensor.rfft(x, a) ⇒ <code> Promise. < Tensor > </code>

计算实值输入的一维傅里叶变换。灵感来源于 https://pytorch.ac.cn/docs/stable/generated/torch.fft.rfft.html

类型: utils/tensor 的静态方法
返回: Promise.<Tensor> - 输出张量。

参数类型描述
xTensor

实值输入张量
aTensor

沿其进行一维实数 FFT 的维度。

utils/tensor.topk(x, [k]) ⇒ <code> * </code>

返回给定输入张量的 k 个最大元素。灵感来源于 https://pytorch.ac.cn/docs/stable/generated/torch.topk.html

类型: utils/tensor 的静态方法
返回: * - 顶 k 个元素及其索引的输出元组 (Tensor, LongTensor)。

参数类型描述
xTensor

输入张量
[k]数字

"top-k" 中的 k

utils/tensor.slice(data:, starts:, ends:, axes:, [steps]) ⇒ <code> Promise. < Tensor > </code>

切片多维 float32 张量。

类型: utils/tensor 的静态方法
返回: Promise.<Tensor> - 切片数据张量。

参数类型描述
dataTensor

从中提取切片的数据张量
startsArray.<number>

axes 中对应轴的起始索引的 1-D 数组
endsArray.<number>

axes 中对应轴的结束索引（不包括）的 1-D 数组
axesArray.<number>

starts 和 ends 应用于的轴的 1-D 数组
[steps]Array.<number>

axes 中对应轴的切片步长的 1-D 数组。

utils/tensor.mean_pooling(last_hidden_state, attention_mask) ⇒ <code> Tensor </code>

执行最后隐藏状态的均值池化，然后进行归一化步骤。

类型: utils/tensor 的静态方法
返回: Tensor - 返回形状为 [batchSize, embedDim] 的新张量。

参数类型描述
last_hidden_stateTensor

形状为 [batchSize, seqLength, embedDim] 的张量
attention_maskTensor

形状为 [batchSize, seqLength] 的张量

utils/tensor.layer_norm(input, normalized_shape, options) ⇒ <code> Tensor </code>

对最后几个维度应用层归一化。

类型: utils/tensor 的静态方法
返回值: Tensor - 归一化后的张量。

参数类型默认值描述
inputTensor

输入张量
normalized_shapeArray.<number>

预期大小的输入的输入形状
optionsObject

层归一化的选项
[options.eps]数字1e-5

为数值稳定性添加到分母的值。

utils/tensor.cat(tensors, dim) ⇒ <code> Tensor </code>

沿指定维度连接张量数组。

类型: utils/tensor 的静态方法
返回: Tensor - 连接后的张量。

参数类型描述
tensorsArray.<Tensor>

要连接的张量数组。
dim数字

沿其连接的维度。

utils/tensor.stack(tensors, dim) ⇒ <code> Tensor </code>

沿指定维度堆叠张量数组。

类型: utils/tensor 的静态方法
返回: Tensor - 堆叠后的张量。

参数类型描述
tensorsArray.<Tensor>

要堆叠的张量数组。
dim数字

沿其堆叠的维度。

utils/tensor.std_mean(input, dim, correction, keepdim) ⇒ <code> Array. < Tensor > </code>

计算由 dim 指定的维度上的标准差和均值。 dim 可以是单个维度，也可以是 null 以在所有维度上进行缩减。

类型: utils/tensor 的静态方法
返回: Array.<Tensor> - (std, mean) 张量的元组。

参数类型描述
inputTensor

输入张量
dimnumber | null

要缩减的维度。如果为 None，则缩减所有维度。
correction数字

样本大小和样本自由度之间的差异。默认为 Bessel 校正，correction=1。
keepdimboolean

输出张量是否保留 dim。

utils/tensor.mean(input, dim, keepdim) ⇒ <code> Tensor </code>

返回给定维度 dim 中输入张量每行的均值。

类型: utils/tensor 的静态方法
返回: Tensor - 沿指定维度取均值的新张量。

参数类型描述
inputTensor

输入张量。
dimnumber | null

要缩减的维度。
keepdimboolean

输出张量是否保留 dim。

utils/tensor.full(size, fill_value) ⇒ <code> Tensor </code>

创建大小为 size 并填充 fill_value 的张量。张量的 dtype 从 fill_value 推断。

类型: utils/tensor 的静态方法
返回: Tensor - 填充后的张量。

参数类型描述
sizeArray.<number>

定义输出张量形状的整数序列。
fill_valuenumber | bigint | boolean

用于填充输出张量的值。

utils/tensor.ones(size) ⇒ <code> Tensor </code>

返回一个填充标量值 1 的张量，其形状由变量参数 size 定义。

类型: utils/tensor 的静态方法
返回: Tensor - ones 张量。

参数类型描述
sizeArray.<number>

定义输出张量形状的整数序列。

utils/tensor.ones_like(tensor) ⇒ <code> Tensor </code>

返回一个填充标量值 1 的张量，其大小与输入相同。

类型: utils/tensor 的静态方法
返回: Tensor - ones 张量。

参数类型描述
tensorTensor

输入的大小将决定输出张量的大小。

utils/tensor.zeros(size) ⇒ <code> Tensor </code>

返回一个填充标量值 0 的张量，其形状由变量参数 size 定义。

类型: utils/tensor 的静态方法
返回: Tensor - zeros 张量。

参数类型描述
sizeArray.<number>

定义输出张量形状的整数序列。

utils/tensor.zeros_like(tensor) ⇒ <code> Tensor </code>

返回一个填充标量值 0 的张量，其大小与输入相同。

类型: utils/tensor 的静态方法
返回: Tensor - zeros 张量。

参数类型描述
tensorTensor

输入的大小将决定输出张量的大小。

utils/tensor.rand(size) ⇒ <code> Tensor </code>

返回一个填充了来自区间 [0, 1) 上均匀分布的随机数的张量

类型: utils/tensor 的静态方法
返回: Tensor - 随机张量。

参数类型描述
sizeArray.<number>

定义输出张量形状的整数序列。

utils/tensor.quantize_embeddings(tensor, precision) ⇒ <code> Tensor </code>

将嵌入张量量化为二进制或无符号二进制精度。

类型: utils/tensor 的静态方法
返回: Tensor - 量化后的张量。

参数类型描述
tensorTensor

要量化的张量。
precision'binary' | 'ubinary'

用于量化的精度。

utils/tensor~args[0] : <code> ONNXTensor </code>

类型: utils/tensor 的内部属性

utils/tensor~reshape(data, dimensions) ⇒ <code> * </code>

根据提供的维度，将一维数组重塑为 n 维数组。

类型：utils/tensor 的内部方法
返回值：* - 重塑后的数组。

参数类型描述
dataArray<T> | DataArray

要重塑的输入数组。
dimensionsDIM

目标形状/维度。

示例

reshape([10                    ], [1      ]); // Type: number[]      Value: [10]
  reshape([1, 2, 3, 4            ], [2, 2   ]); // Type: number[][]    Value: [[1, 2], [3, 4]]
  reshape([1, 2, 3, 4, 5, 6, 7, 8], [2, 2, 2]); // Type: number[][][]  Value: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
  reshape([1, 2, 3, 4, 5, 6, 7, 8], [4, 2   ]); // Type: number[][]    Value: [[1, 2], [3, 4], [5, 6], [7, 8]]

reshape~reshapedArray : <code> any </code>

类型：reshape 的内部属性

utils/tensor~reduce_helper(callbackfn, input, dim, keepdim) ⇒ <code> * </code>

类型：utils/tensor 的内部方法
返回值：* - 降维后的张量数据。

参数类型默认值描述
callbackfn*
inputTensor

输入张量。
dimnumber | null

要缩减的维度。
keepdimbooleanfalse

输出张量是否保留 dim。

utils/tensor~DataArray : <code> * </code>

类型：utils/tensor 的内部类型定义

utils/tensor~NestArray : <code> * </code>

这将创建一个具有给定类型和深度的嵌套数组（请参阅示例）。

类型：utils/tensor 的内部类型定义
示例

NestArray<string, 1>; // string[]

示例

NestArray<number, 2>; // number[][]

示例

NestArray<string, 3>; // string[][][] etc.
< > 在 GitHub 上更新

←音频 (Audio) 数学 (Maths)→