Hugging Face 的 LOGO

Transformers.js 文档

utils/tensor

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

并获得增强的文档体验

开始使用

utils/tensor

用于 `Tensor` 处理的辅助模块。

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

utils/tensor.Tensor

类型：utils/tensor 的静态类

new Tensor(...args)

创建新的张量或复制现有张量。

参数量类型
...args*

tensor.dims : <code> Array. < 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> Iterator </code>

返回一个迭代器对象，用于按行主序迭代张量数据。如果张量有多个维度，迭代器将生成子数组。

类型：Tensor 的实例方法
返回：Iterator - 用于按行主序迭代张量数据的迭代器对象。

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

对张量对象进行索引。

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

参数量类型描述
索引数字

要访问的索引。

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

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

参数量类型描述
项number | bigint

要在张量中搜索的项

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

类型：Tensor 的实例方法

参数量类型
索引数字
迭代大小数字
迭代维度任何

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

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

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

  • 如果张量有多个元素，则会抛出 Error。

tensor.tolist() ⇒ <code> Array </code>

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

类型：Tensor 的实例方法

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

返回一个新的张量，其中每个元素都应用了 sigmoid 函数。

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

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

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

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

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

返回一个新的张量，其中每个元素都应用了回调函数。

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

参数量类型描述
回调函数函数

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

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

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

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

参数量类型描述
回调函数函数

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

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

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

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

参数量类型描述
值数字

要相乘的值。

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

就地将张量乘以一个常数。

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

参数量类型描述
值数字

要相乘的值。

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

返回一个新的张量，其中每个元素都除以一个常数。

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

参数量类型描述
值数字

要除以的值。

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

就地将张量除以一个常数。

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

参数量类型描述
值数字

要除以的值。

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

返回一个新的张量，其中每个元素都加上一个常数。

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

参数量类型描述
值数字

要添加的值。

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

就地将张量加上一个常数。

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

参数量类型描述
值数字

要添加的值。

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

返回一个新的张量，其中每个元素都减去一个常数。

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

参数量类型描述
值数字

要减去的值。

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

就地将张量减去一个常数。

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

参数量类型描述
值数字

要减去的值。

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

创建当前张量的深拷贝。

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

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

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

考虑一个维度为 [4, 7] 的张量。

[ 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 - 包含所选元素的新张量。
抛出:

  • 如果切片输入无效，则会抛出 Error。
参数量类型描述
...切片number | Array<number> | null

每个维度的切片规范。

  • 如果给定一个数字，则选择单个元素。
  • 如果给定一个包含两个数字的数组，则选择一个元素范围 [start, end (exclusive)]。
  • 如果给定 null，则选择整个维度。

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

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

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

参数量类型描述
...维度数字

要置换的维度。

tensor.sum([dim], keepdim) ⇒

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

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

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

要缩减的维度。如果为 null，则缩减所有维度。
保持维度booleanfalse

输出张量是否保留 dim。

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

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

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

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

范数阶数
[dim]数字

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

输出张量是否保留维度。

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>

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

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

类型：Tensor 的实例方法
返回：Tensor - 未压缩的张量

参数量类型默认描述
维度数字

插入单例维度的索引

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 - 展平后的张量。

参数量类型默认描述
开始维度数字0

要展平的第一个维度
结束维度数字

要展平的最后一个维度

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

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

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

参数量类型描述
...维度数字

所需大小

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

逐元素计算输入 > 值。

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

参数量类型描述
值数字

要比较的值。

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

逐元素计算输入 < 值。

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

参数量类型描述
值数字

要比较的值。

tensor.clamp_()

@see Tensor.clamp 的就地版本

类型：Tensor 的实例方法

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

将输入中的所有元素限制在 [min, max] 范围内

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

参数量类型描述
最小数字

要限制的范围下限
最大数字

要限制的范围上限

tensor.round_()

@see Tensor.round 的就地版本

类型：Tensor 的实例方法

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

将输入中的元素四舍五入到最近的整数。

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

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

执行张量数据类型转换。

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

参数量类型描述
类型数据类型

所需的数据类型。

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

根据提供的轴排列张量。

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

参数量类型描述
张量任何

要排列的输入张量。
轴数组

张量沿其排列的轴。

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

将张量插值到给定大小。

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

参数量类型描述
输入张量

要插值的输入张量。数据必须是通道优先的（即 [c, h, w]）
尺寸Array.<number>

图像的输出尺寸
模式字符串

插值模式
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> - 插值后的张量。

参数量类型默认描述
输入张量

输入张量
选项对象

插值的选项
[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> - 两个张量的矩阵乘积。

参数量类型描述
a张量

第一个乘数张量
b张量

第二个乘数张量

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

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

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

参数量类型描述
x张量

实数输入张量
a张量

进行一维实数 FFT 的维度。

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

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

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

参数量类型描述
x张量

输入张量
[k]数字

"top-k" 中的 k 值

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

切片多维 float32 张量。

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

参数量类型描述
data张量

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

axes 中对应轴的起始索引的一维数组
endsArray.<number>

axes 中对应轴的结束索引（不包含）的一维数组
轴Array.<number>

starts 和 ends 应用的轴的一维数组
[steps]Array.<number>

axes 中对应轴的切片步长的一维数组。

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

对最后一个隐藏状态执行平均池化，然后进行归一化。

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

参数量类型描述
last_hidden_state张量

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

形状为 [batchSize, seqLength] 的张量

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

对最后某些维度应用层归一化。

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

参数量类型默认描述
输入张量

输入张量
normalized_shapeArray.<number>

期望输入大小的输入形状
选项对象

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

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

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

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

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

参数量类型描述
张量Array.<Tensor>

要连接的张量数组。
维度数字

要连接的维度。

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

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

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

参数量类型描述
张量Array.<Tensor>

要堆叠的张量数组。
维度数字

要堆叠的维度。

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

计算由 dim 指定的维度的标准差和均值。dim 可以是单个维度，或为 null 以缩减所有维度。

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

参数量类型描述
输入张量

输入张量
维度number | null

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

样本大小与样本自由度之间的差值。默认为贝塞尔校正，correction=1。
保持维度boolean

输出张量是否保留 dim。

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

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

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

参数量类型描述
输入张量

输入张量。
维度number | null

要缩减的维度。
保持维度boolean

输出张量是否保留 dim。

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

创建一个大小为 size 且填充了 fill_value 的张量。张量的数据类型根据 fill_value 推断。

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

参数量类型描述
尺寸Array.<number>

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

用于填充输出张量的值。

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

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

类别: utils/tensor 的静态方法
返回: Tensor - 全为 1 的张量。

参数量类型描述
尺寸Array.<number>

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

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

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

类别: utils/tensor 的静态方法
返回: Tensor - 全为 1 的张量。

参数量类型描述
张量张量

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

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

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

类别: utils/tensor 的静态方法
返回: Tensor - 全为 0 的张量。

参数量类型描述
尺寸Array.<number>

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

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

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

类别: utils/tensor 的静态方法
返回: Tensor - 全为 0 的张量。

参数量类型描述
张量张量

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

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

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

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

参数量类型描述
尺寸Array.<number>

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

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

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

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

参数量类型描述
张量张量

要量化的张量。
精度'binary' | 'ubinary'

用于量化的精度。

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

类别: utils/tensor 的内部属性

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

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

类别: utils/tensor 的内部方法
返回: * - 重塑后的数组。

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

要重塑的输入数组。
维度DIM

目标形状/维度。

示例

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*
输入张量

输入张量。
维度number | null

要缩减的维度。
保持维度booleanfalse

输出张量是否保留 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 上更新

←音频 数学→