jittor
jittor
这里是Jittor主模块的API文档，您可以通过import jittor来获取该模块。
- class jittor.ExitHooks[源代码]
该类主要用于捕获程序退出时的退出码和异常信息。在 Jittor 中，该类经常被用于添加一些在程序结束时需要进行的操作，比如资源清理等。其使用方式主要是将需要进行的操作添加到 exit 方法中。Jittor 中定义了该类的全局对象
jt.hooks供使用。- 属性:
exit_code：程序退出时的退出码。默认值：
Noneexception：程序退出时的异常信息。默认值：
None
- 代码示例:
>>> import jittor as jt >>> import sys, atexit >>> hooks = jt.ExitHooks() >>> hooks.hook() >>> def exitfoo(): ... if hooks.exception is not None: ... print("捕获到异常:", hooks.exception) ... if hooks.exit_code is not None: ... print("程序退出，退出码为", hooks.exit_code) ... >>> atexit.register(exitfoo) >>> print(1/0) # 捕获到异常: division by zero >>> sys.exit(1) # 程序退出，退出码为 1
- class jittor.Function(*args, **kw)[源代码]
用于自定义反向操作（backward operations）的函数模块。
Function类继承自 Jittor 的Module类。其派生类应实现
execute和grad两个方法，作用分别是执行前向计算和计算反向梯度。当使用自定义算子进行前向计算时，应调用类方法apply，而不是直接调用execute。注意grad接收的参数和返回值都可为None，表示无梯度。- 代码示例：
>>> import jittor as jt >>> from jittor import Function >>> class MyFunc(Function): ... def execute(self, x, y): ... self.x = x ... self.y = y ... return x*y, x/y ... def grad(self, grad0, grad1): ... return grad0 * self.y, grad1 * self.x ... >>> a = jt.array(3.0) >>> b = jt.array(4.0) >>> func = MyFunc.apply >>> c,d = func(a, b) >>> da, db = jt.grad(c+d*3, [a, b]) >>> print(da,db) jt.Var([4.], dtype=float32) jt.Var([9.], dtype=float32)
- class jittor.Module(*args, **kw)[源代码]
Module 类通常用于构建神经网络模型。Module 是 Jittor 深度学习框架的基础模块，是所有神经网络层和模型的基类。提供了构建神经网络模型所需的各种基础方法，包括前向计算( execute 方法)、设置混合精度计算(比如 float16/32 方法)、设置模型的训练/评估状态( train/eval 方法)、获取模型参数( parameters 方法) 等等。同时，由于 Jittor 是一个 JIT 编译框架，它还使用了很多 C++ 代码和编译技术来提高执行效率，这使得 Jittor 的 Module 类在运行速度上具有优势。
- 参数：
- 具体的参数取决于所定义的模型结构和网络架构。主要包括以下方面：
初始化参数：初始化 Module 对象的参数。例如权重初始化方式、偏置项初始化方式等。
超参数：定义模型结构和行为的参数。例如隐藏层的维度、激活函数的类型、优化器的学习率等。
输入数据相关参数：定义输入数据的特征维度、输入数据的形状等。
其他配置参数：指定其他模型相关的配置。例如是否使用 GPU 加速、是否打印训练过程中的日志等。
- 形状：
Input：输入形状根据具体的模型结构和网络架构而定。
Output：输出形状根据具体的模型结构和网络架构而确定。
- 代码示例：
>>> import jittor as jt >>> from jittor import nn >>> class LinearModel(nn.Module): ... def __init__(self): ... self.linear = nn.Linear(10, 2) ... def execute(self, x): ... x = self.linear(x) ... return x >>> net = LinearModel() >>> x = jt.random((10, 10)) >>> out = net(x) >>> print(out.shape) [10,2,]
- float_auto()[源代码]
根据 jt.flags.auto_mixed_precision_level 和 jt.flags.amp_reg 自动将所有参数转换为 float16 或 float32。
- load(path: str)[源代码]
从文件中加载参数。
- 参数:
path (str) – 模型位置
代码示例:
>>> class Net(nn.Module): >>> ... >>> net = Net() >>> net.save('net.pkl') >>> net.load('net.pkl')
本方法也支持从pytorch .pth文件中加载状态字典。
备注
当载入的参数与模型定义不一致时, jittor 会输出错误信息, 但是不会抛出异常. 若载入参数出现模型定义中没有的参数名, 则会输出如下信息, 并忽略此参数:
>>> [w 0205 21:49:39.962762 96 __init__.py:723] load parameter w failed ...
若载入参数的 shape 与模型定义不一致, 则会输出如下信息, 并忽略此参数:
>>> [e 0205 21:49:39.962822 96 __init__.py:739] load parameter w failed: expect the shape of w to be [1000,100,], but got [3,100,100,]
如载入过程中出现错误, jittor 会输出概要信息, 您需要仔细核对错误信息
>>> [w 0205 21:49:39.962906 96 __init__.py:741] load total 100 params, 3 failed
- modules() List[源代码]
递归地返回模块中子模块的列表。
示例代码:
>>> net = nn.Sequential(nn.Linear(2, 10), nn.ReLU(), nn.Linear(10, 2)) >>> net.modules() [Sequential( 0: Linear(2, 10, float32[10,], None) 1: relu() 2: Linear(10, 2, float32[2,], None) ), Linear(2, 10, float32[10,], None), relu(), Linear(10, 2, float32[2,], None)]
- named_modules()[源代码]
递归地返回子模块及其名称的列表。
代码示例:
>>> net = nn.Sequential(nn.Linear(2, 10), nn.ReLU(), nn.Linear(10, 2)) >>> net.named_modules() [('', Sequential( 0: Linear(2, 10, float32[10,], None) 1: relu() 2: Linear(10, 2, float32[2,], None) )), ('0', Linear(2, 10, float32[10,], None)), ('1', relu()), ('2', Linear(10, 2, float32[2,], None))]
- named_parameters(recurse=True) List[Tuple[str, Var]][源代码]
返回模块参数及其名称的列表。
示例代码:
>>> net = nn.Linear(2, 5) >>> net.named_parameters() [('weight', jt.Var([[ 0.5964666 -0.3175258 ] [ 0.41493994 -0.66982657] [-0.32677156 0.49614117] [-0.24102807 -0.08656466] [ 0.15868133 -0.12468725]], dtype=float32)), ('bias', jt.Var([-0.38282675 0.36271113 -0.7063226 0.02899247 0.52210844], dtype=float32))]
- parameters(recurse=True) List[源代码]
返回模块参数的列表。
示例代码:
>>> net = nn.Sequential(nn.Linear(2, 10), nn.ReLU(), nn.Linear(10, 2)) >>> for p in net.parameters(): ... print(p.name) ... >>> for p in net.parameters(): ... print(p.name()) ... 0.weight 0.bias 2.weight 2.bias
- register_backward_hook(func)[源代码]
在此模块的反向传播过程中挂钩输入和输出。
- 这个函数参数如下所示::
hook(module, grad_input:tuple(jt.Var)
grad_output:tuple(jt.Var)) -> tuple(jt.Var) or None
grad_input是本模块原本的梯度输入。grad_output是梯度输出, 返回值会替代输入的输入梯度。
- register_forward_hook(func)[源代码]
注册一个前向函数钩子，在Module.execute之后调用。
- 此函数可以按照如下格式调用::
hook(module, input_args, output)
- 或者::
hook(module, input_args, output, input_kwargs)
- register_pre_forward_hook(func)[源代码]
注册一个前向函数钩子，在Module.execute之前调用。
此函数可以按照如下格式调用:
hook(module, input_args)
- 或者::
hook(module, input_args, input_kwargs)
- jittor.abs_(x)[源代码]
计算给定输入的张量
x的绝对值，并直接在原地进行修改。数学公式如下:\[y = |x|\]其中 \(y\) 是输出张量，\(x\) 是输入张量。
- 参数:
x (Var): 要进行绝对值计算的输入张量。
- 返回值:
计算后的原地修改的张量(Var)，维度和输入相同。
- 代码示例：
>>> import jittor as jt >>> x = jt.array([-1, -2, 3]) >>> jt.abs_(x) jt.Var([1 2 3], dtype=int32)
- jittor.add_(x, y)[源代码]
函数是 \(add()\) 的 原地替换版本,即结果会在原始变量x上就地进行修改，不会产生新的变量。
- 参数：
x(Jittor.Var)：第一个输入变量，其值会被函数的结果替代。
y(Jittor.Var)：第二个输入变量。
- 返回值：
返回的是经过添加操作后的x(Var)。
- 代码示例：
>>> import jittor as jt >>> x = jt.array([1.0, 2.0, 3.0]) >>> y = jt.array([4.0, 5.0, 6.0]) >>> jt.add_(x, y) jt.Var([5.0, 7.0, 9.0], dtype=float32)
- jittor.argmax(x: Var, dim: int, keepdims: bool = False)[源代码]
用于找出张量
x中某个维度上元素的最大值的索引。- 参数：
x (Var): Var类型的张量
dim (int， optional): 指定在哪个维度上进行求最大值, 如果
dim指定为None, 则张量自动被展开keepdims (bool, optional): 是否保持原Var的维度，默认为
False
- 返回值：
返回一个新的张量，其中包含指定维度上每个“切片”中最大元素的索引。
- 代码示例：
>>> x = jt.randn(3,2) jt.Var([[-0.1429974 -1.1169171 ] [-0.35682714 -1.5031573 ] [ 0.66668254 1.1606413 ]], dtype=float32) >>> jt.argmax(x, 0) (jt.Var([2 2], dtype=int32), jt.Var([0.66668254 1.1606413 ], dtype=float32))
- 注意事项：
如果在指定的维度上有多个最大值，
argmax函数通常会返回这些最大值中第一个遇到的索引
- jittor.argmin(x, dim: int, keepdims: bool = False)[源代码]
返回输入张量中沿给定维度的最小值的索引。
- 参数:
x (jt.Var) : 输入的张量。
dim(int) : 计算最小值的索引的维度。
keepdims (bool) : 是否要求输出张量的维度是否与输入张量保持一致。如果这个值为True,结果张量的维度将与输入张量
x的维度一致。默认值:False。
- 返回值:
包含两个张量(Var)的元组(tuple)，第一位为返回输入张量
x沿给定维度dim的最小值的索引的张量，第二位为索引对应的最小值的张量。类型为Var的元组。- 代码示例：
>>> x = jt.random((4,4)) jt.Var([[0.4455578 0.4899658 0.854926 0.7409189 ] [0.62386227 0.2531969 0.48017916 0.37137902] [0.76723385 0.8991033 0.22901663 0.08265838] [0.23934306 0.63881433 0.55240405 0.2548534 ]], dtype=float32) >>> jt.argmin(x, dim=0) (jt.Var([3 1 2 2], dtype=int32), jt.Var([0.23934306 0.2531969 0.22901663 0.08265838], dtype=float32)) >>> jt.argmin(x, dim = 1) (jt.Var([0 1 3 0], dtype=int32), jt.Var([0.4455578 0.2531969 0.08265838 0.23934306], dtype=float32)) >>> jt.argmin(x, dim = 1, keepdims = True) (jt.Var([[0] [1] [3] [0]], dtype=int32), jt.Var([[0.4455578 ] [0.2531969 ] [0.08265838] [0.23934306]], dtype=float32))
- jittor.array(data, dtype=None)[源代码]
将输入的对象转化为
Jittor的Var对象。 即函数主要用于将给定的对象转化为Jittor框架可以处理的Var对象。如果输入的是数值，则创建的Var的dtype为输入的数值类型，若是``numpy.ndarray`` ，则Var的dtype以ndarray的dtype为准；若输入为Var对象，其dtype保持不变。- 参数：
obj(float | int | numpy.ndarray | Var): 需要转化的对象。
- 返回值：
对应的 Var 对象
- 代码示例：
>>> import jittor as jt >>> import numpy as np >>> jt.array(1) Var(1, dtype=int32) >>> jt.array(1.0) Var(1.0, dtype=float32) >>> x=jt.array(np.array([1,2,3])) >>> print(x) Var([1 2 3], dtype=int32) >>> jt.array(x) Var([1 2 3], dtype=int32)
- jittor.array64(data, dtype=None)[源代码]
本函数将输入转换为
int64类型的张量。- 参数:
data(array_like): 任何可以被转换为
jittor.Var的数据形式，可以是list，list的list，元组等。dtype(Any | None, 可选): 输出的数据的数据类型，当缺省时，生成的数组将具有
numpy.float64的数据类型。默认值:None
- 返回值:
jittor.Var: 一个
int64类型的张量- 代码示例：
>>> import jittor as jt >>> jt.array64([1,2,3]) jt.Var([1 2 3], dtype=int32)
- jittor.attrs(var)[源代码]
获取变量
var的属性。- 参数:
var (jt.Var) : 输入的变量。
- 返回值:
返回一个字典，包含变量的所有属性。
- 代码示例：
>>> a = jt.array([1, 2, 3]) >>> print(jt.attrs(a)) {'is_stop_fuse': False, 'is_stop_grad': True, 'shape': [3,], 'dtype': int32}
- jittor.clamp(x, min_v=None, max_v=None)[源代码]
- 创建一个新张量，限制张量
x中数值在特定的范围[min_v, max_v]内。对于张量x中的任何一个数值均满足： - \[y_i = \min(\max(x_i, \text{min_value}_i), \text{max_value}_i)\]
- 参数：
x (Var): Var类型的张量
min_v (int, optional): 数值的最小允许值。如果为 None，则不应用最小值限制
max_v (int, optional): 数值的最大允许值。如果为 None，则不应用最大值限制
- 返回值：
返回一个新的张量（Var），其数值的维度被限制在
[min_v, max_v]之间 。- 代码示例：
>>> x = jt.randn(4) jt.Var([ 0.8474737 0.9300491 2.8043647 -0.32242754], dtype=float32) >>> jt.clamp(x, -0.5, 0.5) jt.Var([ 0.5 0.5 0.5 -0.32242754], dtype=float32)
- 注意事项:
如果
min_v大于max_v，会引起异常
- 创建一个新张量，限制张量
- jittor.clamp_(x, min_v=None, max_v=None)[源代码]
原地修改张量
x，限制其数值在特定的范围[min_v, max_v]内。对于张量x中的任何一个数值均满足：\[x_i = \min(\max(x_i, \text{min_value}_i), \text{max_value}_i)\]- 参数：
x (Var): Var类型的张量
min_v (int, optional): 数值的最小允许值。如果为 None，则不应用最小值限制
max_v (int, optional): 数值的最大允许值。如果为 None，则不应用最大值限制
- 返回值：
就地修改输入张量
x，其数值的维度被限制在[min_v, max_v]之间 。- 代码示例：
>>> x = jt.randn(4) jt.Var([ 0.77959126 0.8394206 -1.426833 0.7886605 ], dtype=float32) >>> jt.clamp_(x, -0.5, 0.5) >>> print(x) jt.Var([ 0.5 0.5 -0.5 0.5], dtype=float32)
- 注意事项:
如果
min_v大于max_v，会引起异常
- jittor.clean()[源代码]
清理和重置Jittor的内部状态。
- 参数:
不需要任何参数。
- 返回值:
无。
- 代码示例:
>>> import jittor as jt >>> jt.clean()
- jittor.detach(x)[源代码]
创建一个已经存在的张量
x的副本，这个副本与原始张量共享数据，但不参与梯度计算。- 参数：
x (Var): Var类型的张量
- 返回值：
返回副本张量（Var）
- 代码示例：
>>> x = jt.randn((3,2)) jt.Var([[-1.7332076 -3.9374337] [ 2.2316337 1.2128713] [-2.067835 0.8186041]], dtype=float32) >>> x.detach() jt.Var([[-1.7332076 -3.9374337] [ 2.2316337 1.2128713] [-2.067835 0.8186041]], dtype=float32)
- jittor.dfs_to_numpy(x)[源代码]
将 Jittor 的变量对象转换为 \(numpy\) 数组的函数。 函数使用深度优先搜索 \(（DFS）\) 的方式，遍历输入数据中的所有元素，对每个元素进行判断，如果某个元素是 Jittor 的 \(var\) 对象，就将其转换为 \(numpy\) 数组。否则，保持不变。
- 参数：
x(list, dict, Var 或其它类型)：输入数据，可以是 \(Python\) 的内置类型（list，dict）或者 Jittor 的 \(Var\) 对象，或者是这些类型的嵌套。如果输入数据包含 \(Var\) 对象，它将被转换为 \(numpy\) 数组。其它类型的数据将保持不变。
- 返回值：
输入数据的转换结果 (类型和输入变量一致)。所有的
Jittor Var对象都被转换为numpy数组，其余数据不变。- 代码示例：
>>> import numpy as np >>> a = jt.ones([2, 3])) >>> b = [a, a] >>> c = {"x": a, "y": b} >>> res_c = dfs_to_numpy(c) >>> isinstance(res_c["x"], np.ndarray) True >>> isinstance(res_c["y"][0], np.ndarray) True
- jittor.dirty_fix_pytorch_runtime_error()[源代码]
用于处理PyTorch的运行时错误。
- 注意：
这个方法没有任何参数，对于调用它的客户端是透明的。仅在需要解决PyTorch的运行时错误时使用。没有给出具体的错误类型和解决方法，因为这是由底层库定义的，并且可能会随着时间的推移而改变。
- 代码示例:
>>> import jittor as jt >>> jt.dirty_fix_pytorch_runtime_error() >>> import torch
- 警告：
这个方法仅作为临时解决方案，使用它可能会影响PyTorch的正常使用。在无法通过其他方式解决的情况下使用。
- jittor.display_memory_info()[源代码]
展示当前Jittor正在使用的内存相关信息。
- 参数:
不需要任何参数
- 代码示例：
>>> jt.display_memory_info() === display_memory_info === total_cpu_ram: 125.7GB total_device_ram: 23.69GB hold_vars: 0 lived_vars: 0 lived_ops: 0 name: sfrl is_device: 1 used: 0 B(-nan%) unused: 0 B(-nan%) total: 0 B name: sfrl is_device: 0 used: 0 B(-nan%) unused: 0 B(-nan%) total: 0 B name: sfrl is_device: 0 used: 0 B(-nan%) unused: 0 B(-nan%) total: 0 B name: sfrl is_device: 0 used: 0 B(-nan%) unused: 0 B(-nan%) total: 0 B cpu&gpu: 0 B gpu: 0 B cpu: 0 B free: cpu(51.98GB) gpu(22.28GB) swap: total( 0 B) last( 0 B) ===========================
- 返回值:
None。
- jittor.empty(*shape, dtype='float32')[源代码]
通过指定的形状和数据类型创建一个空的张量。
- 参数：
shape(Tuple[int]):创建的张量的形状。
dtype(str,可选):创建的张量的数据类型，默认值：
float32。
- 返回值：
创建的空的张量(Var)
- 代码示例：
>>> import jittor as jt >>> jt.empty((2, 3))
- class jittor.enable_grad(**jt_flags)[源代码]
在scope类开启梯度。所有在这个scope内创建的变量都会记录梯度。
示例代码:
import jittor as jt with jt.enable_grad(): ...
- jittor.erf_(x)[源代码]
函数实现的是 对
x实施原址元素级误差函数运算，并返回结果。误差函数是高斯函数积分，可以表示为：
\[\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt\]- 参数:
x(Var)：输入的需要进行原址元素级误差函数运算的 Jittor 变量，可以是标量，向量，矩阵或任意维度的张量。
- 代码示例：
>>> import jittor as jt >>> x = jt.array([0, 1., 2.]) >>> print(jt.erf_(x)) jt.Var([0. 0.8427008 0.9953223], dtype=float32)
- 返回值：
原位计算后的与
x具有相同形状和数据类型的 Jittor 变量(Var)。
- jittor.erfinv_(x)[源代码]
函数实现的是数学中的误差反函数(erf)的就地版本 \(erf^{-1}(x)\)
其中，\(erf\) 函数定义如下，
x为实数：\[\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^{2}}\, dt\]\(erfinv\) 函数则是 \(erf\) 函数的反函数.
- 参数:
x (float): 输入的 Jittor 变量。
- 返回:
与输入类型和形状相同的 Jittor 变量(Var)。
- 代码示例:
>>> import jittor as jt >>> x = jt.array([0.5, 0.0, -0.5]) >>> y = jt.erfinv_(x) jt.Var([ 0.47693628 0. -0.47693628], dtype=float32)
- jittor.fetch(*args)[源代码]
注册一个在每个张量都计算完成并拿到数据后的回调函数。给出若干个参数，里面是
Var的都计算完成后，调用回调函数。传入回调函数的参数与fetch除去最后回调函数的参数对应，但是所有Var都替换为其data。- 参数：
前若干个参数为等待完成的
Var和其它参数，最后一个参数是回调函数
- 返回值：
无
- 代码示例：
>>> a = jt.zeros((2, 3), dtype='float32') >>> jt.fetch(a, lambda x: print('got', repr(x))) >>> jt.sync_all() got array([[0., 0., 0.], [0., 0., 0.]], dtype=float32)
- class jittor.flag_scope(**jt_flags)[源代码]
该类用于构建 Jittor 中标志作用域，及将 Jittor 配置或标志在这个作用域内进行变动。该类只是一个上下文管理器类，用于临时设置标志位的值，并在离开作用域时恢复为原始值。
- jittor.flatten(input, start_dim=0, end_dim=-1)[源代码]
将输入张量
input在指定维度的范围[start_dim, end_dim]上进行展平操作。- 参数:
input (jt.Var) : 输入的jittor张量。
start_dim (int) : 展平操作的起始维度，默认值:0。
end_dim (int) : 展平操作的结束维度，默认值:-1(代表最后一个维度)
- 返回值:
经过展平操作后的新张量,类型为jittor.Var。
- 代码示例：
>>> x = jt.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) >>> y = jt.flatten(x) jt.Var([1 2 3 4 5 6 7 8], dtype=int32) >>> y = jt.flatten(x,start_dim=1) jt.Var([[1 2 3 4] [5 6 7 8]], dtype=int32)
- jittor.float_auto(x)[源代码]
将输入的参数自动转化为浮点数。
- 参数:
x (int, float, list, tuple, np.ndarray) : 输入的待转化的参数，可以是数值型数据或者是类似列表、数组这样的容器型数据。容器型数据中的每一个元素都会被转化为相应的浮点数。
- 返回值:
转化后的浮点数。如果输入的是容器型数据，则返回的也是对应的容器型数据。比如输入的是列表，则返回的是浮点数列表；输入的是np.ndarray，则返回的是浮点数np.ndarray。
- 代码示例:
>>> jt.float_auto(1) 1.0 >>> jt.float_auto([1, 2, 3]) [1.0, 2.0, 3.0]
- jittor.format(v, spec)[源代码]
将输入的单个元素的张量转化为python数据类型的指定格式。
- 参数：
v (jittor.Var): 包含单个元素的张量。
spec (str， 可选): 设定的数值v的显示格式的描述。如果值为None，那么将使用默认的显示格式。默认值：None
- 返回值：
output (str): 根据设定格式显示的数值v的字符串形式。
- 示例：
>>> import jittor as jt >>> num1 = jt.jt.rand(1) print(num1) >>> jt.Var([0.6495372], dtype=float32) >>> num2 = jt.format(num1, '.2f') >>> print(num2) 0.65
- jittor.full(shape, val, dtype='float32')[源代码]
创建一个张量(Var)，其中张量的形状由可变参数
shape定义， 张量中的各个标量的值由可变参数val定义，数据类型由dtype定义。如果不给定dtype, 默认类型为float32。- 参数：
shape (int…): 整数序列，定义了输出张量的形状 val: 填充值，任意数值类型 dtype (var.dtype, optional): 数据类型，默认为
float32- 返回值：
返回一个填充值为
val，形状大小为shape的张量(Var)- 代码示例：
>>> jt.full((3,2), 3.14) jt.Var([[3.14 3.14] [3.14 3.14] [3.14 3.14]], dtype=float32)
- jittor.full_like(x, val, dtype=None) Var[源代码]
创建一个张量(Var)，其中张量的形状由张量
x的形状定义，张量中的各个标量的值由可变参数val定义，数据类型默认为None，即张量x的数据类型。- 参数：
x (Var): Var类型的张量
val: 填充值，任意数值类型
dtype (var.dtype, optional): 数据类型，默认为None
- 返回值：
返回一个填充值为
val，形状大小为和x一致的张量(Var)- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.full_like(x, 3.14) jt.Var([3.14 3.14 3.14], dtype=float32)
- jittor.get_len(var)[源代码]
获取输入张量的第一个维度的长度。
- 参数:
var (jittor.Var): 输入的张量(jittor.Var)。
- 返回值:
output (int): 返回输入张量的第一个维度的长度。
- 代码示例:
>>> import jittor as jt >>> v = jt.float32([1,2,3]) >>> len = jt.get_len(v) >>> print(len) 3
- 注意:
此函数通过计算变量的shape属性来获取其长度，长度等于shape的第一个元素。 例如，如果变量的shape为(3, 2, 2)，则其长度为3。
- jittor.grad(loss, targets, retain_graph=True)[源代码]
计算损失函数对目标变量的梯度。对于每个目标变量，求取损失函数对该变量的偏导数，这个偏导数就是该变量的梯度。
- 参数:
loss (Var) : 损失函数值。
targets (Var): 目标变量，可以是一个变量或变量的列表。
retain_graph (bool) : 是否保持计算图。默认值为False。如果设为True，那么在计算梯度之后，计算图不会被删除，可以进行多次反向传播。
- 返回值:
返回计算得到的梯度张量(Var)。
- jittor.is_var(v)[源代码]
检查输入是否为Jittor的张量。
- 参数：
v (Any): 待检查的输入对象。
- 返回值：
output (bool): 如果输入对象是Jittor变量，返回True，否则返回False。
- 代码示例:
>>> import jittor as jt >>> a = jt.array([1, 2, 3]) >>> print(jt.is_var(a)) True >>> b = 30 >>> print(jt.is_var(b)) False
- jittor.jittor_exit()[源代码]
主要作用是关闭Jittor，即在完成Jittor绑定的任务后，安全地退出Jittor运行环境。此函数无需任何输入参数并且没有返回值。
- 代码示例：
>>> import jittor as jt >>> jt.jittor_exit()
- jittor.liveness_info()[源代码]
获取Jittor库中的存活信息。
- 参数:
无
- 返回值:
包含存活信息的字典(dict)，包括
hold_vars,lived_vars,lived_ops。- 代码示例：
>>> jt.liveness_info() {'hold_vars': 0, 'lived_vars': 0, 'lived_ops': 0}
- jittor.load(path: str)[源代码]
从指定路径
path加载一个模型。- 参数:
path (str) :需要加载模型的具体路径，此参数为必需。
- 返回值:
返回加载后的模型。
- 代码示例：
>>> model = jt.load("/path/to/model")
- class jittor.log_capture_scope(**jt_flags)[源代码]
该类是一个上下文管理器，用于捕获并记录 log 信息。所有在该类的上下文管理器内的日志记录信息都将被捕获并保存。该类继承自 _call_no_record_scope 类，通过在代码段中临时地改变 jt_flags 标志来实现记录 LOG 调用信息。
- 参数：
**jt_flags (dict):用于修改 Jittor 运行时的参数，接受任意数量的键值对作为输入。
- 属性：
fs: 一个 flag_scope 对象，用于备份和修改 Jittor 运行时的参数。
logs: 一个空列表，在进入 log_capture_scope 时被创建。这个列表用于存储捕获到的日志信息。
- 代码示例：
>>> with jt.log_capture_scope(log_v=1) as logs: ... jt.LOG.v("...") >>> print(logs) [{'level': 'i', 'lineno': '2', 'msg': '...', 'name': '<stdin>', 'verbose': '1'}]
- jittor.make_module(func, exec_n_args=1)[源代码]
用于根据给定的函数和执行参数的数量，创建一个Jittor模块。
- 参数:
func (callable): 输入的函数，用于创建Jittor模块。
exec_n_args (int): 默认为…执行参数的数量。
- 返回值:
module (Jittor.Module): 根据给定的函数和执行参数的数量创建的Jittor模块。
- 代码示例:
>>> import jittor as jt >>> def add_func(a, b): >>> return a + b >>> module = jt.make_module(add_func, 2) >>> print(module) <class 'jittor.make_module.<locals>.MakeModule'>
- 注意:
输入的函数必须是可以调用的，并且执行参数的数量必须大于等于0。
- jittor.masked_fill(x, mask, value)[源代码]
对张量
x中mask为True的位置进行填充值value。需要保证mask的形状必须和x相匹配。- 参数:
x (jt.Var) : 输入的张量。
mask (bool Var) : 和
x形状相同的布尔类型张量。value (float) : 用于填充张量
x中对应mask为True的位置的值。
- 代码示例：
>>> x = jt.array([1, 2, 3]) >>> mask = jt.array([False, True, False]) >>> print(jt.ops.masked_fill(x, mask, -1)) jt.Var([ 1 -1 3], dtype=int32)
- 返回值:
x填充后的张量。类型为jittor.Var。
- jittor.multiply_(x, y)[源代码]
函数是 \(multiply()\) 的就地版本，即在原始变量上进行操作，不会创建新的变量。该函数主要进行两个输入参数的乘法运算。 数学公式：
\(z = x \times y\)
其中
x和y都是输入变量。- 参数：
x (int,flot or Jittor.Variable): 输入变量。
y (int,flot or Jittor.Variable)：输入变量。
- 代码示例：
>>> import jittor as jt >>> x = jt.array([1.0, 2.0, 3.0]) >>> y = jt.array([4.0, 5.0, 6.0]) >>> z = jt.multiply_(x, y) >>> print(z) array([4., 10., 18.], dtype=float32)
- 返回值：
output(Var)：
x和y的乘法结果。它的形状和数据类型与输入变量x相同。
- jittor.ne()
函数C++定义格式:
jt.Var not_equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否不相等，把结果布尔值放入输出张量的对应位置，也可以使用
!=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素不等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.not_equal(y) jt.Var([ True False True], dtype=bool) >>> x != y jt.Var([ True False True], dtype=bool)
- jittor.new_empty(x, size)[源代码]
返回一个用未初始化数据填充的张量(Var)，形状和元素类型与输入张量
x定义保持一致。- 返回值：
返回一个用初始化数据填充的张量(Var)且数据类型
dtype和输入张量x保持一致- 参数：
x (Var): Var类型的张量 size (int…): 整数序列，定义了输出的形状
- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.new_empty(x, (5,)) jt.Var([0. 0. 0. 0. 0.], dtype=float32)
- jittor.new_full(x, size, val)[源代码]
创建一个张量(Var)，其中张量的形状由可变参数
shape定义，张量中的各个标量的值由可变参数val定义，数据类型由张量x的数据类型定义。- 参数：
x (Var): Var类型的张量
size(int…): 整数序列，定义了输出张量的形状
val: 填充值，任意数值类型
- 返回值：
返回一个填充值为
val，形状大小为size的张量(Var)。- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.new_full(x, (3,2), 3) jt.Var([[3. 3.] [3. 3.] [3. 3.]], dtype=float32)
- jittor.new_ones(x, size)[源代码]
返回一个全为1的张量(Var)，形状和元素类型与输入张量
x定义保持一致。- 参数：
x (Var): Var类型的张量
- 返回值：
全为1的张量(Var)且
dtype和x保持一致- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.new_ones(x, (5,)) jt.Var([1. 1. 1. 1. 1.], dtype=float32)
- jittor.new_zeros(x, size)[源代码]
返回一个全为0的张量(Var)，数据类型由张量
x定义，形状由可变参数size定义。- 参数：
x (Var): Var类型的张量
size (int…): 整数序列，定义了输出的形状
- 返回值：
全为0的张量(Var)且数据类型
dtype和输入张量x保持一致- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.new_zeros(x, (5,)) jt.Var([0. 0. 0. 0. 0.], dtype=float32)
- class jittor.no_grad(**jt_flags)[源代码]
取消梯度范围，所有在此范围内创建的变量都将停止梯度。
继承自 flag_scope 类，作为上下文管理器，通过将 jt_flags 的 no_grad 键值设为 1，使优化器取消计算其范围内每个运算的梯度。
- 参数:
jt_flags (dict): 包含若干 Jittor 标记的字典。默认值：空。
- 代码示例：
>>> import jittor as jt >>> x = jt.array([1, 2, 3], dtype=float) >>> y = jt.array([4, 5, 6], dtype=float) >>> with jt.no_grad(): ... z = x * y ... w = z.sum() >>> optimizer = jt.optim.SGD(params=[x, y, z, w], lr=0.1) >>> optimizer.step(w) >>> x.opt_grad(optimizer) jt.Var([0. 0. 0.], dtype=float64)
- jittor.norm(x, p=2, dim=-1, keepdims=False, eps=1e-30, keepdim=False)[源代码]
计算输入向量
x的p范数(默认为2范数),p只能为1或2。如果p=1，计算公式如下:
\[\|x\|_1=\left|x_1\right|+\left|x_2\right|+\ldots+\left|x_n\right|\]如果p=2，计算公式如下：
\[\|x\|_2=\left(\left|x_1\right|^2+\left|x_2\right|^2+\ldots+\left|x_n\right|^2\right)^{1 / 2}\]- 参数:
x (jt.Var) : 输入的jittor张量。
p (int) : 需要计算的范数的类型，只能为1或2，默认值:2。
dim (int) : 指定需要计算范数的维度，如果为-1,则计算整个张量的范数。默认值:-1。
keepdims (bool) : 指定是否在输出的结果中保留原始的维度。默认值:False。
eps (float) : 用于保持数值稳定性的微小值。默认值:1e-12。
keepdim (bool) : 指定是否在输出的结果中保留原始的维度。默认值:False。
- 返回值:
计算的p范数的结果,类型为jittor.Var。
- 代码示例：
>>> x = jt.array([1.0, 2.0, 3.0]) >>> jt.norm(x) jt.Var([3.7416575], dtype=float32)
- jittor.normal(mean, std, size=None, dtype='float32') Var[源代码]
生成产生满足正态分布的随机数的张量。
- 参数:
mean (int or jt.Var) : 正态分布的均值，是标量或者一个与需要生成的数组shape相同的张量。
std (int or jt.Var) : 正态分布的标准差，是标量或者一个与需要生成的数组shape相同的张量。
size (tuple, optional) : 生成的随机张量的形状。默认值:
None。dtype (str,optional) : 生成的随机张量的数据类型。默认值:
float32。
- 返回值:
生成的产生满足正态分布的随机数的张量(Var)。
- 代码示例：
>>> jt.normal(5, 3, size=(2,3)) jt.Var([[ 8.070848 7.654219 10.252696 ] [ 6.383718 7.8817277 3.0786133]], dtype=float32) >>> mean = jt.randint(low=0, high=10, shape=(10,)) >>> jt.normal(mean, 0.1) jt.Var([1.9524184 1.0749301 7.9864206 5.9407325 8.1596155 4.824019 7.955083 8.972998 6.0674286 8.88026 ], dtype=float32)
- jittor.ones(*shape, dtype='float32')[源代码]
创建一个指定形状和数据类型的全 1 矩阵。
- 参数:
shape (int or sequence of ints): 形成全 1 矩阵的形状。可以是单个整数（生成一维数组）或整数序列（生成多维数组）。
dtype (str, 可选): 矩阵的数据类型，默认为
float。
- 返回值:
返回一个给定形状和数据类型的全 1 矩阵，类型为 jt.Var。
- 代码示例:
>>> import jittor as jt >>> jt.ones(5) jt.Var([1. 1. 1. 1. 1.], dtype=float32)
>>> jt.ones((5,), dtype='int') jt.Var([1 1 1 1 1], dtype=int32)
>>> jt.ones((2, 1), dtype='float') jt.Var([[1.] [1.]], dtype=float32)
- jittor.ones_like(x)[源代码]
返回一个全为1的张量(Var)，形状和元素类型与输入张量
x保持一致。- 参数：
x (Var): Var类型的张量
- 返回值：
全为1的张量(Var)，其形状和元素类型与输入张量
x保持一致- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.ones_like(x) jt.Var([1. 1. 1.], dtype=float32)
- jittor.outer(x, y)[源代码]
计算两个一维向量的外积。具体公式如下:
\[res_{i,j} = x_{i} \times y_{j}\]- 参数：
x(Var, numpy array, python sequence)：输入的 Var 或者 numpy 数组 或者 python 序列，表示第一个向量。
y(Var, numpy array, python sequence): 输入的 Var 或者 numpy 数组 或者 python 序列，表示第二个向量。
- 返回值：
两个一维向量的外积(Var)
- 代码示例:
>>> x = jt.arange(3) >>> y = jt.arange(4) >>> jt.outer(x, y) jt.Var([[0 0 0 0] [0 1 2 3] [0 2 4 6]], dtype=int32) >>> x.outer(y) jt.Var([[0 0 0 0] [0 1 2 3] [0 2 4 6]], dtype=int32)
- jittor.permute(x, *dim)[源代码]
返回一个张量，其数据与原始张量
x相同，其指定的维度已经根据dim参数中的指示进行了交换。- 参数：
x (Var): Var类型的张量
dim (int…): 整数序列，表示需要交换的维度, 默认为空，表示对所有轴进行转置
- 返回值：
返回改变维度的张量（Var）
- 代码示例：
>>> x = jt.randn((3,4)) >>> x jt.Var([[ 1.7929314 0.8375565 0.13141492 1.4283884 ] [ 0.0627789 1.4741095 -0.3331003 0.34370992] [ 0.405448 1.6529875 0.19640142 -0.09192007]], dtype=float32) >>> x.permute(1,0) jt.Var([[ 1.7929314 0.0627789 0.405448 ] [ 0.8375565 1.4741095 1.6529875 ] [ 0.13141492 -0.3331003 0.19640142] [ 1.4283884 0.34370992 -0.09192007]], dtype=float32)
- jittor.pow(x, y)[源代码]
对两个张量逐个元素计算乘方，也可以使用
**运算符调用- 参数：
x (Var): 乘方运算的底数
y (Var): 乘方运算的幂次，形状与
x相同
- 返回值：
乘方结果(Var)，形状与
x和y相同- 代码示例：
>>> x = jt.array([1, 2, 3]) >>> y = jt.array([2, 3, 4]) >>> jt.pow(x, y) jt.Var([ 1 8 81], dtype=int32) >>> x ** y jt.Var([ 1 8 81], dtype=int32)
- class jittor.profile_mark(mark_name: str)[源代码]
profile_mark 类用于分析部分代码的性能。该类继承了 _call_no_record_scope 类，作为上下文管理器，通过临时改变全局变量 flags.compile_options 来实现统计其范围内代码的运行时间和内存等性能参数。
- 代码示例：
>>> a = jt.rand(1000,1000) >>> b = jt.rand(1000,1000) >>> jt.sync_all() >>> results = [] >>> with jt.profile_scope() as rep: ... results.append(jt.matmul(a, b)) ... with jt.profile_mark("mark1"): ... results.append(jt.matmul(a, b)) ... with jt.profile_mark("mark2"): ... results.append(jt.matmul(a, b)) ... with jt.profile_mark("mark3"): ... results.append(jt.matmul(a, b)) ... results.append(jt.matmul(a, b)) # 输出：性能分析结果，包括每个 mark 段落的性能评估报告
- class jittor.profile_scope(warmup=0, rerun=0, **jt_flags)[源代码]
profile_scope 类是用来测量代码执行时间的一个工具，封装了自动化性能分析的功能。使用此上下文管理器来记录 Jittor 程序的性能数据。
- jittor.rand(*size, dtype='float32', requires_grad=True) Var[源代码]
返回一个元素值用从[0, 1)均匀分布中抽样取得的随机Var形式张量。
- 参数:
*size (序列的整数) – 输出张量的期望形状，例如 (m, n, k)。
dtype (str, 可选) – 输出张量的数据类型，默认为
float32。requires_grad (bool, 可选) – 是否需要返回梯度，默认为
False。
- 返回值:
返回一个 *size 维Var形式张量，元素值用从[0, 1)均匀分布中抽样取得的随机Var形式张量。
- 代码示例：
>>> import jittor as jt >>> jt.random.seed(3) >>> jt.rand(3,3) jt.Var([[0.5509497 , 0.6197729 , 0.909781 ], [0.04279451, 0.10358319, 0.9024445 ], [0.09957159, 0.95744824, 0.546594 ]], dtype=float32)
- jittor.rand_like(x, dtype=None) Var[源代码]
生成一个元素值从[0,1]均匀分布中抽样取得的张量，并且形状与输入的张量形状相同。
- 参数:
x (jt.Var) : 输入的张量。
dtype (str,optional) : 生成的随机张量的数据类型。如果此参数为None, 则生成的张量的数据类型将与输入的张量的数据类型相同。默认值:
None。
- 返回值:
与输入的张量
x形状相同，值为[0,1]均匀分布随机抽样的张量。- 代码示例：
>>> x = jt.zeros((2, 3)) >>> jt.rand_like(x) jt.Var([[0.6164821 0.21476883 0.61959815] [0.58626485 0.35345772 0.5638483 ]], dtype=float32)
- jittor.randint(low, high=None, shape=(1,), dtype='int32') Var[源代码]
用于在一个指定的范围 [
low,high)内生成随机整数张量。- 参数:
low (int, optional) : 生成随机数的范围的下限。默认值:
0。high (int) : 生成随机数的范围的上限。
shape (tuple, optional) : 生成的随机张量的形状。默认值:
(1,)。dtype (str,optional) : 生成的随机张量的数据类型。默认值:
int32。
- 返回值:
生成的随机张量(Var)。
- 代码示例：
>>> jt.randint(3, shape=(3, 3)) jt.Var([[2 0 2] [2 1 2] [2 0 1]], dtype=int32) >>> jt.randint(1, 3, shape=(3, 3)) jt.Var([[2 2 2] [1 1 2] [1 1 1]], dtype=int32)
- jittor.randint_like(x, low, high=None) Var[源代码]
用于在一个指定的范围[
low,high)内生成随机整数张量，并且形状与输入变量x相同。- 参数:
x (jt.Var) : 输入的张量。
low (int, optional) : 生成随机数的范围的下限。默认值:
0。high (int) : 生成随机数的范围的上限。
- 返回值:
生成的形状与输入变量
x相同的随机张量(Var)。- 代码示例：
>>> x = jt.zeros((2, 3)) >>> jt.randint_like(x, 10) jt.Var([[9. 3. 4.] [4. 8. 5.]], dtype=float32) >>> jt.randint_like(x, 10, 20) jt.Var([[17. 11. 18.] [14. 17. 15.]], dtype=float32)
- jittor.randn(*size, dtype='float32', requires_grad=True) Var[源代码]
返回一个具有标准正态分布的张量。
- 参数:
size (int or a sequence of int) : 生成张量的形状。
dtype(str,optional) : 生成张量的数据类型，默认值:
float32。requires_grad (bool) : 是否能够进行梯度反向传播。默认值:
True。
- 返回值:
生成的具有标准正态分布的张量。类型为jittor.Var。
- 代码示例：
>>> jt.randn(3) jt.Var([-1.019889 -0.30377278 -1.4948598 ], dtype=float32) >>> jt.randn(2, 3) jt.Var([[-0.15989183 -1.5010914 0.5476955 ] [-0.612632 -1.1471151 -1.1879086 ]], dtype=float32)
- jittor.randn_like(x, dtype=None) Var[源代码]
生成一个元素服从标准正态分布的张量，并且形状与输入的张量形状相同的随机张量。
- 参数:
x (jt.Var) : 输入的张量。
dtype (str,optional) : 生成的随机张量的数据类型。如果此参数为None, 则生成的张量的数据类型将与输入的张量的数据类型相同。默认值:
None。
- 返回值:
与输入的张量
x形状相同，元素服从标准正态分布的张量(Var)。- 代码示例：
>>> x = jt.zeros((2, 3)) >>> jt.randn_like(x) jt.Var([[-1.1647032 0.34847224 -1.3061888 ] [ 1.068085 -0.34366122 0.13172573]], dtype=float32)
- jittor.random(shape, dtype='float32', type='uniform')[源代码]
生成一个给定形状，值为随机数的张量
- 参数：
shape (tuple[int]): 生成张量的形状
dtype (str): 数据类型。默认值：
'float32'type (Literal[‘uniform’, ‘normal’]):
'uniform'：生成 0 到 1 之间的均匀随机数；'normal'：生成均值为 0 方差为 1 的正态分布随机数。默认值：'uniform'
- 返回值：
生成的随机数
- 代码示例：
>>> jt.random((3,)) jt.Var([0.7427739 0.80093205 0.2652795 ], dtype=float32) >>> jt.random((3,), type='normal') jt.Var([ 1.2703565 0.20411628 -1.1991016 ], dtype=float32)
- jittor.register_hook(v, hook)[源代码]
将钩子函数注册到指定变量上。钩子函数将在变量的backward操作结束后被调用，主要用于获取变量的梯度信息。
- 参数：
v (jittor.Var): 需要注册钩子的张量(jittor.Var)
hook (Callable(jittor.Var, Union{None, jittor.Var})): 用于处理变量梯度的钩子函数，接收Jittor变量作为参数，返回None或Jittor变量。
- 返回值：
无返回值
- 代码示例:
>>> import jittor as jt >>> x = jt.array([0.0, 0.0]) >>> y = x * [1, 2] >>> y.register_hook(lambda g: g * 2) >>> dx = jt.grad(y, x) >>> print(dx) jt.Var([2. 4.], dtype=float32)
- jittor.reshape(x, *shape)[源代码]
函数C++定义格式:
jt.Var reshape(jt.Var x, NanoVector shape)
将输入的张量根据指定的形状进行重塑，并返回这个新的张量。保持元素的数据和数量不变。其中一维可以是-1，在这种情况下，它是根据其余的维度和输入的元素数量推断出来的。
- 参数：
x(jt.Var): 输入的张量。
shape(Tuple[int]): 输出的形状,一个整数列表。
- 返回值：
重塑过后的张量（jt.Var）
- 代码示例：
>>> jt.randint(0, 10, shape=(12,)) jt.Var([4 0 8 4 6 3 1 8 1 1 2 2], dtype=int32) >>> jt.reshape(a, (3, 4)) jt.Var([[4 0 8 4] [6 3 1 8] [1 1 2 2]], dtype=int32) >>> jt.reshape(a, (-1, 6)) jt.Var([[4 0 8 4 6 3] [1 8 1 1 2 2]], dtype=int32)
- jittor.safepickle(obj, path)[源代码]
该函数使用pickle模块将指定对象保存至给定路径。
- 参数：
obj(any):需要被保存的对象。
path(str): 一个字符串，用于指定对象保存的文件路径。
- 返回值：
无返回值。
- 代码示例:
>>> import jittor as jt >>> a = [1, 2, 3] >>> jt.safepickle(a, '/path/to/save')
- jittor.safeunpickle(path)[源代码]
该函数用于安全地反序列化pickle文件。
- 参数:
path (str): pickle文件的路径。
- 返回值:
反序列化的对象(obj)。
- 示例代码:
>>> import jittor as jt >>> jt.safeunpickle('path_to_pickle_file')
- jittor.save(params_dict, path: str)[源代码]
将指定的参数
params_dict保存到指定的路径path。- 参数:
params_dict (list or dictionary) : 待保存的参数。
path (str) : 保存的文件路径。
- 返回值:
None。
- 代码示例：
>>> params_dict = {"weight": np.array([1, 2, 3]), "bias": np.array([0.1, 0.2, 0.3])} >>> jt.save(params_dict, "params.p")
- jittor.sigmoid_(x)[源代码]
原地版本的 sigmoid 函数。这个函数会把输入的 Jittor 变量直接进行替换。 sigmoid 函数的数学形式为:
\[\sigma(x) = \frac{1}{1 + e^{-x}}\]- 参数:
x (Var): 输入的 Jittor 变量。
- 返回值:
应用了 \(sigmoid\) 函数后的 Jittor 变量(Var)。
- 代码示例:
>>> import jittor as jt >>> a = jt.array([1.0, 2.0, 3.0]) >>> b = sigmoid_(a) jt.Var([0.7310586 0.880797 0.95257413], dtype=float32)
- jittor.single_process_scope(rank=0)[源代码]
为指定的单个进程建立独立的作用域。
- 参数:
rank (int): 对应进程的的编号。
- 返回值:
无返回值
- 代码示例:
>>> @jt.single_process_scope(rank=0) >>> def xxx(): >>> ...
- jittor.size(v, dim=None)[源代码]
返回该张量的大小。 如果未指定dim，则返回值是该张量的大小。 如果指定了dim，则返回一个该维度的大小。
- 参数：
v (jt.Var): 输入的张量。
dim (int， 可选): 要查询大小的维度。默认值：
None
- 返回值：
output{int, tuple}: 如果dim为None，返回v的总大小；否则返回v在维度dim上的大小。
- 代码示例:
>>> import jittor as jt >>> a = jt.random((2,3)) >>> jt.size(a) 6 >>> jt.size(a, 0) 2 >>> jt.size(a, 1) 3
- 注意：
如果dim < 0，则将其解释为：v的维度数+dim，因此保持其在v的尺寸中。例如，如果v是2D的，dim= -1表示最后一个维度。
- jittor.sqr(x)[源代码]
创建一个张量，其将
x中的每一个数值进行平方运算。\[out_i = \sqr{input_i}\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行平方运算后的值- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-0.29049814 0.3832289 -0.6810643 -0.65432096 0.39759803], dtype=float32) >>> jt.sqr(x) jt.Var([0.08438917 0.14686438 0.4638486 0.4281359 0.1580842 ], dtype=float32)
- jittor.sqrt_(x)[源代码]
对给定的输入变量
x进行开原地开平方，并将结果赋值给原变量。使用算法\[\sqrt{x}\]对输入的每一个元素进行开平方。
- 参数:
x (Var): 需要进行开平方的变量。
- 返回值:
经过开平方处理的变量(Var)。
- 代码示例:
>>> import jittor as jt >>> a = jt.array([4., 9.]) >>> jt.sqrt_(a) jt.Var([2., 3.], dtype=float32)
- jittor.squeeze(x, dim=None)[源代码]
创建一个新张量，移除 输入变量``x`` 张量中所有长度为1的维度。如果指定维度
dim, 则只移除该维度（如果其长度为1）。- 参数：
x (Var): Var类型的张量
dim (int, optional): 需要删除的维度，默认为
None表示所有维度。
- 返回值：
返回一个新的张量（Var），移除指定维度长度为1的维度。
- 代码示例：
>>> x = jt.zeros(2, 1, 2, 1, 2) >>> x.size() [2,1,2,1,2,] >>> y1 = jt.squeeze(x) >>> y1.size() [2,2,2,] >>> y2 = jt.squeeze(x, 1) >>> y2.size() [2,2,1,2,]
- 注意事项:
如果
dim传入了长度不为1的维度，或者多个维度的元组，会引起异常
- jittor.std(x)[源代码]
计算给定张量
x的标准差。 标准差的计算公式如下:\[\sigma=\sqrt{\sum_{i=0}^{N-1}\left(x_i-\bar{x}\right)^2}\]其中 \(\bar{x}\) 为
x的均值, \(N\) 为x中元素的数量， \(x_i\) 为x中的第i个元素- 参数:
x (jt.Var) : 输入的jittor张量。
- 返回值:
输入张量
x的标准差,类型为jittor.Var。- 代码示例：
>>> x = jt.array([1.0, 2.0, 3.0, 4.0]) >>> jt.std(x) jt.Var([1.2909944], dtype=float32)
- jittor.to_bool(v)[源代码]
将输入变量v中元素转化为布尔值.
- 参数:
v (jittor.Var): 输入只能是单个元素的Var, 其中的元素必须是布尔值(bool)或者是整数(int)。
- 返回值:
output (bool): 输出转化之后的布尔值。
- 代码示例:
>>> import jittor as jt >>> print(jt.to_bool(jt.Var([1]))) True >>> print(jt.to_bool(jt.Var(0))) False >>> print(jt.to_bool(jt.Var(False))) False >>> print(jt.to_bool(jt.Var(9))) True
- jittor.to_float(v)[源代码]
将输入变量v中元素转化为浮点数类型.
- 参数:
v (jittor.Var): 输入只能是单个元素的张量(jittor.Var)。
- 返回值:
output (float): 输出转化之后的浮点数。
- 代码示例:
>>> import jittor as jt >>> print(jt.to_float(jt.Var(1))) 1.0 >>> print(jt.to_float(jt.Var([[True]]))) 1.0
- jittor.to_int(v)[源代码]
将v中元素转化为整数.
- 参数:
v (jittor.Var): 输入只能是单个元素的Var。
- 返回值:
output (int): 输出转化之后的整数。
- 代码示例:
>>> import jittor as jt >>> print(jt.to_int(jt.Var(True))) 1 >>> print(jt.to_int(jt.Var([[1.6]]))) 1
- jittor.transpose(x, *dim)[源代码]
函数C++定义格式:
jt.Var transpose(jt.Var x, NanoVector axes=NanoVector())
返回一个张量，其数据与原始张量
x相同，其指定的维度已经根据dim参数中的指示进行了交换。 参数：x (Var): Var类型的张量
axes (int…): 整数序列，表示需要交换的维度, 默认为空，表示对所有轴进行转置
- 返回值：
返回改变维度的张量(Var).
- 代码示例：
>>> x = jt.randn((3,4)) >>> x jt.Var([[ 1.7929314 0.8375565 0.13141492 1.4283884 ] [ 0.0627789 1.4741095 -0.3331003 0.34370992] [ 0.405448 1.6529875 0.19640142 -0.09192007]], dtype=float32) >>> jt.transpose(x) jt.Var([[ 1.7929314 0.0627789 0.405448 ] [ 0.8375565 1.4741095 1.6529875 ] [ 0.13141492 -0.3331003 0.19640142] [ 1.4283884 0.34370992 -0.09192007]], dtype=float32)
- jittor.type_as(a, b)[源代码]
将张量
a的数据类型修改为与张量b的数据类型相同。- 参数:
a (jt.Var) : 输入的源张量，需要修改其数据类型的张量。
b (jt.Var) : 输入的目标张量，将会根据此张量的数据类型修改a的数据类型。
- 返回值:
a中数据类型已经修改为张量b的数据类型的新张量。类型为jittor.Var。- 代码示例：
>>> a = jt.float32([1,2,3]) >>> b = jt.int32([4,5,6]) >>> a = jt.type_as(a, b) >>> print(a) jt.Var([1 2 3], dtype=int32)
- jittor.unsqueeze(x, dim)[源代码]
创建一个新张量，其数据与原始张量
x相同，其形状在指定的dim维度上增加了一个大小为 1 的新维度。- 参数：
x (Var): Var类型的张量
dim (int): 插入单维度的索引值，该值的范围需要满足
[-x.dim() - 1, x.dim() + 1)。
- 代码示例：
>>> x = jt.array([1,2,3,4]) jt.Var([1 2 3 4], dtype=int32) >>> jt.unsqueeze(x, 0) jt.Var([[1 2 3 4]], dtype=int32) >>> jt.unsqueeze(x, 1) jt.Var([[1] [2] [3] [4]], dtype=int32)
- 返回值：
返回一个新的张量（Var），其形状在指定的
dim维度上增加了一个大小为 1 的新维度。其他维度保持不变。
- jittor.var(x, dim=None, dims=None, unbiased=False, keepdims=False)[源代码]
返回样本对指定维度的方差。如果``unbiased``为True，则使用贝塞尔修正。
- 参数:
x (jt.Var) : 输入的jittor变量。
dim (int) : 计算方差的维度。如果dim和dims都为None，则将计算整个张量的方差。默认值:
Nonedims (tuple of int) : 计算方差的维度。如果dim和dims都为None，则将计算整个张量的方差。默认值:
Noneunbiased (bool) : 如果为True，则使用贝塞尔修正。
keepdims (bool) : 用于指定计算的输出是否保持原始张量的维度。如果
keepdims=True，输出形状与输入形状相同。比如，输入的张量形状是 (3, 4) ，方差是对第一维（dim=0）求的，则输出的形状还是 (3, 4)。如果keepdims=False，则输出的形状就是 (4,)。默认值:False。
- 返回值:
返回计算得到的方差,类型为jittor.Var。
- 代码示例：
>>> a = jt.rand(3) >>> a jt.Var([0.79613626 0.29322362 0.19785859], dtype=float32) >>> a.var() jt.Var([0.06888353], dtype=float32) >>> a.var(unbiased=True) jt.Var([0.10332529], dtype=float32)
- jittor.view(x, *shape)
函数C++定义格式:
jt.Var reshape(jt.Var x, NanoVector shape)
将输入的张量根据指定的形状进行重塑，并返回这个新的张量。保持元素的数据和数量不变。其中一维可以是-1，在这种情况下，它是根据其余的维度和输入的元素数量推断出来的。
- 参数：
x(jt.Var): 输入的张量。
shape(Tuple[int]): 输出的形状,一个整数列表。
- 返回值：
重塑过后的张量（jt.Var）
- 代码示例：
>>> jt.randint(0, 10, shape=(12,)) jt.Var([4 0 8 4 6 3 1 8 1 1 2 2], dtype=int32) >>> jt.reshape(a, (3, 4)) jt.Var([[4 0 8 4] [6 3 1 8] [1 1 2 2]], dtype=int32) >>> jt.reshape(a, (-1, 6)) jt.Var([[4 0 8 4 6 3] [1 8 1 1 2 2]], dtype=int32)
- jittor.vtos(v)[源代码]
将给定的输入向量v转换为字符串。
- 参数:
v (jittor.Var): 输入的需要转换的张量。
- 返回值:
output (str): 转换后的字符串。
- 代码示例:
>>> import jittor as jt >>> v = jt.array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]) >>> print(jt.vtos(v)) # '1 2 3' jt.Var([[1 2 3] [1 2 3] [1 2 3]], dtype=int32)
- jittor.zeros(*shape, dtype='float32')[源代码]
返回一个全为0的张量(Var)，形状由可变参数
size定义，数据类型由dtype定义。如果不给定dtype, 默认类型为float32。- 参数：
size (int…): 整数序列，定义了输出的形状
dtype (var.dtype, optional): 数据类型，默认为
float32
- 返回值：
元素全为0的张量(Var)
- 代码示例：
>>> jt.zeros((3,2), dtype='int32') jt.Var([[0 0] [0 0] [0 0]], dtype=int32) >>> jt.ones_like(x) jt.Var([1. 1. 1.], dtype=float32)
- jittor.zeros_like(x, dtype=None) Var[源代码]
创建一个全为0的张量(Var)，其中张量的形状由张量
x的形状定义，数据类型默认为None,即张量x的数据类型。- 参数：
x (Var): Var类型的张量
dtype (var.dtype, optional): 数据类型，默认为
None
- 返回值：
返回一个值全为0，形状大小为和
x一致的张量(Var)- 代码示例：
>>> jt.array([1, 2, 3]).float() jt.Var([1. 2. 3.], dtype=float32) >>> jt.zeros_like(x) jt.Var([0. 0. 0.], dtype=float32)
jittor.Var
这里是Jittor的基础变量类的API文档。
- jittor_core.Var.abs()
函数C++定义格式:
jt.Var abs(jt.Var x)
创建一个张量，其将输入变量
x中的每一个数值转换为其绝对值。\[out_i = |input_i|\]- 返回值：
返回一个新的张量, 其数值是
x中对应位置的绝对值- 参数：
x (Var): Var类型的张量
- 代码示例：
>>> jt.float32([-1, 0, 1]).abs() jt.Var([1. 0. 1.], dtype=float32)
- jittor_core.Var.acos()
函数C++定义格式:
jt.Var acos(jt.Var x)
创建一个张量, 其将输入变量
x中的每一个数值进行反余弦运算。\[y_i = \cos^{-1}(x_i)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反余弦运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-0.8017247 2.4553642 -0.57173574 -0.06912863 1.5478854 ], dtype=float32) >>> x.arccos() jt.Var([2.5009716 nan 2.1794162 1.6399801 nan], dtype=float32)
- 注意事项：
反余弦函数的定义域是
[-1, 1]，值域是[0,pi]， 如果定义域不在规定范围内， 返回nan支持使用
jt.arccos()进行调用同
jt.acos()函数
- jittor_core.Var.acosh()
函数C++定义格式:
jt.Var acosh(jt.Var x)
创建一个张量, 其将输入变量
x中的每一个元素进行反双曲余弦运算。\[y_i = \cosh^{-1}(x_i) \]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反双曲余弦运算的结果- 代码示例：
>>> x = jt.randn(5) + 1 >>> x jt.Var([-0.46972263 -0.6531948 1.7161269 1.007987 1.3451817 ], dtype=float32) >>> x.acosh() jt.Var([ nan nan 1.1348774 0.1263045 0.8086661], dtype=float32)
- 注意事项：
该函数的定义域是[1, ∞)，值域是实数集， 如果定义域不在规定范围内， 返回
nan支持使用
x.arccosh()进行调用同
jt.arccosh()
- jittor_core.Var.add()
函数C++定义格式:
jt.Var add(jt.Var x, jt.Var y)
对两个张量中对应元素计算求和，也可以使用
+运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相加结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.add(y) jt.Var([4 6 9], dtype=int32) >>> x + y jt.Var([4 6 9], dtype=int32)
- jittor_core.Var.all_()
函数C++定义格式:
jt.Var reduce_logical_and(jt.Var x, int dim, bool keepdims=false)
对输入的数组计算指定维度上所有元素的逻辑与。
如果输入 Var 中沿此维度的元素中全为 True，结果对应位置才是 True，否则为 False。
x无论是什么数据类型，都将被转换为 bool 类型来计算。- 参数:
x(Var): 输入的张量
dims(int, or Tuple of int): 要计算逻辑与的轴，如果是 Tuple 则在这些维度上依次进行降维求逻辑与计算，如果是 int 则在这一维度上进行降维求逻辑与计算。如果为空则对张量整体求逻辑与运算
keepdims(bool or int): 如果为 True，则进行求逻辑与的维度将被保留，否则消除这一维度。如果输入的是 int, 0 被认为是 False，非 0 被认为是 True。默认值：
False
- 返回值:
Var: 返回一个新的数组，进行过一次或多次降维求逻辑与后的结果。
- 代码示例:
>>> a = jt.array([[1,1,1],[1,0,1],[0,1,1]]) >>> jt.all_(a, 1) jt.Var([1 0 0], dtype=int32) >>> jt.reduce_logical_and(a, 1, True) jt.Var([[1] [0] [0]], dtype=int32) >>> jt.all_(a, (1, 0)) jt.Var([0], dtype=int32) >>> jt.reduce_logical_and(a, 0) jt.Var([0 0 1], dtype=int32)
- 注意事项:
jt.all_等价于jt.reduce_logical_and
- jittor_core.Var.any_()
函数C++定义格式:
jt.Var reduce_logical_or(jt.Var x, int dim, bool keepdims=false)
对输入的数组计算指定维度上所有元素的逻辑或。
如果输入 Var 中沿此维度的元素中全为 False，结果对应位置才是 False，否则为 True。
x无论是什么数据类型，都将被转换为 bool 类型来计算。- 参数:
x(Var): 输入的张量
dims(int, or Tuple of int，可选): 要计算逻辑或的轴，如果是 Tuple 则在这些维度上依次进行降维求逻辑或计算，如果是 int 则在这一个维度上进行降维求逻辑或计算。如果为空则对张量整体求逻辑与运算
keepdims(bool or int，可选): 如果为 True，则进行求逻辑或的维度将被保留，否则消除这一维度。如果输入的是 int, 0 被认为是 False，非 0 被认为是 True。默认值：
False
- 返回值:
Var: 返回一个新的张量，进行过一次或多次降维求逻辑或后的结果。
- 代码示例:
>>> a = jt.array([[0,0,0],[0,1,0],[1,0,0]]) >>> jt.reduce_logical_or(a, 1) jt.Var([0 1 1], dtype=int32) >>> jt.any_(a, 1, True) jt.Var([[0] [1] [1]], dtype=int32) >>> jt.reduce_logical_or(a, (1, 0)) jt.Var([1], dtype=int32) >>> jt.any_(a, 0) jt.Var([1 1 0], dtype=int32)
- 注意事项:
jt.any_等价于jt.reduce_logical_or
- jittor_core.Var.arccos()
函数C++定义格式:
jt.Var acos(jt.Var x)
创建一个张量, 其将输入变量
x中的每一个数值进行反余弦运算。\[y_i = \cos^{-1}(x_i)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反余弦运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-0.8017247 2.4553642 -0.57173574 -0.06912863 1.5478854 ], dtype=float32) >>> x.arccos() jt.Var([2.5009716 nan 2.1794162 1.6399801 nan], dtype=float32)
- 注意事项：
反余弦函数的定义域是
[-1, 1]，值域是[0,pi]， 如果定义域不在规定范围内， 返回nan支持使用
jt.arccos()进行调用同
jt.acos()函数
- jittor_core.Var.arcsin()
函数C++定义格式:
jt.Var asin(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行反正弦运算。\[y_i = \sin^{-1}(x_i)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反正弦运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-1.6485653 -0.10077649 -0.7546536 -0.02543143 1.0830703 ], dtype=float32) >>> x.arcsin() jt.Var([ nan -0.10094785 -0.85512596 -0.02543417 nan], dtype=float32)
- 注意事项：
反正弦函数的定义域是
[-1, 1]，值域是实数集， 如果定义域不在规定范围内， 返回nan支持使用
jt.arcsin()进行调用同
jt.asin()函数
- jittor_core.Var.arcsinh()
函数C++定义格式:
jt.Var asinh(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行反双曲正弦运算。\[y_i = \sinh^{-1}(x_i) = \ln\left(x_i + \sqrt{x_i^2 + 1}\right)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反双曲正弦运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 0.50530916 -1.0814334 0.0039318 1.1737247 -1.4199417 ], dtype=float32) >>> x.arcsinh() jt.Var([ 0.48595542 -0.9377998 0.00393179 0.99904275 -1.1495185 ], dtype=float32)
- 注意事项：
反正弦函数的定义域和值域是实数集
支持使用
x.asinh()进行调用同
jt.asinh()
- jittor_core.Var.arctan()
函数C++定义格式:
jt.Var atan(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行反正切运算。\[y_i = \tan^{-1}(x_i)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反正切运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-0.1146331 -0.22897322 -1.1813502 0.7146521 -0.02658333], dtype=float32) >>> x.arctan() jt.Var([-0.1141349 -0.22509298 -0.86834407 0.6204921 -0.02657707], dtype=float32)
- 注意事项：
该函数的定义域为实数集，值域为
\[\left(-\frac{\pi}{2}, \frac{\pi}{2}\right)\]支持使用
jt.arctan()进行调用同
jt.atan()函数
- jittor_core.Var.arctanh()
函数C++定义格式:
jt.Var atanh(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行反双曲正切运算。\[atanh(x) = \frac{1}{2} * log(\frac{1 + x}{1 - x})\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反双曲正切运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 0.561267 1.7155168 -0.53718305 1.6382825 0.5129911 ], dtype=float32) >>> x.arctanh() jt.Var([ 0.634681 nan -0.6001876 nan 0.5667807], dtype=float32)
- 注意事项：
该函数的定义域是(-1, 1)，值域是实数集，如果定义域不在规定范围内， 返回
nan支持使用
jt.arctanh()进行调用同
jt.atanh()
- jittor_core.Var.arg_reduce()
函数C++定义格式:
vector_to_tuple<VarHolder*> arg_reduce(jt.Var x, String op, int dim, bool keepdims)
计算张量在
dim维度最大或最小值的索引和实际值- 参数：
x (Var): 输入数据
op (Literal[‘max’, ‘min’]): 计算的操作， 有2个选择：
'max'或'min'dim (int): 在哪个维度计算
keepdims (bool): 是否保留
dim维度
- 返回值：
tuple[Var, Var]类型，表示x在dim维度的最大和最小值的索引和实际值。如果keepdims为True则形状为x将dim维的长度变成 1，否则是x的形状去掉dim维- 代码示例：
>>> x = jt.randint(0, 10, shape=(2, 3)) >>> x jt.Var([[4 2 5] [6 7 1]], dtype=int32) >>> jt.arg_reduce(x, 'max', dim=1, keepdims=False) (jt.Var([2 1], dtype=int32), jt.Var([5 7], dtype=int32)) >>> jt.arg_reduce(x, 'min', dim=1, keepdims=False) (jt.Var([1 2], dtype=int32), jt.Var([2 1], dtype=int32)) >>> jt.arg_reduce(x, 'max', dim=0, keepdims=False) (jt.Var([1 1 0], dtype=int32), jt.Var([6 7 5], dtype=int32))
- jittor_core.Var.argsort()
函数C++定义格式:
vector_to_tuple<VarHolder*> argsort(jt.Var x, int dim=-1, bool descending=false, String dtype=ns_int32)
返回张量在
dim维排序的所用的下标排列和排序后的值- 参数：
x (Var): 被排序的数据
dim (int): 在哪个维度排序，负数表示从后往前数。默认值：
-1descending (bool): 是否降序排列，False表示升序排列。默认值：
Falsedtype (str): 返回的下标的数据类型
- 返回值：
tuple[Var, Var]，其中第一个返回张量中每个第dim维的切片是一个[0, x.shape[dim]]的排列，表示将x中对应的切片中元素排序的下标顺序，第二个返回张量是排序结果- 代码示例：
>>> x = jt.array([3, 2, 10, 8]) >>> jt.argsort(x) (jt.Var([1 0 3 2], dtype=int32), jt.Var([ 2 3 8 10], dtype=int32))
- jittor_core.Var.assign()
函数C++定义格式:
jt.Var assign(jt.Var v)
将另一个Var的数据复制到这个Var中。
- 参数:
v (Var): 另一个Var
- 返回值:
Var: 返回自身，但实际上已经原地复制完毕
- 代码示例:
>>> x, y = jt.randn(5), jt.randn(5) >>> x jt.Var([-1.3378737 0.8863208 1.9383168 0.35481802 1.4916613 ], dtype=float32) >>> y jt.Var([ 0.59842813 1.281807 0.05155467 -0.74704844 -1.0341489 ], dtype=float32) >>> x.assign(y) jt.Var([ 0.59842813 1.281807 0.05155467 -0.74704844 -1.0341489 ], dtype=float32) >>> x jt.Var([ 0.59842813 1.281807 0.05155467 -0.74704844 -1.0341489 ], dtype=float32)
- jittor_core.Var.bfloat16()
函数C++定义格式:
jt.Var bfloat16_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为bfloat16(brain half-precision float)- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
bfloat16- 代码示例：
>>> x = jt.rand(3) * 10 >>> x jt.Var([4.093273 2.0086648 8.474352 ], dtype=float32) >>> x.bfloat16() jt.Var([4.094 2.008 8.48 ], dtype=bfloat16) >>> jt.bfloat16(x) jt.Var([4.094 2.008 8.48 ], dtype=bfloat16)
- jittor_core.Var.binary()
函数C++定义格式:
jt.Var binary(jt.Var x, jt.Var y, String p)
对两个张量元素计算二元运算
- 参数：
x (Var): 二元运算的第一个操作数
y (Var): 二元运算的第二个操作数，形状与
x相同p (str): 二元运算的名字对应字符串，例如
'add', 'divide'等
- 返回值：
二元运算的结果，形状与
x和y相同- 代码示例：
>>> x = jt.array([1, 2, 3]) >>> y = jt.array([4, 7, 5]) >>> jt.binary(x, y, 'add') jt.Var([5 9 8], dtype=int32) >>> jt.binary(x, y, 'divide') jt.Var([0.24999999 0.28571427 0.6 ], dtype=float32)
- jittor_core.Var.bitwise_and()
函数C++定义格式:
jt.Var bitwise_and(jt.Var x, jt.Var y)
对两个张量中对应元素计算按位与，也可以使用
&运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量。 其元素为x和y对应索引位置上元素的按位与结果。- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.bitwise_and(y) jt.Var([1 0 4], dtype=int32) >>> x & y jt.Var([1 0 4], dtype=int32)
- jittor_core.Var.bitwise_not()
函数C++定义格式:
jt.Var bitwise_not(jt.Var x)
创建一个张量，其将输入变量
x中的每一个数值进行位非运算。- 参数：
x (Var): Var类型的张量，数据类型应为布尔型或整型
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行位非运算后的值- 代码示例：
>>> (jt.int32([-2, 3, 1])).bitwise_not() jt.Var([ 1 -4 -2], dtype=int32)
- jittor_core.Var.bitwise_or()
函数C++定义格式:
jt.Var bitwise_or(jt.Var x, jt.Var y)
两个张量的元素级按位或，也可以使用
|运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量。x和y对应索引位置上元素的按位或结果。- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.bitwise_or(y) jt.Var([3 6 5], dtype=int32) >>> x | y jt.Var([3 6 5], dtype=int32)
- jittor_core.Var.bitwise_xor()
函数C++定义格式:
jt.Var bitwise_xor(jt.Var x, jt.Var y)
两个张量的元素级按位异或，也可以使用
^运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量。x和y对应索引位置上元素的按位异或结果。- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> jt.(x.bitwise_xor(y) jt.Var([2 6 1], dtype=int32) >>> x ^ y jt.Var([2 6 1], dtype=int32)
- jittor_core.Var.bool()
函数C++定义格式:
jt.Var bool_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为bool。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
bool- 代码示例：
>>> x = jt.arange(3) >>> x jt.Var([0 1 2], dtype=int32) >>> x.bool() jt.Var([False True True], dtype=bool) >>> jt.bool(x) jt.Var([False True True], dtype=bool)
- jittor_core.Var.broadcast()
函数C++定义格式:
jt.Var broadcast_to(jt.Var x, NanoVector shape, NanoVector dims=NanoVector())
将
x广播到与y相同的形状。- 参数：
x(Var)：输入的 Var。
y(jt.Var)：作为参考的 Var。
dims(Tuple[int])：指定输出形状中的新维度，为一个整数数组。默认值：()
- 返回值：
广播后的结果(jt.Var)
- 代码示例：
>>> jt.randint(0, 10, shape=(2, 2)) jt.Var([[8 1] [7 6]], dtype=int32) >>> jt.randint(0, 10, shape=(2, 3, 2)) >>> jt.broadcast(x, y, dims=[1]) jt.Var([[[8 1] [8 1] [8 1]], [[7 6] [7 6] [7 6]]], dtype=int32) >>> jt.broadcast_var(x, y, dims=[1]) jt.Var([[[8 1] [8 1] [8 1]], [[7 6] [7 6] [7 6]]], dtype=int32)
- jittor_core.Var.candidate()
函数C++定义格式:
jt.Var candidate(jt.Var x, string&& fail_cond, String dtype=ns_int32)
Candidate算子根据给定的fail_cond进行过滤操作。
x是输入。y是输出, 且满足如下条件,这里m是选中的数量。:
not fail_cond(y[0], y[1]) and not fail_cond(y[0], y[2]) and not fail_cond(y[1], y[2]) and ... ... and not fail_cond(y[m-2], y[m-1])
python伪代码:
y = [] for i in range(n): pass = True for j in y: if (@fail_cond): pass = false break if (pass): y.append(i) return y
参数:
x: 等待过滤输入
fail_cond: 失败情况对应代码
dtype: 返回类型
index: 下标
代码示例:
jt.candidate(jt.random(100,2), '(@x(j,0)>@x(i,0))or(@x(j,1)>@x(i,1))') # return y satisfy: # x[y[0], 0] <= x[y[1], 0] and x[y[1], 0] <= x[y[2], 0] and ... and x[y[m-2], 0] <= x[y[m-1], 0] and # x[y[0], 1] <= x[y[1], 1] and x[y[1], 1] <= x[y[2], 1] and ... and x[y[m-2], 1] <= x[y[m-1], 1]
- jittor_core.Var.ceil()
函数C++定义格式:
jt.Var ceil(jt.Var x)
创建一个张量, 其将
x中的每一个数值转换为向上取整离其最近的整数。 如：ceil(3.7)的结果是4,ceil(-3.7)的结果是-3。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置向上取整离其最近的整数- 代码示例：
>>> x = jt.rand(5) * 5 >>> x jt.Var([ 1.1675875 -0.36471805 2.0246403 1.1496693 -0.09650089], dtype=float32) >>> x.ceil() jt.Var([ 2. -0. 3. 2. -0.], dtype=float32)
- 注意事项：
支持使用
jt.ceil()进行调用
- jittor_core.Var.ceil_int()
函数C++定义格式:
jt.Var ceil_int(jt.Var x)
创建一个张量, 其将
x中的每一个数值转换为向上取整离其最近的整数。 如：ceil_int(3.7)的结果是4,ceil_int(-3.7)的结果是-3。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应向上取整离其最近的整数, 数据类型为int32- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 2.00422 -2.081075 -0.7260027 0.46558696 -0.1570169 ], dtype=float32) >>> x.ceil_int() jt.Var([ 3 -2 0 1 0], dtype=int32)
- 注意事项：
支持使用
jt.ceil_int()进行调用
- jittor_core.Var.clone()
函数C++定义格式:
jt.Var clone(jt.Var x)
创建并返回一个新的变量，该变量是张量
x的深度拷贝- 参数：
x(Var): Var类型的张量
- 返回值：
返回一个新的张量, 其形状、类型和值与输入张量相同。
- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[-0.22726686 -0.7055701 -0.40404484] [ 0.25013736 -1.2239726 0.45218712]], dtype=float32) >>> x.clone() >jt.Var([[-0.22726686 -0.7055701 -0.40404484] [ 0.25013736 -1.2239726 0.45218712]], dtype=float32)
- jittor_core.Var.copy()
函数C++定义格式:
jt.Var copy(jt.Var x)
该函数将复制输入变量并返回一个新的变量。它会创建一个与输入变量具有相同形状和类型的新变量，并将新变量的值设置为输入变量的值。函数不会改变输入变量
x的值。- 参数:
x (Var): 需要复制的输入变量。
- 返回值:
复制的新变量(Var)，其形状、类型和值与输入变量相同。
- 代码示例:
>>> import jittor as jt >>> x = jt.array([1, 2, 3]) >>> y = jt.copy(x)
- jittor_core.Var.cos()
函数C++定义格式:
jt.Var cos(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行余弦运算。\[y_i = \cos(x_i) \]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行余弦运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-0.8017247 2.4553642 -0.57173574 -0.06912863 1.5478854 ], dtype=float32) >>> x.cos() jt.Var([ 0.6954685 -0.7736413 0.84096307 0.9976116 0.0229089 ], dtype=float32)
- 注意事项：
余弦函数的定义域是实数集，值域是
[-1, 1]支持使用
jt.cos()进行调用
- jittor_core.Var.cosh()
函数C++定义格式:
jt.Var cosh(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行双曲余弦运算。\[y_i = \cosh(x_i) = \frac{e^x_i + e^{-x_i}}{2}\]- 参数：
x (Var): Var类型的张量
- 代码示例：
>>> x = jt.randn(5) + 1 >>> x jt.Var([-0.46972263 -0.6531948 1.7161269 1.007987 1.3451817 ], dtype=float32) >>> x.cosh() jt.Var([1.1123631 1.2210255 2.871351 1.5525162 2.0496883], dtype=float32)
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行双曲余弦运算的结果- 注意事项：
双曲余弦运算的定义域和值域为 [1, ∞)
支持使用
x.cosh()进行调用
- jittor_core.Var.debug_msg()
函数C++定义格式:
string debug_msg()
打印对应参数的信息用于debug。
- 返回值:
str: 返回对应参数的信息。
- 代码示例:
>>> x = jt.randn(5) >>> x.debug_msg() 'Var(17:1:1:1:i1:o0:s0:n0:g1,float32,,0)[5,]'
- jittor_core.Var.detach()
函数C++定义格式:
inline jt.Var detach()
创建一个已经存在的张量
x的副本，这个副本与原始张量共享数据，但不参与梯度计算。这在神经网络的训练过程中非常重要，尤其是在需要操作数据但又不想影响梯度计算时。- 参数：
x (Var): Var类型的张量
- 返回值：
返回副本张量（Var）
- 代码示例：
>>> x = jt.randn((3,2)) jt.Var([[-1.7332076 -3.9374337] [ 2.2316337 1.2128713] [-2.067835 0.8186041]], dtype=float32) >>> x.detach() jt.Var([[-1.7332076 -3.9374337] [ 2.2316337 1.2128713] [-2.067835 0.8186041]], dtype=float32)
- jittor_core.Var.detach_inplace()
函数C++定义格式:
jt.Var start_grad()
开启当前变量的梯度记录。
- jittor_core.Var.dim()
函数C++定义格式:
inline int ndim()
返回张量有维度数量。
- jittor_core.Var.div()
函数C++定义格式:
jt.Var divide(jt.Var x, jt.Var y)
对两个张量中对应元素计算求商，也可以使用
/运算符调用。- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相除结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.divide(y) jt.Var([0.3333333 0.49999997 0.8 ], dtype=float32) >>> x / y jt.Var([0.3333333 0.49999997 0.8 ], dtype=float32)
- 注意：
输入数据类型是整数的情况下，会返回浮点数结果
- jittor_core.Var.divide()
函数C++定义格式:
jt.Var divide(jt.Var x, jt.Var y)
对两个张量中对应元素计算求商，也可以使用
/运算符调用。- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相除结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.divide(y) jt.Var([0.3333333 0.49999997 0.8 ], dtype=float32) >>> x / y jt.Var([0.3333333 0.49999997 0.8 ], dtype=float32)
- 注意：
输入数据类型是整数的情况下，会返回浮点数结果
- jittor_core.Var.double()
函数C++定义格式:
jt.Var float64_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为float64，返回双精度的浮点数，即用64个比特(8个字节)表示一个数。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
float64- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[ 1.4581492 0.2615918 ] [ 0.26567948 -0.34585235]], dtype=float32) >>> x.float64() jt.Var([[ 1.45814919 0.26159179] [ 0.26567948 -0.34585235]], dtype=float64)
- jittor_core.Var.equal()
函数C++定义格式:
jt.Var equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否相等，把结果布尔值放入输出张量的对应位置，也可以使用
=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.equal(y) jt.Var([False True False], dtype=bool) >>> x == y jt.Var([False True False], dtype=bool)
- jittor_core.Var.erf()
函数C++定义格式:
jt.Var erf(jt.Var x)
创建一个张量, 其为对输入变量
x中的每一个数值进行误差变换得到的结果。 该函数为误差函数。\[\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} \, dt\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行误差函数运算- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 2.7442768 -0.6135011 -0.09157802 -2.3600576 0.98465353], dtype=float32) >>> x.erf() jt.Var([-0.91196376 0.19675992 0.9940873 -0.99938697 0.10797469], dtype=float32)
- 注意事项：
该函数定义域是实数集，值域是 [-1,1]
支持使用
jt.erf()进行调用
- jittor_core.Var.erfinv()
函数C++定义格式:
jt.Var erfinv(jt.Var x)
创建一个张量, 其为对输入变量
x中的每一个数值进行反误差变换得到的结果。该函数为反误差函数。\[\text{erfinv}(x) = \text{erf}^{-1}(x)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行反误差函数运算- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 0.73859763 1.0348558 2.4863744 -0.36372563 -0.6050172 ], dtype=float32) >>> x.erfinv() jt.Var([ 0.79413944 nan nan -0.33440086 -0.6014762 ], dtype=float32)
- 注意事项：
该函数定义域是[-1,1]，值域是实数集
支持使用
jt.erfinv()进行调用
- jittor_core.Var.exp()
函数C++定义格式:
jt.Var exp(jt.Var x)
创建一个张量，其将
x中的每一个数值的进行指数运算。\[y_i = e^{x_i}\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行指数运算后的值- 代码示例：
>>> x = jt.rand(5) * 5 >>> x jt.Var([2.8649285 0.854602 3.2959728 0.41697088 3.0296502 ], dtype=float32) >>> x.exp() jt.Var([17.547798 2.3504386 27.003672 1.5173583 20.689995 ], dtype=float32)
- 注意事项：
可以使用
jt.exp()进行调用
- jittor_core.Var.float()
函数C++定义格式:
jt.Var float32_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为float32，返回单精度的浮点数，即用32个比特(4个字节)表示一个数。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
float32- 代码示例：
>>> x = jt.ones((2,2), dtype='int8') >>> x jt.Var([[1 1] [1 1]], dtype=int8) >>> x.float32() jt.Var([[1. 1.] 1. 1.]], dtype=float32)
- jittor_core.Var.float16()
函数C++定义格式:
jt.Var float16_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为float16，返回半精度的浮点数，即用16个比特(2个字节)表示一个数。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
float16- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[ 1.4581492 0.2615918 ] [ 0.26567948 -0.34585235]], dtype=float32) >>> x.float16() jt.Var([[ 1.458 0.2615] [ 0.2656 -0.346 ]], dtype=float16)
- jittor_core.Var.float32()
函数C++定义格式:
jt.Var float32_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为float32，返回单精度的浮点数，即用32个比特(4个字节)表示一个数。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
float32- 代码示例：
>>> x = jt.ones((2,2), dtype='int8') >>> x jt.Var([[1 1] [1 1]], dtype=int8) >>> x.float32() jt.Var([[1. 1.] 1. 1.]], dtype=float32)
- jittor_core.Var.float64()
函数C++定义格式:
jt.Var float64_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为float64，返回双精度的浮点数，即用64个比特(8个字节)表示一个数。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
float64- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[ 1.4581492 0.2615918 ] [ 0.26567948 -0.34585235]], dtype=float32) >>> x.float64() jt.Var([[ 1.45814919 0.26159179] [ 0.26567948 -0.34585235]], dtype=float64)
- jittor_core.Var.floor()
函数C++定义格式:
jt.Var floor(jt.Var x)
创建一个张量, 其将
x中的每一个数值转换为向下取整离其最近的整数。 如：floor(3.7)的结果是3,floor(-3.7)的结果是-4。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置向下取整离其最近的整数- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 1.1675875 -0.36471805 2.0246403 1.1496693 -0.09650089], dtype=float32) >>> x.floor() jt.Var([ 1. -1. 2. 1. -1.], dtype=float32)
- 注意事项：
支持使用
jt.floor()进行调用
- jittor_core.Var.floor_divide()
函数C++定义格式:
jt.Var floor_divide(jt.Var x, jt.Var y)
对两个张量中对应元素计算求商并向下取整，也可以使用
//运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相除向下取整结果，形状与x和y相同，输入数据类型是整数的情况下，会返回整数- 代码示例：
>>> x = jt.array([3, 4, 5]) >>> y = jt.array([1, 2, 4]) >>> x.floor_divide(y) jt.Var([3 2 1], dtype=int32) >>> x // y jt.Var([3 2 1], dtype=int32)
- jittor_core.Var.floor_int()
函数C++定义格式:
jt.Var floor_int(jt.Var x)
创建一个张量, 其将
x中的每一个数值转换为向下取整离其最近的整数。 如：floor_int(3.7)的结果是3,floor_int(-3.7)的结果是-4。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量，其数值是
x中对应位置向下取整离其最近的整数，数据类型为int32- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 2.00422 -2.081075 -0.7260027 0.46558696 -0.1570169 ], dtype=float32) >>> x.floor_int() jt.Var([ 2 -3 -1 0 -1], dtype=int32)
- 注意事项：
支持使用
jt.floor_int()进行调用
- jittor_core.Var.fuse_transpose()
函数C++定义格式:
jt.Var fuse_transpose(jt.Var x, NanoVector axes=NanoVector())
将输入的多维数组根据指定的轴进行转置。转置操作的数学公式为: .. math:
y_{i_1,...,i_N} = x_{i_{\pi(1)},...,i_{\pi(N)}}
其中, .. math::y_{i_1,…,i_N} = x_{j_1,…,j_N} 为 axes 给出的轴值列表
- 参数:
x(Var): 待转置的多维数组。
axes(Tuple[int]): 轴值的元组,用于指定转置操作的顺序。 默认值：空元组。
- 返回值:
经转置操作后的多维数组(Var)。
- 代码示例:
>>> from typing import Tuple >>> x = Var() >>> axes = (1, 0, 2) >>> fuse_transpose(x, axes)
- jittor_core.Var.greater()
函数C++定义格式:
jt.Var greater(jt.Var x, jt.Var y)
两个张量中对应元素比较是否为大于，把结果布尔值放入输出张量的对应位置，也可以使用
>运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示x和y对应元素里是否x中的元素大于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.greater(y) jt.Var([ True False False], dtype=bool) >>> x > y jt.Var([ True False False], dtype=bool)
- jittor_core.Var.greater_equal()
函数C++定义格式:
jt.Var greater_equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否为大于或等于，把结果布尔值放入输出张量的对应位置，也可以使用
>=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素大于或等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.greater_equal(y) jt.Var([ True True False], dtype=bool) >>> x >= y jt.Var([ True True False], dtype=bool)
- jittor_core.Var.half()
函数C++定义格式:
jt.Var float16_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为float16，返回半精度的浮点数，即用16个比特(2个字节)表示一个数。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
float16- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[ 1.4581492 0.2615918 ] [ 0.26567948 -0.34585235]], dtype=float32) >>> x.float16() jt.Var([[ 1.458 0.2615] [ 0.2656 -0.346 ]], dtype=float16)
- jittor_core.Var.index()
函数C++定义格式:
jt.Var index__(jt.Var a, int64 dim, String dtype=ns_int32)
获得
a中每个元素在每一维的下标- 参数：
a (Var): 一个张量
dtype (str，可选): 返回的数据类型。默认值：
'int32'
- 返回值：
tuple[Var]包含a.ndims个张量，每个张量形状和a一样，第 \(k\) 个张量下标 \((i_0, ..., i_k, ...)\) 处元素值是 \(i_k\) ，即第 \(k\) 维的下标- 代码示例：
>>> x = jt.zeros((2, 3, 4)) >>> jt.index_var(x) (jt.Var([[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[1 1 1 1] [1 1 1 1] [1 1 1 1]]], dtype=int32), jt.Var([[[0 0 0 0] [1 1 1 1] [2 2 2 2]] [[0 0 0 0] [1 1 1 1] [2 2 2 2]]], dtype=int32), jt.Var([[[0 1 2 3] [0 1 2 3] [0 1 2 3]] [[0 1 2 3] [0 1 2 3] [0 1 2 3]]], dtype=int32))
- jittor_core.Var.index_var()
函数C++定义格式:
jt.Var index__(jt.Var a, int64 dim, String dtype=ns_int32)
获得
a中每个元素在每一维的下标- 参数：
a (Var): 一个张量
dtype (str，可选): 返回的数据类型。默认值：
'int32'
- 返回值：
tuple[Var]包含a.ndims个张量，每个张量形状和a一样，第 \(k\) 个张量下标 \((i_0, ..., i_k, ...)\) 处元素值是 \(i_k\) ，即第 \(k\) 维的下标- 代码示例：
>>> x = jt.zeros((2, 3, 4)) >>> jt.index_var(x) (jt.Var([[[0 0 0 0] [0 0 0 0] [0 0 0 0]] [[1 1 1 1] [1 1 1 1] [1 1 1 1]]], dtype=int32), jt.Var([[[0 0 0 0] [1 1 1 1] [2 2 2 2]] [[0 0 0 0] [1 1 1 1] [2 2 2 2]]], dtype=int32), jt.Var([[[0 1 2 3] [0 1 2 3] [0 1 2 3]] [[0 1 2 3] [0 1 2 3] [0 1 2 3]]], dtype=int32))
- jittor_core.Var.int()
函数C++定义格式:
jt.Var int32_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为int32。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
int32- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[-1.8707825 -0.5307898 -2.2583888 ] [-0.1800911 0.10568491 0.0891161 ]], dtype=float32) >>> x.int32() jt.Var([[-1 0 -2] [ 0 0 0]], dtype=int32)
- jittor_core.Var.int16()
函数C++定义格式:
jt.Var int16_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为int16。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
int16- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[ 1.8623732 -1.060122 0.82836497] [-0.17111613 1.0357065 -0.4598468 ]], dtype=float32) >>> x.int16() jt.Var([[ 1 -1 0] [ 0 1 0]], dtype=int16)
- jittor_core.Var.int32()
函数C++定义格式:
jt.Var int32_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为int32。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
int32- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[-1.8707825 -0.5307898 -2.2583888 ] [-0.1800911 0.10568491 0.0891161 ]], dtype=float32) >>> x.int32() jt.Var([[-1 0 -2] [ 0 0 0]], dtype=int32)
- jittor_core.Var.int64()
函数C++定义格式:
jt.Var int64_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为int64。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
int64- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[-1.4805598 -0.34178254 -0.3623456 ] [-0.31025547 0.3924162 -1.5397007 ]], dtype=float32) >>> x.int64() jt.Var([[-1 0 0] [ 0 0 -1]], dtype=int64)
- jittor_core.Var.int8()
函数C++定义格式:
jt.Var int8_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为int8。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
int8- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[-0.3373416 0.28905255 1.496737 ] [-1.0225579 -1.0431367 0.3423414 ]], dtype=float32) >>> x.int8() jt.Var([[ 0 0 1] [-1 -1 0]], dtype=int8)
- jittor_core.Var.is_stop_fuse()
函数C++定义格式:
inline bool is_stop_fuse()
若算子的fusion已经关闭返回
True，否则返回False。
- jittor_core.Var.is_stop_grad()
函数C++定义格式:
inline bool is_stop_grad()
若当前变量已关闭梯度记录则返回
True，否则返回False。
- jittor_core.Var.item()
函数C++定义格式:
ItemData item()
如果此张量只包含一个元素，返回python对应类型数值。否则请使用data()。
- jittor_core.Var.left_shift()
函数C++定义格式:
jt.Var left_shift(jt.Var x, jt.Var y)
对两个张量中对应元素计算左移移位运算，也可以使用
<<运算符调用- 参数：
x (Var): 被左移的张量，元素的数据类型是
int32或int64y (Var): 左移的位数张量，元素数据类型是
int32或int64，形状与x相同
- 返回值：
形状与
x和y相同的张量，其元素为x和y对应索引位置的元素计算左移操作的结果数- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.left_shift(y) jt.Var([ 8 32 128], dtype=int32) >>> x << y jt.Var([ 8 32 128], dtype=int32)
- 注意事项：
支持使用
jt.left_shift()进行调用
- jittor_core.Var.less()
函数C++定义格式:
jt.Var less(jt.Var x, jt.Var y)
两个张量中对应元素比较是否为小于，把结果布尔值放入输出张量的对应位置，也可以使用
<运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
输出张量，形状与
x和y相同，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素小于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.less(y) jt.Var([False False True], dtype=bool) >>> x < y jt.Var([False False True], dtype=bool)
- jittor_core.Var.less_equal()
函数C++定义格式:
jt.Var less_equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否为小于或等于，把结果布尔值放入输出张量的对应位置，也可以使用
<=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素小于或等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.less_equal(y) jt.Var([False True True], dtype=bool) >>> x <= y jt.Var([False True True], dtype=bool)
- jittor_core.Var.log()
函数C++定义格式:
jt.Var log(jt.Var x)
创建一个张量，其将输入变量
x中的每一个数值的进行自然对数运算。\[y_i = \ln(x_i)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行自然对数运算后的值- 代码示例：
>>> x = jt.rand(5) * 5 >>> x jt.Var([2.8649285 0.854602 3.2959728 0.41697088 3.0296502 ], dtype=float32) >>> x.log() jt.Var([ 1.0525434 -0.15711944 1.1927013 -0.8747389 1.1084472 ], dtype=float32)
- 注意事项：
自然对数是以常数e（数学常量，大约等于2.71828）为底的对数
可以使用
jt.log()进行调用
- jittor_core.Var.logical_and()
函数C++定义格式:
jt.Var logical_and(jt.Var x, jt.Var y)
对两个张量中对应元素计算逻辑与
- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，元素数据类型为bool。其元素为x和y对应索引位置上的元素进行逻辑与操作的结果，即：如果都为非零值或True则输出为True，否则为False。- 代码示例：
>>> x = jt.array([0, 0, 1, 1]) >>> y = jt.array([0, 1, 0, 1]) >>> x.logical_and(y) jt.Var([False False False True], dtype=bool)
- 注意事项：
支持使用
jt.logical_and()进行调用
- jittor_core.Var.logical_not()
函数C++定义格式:
jt.Var logical_not(jt.Var x)
创建一个张量，其将
x中的每一个数值转换为其逻辑非, 数据类型为bool。 如果输入张量x不是数据类型为bool的张量，则零被视为False，非零被视为True。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置的逻辑非.- 代码示例：
>>> (jt.float32([-1, 0, 1])).logical_not() jt.Var([False True False], dtype=bool)
- 注意事项：
可以使用
jt.logical_not()进行调用
- jittor_core.Var.logical_or()
函数C++定义格式:
jt.Var logical_or(jt.Var x, jt.Var y)
对两个张量中对应元素计算逻辑或
- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，元素数据类型为bool。其元素为x和y对应索引位置上的元素进行逻辑或操作的结果，即：如果两者有非零值或True则输出为True，否则为False- 代码示例：
>>> x = jt.array([0, 0, 1, 1]) >>> y = jt.array([0, 1, 0, 1]) >>> x.logical_or(y) jt.Var([False True True True], dtype=bool)
- 注意事项：
支持使用
jt.logical_or()进行调用
- jittor_core.Var.logical_xor()
函数C++定义格式:
jt.Var logical_xor(jt.Var x, jt.Var y)
两个张量的元素级逻辑异或
- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，元素数据类型为bool。其元素为x和y对应索引位置上的元素进行逻辑异或操作的结果，即：如果两者有且仅有一个为非零值或True则输出为True，否则为False，数据类型为bool，形状与x和y相同- 代码示例：
>>> x = jt.array([0, 0, 1, 1]) >>> y = jt.array([0, 1, 0, 1]) >>> x.logical_xor(y) jt.Var([False True True False], dtype=bool)
- 注意事项：
支持使用
jt.logical_xor()进行调用
- jittor_core.Var.long()
函数C++定义格式:
jt.Var int32_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为int32。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
int32- 代码示例：
>>> x = jt.randn((2,3)) >>> x jt.Var([[-1.8707825 -0.5307898 -2.2583888 ] [-0.1800911 0.10568491 0.0891161 ]], dtype=float32) >>> x.int32() jt.Var([[-1 0 -2] [ 0 0 0]], dtype=int32)
- jittor_core.Var.max()
函数C++定义格式:
jt.Var reduce_maximum(jt.Var x, int dim, bool keepdims=false)
返回输入张量中的最大元素。
- 参数:
x (Var): 输入的jt.Var.
dims_mask (int，可选): 指定的维度，如果指定，则沿给定的维度进行缩减。默认值：
Nonekeepdims_mask (int，可选): 输出是否保留
dim。默认值：None
- 返回值:
对应维度的最大元素。
- 代码示例:
>>> x = jt.randint(10, shape=(2, 3)) >>> x jt.Var([[4 1 2] [0 2 4]], dtype=int32) >>> jt.max(x) jt.Var([4], dtype=int32) >>> x.max() jt.Var([4], dtype=int32) >>> x.max(dim=1) jt.Var([4 4], dtype=int32) >>> x.max(dim=1, keepdims=True) jt.Var([[4] [4]], dtype=int32)
- jittor_core.Var.maximum()
函数C++定义格式:
jt.Var maximum(jt.Var x, jt.Var y)
对两个张量中对应位置元素计算最大值
- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素中的较大者，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 2, 0]) >>> x.maximum(y) jt.Var([3 2 4], dtype=int32)
- 注意事项：
支持使用
jt.maximum()进行调用
- jittor_core.Var.mean()
函数C++定义格式:
jt.Var reduce_mean(jt.Var x, int dim, bool keepdims=false)
计算输入张量的均值。
- 参数:
x (Var): 输入的 Jittor 的变量。
dims_mask (int): 如果给定，沿着指定的维度缩减。
keepdims_mask (bool): 如果为True，则输出结果会保留维度。默认值：False
- 返回值:
计算得到的均值(Var)
- 代码示例:
>>> x = jt.randint(10, shape=(2, 3)) >>> x jt.Var([[9 4 4] [1 9 6]], dtype=int32) >>> jt.mean(x) jt.Var([5.5000005], dtype=float32) >>> x.mean(dim=1) jt.Var([5.666667 5.3333335], dtype=float32) >>> x.mean(dim=1, keepdims=True) jt.Var([[5.666667 ] [5.3333335]], dtype=float32)
- jittor_core.Var.min()
函数C++定义格式:
jt.Var reduce_minimum(jt.Var x, int dim, bool keepdims=false)
对张量的
dims这些维度计算最小值- 参数：
x (Var): 输入数据
dim (tuple[int]): 在哪些维度计算最小值。默认是全部元素的最小值。默认值：
()keepdims (bool): 是否在结果中保留
dim维度。默认值：False
- 返回值：
计算最小值的结果。如果
keepdims为True则形状为x将dims里给出的维度的长度变成 1，否则是x的形状去掉dims给出的维度- 代码示例：
>>> x = jt.randint(0, 10, shape=(2, 3)) >>> x jt.Var([[2 7 9] [2 6 3]], dtype=int32) >>> x.min() jt.Var([2], dtype=int32) >>> x.min((0, 1)) jt.Var([2], dtype=int32)
- jittor_core.Var.minimum()
函数C++定义格式:
jt.Var minimum(jt.Var x, jt.Var y)
对两个张量中对应元素计算最小值
- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素中的较小者，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 2, 0]) >>> x.minimum(y) jt.Var([1 2 0], dtype=int32)
- 注意事项：
支持使用
jt.minimum()进行调用
- jittor_core.Var.mod()
函数C++定义格式:
jt.Var mod(jt.Var x, jt.Var y)
对两个张量中对应元素计算求余数，也可以使用
%运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相除的余数，形状与x和y相同。非零余数的符号和y中元素的符号相同，该行为与 Python 的x % y运算一致- 代码示例：
>>> x = jt.array([3, 4, 5, -5, 5]) >>> y = jt.array([1, 2, 3, 3, -3]) >>> x.mod(y) jt.Var([ 0 0 2 -2 2], dtype=int32) >>> x % y jt.Var([ 0 0 2 -2 2], dtype=int32)
- jittor_core.Var.mul()
函数C++定义格式:
jt.Var multiply(jt.Var x, jt.Var y)
对两个张量中对应元素计算求积，也可以使用
*运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相乘结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.multiply(y) jt.Var([ 3 8 20], dtype=int32) >>> x * y jt.Var([ 3 8 20], dtype=int32)
- 注意：
同时支持使用
jt.multiply()和jt.mul()进行调用
- jittor_core.Var.multiply()
函数C++定义格式:
jt.Var multiply(jt.Var x, jt.Var y)
对两个张量中对应元素计算求积，也可以使用
*运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相乘结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.multiply(y) jt.Var([ 3 8 20], dtype=int32) >>> x * y jt.Var([ 3 8 20], dtype=int32)
- 注意：
同时支持使用
jt.multiply()和jt.mul()进行调用
- jittor_core.Var.name()
函数C++定义格式:
inline jt.Var name(const char* s)
给对应变量命名。
函数C++定义格式:
inline const char* name()
返回该变量的名称。
- 返回值：
str: 返回该变量的名称。
- 示例代码:
>>> x = jt.randn(5) >>> x.name("xx") jt.Var([-0.81336606 0.5333854 1.4687881 -1.1453031 -2.052226 ], dtype=float32) >>> x.name() 'xx'
- jittor_core.Var.ne()
函数C++定义格式:
jt.Var not_equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否不相等，把结果布尔值放入输出张量的对应位置，也可以使用
!=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素不等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.not_equal(y) jt.Var([ True False True], dtype=bool) >>> x != y jt.Var([ True False True], dtype=bool)
- jittor_core.Var.negative()
函数C++定义格式:
jt.Var negative(jt.Var x)
创建一个张量，其将输入变量
x中的每一个数值转换为其相反数。\[out_i = - input_i\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置的相反数- 代码示例：
>>> (jt.float32([-1, 0, 1])).negative() jt.Var([1. 0. -1.], dtype=float32)
- jittor_core.Var.not_equal()
函数C++定义格式:
jt.Var not_equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否不相等，把结果布尔值放入输出张量的对应位置，也可以使用
!=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素不等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.not_equal(y) jt.Var([ True False True], dtype=bool) >>> x != y jt.Var([ True False True], dtype=bool)
- jittor_core.Var.numpy()
函数C++定义格式:
ArrayArgs fetch_sync()
返回此变量的对应
numpy.ndarray类型变量。- 返回值:
Var: 返回自身对应的numpy类型变量。
- 代码示例:
>>> x = jt.randn(5) >>> x jt.Var([-0.39287043 1.3877422 -1.2779838 0.968416 1.6573125 ], dtype=float32) >>> x.numpy() array([-0.39287043, 1.3877422 , -1.2779838 , 0.968416 , 1.6573125 ], dtype=float32)
- jittor_core.Var.prod()
函数C++定义格式:
jt.Var reduce_multiply(jt.Var x, int dim, bool keepdims=false)
对输入的数组进行降维求积操作，计算指定维度上元素的乘积。
- 参数:
x(Var): 输入的张量
dims(int, or Tuple of int): 要计算乘法的轴，如果是 Tuple 则在这些维度上依次进行降维求积计算，如果是 int 则在这一维度上进行降维求积计算。如果为空，则对输入张量整体计算求积
keepdims(bool or int): 如果为 True，则进行求积的维度将被保留，否则消除这一维度。如果输入的是 int, 0 被认为是 False，非 0 被认为是 True。默认值：
False。
- 返回值:
Var: 返回一个新的张量，进行过一次或多次降维求积后的结果。
- 代码示例:
>>> a = jt.arange(1, 7).reshape(2, 3) jt.Var([[1 2 3] [4 5 6]], dtype=int32) >>> jt.prod(a, 1) jt.Var([ 6 120], dtype=int32) >>> jt.prod(a, 1, True) jt.Var([[ 6] [120]], dtype=int32) >>> jt.prod(a, (1, 0)) jt.Var([ 720], dtype=int32) >>> jt.prod(a, 0) jt.Var([ 4 10 18], dtype=int32)
- jittor_core.Var.reduce()
函数C++定义格式:
jt.Var reduce(jt.Var x, String op, int dim, bool keepdims=false)
对张量的
dims这些维度计算一个聚合函数- 参数：
x (Var): 输入数据
op (str): 计算的聚合函数，可从下列函数中选择：
'maximum','minimum','add','multiply','logical_and','logical_or','logical_xor','bitwise_and','bitwise_or','bitwise_xor','mean'dims (tuple[int]): 在哪些维度计算聚合函数。默认是全部元素都聚合。默认值：
()keepdims (bool): 是否在结果中保留
dim维度。默认值：False
- 返回值：
计算聚合函数的结果。如果
keepdims为True则形状为x将dims里给出的维度的长度变成 1，否则是x的形状去掉dims给出的维度- 代码示例：
>>> x = jt.randint(0, 10, shape=(2, 3)) >>> x jt.Var([[2 7 9] [2 6 3]], dtype=int32) >>> x.reduce('maximum') jt.Var([9], dtype=int32) >>> x.reduce('maximum', (0, 1)) jt.Var([9], dtype=int32) >>> x.reduce('add') jt.Var([29], dtype=int32)
- jittor_core.Var.reduce_add()
函数C++定义格式:
jt.Var reduce_add(jt.Var x, int dim, bool keepdims=false)
对张量的
dims这些维度求和- 参数：
x (Var): 输入数据
dim (tuple[int]): 在哪些维度求和。默认是全部元素的最大值。默认值：
()keepdims (bool): 是否在结果中保留
dim维度。默认值：False
- 返回值：
求和的结果。如果
keepdims为True则形状为x将dims里给出的维度的长度变成 1，否则是x的形状去掉dims给出的维度- 代码示例：
>>> x = jt.randint(0, 10, shape=(2, 3)) >>> x jt.Var([[2 7 9] [2 6 3]], dtype=int32) >>> x.sum() jt.Var([29], dtype=int32) >>> x.sum((0, 1)) jt.Var([29], dtype=int32)
- jittor_core.Var.reduce_bitwise_and()
函数C++定义格式:
jt.Var reduce_bitwise_and(jt.Var x, int dim, bool keepdims=false)
对输入的张量计算指定维度上所有元素进行按位与 (bitwise and) 计算。输入的张量必须是 int 或 bool 类型。
- 参数:
x(Var): 输入的张量
dims(int或Tuple[int]，可选): 要计算按位与的轴，如果是 Tuple 则在这些维度上依次进行降维求按位与计算，如果是 int 则在这一个维度上进行降维求按位与计算。如果为空则对张量整体求按位与运算
keepdims(bool或int，可选): 如果为 True，则进行求按位与的维度将被保留，否则消除这一维度。如果输入的是 int, 0 被认为是 False，非 0 被认为是 True。默认值：
False
- 返回值:
Var: 返回一个新的张量，进行过一次或多次降维求按位与后的结果。
- 代码示例:
>>> a = jt.array([[3,2,3],[4,5,6],[7,8,7]]) >>> jt.reduce_bitwise_and(a, 1) jt.Var([2 4 0], dtype=int32) >>> jt.reduce_bitwise_and(a, 1, True) jt.Var([[2] [4] [0]], dtype=int32) >>> jt.reduce_bitwise_and(a, (1, 0)) jt.Var([0], dtype=int32) >>> jt.reduce_bitwise_and(a, 0) jt.Var([0 0 2], dtype=int32)
- jittor_core.Var.reduce_bitwise_or()
函数C++定义格式:
jt.Var reduce_bitwise_or(jt.Var x, int dim, bool keepdims=false)
对输入的张量计算指定维度上所有元素进行按位或 (bitwise or) 计算。输入的张量必须是 int 或 bool 类型。
- 参数:
x(Var): 输入的张量
dims(int或Tuple[int]，可选): 要计算按位或的轴，如果是 Tuple 则在这些维度上依次进行降维求按位或计算，如果是 int 则在这一个维度上进行降维求按位或计算。如果为空则对张量整体求按位或运算
keepdims(bool或int，可选): 如果为 True，则进行求按位或的维度将被保留，否则消除这一维度。如果输入的是 int, 0 被认为是 False，非 0 被认为是 True。默认值：False
- 返回值:
Var: 返回一个新的张量，进行过一次或多次降维求按位或后的结果。
- 代码示例:
>>> x = jt.array([[1,2,4],[8,16,32]]) >>> jt.reduce_bitwise_or(x) jt.Var([63], dtype=int32) >>> jt.reduce_bitwise_or(x, 1) jt.Var([ 7 56], dtype=int32) >>> jt.reduce_bitwise_or(x, 1, True) jt.Var([[ 7] [56]], dtype=int32) >>> jt.reduce_bitwise_or(x, (1, 0)) jt.Var([63], dtype=int32)
- jittor_core.Var.reduce_bitwise_xor()
函数C++定义格式:
jt.Var reduce_bitwise_xor(jt.Var x, int dim, bool keepdims=false)
将输入的张量在指定的dims上进行按位异或操作。
\[\text{out} = x_1 \oplus x_2 \oplus x_3 \oplus ... \oplus x_n\]其中，\(x_i\) 是输入张量的元素，\(\oplus\) 是按位异或操作。
- 参数：
x(Var): 输入的张量
dims(Tuple[int], optional): 需要做异或操作的维度，默认值：
Nonekeepdims(bool, optional): 是否保持原始的张量维度。默认值：
False。
- 返回值：
进行按位异或操作后的张量(Var)
- 代码示例:
>>> import jittor as jt >>> x = jt.array([0, 1, 2, 3, 4]) >>> jt.reduce_bitwise_xor(x).item() 4 >>> jt.reduce_bitwise_xor(x, keepdims=True) jt.Var([4])
- jittor_core.Var.reduce_logical_xor()
函数C++定义格式:
jt.Var reduce_logical_xor(jt.Var x, int dim, bool keepdims=false)
对输入的数组计算指定维度上所有元素进行逻辑异或 (XOR) 计算。
逻辑异或有这样的性质：如果参与计算的元素中有奇数个 True，则结果为 True；如果有偶数个 True，结果则为 False。
- 参数:
x(Var): 输入的张量
dims(int或Tuple[int]，可选): 要计算逻辑异或的轴，如果是 Tuple 则在这些维度上依次进行降维求逻辑异或计算，如果是 int 则在这一个维度上进行降维求逻辑异或计算。如果为空则对张量整体求逻辑异或运算
keepdims(bool或int，可选): 如果为 True，则进行求逻辑异或的维度将被保留，否则消除这一维度。如果输入的是 int, 0 被认为是 False，非 0 被认为是 True。默认值：
False
- 返回值:
Var: 返回一个新的张量，进行过一次或多次降维求逻辑异或后的结果。
- 代码示例:
>>> a = jt.array([[0,1,0],[0,1,1],[1,1,1]]) >>> jt.reduce_logical_xor(a, 1) jt.Var([1 0 1], dtype=int32) >>> jt.reduce_logical_xor(a, 1, True) jt.Var([[1] [0] [1]], dtype=int32) >>> jt.reduce_logical_xor(a, (1, 0)) jt.Var([0], dtype=int32) >>> jt.reduce_logical_xor(a, 0) jt.Var([1 1 0], dtype=int32)
- jittor_core.Var.reduce_maximum()
函数C++定义格式:
jt.Var reduce_maximum(jt.Var x, int dim, bool keepdims=false)
返回输入张量中的最大元素。
- 参数:
x (Var): 输入的jt.Var.
dims_mask (int，可选): 指定的维度，如果指定，则沿给定的维度进行缩减。默认值：
Nonekeepdims_mask (int，可选): 输出是否保留
dim。默认值：None
- 返回值:
对应维度的最大元素。
- 代码示例:
>>> x = jt.randint(10, shape=(2, 3)) >>> x jt.Var([[4 1 2] [0 2 4]], dtype=int32) >>> jt.max(x) jt.Var([4], dtype=int32) >>> x.max() jt.Var([4], dtype=int32) >>> x.max(dim=1) jt.Var([4 4], dtype=int32) >>> x.max(dim=1, keepdims=True) jt.Var([[4] [4]], dtype=int32)
- jittor_core.Var.reindex()
函数C++定义格式:
jt.Var reindex(jt.Var x, NanoVector shape, vector<string>&& indexes, float64 overflow_value=0, vector<string>&& overflow_conditions={}, vector<VarHolder*>&& extras={})
根据特定的索引规则将一个张量中的元素映射到另一个张量中。
- 参数:
x (jittor.Var): 输入的 jittor 变量.
shape (Tuple[int]): 输出的形状, 一个整数元组。
indexes (List[str]): 由C++样式整数表达式构成的数组, 它的长度应该与x的维数相同。
overflow_value (float， 可选): 溢出值。默认值：0
overflow_conditions (List[str]): 由C++样式布尔表达式构成的数组, 它的长度可以不同。默认值：空字典，即{}。
extras (List[jittor.Var]): 用于索引的额外变量。默认值：空字典，即{}。
- 返回值：
output (jittor.Var): 输出映射之后的jittor张量.
- 代码示例：
>>> import jittor as jt >>> # 使用 reindex 操作实现的卷积操作 >>> def conv(x, w): >>> N, H, W, C = x.shape >>> Kh, Kw, _C, Kc = w.shape >>> assert C == _C >>> xx = jt.reindex(x,shape= [N, H - Kh + 1, W - Kw + 1, Kh, Kw, C, Kc], indexes=[ >>> 'i0', # Nid >>> 'i1+i3', # Hid+Khid >>> 'i2+i4', # Wid+KWid >>> 'i5', # Cid >>> ]) >>> ww = w.broadcast_var(xx) >>> yy = xx * ww >>> y = yy.sum([3, 4, 5]) # Kh, Kw, C >>> return y, yy
- jittor_core.Var.reindex_reduce()
函数C++定义格式:
jt.Var reindex_reduce(jt.Var y, String op, NanoVector shape, vector<string>&& indexes, vector<string>&& overflow_conditions={}, vector<VarHolder*>&& extras={})
reindex_reduce算子是一种many-to-one的映射算子。 它的运行机制和下面的python伪代码一致:
# input is y, output is x n = len(y.shape)-1 m = len(shape)-1 k = len(overflow_conditions)-1 x = np.zeros(shape, y.dtype) x[:] = initial_value(op) for i0 in range(y.shape[0]): # 1-st loop for i1 in range(y.shape[1]): # 2-nd loop ...... # many loops for in in range(y.shape[n]) # n+1 -th loop # indexes[i] is a c++ style integer expression consisting of i0,i1,...,in xi0,xi1,...,xim = indexes[0],indexes[1],...,indexes[m] if not is_overflow(xi0,xi1,...,xim): x[xi0,xi1,...,xim] = op(x[xi0,xi1,...,xim], y[i0,i1,...,in]) # is_overflow is defined as following def is_overflow(xi0,xi1,...,xim): return ( xi0 < 0 || xi0 >= shape[0] || xi1 < 0 || xi1 >= shape[1] || ...... xim < 0 || xim >= shape[m] || # overflow_conditions[i] is a c++ style boolean expression consisting of i0,i1,...,in overflow_conditions[0] || overflow_conditions[1] || ...... overflow_conditions[k] )
参数:
y: 输入Jittor变量
op: 一个代表reduce操作类型的str。
shape: 输出形状。
indexes: C++风格的数组表达式。它的长度需要和输出形状一致。一些内建变量如下所示:
XDIM, xshape0, ..., xshapem, xstride0, ..., xstridem YDIM, yshape0, ..., yshapen, ystride0, ..., ystriden i0, i1, ..., in @e0(...), @e1(...) for extras input index e0p, e1p , ... for extras input pointer
overflow_conditions: C++风格的数组表达式，用于限制什么时候进行映射操作。它长度随意，内建变量同上。
extras: 用于索引的额外变量，注意需要用 List 形式传入。
示例代码:
使用此算子实现pool操作:
def pool(x, size, op): N,H,W,C = x.shape h = (H+size-1)//size w = (W+size-1)//size return x.reindex_reduce(op, [N,h,w,C], [ "i0", # Nid f"i1/{size}", # Hid f"i2/{size}", # Wid "i3", # Cid ])
- jittor_core.Var.right_shift()
函数C++定义格式:
jt.Var right_shift(jt.Var x, jt.Var y)
对两个张量中对应元素计算右移移位运算，也可以使用
>>运算符调用- 参数：
x (Var): 被右移的张量，元素的数据类型是
int32或int64y (Var): 右移的位数张量，元素的数据类型是
int32或int64，形状与x相同
- 返回值：
形状与
x和y相同的张量，其元素为x和y对应索引位置的元素计算右移操作的结果数- 代码示例：
>>> x = jt.array([123, 345, -456]) >>> y = jt.array([3, 4, 5]) >>> x.right_shift(y) jt.Var([ 15 21 -15], dtype=int32) >>> x >> y jt.Var([ 15 21 -15], dtype=int32)
- 注意事项：
支持使用
jt.right_shift()进行调用
- jittor_core.Var.round()
函数C++定义格式:
jt.Var round(jt.Var x)
创建一个张量, 其将
x中的每一个数值转换为离其最近的整数（四舍五入）。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置取最近整数的值- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 1.1675875 -0.36471805 2.0246403 1.1496693 -0.09650089], dtype=float32) >>> x.round() jt.Var([ 1. -0. 2. 1. -0.], dtype=float32)
- 注意事项：
支持使用
jt.round()进行调用
- jittor_core.Var.round_int()
函数C++定义格式:
jt.Var round_int(jt.Var x)
创建一个张量, 其将
x中的每一个数值转换为离其最近的整数（四舍五入）, 数据类型为int32。- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置取最近整数的值, 数据类型为int32- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 2.00422 -2.081075 -0.7260027 0.46558696 -0.1570169 ], dtype=float32) >>> x.round_int() jt.Var([ 2 -2 -1 0 0], dtype=int32)
- 注意事项：
支持使用
jt.round_int()进行调用
- jittor_core.Var.safe_clip()
函数C++定义格式:
jt.Var safe_clip(jt.Var x, float64 left=-1e300, float64 right=1e300)
对一个值在一个区间[left, right]内进行安全剪裁,并保持梯度通过。当输入值在剪裁区间之外时,其梯度保持不变。
- 公式如下：
如果 left <
x< right ,那么返回值y=x。否则，如果x<= left ,那么y= left ；如果x>=right,那么y=right。- 参数：
x(Var):输入值。
left(float):剪裁的最小值。默认值：
float64right(float):剪裁的最大值。默认值：
float64
- 返回值：
剪裁后的值(Var)。
- 代码示例：
>>> import jittor as jt >>> x = jt.Var([-1,0.75,2]) >>> jt.safe_clip(x, 0.5, 1) [0.5,0.75,1.]
- jittor_core.Var.setitem()
函数C++定义格式:
jt.Var setitem(jt.Var x, VarSlices&& slices, jt.Var y, String op=ns_void)
将 Jittor 变量的某一个切片设置为另一个 Jittor 变量的值。在操作中的
x和y可看作两个 tensor ， op 决定了如何计算这两个 tensor。- 参数：
x(Var): 变量实例。
slices(slice): 描述要被剪切的切片信息, 类型为切片。
y(Var): 用于赋值给x的某个切片。
op(str, optional): 操作类型。默认值：
"void"
- 返回值：
更新后的变量(Var)
- 代码示例：
>>> import jittor as jt >>> x = jt.array([[1,2],[3,4]]) >>> y = jt.array([0.1,0.2]) >>> jt.setitem(x, slice(1, 2), y) [[1,2],[0.1,0.2]]
- jittor_core.Var.sigmoid()
函数C++定义格式:
jt.Var sigmoid(jt.Var x)
创建一个张量, 其将输入变量
x中的每一个数值进行sigmoid变换。\[out_i = \frac{1}{1 + e^{-x_i}}\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行sigmoid变换后的值- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 2.7442768 -0.6135011 -0.09157802 -2.3600576 0.98465353], dtype=float32) >>> x.sigmoid() jt.Var([0.93958926 0.35126096 0.47712144 0.08626965 0.72803056], dtype=float32)
- 注意事项：
sigmoid变换的定义域是实数集，值域是(0, 1)支持使用
jt.sigmoid()进行调用
- jittor_core.Var.sin()
函数C++定义格式:
jt.Var sin(jt.Var x)
创建一个张量, 其将
x中的每一个元素进行正弦运算。\[y_i = \sin(x_i)\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行正弦运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-1.6485653 -0.10077649 -0.7546536 -0.02543143 1.0830703 ], dtype=float32) >>> x.sin() jt.Var([-0.9969775 -0.10060599 -0.68503636 -0.02542868 0.88340074], dtype=float32)
- 注意事项：
正弦函数的定义域是实数集，值域是
[-1, 1]支持使用
jt.sin()进行调用
- jittor_core.Var.sinh()
函数C++定义格式:
jt.Var sinh(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行双曲正弦运算。\[y_i = \sinh(x_i) = \frac{e^x - e^{-x}}{2}\]- 参数：
x (Var): Var类型的张量
- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 0.50530916 -1.0814334 0.0039318 1.1737247 -1.4199417 ], dtype=float32) >>> jt.sin(x) jt.Var([ 0.5270894 -1.3048973 0.00393181 1.4624014 -1.9475756 ], dtype=float32)
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行双曲正弦运算的结果- 注意事项：
正弦函数的定义域和值域是实数集
支持使用
x.sinh()进行调用
- jittor_core.Var.sqrt()
函数C++定义格式:
jt.Var sqrt(jt.Var x)
创建一个张量，其将
x中的每一个数值进行平方根运算。\[out_i = \sqrt{input_i}\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行平方根运算后的值- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 1.1675875 -0.36471805 2.0246403 1.1496693 -0.09650089], dtype=float32) >>> x.sqrt() jt.Var([1.0805496 nan 1.4228985 1.0722263 nan], dtype=float32)
- 注意事项：
如果输入元素是负数，返回
nan支持使用
jt.sqrt()进行调用
- jittor_core.Var.start_grad()
函数C++定义格式:
jt.Var start_grad()
开启当前变量的梯度记录。
- jittor_core.Var.stop_fuse()
函数C++定义格式:
inline jt.Var stop_fuse()
停止算子的fusion，注意这可能会影响性能。
- jittor_core.Var.stop_grad()
函数C++定义格式:
inline jt.Var stop_grad()
关闭当前变量的梯度记录。
- jittor_core.Var.sub()
函数C++定义格式:
jt.Var subtract(jt.Var x, jt.Var y)
对两个张量中对应元素计算求差，也可以使用
-运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相减结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.subtract(y) jt.Var([-2 -2 -1], dtype=int32) >>> x - y jt.Var([-2 -2 -1], dtype=int32)
- 注意事项：
jt.sub()和jt.subtract()是等价的。
- jittor_core.Var.subtract()
函数C++定义格式:
jt.Var subtract(jt.Var x, jt.Var y)
对两个张量中对应元素计算求差，也可以使用
-运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
x和y每对对应元素相减结果，形状与x和y相同- 代码示例：
>>> x = jt.array([1, 2, 4]) >>> y = jt.array([3, 4, 5]) >>> x.subtract(y) jt.Var([-2 -2 -1], dtype=int32) >>> x - y jt.Var([-2 -2 -1], dtype=int32)
- 注意事项：
jt.sub()和jt.subtract()是等价的。
- jittor_core.Var.sum()
函数C++定义格式:
jt.Var reduce_add(jt.Var x, int dim, bool keepdims=false)
对张量的
dims这些维度求和- 参数：
x (Var): 输入数据
dim (tuple[int]): 在哪些维度求和。默认是全部元素的最大值。默认值：
()keepdims (bool): 是否在结果中保留
dim维度。默认值：False
- 返回值：
求和的结果。如果
keepdims为True则形状为x将dims里给出的维度的长度变成 1，否则是x的形状去掉dims给出的维度- 代码示例：
>>> x = jt.randint(0, 10, shape=(2, 3)) >>> x jt.Var([[2 7 9] [2 6 3]], dtype=int32) >>> x.sum() jt.Var([29], dtype=int32) >>> x.sum((0, 1)) jt.Var([29], dtype=int32)
- jittor_core.Var.swap()
函数C++定义格式:
inline jt.Var swap(jt.Var v)
和另外一个Var交换数据内容。
- 参数:
v (Var): 另一个Var
- 返回值:
就地交换，返回交换后
x的值。- 代码示例:
>>> x, y = jt.randn(5), jt.randn(5) >>> x jt.Var([-1.9465057 -0.17227498 0.08347224 -1.2592555 0.1071676 ], dtype=float32) >>> y jt.Var([ 0.27618277 -0.8328144 -0.33380997 0.03772787 0.89321905], dtype=float32) >>> x.swap(y) jt.Var([ 0.27618277 -0.8328144 -0.33380997 0.03772787 0.89321905], dtype=float32) >>> x jt.Var([ 0.27618277 -0.8328144 -0.33380997 0.03772787 0.89321905], dtype=float32) >>> y jt.Var([-1.9465057 -0.17227498 0.08347224 -1.2592555 0.1071676 ], dtype=float32)
- jittor_core.Var.tan()
函数C++定义格式:
jt.Var tan(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行正切运算，即正弦值除以余弦值。\[y_i = \tan(x_i) = \frac{\sin(x)}{\cos(x)}\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行正切运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([-0.1146331 -0.22897322 -1.1813502 0.7146521 -0.02658333], dtype=float32) >>> x.tan() jt.Var([-0.11513788 -0.23306055 -2.4366024 0.8676503 -0.02658959], dtype=float32)
- 注意事项：
该函数的值域为实数集，定义域为
\[x \in \mathbb{R} \setminus \left\{ \left(2k+1\right)\frac{\pi}{2} \mid k \in \mathbb{Z} \right\}\]支持使用
jt.tan()进行调用
- jittor_core.Var.tanh()
函数C++定义格式:
jt.Var tanh(jt.Var x)
创建一个张量, 其将
x中的每一个数值进行双曲正切运算。\[\tanh(x) = \frac{{e^{x} - e^{-x}}}{{e^{x} + e^{-x}}}\]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 其数值是
x中对应位置进行双曲正切运算的结果- 代码示例：
>>> x = jt.randn(5) >>> x jt.Var([ 0.561267 1.7155168 -0.53718305 1.6382825 0.5129911 ], dtype=float32) >>> x.tanh() jt.Var([ 0.508917 0.93732095 -0.4908527 0.9272321 0.47227246], dtype=float32)
- 注意事项：
双曲正切运算的定义域为所有实数，值域为 (-1, 1)
支持使用
jt.tanh()进行调用
- jittor_core.Var.tape()
函数C++定义格式:
jt.Var tape(jt.Var x)
此函数用于计算Jittor变量的tape。
- 参数:
x(Var): 需要计算tape的Jittor变量。
- 返回值:
输入变量的tape。
- 代码示例:
>>> import jittor as jt >>> jt.set_seed(2) >>> a = jt.random([2,3]) >>> tape_a = a.tape() jt.Var([[0.4359949 0.18508208 0.02592623] [0.93154085 0.5496625 0.9477306 ]], dtype=float32)
- jittor_core.Var.ternary()
函数C++定义格式:
jt.Var ternary(jt.Var cond, jt.Var x, jt.Var y)
根据条件变量cond的值，从变量x或y中选择一个作为输出。当cond为真时，返回x的值；否则，返回y的值。这个功能类似于C/C++中的三元运算符。
- 参数:
cond (jittor.Var): 一个布尔类型的Jittor张量，用于决定返回x还是y。
x (jittor.Var): 当cond为真时返回的Jittor张量。
y (jittor.Var): 当cond为假时返回的Jittor张量。
- 返回值:
output (jittor.Var): 返回由cond决定的，x或y中的一个Jittor张量。
- 代码示例:
>>> import jittor as jt >>> cond = jt.Var(False) >>> x = jt.Var(2) >>> y = jt.Var(1) >>> z = jt.ternary(cond, x, y) >>> print(z) jt.Var([1], dtype=int32)
- 注意：
如果cond、x和y不是同类型的变量，可能会有类型转换的问题，可能会导致运算错误。
- jittor_core.Var.uint16()
函数C++定义格式:
jt.Var uint16_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为uint16，数据范围为[0, 65535]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
uint16- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[-0.7970826 0.99872327] [-0.543484 -2.133479 ]], dtype=float32) >>> x.uint16() jt.Var([[ 0 0] [ 0 65534]], dtype=uint16)
- jittor_core.Var.uint32()
函数C++定义格式:
jt.Var uint32_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为uint32，数据范围为[0, 4294967295]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
uint32- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[-0.7970826 0.99872327] [-0.543484 -2.133479 ]], dtype=float32) >>> x.uint32() jt.Var([[ 0 0] [ 0 4294967294]], dtype=uint32)
- jittor_core.Var.uint64()
函数C++定义格式:
jt.Var uint64_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为uint64，数据范围为[0, 18446744073709551615]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
uint64- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[-0.7970826 0.99872327] [-0.543484 -2.133479 ]], dtype=float32) >>> x.uint64() jt.Var([[ 0 0] [ 0 18446744073709551614]], dtype=uint64)
- jittor_core.Var.uint8()
函数C++定义格式:
jt.Var uint8_(jt.Var x)
创建并返回一个
x的张量副本，并将其类型转换为uint8，数据范围为[0, 255]- 参数：
x (Var): Var类型的张量
- 返回值：
返回一个新的张量, 数据类型为
uint8- 代码示例：
>>> x = jt.randn((2,2)) >>> x jt.Var([[-0.7970826 0.99872327] [-0.543484 -2.133479 ]], dtype=float32) >>> x.uint8() jt.Var([[ 0 0] [ 0 254]], dtype=uint8)
- jittor_core.Var.unary()
函数C++定义格式:
jt.Var unary(jt.Var x, String op)
函数的目的是在输入张量上应用一个一元运算。具体的一元运算是由字符串参数`op`指定的。
- 以下是对某些一元运算的数学描述：
“abs”: 计算元素的绝对值。对于实数x，其绝对值定义为 \(|x| = \sqrt{x^2}\)，其中 \(\sqrt{}\) 表示平方根。
“sin”: 计算元素的正弦值。对于实数x，其正弦值定义为 \(\sin(x)\) ，其中
x是以弧度表示的角度。“cos”: 计算元素的余弦值。对于实数x，其余弦值定义为 \(\cos(x)\) ，其中
x是以弧度表示的角度。“neg”: 对元素求负，即 \(-x\) 。
“reciprocal”: 计算元素的倒数，即 \(1/x\) 。
“round”: 对元素进行四舍五入。
“ceil”: 对元素进行上取整。
“floor”: 对元素进行下取整。
“rsqrt”: 计算元素的反平方根，即 \(1/\sqrt{x}\) ，其中 math:sqrt{} 表示平方根。
“sqrt”: 计算元素的平方根，即 \(\sqrt{x}\) ，其中 \(\sqrt{}\) 表示平方根。
- 参数：
x(Var): 输入的张量。
op(str):一元运算的字符串。
- 返回值：
结果张量(Var)。运算
op被应用到输入张量x的每一个元素上，结果是一个新的张量，与输入张量有相同的形状。- 代码示例：
>>> import jittor as jt >>> x = jt.array([1.0, -1.0, 3.0, -3.0]) >>> x.unary('abs') [1., 1., 3., 3.]
- jittor_core.Var.update()
函数C++定义格式:
jt.Var update(jt.Var v)
更新参数和全局变量。和assign不同，它会停止原始变量和分配变量之间的梯度，并在后台更新。
- 参数:
v (Var): 另一个Var
- 返回值:
Var: 返回自身，但实际上已经原地复制完毕
- 代码示例:
>>> x, y = jt.randn(5), jt.randn(5) >>> x jt.Var([-1.3378737 0.8863208 1.9383168 0.35481802 1.4916613 ], dtype=float32) >>> y jt.Var([ 0.59842813 1.281807 0.05155467 -0.74704844 -1.0341489 ], dtype=float32) >>> x.update(y) jt.Var([ 0.59842813 1.281807 0.05155467 -0.74704844 -1.0341489 ], dtype=float32) >>> x jt.Var([ 0.59842813 1.281807 0.05155467 -0.74704844 -1.0341489 ], dtype=float32)
- jittor_core.Var.where()
函数C++定义格式:
jt.Var where_(jt.Var cond, jt.Var x, jt.Var y)
对张量中元素根据计算条件 cond 进行选择。
- 参数：
cond (Var): 选择条件
x (Var): 条件我非零值或
True时选择的数据，形状与cond一样y (Var): 条件为零或
False时选择的数据，形状与cond一样
- 返回值：
形状与输入都一样，每个值如果对应
cond中的值为非零或True则返回x中对应的元素，否则返回y中对应的元素- 代码示例：
>>> cond = jt.array([1, 0, 1]) >>> x = jt.array([3, 4, 5]) >>> y = jt.array([9, 8, 7]) >>> jt.where(cond, x, y) jt.Var([3 8 5], dtype=int32)
jittor.Misc
这里是Jittor的基础算子模块的API文档，该API可以通过jittor.misc.XXX或者jittor.XXX直接访问。
- class jittor.misc.CTCLoss(blank=0, reduction='mean', zero_infinity=False)[源代码]
计算链接主义时序分类 (Connectionist Temporal Classification) 损失函数。
计算一个连续时间序列和目标差别的损失函数，刻画输入与目标的对应。CTCLoss 对输入到目标的各个对齐方式的概率求和，得到一个对每个输入可微分的损失值。输入到目标的对齐应该是“多对一的”，因此目标序列长度被限制为不超过输入序列长度。
- 参考文献：
Graves et al.: Connectionist Temporal Classification: Labelling Unsegmented Sequence Data with Recurrent Neural Networks:
- 参数：
blank (int): 空标签的编号。默认值：0
reduction (string): 如何聚合所有批次的计算结果，mean 是均值，sum 是求和，none 是不聚合全部返回。默认值：
'mean'zero_infinity (bool): 将损失函数中的无穷大项和对应梯度置零（这种情况一般是在输入短于目标时出现）。默认值：False
- 形状：
- Input:
log_probs: \((T, N, C)\)，其中 \(T\) 为序列长度，\(N\) 为批次大小，\(S\) 为分类个数，表示输出序列的每项被分类到各个类的概率的对数。
targets: \((N, S)\)，其中 \(N\) 为批次大小，\(S\) 为目标序列长度，表示目标序列每项的分类序号，范围 \([0, C)\)
input_lengths: \((N)\)，其中 \(N\) 为批次大小，表示每个输入的实际长度，范围 \([0, T]\)
target_lengths: \((N)\)，其中 \(N\) 为批次大小，表示每个目标序列的实际长度，范围 \([0, S]\)
Output: 如果 reduction 为
'mean'（默认）或'sum'则为一标量；如果 reduction 为'none'则为 \((N,)\)，其中 \(N\) 为批次大小。
- 代码示例：
>>> T, C, N, S = 50, 20, 16, 30 >>> S_min = 10 # 最小目标长度，用于演示目的 >>> input = jt.randn(T, N, C).log_softmax(2) >>> # 初始化随机批次的目标 (0 = 空白, 1:C = 类别) >>> target = jt.randint(low=1, high=C, shape=(N, S), dtype=jt.int) >>> input_lengths = jt.full((N,), T, dtype=jt.int) >>> target_lengths = jt.randint(low=S_min, high=S+1, shape=(N,), dtype=jt.int) >>> ctc_loss = jt.CTCLoss() >>> ctc_loss(input, target, input_lengths, target_lengths) jt.Var([114.68321], dtype=float32)
- class jittor.misc.Finfo[源代码]
浮点数类型相关参数。
由
jt.finfo返回，包括浮点数的相关参数。- 属性：
min: 该浮点数类型的最小有限值，值类型取决于选取的浮点数类型
max: 该浮点数类型的最大有限值，值类型取决于选取的浮点数类型
- 代码示例：
>>> jt.finfo('float32').min -3.4028235e+38 >>> jt.finfo('bfloat16').min -1e+38
- jittor.misc.all(x, dim=())[源代码]
在指定维度上计算逻辑与
- 参数：
x (Var): 被计算逻辑与的张量
dim (int | tuple[int, …]): 计算逻辑与的维度，默认为全部维度，即全部元素逻辑与得到一个元素
- 返回值：
计算逻辑与的结果，形状为
x去掉dim所选维度，元素类型为bool- 代码示例：
>>> x = jt.randn(2, 3) > 0 >>> x jt.Var([[ True True False] [ True False True]], dtype=bool) >>> jt.all(x) jt.Var([False], dtype=bool) >>> jt.all(x, 0) jt.Var([ True False False], dtype=bool) >>> jt.all(x, 1) jt.Var([False False], dtype=bool)
- jittor.misc.all_equal(a: Var, b: Var)[源代码]
检查两个Jittor变量（jt.Var）是否完全相等。如果每一个元素都一致，函数则返回True，否则返回False。 这个函数通过逐元素的比较来判断两个变量是否相等。首先，使用 a == b 操作进行元素级的比较。然后，通过 .all() 操作来验证所有元素是否与 b 一致。最后， .item() 操作将结果转化为Python的bool值。 传入变量应该是Jittor的Var类型，a和b的尺寸应该是一样的。如果不一样，函数将抛出ValueError`。
- 参数：
a (jt.Var) : 第一个Jittor变量，用于比较的输入
b (jt.Var): 第二个Jittor变量，用于比较的输入
- 返回值：
bool类型，如果a和b所有元素相等，返回True，否则返回False
- 代码示例：
>>> a = jt.array([1, 2, 3]) >>> b = jt.array([1, 2, 3]) >>> print(all_equal(a, b)) True >>> a = jt.array([1, 2, 3]) >>> b = jt.array([1, 2, 4]) >>> print(all_equal(a, b)) False
- jittor.misc.any(x, dim=())[源代码]
在指定维度上计算逻辑或
- 参数：
x (Var): 被计算逻辑或的张量
dim (int | tuple[int, …]): 计算逻辑或的维度，默认为全部维度，即全部元素逻辑或得到一个元素
- 返回值：
计算逻辑或的结果，形状为
x去掉dim所选维度，元素类型为bool- 代码示例：
>>> x = jt.randn(2, 3) > 0 >>> x jt.Var([[ True False True] [False False True]], dtype=bool) >>> jt.any(x) jt.Var([ True], dtype=bool) >>> jt.any(x, 0) jt.Var([ True False True], dtype=bool) >>> jt.any(x, 1) jt.Var([ True True], dtype=bool)
- jittor.misc.arange(start=0, end=None, step=1, dtype=None)[源代码]
生成一个包含在区间[
start,end)内等间隔分布的数字的序列。- 参数:
start(float | Var, 可选): 默认值=0, 序列的开始值。也可以是一个仅包含一个元素的 Var
end(float | Var, 可选): , 默认值=None, 序列的结束值，也可以是一个仅包含一个元素的 Var
step(float | Var, 可选):, 默认值=1, 生成的数字序列之间的固定间隔，也可以是一个仅包含一个元素的 Var
dtype(type, 可选): 把返回的 Var 转换为指定的数据类型。
- 代码示例:
>>> jt.arange(1, 3.5, 0.5, jt.float32) jt.Var([1. 1.5 2. 2.5 3. ], dtype=float32)
- 返回值:
一个 1-D 的 Var 对象，包含从
start(包含)到end(不包含)以step为步长的等差序列。
- jittor.misc.arctan2(y, x)[源代码]
按元素计算y/x的反正切值，以弧度计算。注意第一个参数 y 中的元素是 y 坐标，第二个参数 x 中的元素是 x 坐标。
\[\begin{split}\text{arctan2}(y, x) = \begin{cases} \arctan(y / x) - \pi, & \text{ if } x \lt 0, y \lt 0 \\ \arctan(y / x) + \pi, & \text{ if } x \lt 0, y \geq 0 \\ \arctan(y / x), & \text{ otherwise } \end{cases}\end{split}\]参数：
y (Var): Jittor数组，任何shape和dtype。
x (Var): Jittor数组，与y相同的shape和dtype。+
返回：
Jittor数组，具有和输入相同的shape和dtype。
代码示例：
>>> x = jt.randn(3) jt.Var([0.8616086 0.81152385 0.0437891], dtype=float32) >>> y = jt.randn(3) jt.Var([-0.0904924 1.4761028 -1.367789], dtype=float32) >>> c = jt.arctan2(y, x) jt.Var([-0.10464364 1.0681262 -1.5387927], dtype=float32)
- jittor.misc.bernoulli(input)[源代码]
对于每个元素
p，返回概率为p的伯努利分布的随机值：\[\begin{split}\begin{cases} 1 & \text{ with probability } p \\ 0 & \text{ with probability } (1 - p) \end{cases}\end{split}\]- 参数：
input (Var): 每个采样所用的概率
p
- 返回值：
形状与数据类型和
input一样的张量，原张量中每个元素p对应返回值里的元素，以概率p为 1，概率1 - p为 0- 代码示例：
>>> x = jt.array([0.0, 0.5, 1.0]) >>> jt.bernoulli(x) jt.Var([0. 0. 1.], dtype=float32) >>> jt.bernoulli(x) jt.Var([0. 0. 1.], dtype=float32) >>> jt.bernoulli(x) jt.Var([0. 1. 1.], dtype=float32)
- jittor.misc.chunk(x, chunks, dim=0)[源代码]
将张量在
dim维度切分为chunks块切块尽量均匀。如果
x在dim维的长度不是chunks的整倍数，最后一个块的长度会小于之前块的长度。如果无法切分出chunks个非空的块，则会返回少于chunks个块。- 参数：
x (Var): 被切块的张量，形状 \((n_0, \ldots, n_{\mathtt{dim}}, \ldots, n_k)\)
chunks (int): 切成的块数
dim (int, 可选): 在哪个维度切块，负数表示从后往前数。默认值：0
- 返回值：
list[Var]为切块后按顺序得到的各个块组成的列表。- 示例代码：
>>> x = jt.arange(10) >>> x.chunk(2) [jt.Var([0 1 2 3 4], dtype=int32), jt.Var([5 6 7 8 9], dtype=int32)] >>> x.chunk(4) [jt.Var([0 1 2], dtype=int32), jt.Var([3 4 5], dtype=int32), jt.Var([6 7 8], dtype=int32), jt.Var([9], dtype=int32)] >>> x.chunk(6) [jt.Var([0 1], dtype=int32), jt.Var([2 3], dtype=int32), jt.Var([4 5], dtype=int32), jt.Var([6 7], dtype=int32), jt.Var([8 9], dtype=int32)]
- jittor.misc.contiguous(x)[源代码]
在内存中创建给定 Var 的深拷贝。
该函数确保结果的内存是连续的，且与源张量分开。这在您需要更改张量，但不希望这些更改反映在原始张量中时非常有用。
- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> x = jt.array([1,2,3]) >>> y = contiguous(x) >>> y[0] = 5 >>> print(x) jt.Var([1 2 3], dtype=int32) >>> print(y) jt.Var([5 2 3], dtype=int32)
- 返回值:
Var,
x的深拷贝，占用连续的内存
- jittor.misc.cpu(x)[源代码]
将指定的 Var 复制到CPU。
- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> a = jt.array([1, 2, 3]) >>> b = jt.cpu(a) >>> print(b) jt.Var([1 2 3], dtype=int32)
- 返回值:
Var, 与输入数据有相同值的新数据变量，位于 CPU 上。
- jittor.misc.cross(input, other, dim=-1)[源代码]
批量计算向量叉乘：
\((a_1, a_2, a_3) \times (b_1, b_2, b_3) = (a_2 b_3 - a_3 b_2 , a_3 b_1 - a_1 b_3 , a_1 b_2 - a_2 b_1)\)
- 参数：
input (Var): 叉乘的左参数
other (Var): 叉乘的右参数，形状与
input相同dim (int): 计算叉乘的向量所在的维度，要求
input和other在dim维的长度都是 3。负数表示从后往前数。默认值：-1
- 返回值：
input和other对应向量叉乘的结果，形状与input和other相同- 代码示例：
>>> x = jt.randn(2, 3) >>> y = jt.randn(2, 3) >>> x, y, x.cross(y) (jt.Var([[ 0.6452728 -1.7699949 0.7562031 ] [ 0.32050335 0.7093985 -0.44102713]], dtype=float32), jt.Var([[ 0.42947495 0.6956272 -0.35488197] [ 0.44775873 -0.19148853 -0.52726024]], dtype=float32), jt.Var([[ 0.10210377 0.553766 1.2090378 ] [-0.45848927 -0.02848507 -0.3790121 ]], dtype=float32)) >>> x.cross(x) jt.Var([[0. 0. 0.] [0. 0. 0.]], dtype=float32)
- jittor.misc.ctc_loss(log_probs, targets, input_lengths, target_lengths, blank=0, reduction='mean', zero_infinity=False)[源代码]
完成连通时间分类 (CTC, Connectionist Temporal Classification) 损失的计算。
计算连续（未分段）时间序列与目标序列之间的损失。CTCLoss 对输入到目标的可能对齐的概率求和，生成一个损失值，该值对每个输入节点可微分。假定输入到目标的对齐是“多对一”的，这限制了目标序列的长度，使其必须小于等于输入长度。
- 参数:
log_probs (Var): 形状为[T, N, C]的张量，T为序列长度，N为批次大小，C为类别数量。
targets (Var): 形状为[N, S]的张量，N为批次大小，S为目标序列长度，其中的元素应在[0,C)范围内。
input_lengths (Var): 形状为[N]的张量，每个元素代表输入序列的长度，元素应在[0,T]范围内。
target_lengths (Var): 形状为[N]的张量，每个元素代表目标序列的长度，元素应在[0,S]范围内。
blank (int)： 默认为 0，空白标签索引
reduction (str)：减少批量损失，如果reduction是none，它会返回一个(N,)的数组，如果reduction是mean或sum，它会返回一个标量。默认为 “mean”。
zero_infinity (bool): 默认为 False, 用于梯度计算
代码示例:
import jittor as jt T = 50 # Input sequence length C = 20 # Number of classes (including blank) N = 16 # Batch size S = 30 # Target sequence length of longest target in batch (padding length) S_min = 10 # Minimum target length, for demonstration purposes input = jt.randn(T, N, C).log_softmax(2) # Initialize random batch of targets (0 = blank, 1:C = classes) target = jt.randint(low=1, high=C, shape=(N, S), dtype=jt.int) input_lengths = jt.full((N,), T, dtype=jt.int) target_lengths = jt.randint(low=S_min, high=S+1, shape=(N,), dtype=jt.int) loss = jt.ctc_loss(input, target, input_lengths, target_lengths) # calculation result, loss is: jt.Var([115.42529], dtype=float32) dinput = jt.grad(loss, input)
- 返回值:
Var，包含一个数，是计算出的 CTC 值。
- jittor.misc.cub_cumsum(x, dim=None)[源代码]
沿着指定维度计算输入张量在这个维度上的累加求和，使用CUB实现。
累加求和是指，在指定方向上：
\[y_i=x_1+x_2+x_3+\cdots+x_i\]注意，该函数不应该直接调用。推荐使用jittor.misc.cumsum。该函数不支持 CPU 模式，需要先指定在 GPU 上计算。
- 参数:
x (Var): 输入张量 Var, 任意形状
dim (int): 指定进行累加求和的轴。默认为最后一维。
- 代码示例:
>>> jt.flags.use_cuda = 1 # 使用 GPU 计算 >>> a = jt.randn(4, 2) jt.Var([[ 0.7793252 -2.1805465 ] [-0.46900165 2.0724497 ] [-1.2677554 0.31553593] [ 0.14260457 -1.4511695 ]], dtype=float32) >>> jt.cub_cumsum(a, 1) jt.Var([[ 0.7793252 -1.4012213 ] [-0.46900165 1.603448 ] [-1.2677554 -0.9522195 ] [ 0.14260457 -1.3085649 ]], dtype=float32) >>> jt.cub_cumsum(a, 0) jt.Var([[ 0.7793252 -2.1805465 ] [ 0.31032354 -0.10809684] [-0.95743185 0.2074391 ] [-0.81482726 -1.2437304 ]], dtype=float32)
- 返回值:
Var，输出的张量，累加求和后的结果
- jittor.misc.cuda(x)[源代码]
这是一个用于将Jittor的全局标记 use_cuda 设置为1，并返回输入值的函数。当 use_cuda 被设置为1时，这意味着Jittor将使用CUDA进行加速。
- 参数
x : 输入值, 类型不限。
- 返回值：
x : 传入该函数的输入值。
- 代码示例：
>>> import jittor as jt >>> jt.flags.use_cuda 0 >>> jt.cuda(5) 5 >>> jt.flags.use_cuda 1
- jittor.misc.cumprod(x, dim=None)[源代码]
沿着指定维度计算输入张量在这个维度上的累乘。
累乘是指，在指定方向上：
\[y_i=x_1 \times x_2 \times x_3 \times \cdots \times x_i\]注意，由于此函数的实现是先取 \(\log\) 再做累加，因此务必保证输入为正数，否则计算结果会有
nan。- 参数:
x (Var): 输入张量 Var, 任意形状
dim (int): 指定进行乘法的轴。默认为最后一维。
- 代码示例:
>>> a = jt.arange(1, 7).reshape(2, 3) jt.Var([[1 2 3] [4 5 6], dtype=int32) >>> jt.cumprod(a, 1) jt.Var([[ 1. 2. 6. ] [ 4. 20. 120.00001]], dtype=float32) >>> jt.cumprod(a, 0) jt.Var([[ 1. 2. 3.] [ 4. 10. 18.]], dtype=float32)
- 返回值:
Var，输出的张量，累乘后的结果，形状和输入一致
- jittor.misc.cumsum(x, dim=None)[源代码]
沿着指定维度计算输入张量在这个维度上的累加求和。
累加求和是指，在指定方向上：
\[y_i=x_1+x_2+x_3+\cdots+x_i\]推荐直接调用该函数计算 cumsum。取决于是否指定在 GPU 上计算，该函数会调用不同的算子实现。
- 参数:
x (Var): 输入张量 Var, 任意形状
dim (int): 指定进行累加求和的轴。默认为最后一维。
- 代码示例:
>>> a = jt.randn(4, 2) jt.Var([[ 0.7793252 -2.1805465 ] [-0.46900165 2.0724497 ] [-1.2677554 0.31553593] [ 0.14260457 -1.4511695 ]], dtype=float32) >>> jt.cumsum(a, 1) jt.Var([[ 0.7793252 -1.4012213 ] [-0.46900165 1.603448 ] [-1.2677554 -0.9522195 ] [ 0.14260457 -1.3085649 ]], dtype=float32) >>> jt.cumsum(a, 0) jt.Var([[ 0.7793252 -2.1805465 ] [ 0.31032354 -0.10809684] [-0.95743185 0.2074391 ] [-0.81482726 -1.2437304 ]], dtype=float32)
- 返回值:
Var，输出的张量，累加求和后的结果
- jittor.misc.deg2rad(x)[源代码]
将输入中的每一个元素从角度值（以度为单位）转换为弧度值。转换的公式为:
\[rad = deg * \frac{\pi}{180}\]- 参数:
x (Var) : 输入的角度值，可以是单一浮点数或任意形状的输入 Var
- 返回:
float 或 Var: 转换后的弧度值，其形状与输入相同。
代码示例:
>>> input = jt.float32([[180.0, -180.0], [360.0, -360.0], [90.0, -90.0]]) >>> jt.deg2rad(a) jt.Var([[ 3.141593 -3.141593 ] [ 6.283186 -6.283186 ] [ 1.5707965 -1.5707965]], dtype=float32)
- jittor.misc.diag(x, diagonal=0)[源代码]
从向量构建对角矩阵或从方阵中提取对角元素。
如果输入是一个一维向量，返回一个二维方阵，其对角线上的元素由输入向量中的元素构成。
如果输入是一个二维方阵，返回一个由它的对角元素构成的一维向量。
对角线的偏移量可以用
diagonal确定，diagonal = 0代表主对角线，diagonal > 0为沿右上方移动，diagonal < 0为沿左下方移动。- 参数:
x (Var): 输入张量 Var, 向量或矩阵。
diagonal (int): 对角偏移量，默认为 0。
- 代码示例:
>>> a = jt.arange(4) >>> jt.diag(a) jt.Var([[0 0 0 0] [0 1 0 0] [0 0 2 0] [0 0 0 3]], dtype=int32) >>> b = jt.randn(2,2) jt.Var([[-0.36892104 1.5115978 ] [ 0.8735136 0.81891364]], dtype=float32) >>> jt.diag(b) jt.Var([-0.36892104, 0.81891364], dtype=float32)
- 返回值:
向量或方阵 (Var)
- jittor.misc.expand(x, *shape)[源代码]
扩展并广播一个张量到指定形状。
指定的形状每一维必须为下列值之一：
-1表示不改变这维度的长度和
x对应维长度一样，表示不改变这个维度的长度新的长度，要求
x对应维长度为 1，表示在这个维度上扩展
- 参数：
x (Var): 被扩展的张量
shape (tuple[int, …]): 扩展到的形状
或者
x (Var): 被扩展的张量
n0, n1, … (int): 扩展到的形状
- 返回值：
扩展到指定形状的张量
- 示例代码：
>>> a = jt.zeros((3,1)) >>> a.expand(3, 4).shape [3,4,] >>> a.expand(-1, 4).shape [3,4,]
- jittor.misc.finfo(dtype)[源代码]
根据指定的数据类型，返回其numpy浮点数类型的机器限制信息。numpy为每个浮点数提供了一个finfo对象，该对象提供了关于机器限制的信息，例如浮点数类型可以表示的最大和最小的正值、精度和“数字”的数量等，参见
https://numpy.org/doc/stable/reference/generated/numpy.finfo.html- 参数：
dtype (str) : 指定的数据类型。例如：’float16’。
- 返回值：
返回对应指定数据类型的 numpy finfo 对象或者 ‘bfloat16_finfo’对象。
- 代码示例：
>>> from jittor import misc >>> misc.finfo('float32') finfo(resolution=1e-06, min=-3.4028235e+38, max=3.4028235e+38, dtype=float32)
- jittor.misc.flip(x, dim=0)[源代码]
将张量在指定维度镜像翻转
- 参数：
x (Var): 需要翻转的张量
dim (int | tuple[int, …]): 需要翻转的维度，负数表示从后往前数。默认值：0
- 返回值：
x 在指定维度翻转后的结果
- 代码示例：
>>> x = jt.array([[1, 2], [3, 4]]) >>> x.flip() jt.Var([[3 4] [1 2]], dtype=int32) >>> x.flip(1) jt.Var([[2 1] [4 3]], dtype=int32) >>> x.flip((0, 1)) jt.Var([[4 3] [2 1]], dtype=int32)
- jittor.misc.from_torch(x)[源代码]
将PyTorch Tensor转化为Jittor Var。
- 参数:
x (torch.Tensor): 需要转化的PyTorch Tensor。
- 返回值:
jt.Var: 转化后的Jittor Variable。
- 代码示例:
>>> import torch >>> import jittor as jt >>> a = torch.tensor([1.0, 2.0, 3.0]) >>> b = from_torch(a) >>> print(b) jt.Var([1.0, 2.0, 3.0])
- jittor.misc.gather(x, dim, index)[源代码]
该函数用给定的索引数组重新索引源数组（如果源数组是3-D数组）。
对于索引数组中的每个元素，假设当前元素的坐标是(i,j,k)，则在结果数组中当前索引对应的元素取决于参数
dim的值：如果dim == 0, out[i][j][k] = input[index[i][j][k]][j][k]
如果dim == 1, out[i][j][k] = input[i][index[i][j][k]][k]
如果dim == 2, out[i][j][k] = input[i][j][index[i][j][k]]
- 参数:
x (Var): 输入数组
dim (int): 索引操作进行的轴
index (Var): 元素的索引数组
- 代码示例:
>>> t = jt.array([[1, 2], [3, 4]]) >>> jt.gather(t, 1, jt.array([[0, 0], [1, 0]])) jt.Var([[1 1] [4 3]], dtype=int32) >>> jt.gather(t, 0, jt.array([[0, 0], [1, 0]])) jt.Var([[1 2] [3 2]], dtype=int32)
- 返回值:
Var，通过指定的索引方式重新索引源数组，汇总得到的结果。
- jittor.misc.get_max_memory_treemap(build_by=0, do_print=True)[源代码]
显示最大内存消耗的树图。
- 参数:
build_by (int, 可选): 0或1，0表示按照名称构造树，1表示按照路径构造树。默认值: 0
do_print (bool, 可选): 是否打印输出。如果do_print=True，那么会在函数中打印输出。默认值: True
- 返回值:
最大内存消耗的树图
- 示例代码:
>>> from jittor.models import resnet18 >>> import jittor as jt >>> net = resnet18() >>> with jt.flag_scope(trace_py_var=3, profile_memory_enable=1): ... imgs = jt.randn((1,3,224,224)) ... net(imgs).sync() ... jt.get_max_memory_treemap() ... | ├─./python/jittor/test/test_memory_profiler.py:100(test_sample) | [19.03 MB; 29.67%] | ./python/jittor/test/test_memory_profiler.py:100 | | | └─./python/jittor/__init__.py:730(__call__) | [19.03 MB; 29.67%] | ./python/jittor/__init__.py:730 | | | └─./python/jittor/models/resnet.py:152(execute) | [19.03 MB; 29.67%] | ./python/jittor/models/resnet.py:152 | | | ├─./python/jittor/models/resnet.py:142(_forward_impl) | | [6.13 MB; 9.55%] | | ./python/jittor/models/resnet.py:142 | | |
- jittor.misc.histc(input, bins, min=0.0, max=0.0)[源代码]
计算输入的N维数组的直方图。
元素被排序进入最小值和最大值之间等宽的箱中。若 min 和 max 都为0，则会取输入数组的最小值和最大值作为范围。返回的结果中，每个箱的值表示输入数组中值落在该 箱范围的元素数量。
- 参数：
input(Var): 输入的数组
bins(int): 直方图的分隔宽度数量
min(float,optional): 箱的最小边界，默认值：0
max(float,optional): 箱的最大边界，默认值：0
- 返回值：
计算得到的直方图（Var）
代码示例:
>>> inputs = jt.randn((40,40)) >>> jt.histc(inputs, bins=10) jt.Var([ 1. 12. 40. 143. 323. 398. 386. 202. 72. 23.], dtype=float32)
- jittor.misc.hypot(a, b)[源代码]
计算输入平方之和的平方根 \(\sqrt{a^2 + b^2}\)
- 参数：
a (Var): 输入参数
b (Var): 输入参数，形状和
b一样
- 返回值：
a和b平方之和的平方根- 代码示例：
>>> a = jt.array([3.0, 5.0]) >>> b = jt.array([4.0, 12.0]) >>> jt.hypot(a, b) jt.Var([ 5. 13.], dtype=float32)
- jittor.misc.iinfo(dtype)[源代码]
此函数返回给定数据类型可表示的最大/最小整数的信息。此函数仅支持整数类型，如果dtype不是整数类型，会引发ValueError。
- 参数:
dtype (str)：期望获得其信息的数据类型的名称。如 ‘int32’ 、 ‘int16’ 等。
- 返回值:
返回一个iinfo对象，它有以下属性：min, max, dtype等。
- 代码示例：
>>> from jittor import misc >>> misc.iinfo('int32') iinfo(min=-2147483648, max=2147483647, dtype=int32)
- jittor.misc.index_add_(x, dim, index, tensor)[源代码]
对于
index中的每个下标和tensor里对应的每个张量，在x的dim维对应的下标处加上这个张量- 参数：
x (Var): 形状
(..., k, ...)dim (int): 上面
x中k对应的是第几维index (Var): 形状
(n)选取要加上张量的下标tensor (Var): 形状
(n, ..., ...)每个下标处要加上的张量
- 代码示例：
>>> x = jt.ones(2, 3, 4) >>> jt.index_add_(x, 0, jt.array([0, 1]), jt.array([jt.ones(3, 4), jt.ones(3, 4) * 2])) >>> jt.index_add_(x, 1, jt.array([0, 1]), jt.array([jt.ones(2, 4), jt.ones(2, 4) * 2])) >>> x jt.Var([[[3. 3. 3. 3.] [3. 3. 3. 3.] [2. 2. 2. 2.]] [[5. 5. 5. 5.] [5. 5. 5. 5.] [3. 3. 3. 3.]]], dtype=float32)
- jittor.misc.index_fill_(x, dim, indexs, val)[源代码]
根据给定的索引
indexs在指定维度dim上替换为给定元素值val- 参数:
x (Var): 输入的 Var， 任意形状
dim (int): 进行索引替换的维度
indexs (Var): 需要替换的索引，类型为 Var，shape 为 (N, )，N 代表需要替换的索引个数
val (float): 替换的元素值
- 代码示例:
>>> x = jt.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype="float32") >>> jt.index_fill_(x, 0, jt.array([0, 2]), -1) jt.Var([[-1. -1. -1.] [ 4. 5. 6.] [-1. -1. -1.]], dtype=float32) >>> jt.index_fill_(x, 1, jt.array([0, 2]), -1) jt.Var([[-1. 2. -1.] [-1. 5. -1.] [-1. 8. -1.]], dtype=float32)
- 返回值:
进行索引替换之后的 Var，shape 与输入的 Var 一致
- jittor.misc.index_select(x: Var, dim: int, index: Var)[源代码]
该方法返回一个新的张量，该张量通过使用索引在dim维度上对输入张量x进行索引。 返回的张量具有与原始张量（x）相同的维度数。dim维度的大小与索引的长度相同; 其他维度的大小与原始张量中的大小相同。
- 参数:
x: jt.Var类型，输入的张量。
dim: int类型，需要进行索引的维度。
index: jt.Var类型，包含要索引的索引的1-D张量。
- 返回值:
jt.Var类型，新的通过索引获得的张量。
- 代码示例::
>>> x = jt.randn(3, 4) >>> indices = torch.tensor([2, 1]) >>> y = jt.index_select(x, 0, indices) >>> assert jt.all_equal(y, x[indices]) >>> y = jt.index_select(x, 1, indices) >>> assert jt.all_equal(y, x[:, indices])
- 返回值:
jt.Var类型，新的通过索引获得的张量。
- jittor.misc.isfinite(x)[源代码]
检查输入 Var 中的元素是否为有限数值。
如果
x中元素既不是NaN（Not a Number）也不是无穷大或无穷小（Infinity 或 -Infinity）,则返回True，否则返回False。- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> x = jt.array([1.0, float('Infinity'), float('nan'), 3]) >>> jt.isfinite(x) jt.Var([ True False False True], dtype=bool)
- 返回值:
Var, 返回一个与输入张量x同形状的张量，每个元素是判断x对应元素是否为有限数值的结果。
- jittor.misc.isinf(x)[源代码]
检查输入 Var 中的元素是否为无穷大值。
如果
x中元素是无穷大或无穷小（Infinity 或 -Infinity）,则返回True，否则返回False。- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> x = jt.array([1.0, float('inf'), float('nan'), float('-inf'), 3]) >>> jt.isinf(x) jt.Var([False True False True False], dtype=bool)
- 返回值:
Var, 返回一个与输入张量x同形状的张量，每个元素是判断x对应元素是否为无穷大值的结果。
- jittor.misc.isnan(x)[源代码]
检查输入 Var 中的元素是否为 NaN。
- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> x = jt.array([1.0, float('nan'), 3]) >>> jt.isnan(x) jt.Var([False True False], dtype=bool)
- 返回值:
Var, 返回一个与输入张量x同形状的张量，每个元素是判断x对应元素是否为NaN的结果。
- jittor.misc.isneginf(x)[源代码]
检查输入 Var 中的元素是否为负无穷。
如果
x中元素是无穷小（-Infinity）,则返回True，否则返回False。- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> x = jt.array([1.0, float('inf'), float('nan'), float('-inf'), 3]) >>> jt.isneginf(x) jt.Var([False False False True False], dtype=bool)
- 返回值:
Var, 返回一个与输入张量x同形状的张量，每个元素是判断x对应元素是否为负无穷的结果。
- jittor.misc.isposinf(x)[源代码]
检查输入 Var 中的元素是否为正无穷。
如果
x中元素是无穷大（+Infinity）,则返回True，否则返回False。- 参数:
x (Var): 输入的张量。
- 代码示例:
>>> x = jt.array([1.0, float('inf'), float('nan'), float('-inf'), 3]) >>> jt.isposinf(x) jt.Var([False True False False False], dtype=bool)
- 返回值:
Var, 返回一个与输入张量x同形状的张量，每个元素是判断x对应元素是否为正无穷的结果。
- jittor.misc.knn(unknown, known, k)[源代码]
对未知向量寻找与已知向量里中的欧氏距离最近的
k个向量- 参数：
unknown (Var): 形状
(b, n, c)，其中b是批次数，n是每批次未知向量个数，c是每个向量维数known (Var): 形状
(b, m, c)，其中b和c上同，m是每批次已知向量个数k (int): 对于每个未知向量寻找多少个最近向量
- 返回值：
tuple[Var, Var]，其中第一个元素是形状(b, n, k)表示对每个未知向量，在当前批次中找到的最近k个已知向量的欧式距离的平方，第二个元素是形状(b, n, k)表示找到最近向量的下标
- 代码示例：
>>> unknown = jt.randn(1, 4, 3) >>> known = jt.randn(1, 10, 3) >>> jt.misc.knn(unknown, known, 2) (jt.Var([[[0.04125667 1.0006377 ] [1.2794693 2.05327 ] [1.4255599 3.4547305 ] [0.849751 1.5978208 ]]], dtype=float32), jt.Var([[[8 4] [9 4] [4 8] [1 3]]], dtype=int32))
这个函数只在
c为 3 的时候正确工作。
- jittor.misc.kthvalue(input, k, dim=None, keepdim=False, keepdims=False)[源代码]
在指定维度上保留最小的第
k个元素在输入 Var
input的指定维度上找出最小的第k个元素，并返回这些元素的值以及其在原始 Var 中的索引。返回的 Var 的大小在指定的维度上大小为 1，其他维度与input一致。- 参数:
input (Var): 输入张量 Var, 任意形状
k (int): 指定寻找第 k 小的元素
dim (int): 指定在哪个维度上寻找第 k 小的元素，默认为最后一个维度
keepdim (bool): 为
True时，则在输出中保持缩减的维度。默认为Falsekeepdims (bool): 和 keepdim 的作用相同。旨在与numpy对齐，其在numpy中采用的参数名称是keepdims。默认为
False
- 代码示例:
>>> var = jt.arange(1, 7).reshape(2, 3) jt.Var([[1 2 3] [4 5 6]], dtype=int32) >>> jt.misc.kthvalue(var, 2, dim=0, keepdim=True) (jt.Var([[4 5 6]], dtype=int32), jt.Var([[1 1 1]], dtype=int32)) >>> jt.misc.kthvalue(var, 2, dim=0, keepdim=False) (jt.Var([4 5 6], dtype=int32), jt.Var([1 1 1], dtype=int32))
- 返回值:
Tuple of Var, 其中包含
input在指定维度上仅保留第k小元素后的张量 (Var)，以及这些元素在input中的索引 (Var)。
- jittor.misc.linspace(start, end, steps)[源代码]
生成一个由
start到end等距的一维张量，其中共有steps个元素，并且包含end。也就是说输出张量为：\[\left(\text { start, } \text { start }+\frac{\text { end }- \text { start }}{\text { steps }-1}, \ldots, \text { start }+(\text { steps }-2) * \frac{\text { end }- \text { start }}{\text { steps }-1}, \text { end }\right)\]- 参数:
start (int, float): 起始值
end (int, float): 结束值
steps (int): 构造的 Var 的长度
- 代码示例:
>>> jt.linspace(3, 10, 5) jt.Var([ 3. 4.75 6.5 8.25 10. ], dtype=float32)
- 返回值:
Var，一个一维张量，包含在
start和end之间的等间隔步数。
- jittor.misc.log2(x)[源代码]
计算
x中每个元素的以 2 为底的对数值。\[y_i=\log _2\left(x_i\right)\]- 参数:
x(Var): 任意形状的输入 Var
- 代码示例:
>>> jt.array([1,2,4,8,10]).log2() jt.Var([0. 1. 2. 3. 3.321928], dtype=float32)
- 返回值:
返回与输入形状相同的 Var, 其元素为输入元素的以2为底的对数。
- jittor.misc.make_grid(x, nrow=8, padding=2, normalize=False, range=None, scale_each=False, pad_value=0)[源代码]
将多个图片按网格状拼成一个图片
- 参数：
x (Var): 图片数据，形状 \((n, c, h, w)\)
nrow (int): 每行多少个图片，最终拼成的网格形状是 \((n / \mathtt{nrow}, nrow)\) 。默认值：8
padding (int): 图片间的间隔。默认值：2
normalize (bool): 是否将图片值线性映射到 \([0, 1]\) 。默认值：False
range (None | tuple[float, float]): 映射到 \([0, 1]\) 的范围，或者不指定则使用图片数据中的最小最大值。默认值：None
scale_each (bool): 不支持，必须为 False。默认值：False
pad_value (float): 图片间填充的值。默认值：0
- 示例：
>>> x = jt.randn(100, 3, 64, 64) >>> grid = jt.make_grid(x) >>> print(grid.shape) [3,860,530,]
- 返回值：
形状 \((c, h', w')\) 的图片，由
x中的图片组合成网格状而成
- jittor.misc.meshgrid(*tensors)[源代码]
创建由
*tensors这个输入的 Var 列表指定的坐标网格列表。给定 \(N\) 个 1D 张量 \(T_0 \ldots T_{N-1}\) 作为输入，输入对应的尺寸分别为 \(S_0 \ldots S_{N-1}\)，输出 \(N\) 个 \(N\) 维张量 \(G_0 \ldots G_{N-1}\)，每个形状为 \(\left(S_0, \ldots, S_{N-1}\right)\)，其中输出 \(G_i\) 是通过将 \(T_i\) 扩展到结果形状而构建的。
- 参数:
*tensors: (jt.Var, 不限个数)- 输入的张量, 每个张量需要是一维的jt.Var向量。- 代码示例:
>>> a = jt.array([1, 2, 3]) >>> b = jt.array([4, 5, 6, 7]) >>> jt.meshgrid(a, b) [jt.Var([[1 1 1 1] [2 2 2 2] [3 3 3 3]], dtype=int32), jt.Var([[4 5 6 7] [4 5 6 7] [4 5 6 7]], dtype=int32)]
- 返回值:
grids(Var): 包含了 N 个 Var 的列表, 由输入张量列表决定。
- jittor.misc.multinomial(weights: Var, num_samples: int, replacement: bool = False)[源代码]
返回一个var，其中每一行包含从对应输入权重行的多项分布中抽取的
num_samples个索引。- 参数:
weights(
Var): 输入概率。（如：weights = jt.float32([0, 10, 3, 0])）num_samples(
int): 抽取的样本数量（如：num_samples = 4）。这个参数必须小于等于weights的个数。换句话说如果你在不放回的情况下设置num_samples为比weights个数还多，将会报错。replacement(
bool): 是否放回地抽样，默认为False。如果设置为True，那么每一次抽样权重不变，可以多次抽到同一个。反之，每抽一次，权重会进行相应改变，不会抽到同一个。
- 代码示例:
>>> weights = jt.float32([0, 10, 3, 0]) ... x = jt.multinomial(weights, 2) ... assert jt.all_equal(x, [1, 2]) or jt.all_equal(x, [2, 1]) ... x = jt.multinomial(weights, 4, replacement=True) ... assert x.shape == (4, )
>>> weights = jt.float32([[0,0,2],[0,1,0], [0.5,0,0]]) ... x = jt.multinomial(weights, 1) ... assert jt.all_equal(x, [[2],[1],[0]])
- 返回值:
返回一个var，其中每一行包含从对应输入权重行的多项分布中抽取的
num_samples个索引。
- jittor.misc.ne()
函数C++定义格式:
jt.Var not_equal(jt.Var x, jt.Var y)
两个张量中对应元素比较是否不相等，把结果布尔值放入输出张量的对应位置，也可以使用
!=运算符调用- 参数：
x (Var): 输入数据
y (Var): 输入数据，形状与
x相同
- 返回值：
形状与
x和y相同的张量，数据类型是bool。其中每个索引位置的布尔值表示该索引对应的x和y对应元素里是否x中的元素不等于y中的元素- 代码示例：
>>> x = jt.array([3, 2, 1]) >>> y = jt.array([1, 2, 3]) >>> x.not_equal(y) jt.Var([ True False True], dtype=bool) >>> x != y jt.Var([ True False True], dtype=bool)
- jittor.misc.new(x, *args)[源代码]
创建一个和
x类型相同的张量- 参数：
x (
Var): 一个张量a (
Var): 待转换类型的张量
- 或者
n1, n2, … (
int): 新张量每维的长度
- 返回值：
如果给的参数是一个张量，则将其转换为和
x类型相同的张量；否则新创建一个给定形状，类型与x相同的未初始化张量- 代码示例：
>>> x = jt.array([1.0, 2.0, 3.0]) >>> x jt.Var([1. 2. 3.], dtype=float32) >>> x.new(3, 4) jt.Var([[-0.62324923 0.81981313 0.49348482 -0.80826735] [-2.185655 -0.12619412 -0.36160922 -0.28803992] [-1.3812838 -0.3991161 0.9999802 -0.11363947]], dtype=float32) >>> a = jt.array([4, 5]) >>> a jt.Var([4 5], dtype=int32) >>> x.new(a) jt.Var([4. 5.], dtype=float32)
- jittor.misc.nms(dets, thresh)[源代码]
对给定的一个未排序的矩阵，执行非极大值抑制(non-maximum suppression, NMS)操作。
输入应当是一个二维矩阵，矩阵的每一行代表一个边界框，格式为：
[x1, y1, x2, y2, score]，其中，[x1, y1]为左上角的坐标，[x2, y2]为右下角的坐标，score是该边界框对应的置信度分数。使用的是贪婪策略，首先将所有边界框按照置信度得分降序排序，然后从中选取分数最高的边界框并移除所有与该边界框的 IoU 值大于阈值的边界框。然后对剩余的边界框重复上述过程直到没有边界框，最后返回被选出的边界框的索引。
IoU 是衡量两个边界框重叠程度的指标，其定义为两个边界框的交集面积除以并集面积。
- 参数:
dets (Var): 输入的
Var， shape 为(N, 5), N代表边界框的个数，5列分别代表[x1, y1, x2, y2, score]thresh (float): IoU 阈值，IoU 值大于此的边界框将被移除
- 返回值:
被选出的边界框的索引，类型为
Var，在原dets中的行索引。- 代码示例:
>>> a = dets = jt.array([[20, 20, 40, 40, 0.9],[22, 22, 42, 42, 0.8],[200, 200, 240, 240, 0.7]], dtype="float32") >>> jt.nms(dets, 0.5) jt.Var([0 2], dtype=int32)
- jittor.misc.nonzero(x)[源代码]
返回输入Var中每一个非零元素的索引。
- 参数:
x (
Var): 任意形状的输入Var- 返回值:
返回一个二维 Var, 每一行代表一个非零元素的索引。注意每一行的长度取决于输入 Var 的维度。
- 代码示例:
>>> x = jt.array([0, 1, 2, 0, 3, 0]) >>> y = jt.array([[0, 1, 2], [0, 3, 4], [0, 0, 1]]) >>> jt.nonzero(x) jt.Var([[1] [2] [4]], dtype=int32) >>> jt.nonzero(y) jt.Var([[0 1] [0 2] [1 1] [1 2] [2 2]], dtype=int32)
- jittor.misc.normalize(input, p=2, dim=1, eps=1e-30)[源代码]
在指定维度对张量 \(L_p\) 归一化
\[v' = \frac{v}{\max(\lVert v \rVert_p, \epsilon)}\]- 参数：
input (
Var): 被归一化的张量p (
float): 计算向量范数所用的指数。默认值：2dim (
intortuple[int, ...]): 被归一化的维度。默认值：1eps (
float): 避免除以零所用的小量 \(\epsilon\) 。默认值：1e-30
- 返回值：
在
dim指定维度归一化后的张量- 代码示例：
>>> x = jt.randn(2, 3) >>> x, x.normalize() (jt.Var([[ 0.6452728 -1.7699949 0.7562031 ] [ 0.32050335 0.7093985 -0.44102713]], dtype=float32), jt.Var([[ 0.31786057 -0.8718973 0.3725047 ] [ 0.35822764 0.792897 -0.49293745]], dtype=float32)) >>> x.normalize().norm() jt.Var([1. 1.], dtype=float32)
- jittor.misc.numpy_cumprod(a, dim)[源代码]
沿着指定维度计算输入张量在这个维度上的累乘，基于numpy实现。
累乘是指，在指定方向上：
\[y_i=x_1 \times x_2 \times x_3 \times \cdots \times x_i\]- 参数:
a (
Var): 输入张量 Var, 任意形状dim (
int): 指定进行乘法的轴。默认为最后一维。
- 代码示例:
>>> a = jt.arange(-3, 6).reshape(3, 3) jt.Var([[-3 -2 -1] [ 0 1 2] [ 3 4 5]], dtype=int32) >>> jt.numpy_cumprod(a, 1) jt.Var([[-3 6 -6] [ 0 0 0] [ 3 12 60]], dtype=int32) >>> jt.numpy_cumprod(a, 0) jt.Var([[ -3 -2 -1] [ 0 -2 -2] [ 0 -8 -10]], dtype=int32)
- 返回值:
Var，输出的张量，累乘后的结果，形状和输入一致
- jittor.misc.numpy_cumsum(x, dim=None)[源代码]
沿着指定维度计算输入张量在这个维度上的累加求和。
累加求和是指，在指定方向上：
\[y_i=x_1+x_2+x_3+\cdots+x_i\]注意，该函数不应该直接调用。推荐使用jittor.misc.cumsum。
- 参数:
x (Var): 输入张量 Var, 任意形状
dim (int): 指定进行累加求和的轴。默认为最后一维。
- 代码示例:
>>> a = jt.randn(4, 2) jt.Var([[ 0.7793252 -2.1805465 ] [-0.46900165 2.0724497 ] [-1.2677554 0.31553593] [ 0.14260457 -1.4511695 ]], dtype=float32) >>> jt.numpy_cumsum(a, 1) jt.Var([[ 0.7793252 -1.4012213 ] [-0.46900165 1.603448 ] [-1.2677554 -0.9522195 ] [ 0.14260457 -1.3085649 ]], dtype=float32) >>> jt.numpy_cumsum(a, 0) jt.Var([[ 0.7793252 -2.1805465 ] [ 0.31032354 -0.10809684] [-0.95743185 0.2074391 ] [-0.81482726 -1.2437304 ]], dtype=float32)
- 返回值:
Var，输出的张量，累加求和后的结果
- jittor.misc.peek(x)[源代码]
输出一个Var的构成的字符串。
- 参数：
x (
Var): 输入的张量。
- 代码示例：
>>> import jittor as jt >>> a = [jt.ones((5,4))] >>> jt.peek(a) [float32[5,4,], ]
- jittor.misc.peek_s(x)[源代码]
返回一个Var的构成的字符串。
- 参数：
x (
Var): 输入的张量。
- 返回值：
str，返回一个递归组成的字符串。- 代码示例：
>>> import jittor as jt >>> a = [jt.ones((5,4))] >>> jt.peek_s(a) '[float32[5,4,], ]'
- jittor.misc.python_pass_wrapper(mod_func, args, kw)[源代码]
使用给定的模块函数
mod_func、参数args和关键字参数kw通过 Python 的importlib导入模块函数并执行它，最后返回执行结果。- 参数:
mod_func (
str): 完全限定名称的模块函数，例如numpy.matmul。args (
Tuple[str]): 需要传递给模块函数的参数，这些参数应以元组的形式提供，元组中的每一项都要是字符串。 例如，如果函数需要两个参数 a 和 b，调用应该为python_pass_wrapper('func', ('a', 'b'), kw)kw (
dict): 需要传递给模块函数的关键字参数，应以字典的形式提供。
- 代码示例:
>>> jt.python_pass_wrapper('math.sqrt', ('25',), {}) 5 >>> jt.python_pass_wrapper('builtins.len', ('[1, 2, 3]',), {}) 3
- 返回值:
Any: 返回模块函数调用的结果。
- jittor.misc.rad2deg(x)[源代码]
将弧度转换为角度
\[x' = \frac{180 x}{\pi}\]- 参数：
x (
Var): 弧度值组成的张量
- 返回值：
x中每个元素换成角度- 代码示例：
>>> x = jt.array([[3.142, -3.142], [6.283, -6.283], [1.570, -1.570]]) >>> x.rad2deg() jt.Var([[ 180.02333 -180.02333] [ 359.98935 -359.98935] [ 89.95437 -89.95437]], dtype=float32)
- jittor.misc.randperm(n, dtype='int32')[源代码]
生成一个随机排列张量
Var，其中元素为从0到n - 1这n个整数。- 参数:
n (
int): 要生成的随机排列数组的长度。dtype (
str): 返回的张量中的数据类型，默认为int32
- 代码示例:
>>> print(jt.randperm(7)) jt.Var([5 3 6 0 4 2 1], dtype=int32)
- 返回值:
一个从
0到n-1的随机排列的Var对象。
- jittor.misc.repeat(x, *shape)[源代码]
在指定维度上重复张量。
参数:
x (
Var): 输入张量shape (
tuple[int]): 重复的次数，可以是一个整数，也可以是一个元组。如果是一个整数，则表示在所有维度上重复相同次数；如果是一个元组，则表示在每个维度上重复的次数。代码示例:
>>> x = jt.array([1, 2, 3]) >>> x.repeat(4, 2) jt.Var([[1 2 3 1 2 3] [1 2 3 1 2 3] [1 2 3 1 2 3] [1 2 3 1 2 3]], dtype=int32) >>> x.repeat(4, 2, 1).size() [4, 2, 3,]
- jittor.misc.repeat_interleave(x, repeats, dim=None)[源代码]
将张量在某个维度上每个元素重复多次
- 参数：
x (
Var): 被重复的张量，形状 \((n_0, \ldots, n_{\mathtt{dim}}, \ldots, n_k)\)repeats (
int): 每个元素重复的次数dim (
int): 在哪个维度上重复，负数表示从后往前数，默认为将向量扁平化后重复
- 返回值：
x在dim维度每个元素重复repeat次得到的向量，形状 \((n_0, \ldots, n_{\mathtt{dim}} \times \mathtt{repeats}, \ldots, n_k)\)- 示例代码：
>>> x = jt.array([[1, 2], [3, 4]]) >>> x.repeat_interleave(2, 0) jt.Var([[1 2] [1 2] [3 4] [3 4]], dtype=int32) >>> x.repeat_interleave(2, 1) jt.Var([[1 1 2 2] [3 3 4 4]], dtype=int32) >>> x.repeat_interleave(2) jt.Var([1 1 2 2 3 3 4 4], dtype=int32)
- jittor.misc.roll(x, shifts, dims=None)[源代码]
将给定的张量在指定维度上滚动，或者说循环移动
shifts位。- 参数:
x (Var): 输入的张量
shifts (
tuple[int]): 滚动的偏移量dims (
tuple[int], 可选): 滚动的维度，默认为最后一维
- 代码示例:
>>> x = jt.array([1, 2, 3, 4, 5, 6, 7, 8]).view(4, 2) >>> jt.roll(x, 1, 0) jt.Var([[7 8] [1 2] [3 4] [5 6]], dtype=int32) >>> jt.roll(x, -2, 0) jt.Var([[5 6] [7 8] [1 2] [3 4]], dtype=int32)
- 返回值:
Var，循环移位后的张量
- jittor.misc.rsqrt(x)[源代码]
计算并返回 Jittor 变量的平方根的倒数。 此函数对给定的 Jittor 变量执行平方根的倒数运算。它等效于 \(\displaystyle \frac{1}{\sqrt x}\)。
- 参数:
x (
Var): 输入的 Jittor 变量。- 返回值:
Var: 输入变量的平方根的倒数。返回结果的形状和数据类型与输入参数一致。- 代码示例:
>>> var = jt.array([4, 9, 16]) >>> result = rsqrt(var) >>> print(result) [0.5, 0.33333333, 0.25] # 分别是 2, 3, 4 的平方根的倒数
- jittor.misc.safe_log(x)[源代码]
计算输入矩阵 x 的对数值。
\[y_i=\ln\left(x_i\right)\]该函数在执行对数运算之前，使用
jt.safe_clip将 x 的值限制在一个安全范围内(1e-30, 1e+30)，以避免因取对数时出现零或极大值造成计算错误。- 参数:
x (
Var): 输入变量
- 返回值:
Var，
x中元素的对数值，与x的形状相同。- 代码示例:
>>> x = jt.array([0, 0.1, 1.0, 10.0, 100.0, -123]) >>> jt.safe_log(x) jt.Var([-69.07755 -2.3025851 0. 2.3025851 4.6051702 -69.07755], dtype=float32)
- jittor.misc.save_image(x, filepath, nrow: int = 8, padding: int = 2, normalize: bool = False, range=None, scale_each=False, pad_value=0, format=None)[源代码]
将多个图片按网格状拼成一个图片后保存到
filepath指定的文件- 参数：
x (
Var): 图片数据，形状 \((n, c, h, w)\)filepath (
str): 保存目标，文件名或打开的文件对象nrow (
int): 每行多少个图片，最终拼成的网格形状是 \((n / \text{nrow}, \text{nrow})\) 。默认值：8padding (
int): 图片间的间隔。默认值：2normalize (
bool): 是否将图片值线性映射到 \([0, 1]\) 。默认值：Falserange (
None, tuple[float, float]): 映射到 \([0, 1]\) 的范围，或者不指定则使用图片数据中的最小最大值。默认值：Nonescale_each (
bool): 不支持，必须为 False。默认值：Falsepad_value (
float): 图片间填充的值。默认值：0format：保存的文件格式，默认由文件名扩展名确定
- 示例代码：
>>> x = jt.randn(100, 3, 64, 64) >>> save_image(x, 'random.png')
- jittor.misc.scatter(x: Var, dim: int, index: Var, src: Var, reduce='void')[源代码]
根据指定的索引
index将src中的元素散布到输入数组x的dim维度，返回修改后的x数组。当
x是3维数组时，该函数的效果可表述为:self[index[i][j][k]][j][k] = src[i][j][k] # if dim == 0 self[i][index[i][j][k]][k] = src[i][j][k] # if dim == 1 self[i][j][index[i][j][k]] = src[i][j][k] # if dim == 2
- 参数:
x (
Var): 输入数组dim (
int): 指定的维度，用于指定沿哪个轴进行索引index (
Var): 用于散布元素的索引，可以为空，或与src的维数相同。当索引为空时，该操作返回的是原始的x数组，即没有做任何修改。src (
Var): 需要散布的源元素reduce (
str，可选): 确定如何执行散布操作。此参数可以是add或multiply。
- 代码示例:
>>> src = jt.arange(1, 11).reshape((2, 5)) >>> index = jt.array([[0, 1, 2, 0]]) >>> x = jt.zeros((3, 5), dtype=src.dtype) >>> jt.scatter(x, 0, index, src) jt.Var([[1 0 0 4 0] [0 2 0 0 0] [0 0 3 0 0]], dtype=int32)
- 返回值:
Var，修改后的
x数组，形状与其一致
- jittor.misc.searchsorted(sorted, values, right=False)[源代码]
对有序张量
sorted的最后一个维度进行搜索以查找values中每个值应该插入到（插入后仍保持数组有序）的索引位置。- 参数:
sorted (
Var): 输入的有顺序的数组values (
Var): 要进行插入的值right (
bool): 默认为False。
如果为
False，则返回的索引i满足sorted[i-1] < value <= sorted[i]；如果为True，则返回的索引i满足sorted[i-1] <= value < sorted[i]。- 返回值:
返回一个形状与
values相同的 Var ，数组中的每个值表示对应的values在sorted中的索引位置。- 代码示例:
>>> sorted = jt.array([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]]) >>> values = jt.array([[3, 6, 9], [3, 6, 9]]) >>> ret = jt.searchsorted(sorted, values) >>> assert (ret == [[1, 3, 4], [1, 2, 4]]).all(), ret >>> ret = jt.searchsorted(sorted, values, right=True) >>> assert (ret == [[2, 3, 5], [1, 3, 4]]).all(), ret >>> sorted_1d = jt.array([1, 3, 5, 7, 9]) >>> ret = jt.searchsorted(sorted_1d, values) >>> assert (ret == [[1, 3, 4], [1, 3, 4]]).all(), ret
- jittor.misc.set_global_seed(seed, different_seed_for_mpi=True)[源代码]
设置Python，numpy和jittor的随机数生成器的种子。
这个函数同步地设置了这三个随机数生成器的种子，将它们设置为同一个值，以保证在使用这些生成器时获得一致的随机数。
Jittor还确保了jittor.dataset.Dataset的每一个工作进程都持有一个不同的种子，同时也保证了使用mpi的每一个进程都持有一个不同的种子。这是通过如下的公式实现的:
(global_seed ^ (worker_id * 1167)) ^ 1234 + jt.rank * 2591
- 参数:
seed (
int): 指定要设置的随机数种子的值，无默认值different_seed_for_mpi (
bool): 是否为每一个使用mpi的进程设置一个不同的种子，默认为True。
- jittor.misc.sort(input, dim=-1, descending=False, stable=False)[源代码]
对输入张量
input沿着指定维按升序非稳定排序。如果不给定dim，则默认为输入的最后一维。如果指定参数descending为True，则按降序排序。如果指定参数``stable`` 为True，则为稳定排序。- 参数：
input (
Var): 要对比的张量dim (
int, 可选): 沿着此维排序，默认为最后一维descending (
bool, 可选): 布尔值，控制升降排序，默认为升序stable(
bool, 可选): 布尔值，控制稳定排序，默认非稳定排序
- 返回值：
返回元组
(value, index)，index为原始输入中的下标。- 代码示例：
>>> x = jt.random((3, 4)) jt.Var([[ 0.25843996 0.6806731 0.48188502 -0.8385996 ] [-0.97904104 -1.0399561 -0.97162217 3.834338 ] [-0.6144879 -0.97539455 -0.81440794 -0.12566419]], dtype=float32) >>> value, index = jt.sort(x) >>> value jt.Var([[-0.8385996 0.25843996 0.48188502 0.6806731 ] [-1.0399561 -0.97904104 -0.97162217 3.834338 ] [-0.97539455 -0.81440794 -0.6144879 -0.12566419]], dtype=float32) >>> index jt.Var([[3 0 2 1] [1 0 2 3] [1 2 0 3]], dtype=int32)
- jittor.misc.split(d, split_size, dim=0)[源代码]
将张量分割成多个块。每个块都是原始张量的一个视图。
如果
split_size是整型，那么张量将被平均分割成等大小的块（如果可能的话）。如果给定维度dim上的张量大小不能被split_size整除，那么最后一个块的大小将会小于其他块。如果
split_size是列表，那么张量将被分割成len(split_size)块，每个块在dim维度上的大小将按照split_size列表指定。- 参数:
d (
Var): 需要被分割的张量 Var, 任意形状。split_size (
int,list(int)): 单个块的大小，或者每个块的大小的列表。注意如果这里传入列表的话，应当确保列表的元素之和等于输入张量在给定分割维度上的长度d.shape[dim]。dim (
int): 需要分割的张量的维度。默认值为0。
- 代码示例:
>>> a = jt.arange(10).reshape(5, 2)) >>> jt.split(a, 2) (jt.Var([[0 1] [2 3]], dtype=int32), jt.Var([[4 5] [6 7]], dtype=int32), jt.Var([[8 9]], dtype=int32)) >>> jt.split(a, [3, 1, 1]) (jt.Var([[0 1] [2 3] [4 5]], dtype=int32), jt.Var([[6 7]], dtype=int32), jt.Var([[8 9]], dtype=int32))
- 返回值:
分割后的张量块，以元组的形式返回:
Tuple[Var, ...]
- jittor.misc.stack(x, dim=0)[源代码]
将多个形状相同的张量组合成为一个更高维的张量
- 参数：
x (
list[Var]): 被组合的张量，每个形状相同，都是 \((n_0, \ldots, n_{\mathtt{dim}}, \ldots, n_k)\)dim (
int): 第几个维度前插入一个维度。默认值：0
- 返回值：
组合为的张量，形状 \((n_0, \ldots, n_{\mathtt{dim} - 1}, \mathtt{len(x)}, n_{\mathtt{dim}}, \ldots, n_k)\)
- 示例代码：
>>> a = jt.array([1, 2, 3]) >>> b = jt.array([4, 5, 6]) >>> jt.stack([a, b]) jt.Var([[1 2 3] [4 5 6]], dtype=int32) >>> jt.stack([a, b], dim=1) jt.Var([[1 4] [2 5] [3 6]], dtype=int32)
- jittor.misc.t(x)[源代码]
转置张量的最后两个维度
- 参数：
x (
Var): 被转置的张量，形状 \((n_0, n_1, \ldots, n_{k - 3}, n_{k - 2}, n_{k - 1})\)
- 返回值：
转置后的张量，形状 \((n_0, n_1, \ldots, n_{k - 3}, n_{k - 1}, n_{k - 2})\)
- 示例代码：
>>> x = jt.array([[1, 2], [3, 4]]) >>> x.t() jt.Var([[1 3] [2 4]], dtype=int32)
- jittor.misc.to(x, *args, **kargs)[源代码]
将 Jittor变量
x转换为指定类型或将其移动到指定计算设备上。 这个函数可以对Jittor变量进行类型转换(如，将整数类型转换为浮点数类型)，还可以把数据在CPU和GPU设备之间移动(假设你的系统有GPU设备，且已经安装好了CUDA)。- 参数:
x (
Var): 要转移或转换的 Jittor 变量。- *args: 可变长度参数列表,第一个参数可以是:
NanoString或可调用对象：在这种情况下，x将被转换为指定的数据类型。str: 指定设备的字符串（’cuda’ 或 ‘cpu’）。如果字符串中包含 ‘cuda’，Jittor 将使用 CUDA（GPU）进行未来的操作。如果字符串中包含 ‘cpu’，Jittor 将使用 CPU。
**kargs: 任意关键字参数。
- 返回值:
Var: 一个新的 Jittor 变量，已移至指定设备或转换为新的数据类型。如果未指定设备或数据类型，则返回 ‘x’ 的克隆。- 代码示例:
>>> var = jt.array([1, 2, 3]) >>> var_cuda = to(var, 'cuda') # 移动到 GPU >>> var_float = to(var, jt.float32) # 转换为 float32
- jittor.misc.tolist(x)[源代码]
将输入的 Jittor Var 类型变量转化为 Python 的 list 类型。
- 参数:
x (
Var): 任意形状的输入张量Var。- 返回值:
转化后的 Python 列表类型 (
list)- 代码示例:
>>> a = jt.array([1,2,3]) >>> jt.tolist(a) [1, 2, 3]
- jittor.misc.topk(input, k, dim=None, largest=True, sorted=True)[源代码]
在指定维度上保留最大/最小的
k个元素该函数实现了在输入 Var
input的指定维度上找出最大（或最小）的k个元素，并返回这些元素的值以及其在原始 Var 中的索引。返回的 Var 的大小与input一致，除了在指定的维度上大小为k- 参数:
input (
Var): 输入张量 Var, 任意形状k (
int): 指定寻找最大/最小元素个数dim (
int): 指定在哪个维度上寻找最大/最小元素，默认为最后一个维度largest (
bool): 为True时，返回最大的k个元素；为False时，返回最小的k个元素。默认为Truesorted (
bool): 为True时，返回的k个元素按照从大到小的顺序排列；为False时，返回的k个元素顺序是未指定的。默认为True
- 返回值:
Tuple[Var], 其中包含input在指定维度上仅保留最大/最小k个元素后的张量 (Var)，以及这些元素在input中的索引 (Var)。- 代码示例:
>>> var = jt.array([[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12]]) >>> jt.topk(var, 2, dim=0) (jt.Var([[ 9 10 11 12] [ 5 6 7 8]], dtype=int32), jt.Var([[2 2 2 2] [1 1 1 1]], dtype=int32)) >>> jt.topk(var, 2, dim=1) (jt.Var([[ 4 3] [ 8 7] [12 11]], dtype=int32), jt.Var([[3 2] [3 2] [3 2]], dtype=int32))
- jittor.misc.tril(input: Var, diagonal: int = 0)[源代码]
返回一个矩阵（2-D张量）或批量矩阵输入的下三角部分，结果张量out的其它元素被设为0.
- 参数:
input(
Var): 输入张量。diagonal(
int): 考虑的对角线，默认值为0。
- 返回值:
下三角矩阵，类型为
Var。- 代码示例:
>>> a = jt.ones(3, 3) >>> b = jt.tril(a) >>> assert jt.all_equal(b, [[1,0,0],[1,1,0],[1,1,1]]) >>> b = jt.tril(a, diagonal=1) >>> assert jt.all_equal(b, [[1,1,0],[1,1,1],[1,1,1]]) >>> b = jt.tril(a, diagonal=-1) >>> assert jt.all_equal(b, [[0,0,0],[1,0,0],[1,1,0]])
- jittor.misc.triu(input: Var, diagonal: int = 0)[源代码]
返回输入的矩阵 (即2-D张量) 或者批量矩阵的上三角部分，其他元素被设置为0。
- 参数:
input(
Var): 输入张量。diagonal(
int): 考虑的对角线，默认值为0。
- 返回值:
返回上三角的张量，类型为
Var.- 代码示例:
>>> a = jt.ones(3, 3) >>> b = jt.triu(a) >>> assert jt.all_equal(b, [[1,1,1],[0,1,1],[0,0,1]]) >>> b = jt.triu(a, diagonal=1) >>> assert jt.all_equal(b, [[0,1,1],[0,0,1],[0,0,0]]) >>> b = jt.triu(a, diagonal=-1) >>> assert jt.all_equal(b, [[1,1,1],[1,1,1],[0,1,1]])
- jittor.misc.triu_(x, diagonal=0)[源代码]
返回输入二维矩阵或批量矩阵输入
x的上三角部分，其余部分为 0。注意输入矩阵可以不是方阵。对角线的偏移量可以用
diagonal确定，diagonal= 0 代表主对角线，diagonal> 0 为沿右上方移动，diagonal< 0 为沿左下方移动。- 参数:
x (
Var): 输入的Var， 维度需要大于等于2diagonal (
int): 对角偏移量，默认为0。
- 代码示例:
>>> x = jt.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype="float32") >>> jt.triu_(x, 0) jt.Var([[1. 2. 3.] [0. 5. 6.] [0. 0. 9.]], dtype=float32) >>> jt.triu_(x, 1) jt.Var([[0. 2. 3.] [0. 0. 6.] [0. 0. 0.]], dtype=float32) >>> jt.triu_(x, -1) jt.Var([[1. 2. 3.] [4. 5. 6.] [0. 8. 9.]], dtype=float32)
- 返回值:
基于输入的上三角矩阵,
Var
- jittor.misc.unbind(x, dim=0)[源代码]
解除var的一个维度。返回沿着给定维度的所有切片的元组，这个维度会从输出的各个切片中移除。
- 参数:
x (
Var): 需要解除维度的vardim (
int): 需要移除的维度，默认值为0
- 返回值:
返回一个
List，包含了沿着给定维度的所有切片的元组。- 代码示例:
>>> a = jt.random((2,3)) >>> b = jt.unbind(a, 0) >>> c = jt.unbind(a, 1) >>> a,b,c jt.Var([[0.2874082 0.46987164 0.13281713] [0.2576157 0.7470389 0.48285943]], dtype=float32) [jt.Var([0.2874082 0.46987164 0.13281713], dtype=float32), jt.Var([0.2576157 0.7470389 0.48285943], dtype=float32)] [jt.Var([0.2874082 0.2576157], dtype=float32), jt.Var([0.46987164 0.7470389 ], dtype=float32), jt.Var([0.13281713 0.48285943], dtype=float32)]
- 注意：
如果
dim值给定为负数，那么需要首先对其进行处理，使其等于dim加上x的形状的长度之和。
- jittor.misc.unique(input: Var, return_inverse: bool = False, return_counts: bool = False, dim: int | None = None)[源代码]
返回张量中去重后的元素
- 参数：
input (
Var): 被去重的张量return_inverse (
bool): 是否返回input每个元素对应去重结果中的不重复元素下标。默认值：Falsereturn_counts (
bool): 是否返回去重结果中每个不重复元素在input里出现次数，必须同时指定return_inverse=True才有效。默认值：Falsedim (
int): 去重的维度，如果为None则将输入扁平化后再去重。默认值：None
- 返回值：
如果
return_inverse未指定，则返回Var为去重结果否则，如果
return_inverse和return_counts指定，则返回tuple[Var, Var, Var]为去重结果、下标、出现次数否则，仅
return_inverse指定，则返回tuple[Var, Var]为去重结果、下标
- 代码示例：
>>> jt.unique(jt.array([1, 3, 2, 3])) jt.Var([1 2 3], dtype=int32) >>> jt.unique(jt.array([1, 3, 2, 3, 2]), return_inverse=True, return_counts=True) (jt.Var([1 2 3], dtype=int32), jt.Var([0 2 1 2 1], dtype=int32), jt.Var([1 2 2], dtype=int32)) >>> jt.unique(jt.array([[1, 3], [2, 3]]), return_inverse=True) (jt.Var([1 2 3], dtype=int32), jt.Var([[0 2] [1 2]], dtype=int32)) >>> jt.unique(jt.array([[1, 3], [1, 3]]), dim=0) jt.Var([[1 3]], dtype=int32)
- jittor.misc.view_as(x, y)[源代码]
以
y的形状对x进行reshape。也就是说，对
x中的元素进行重排，使得x与y的形状相同。注意，x中的元素数量必须与y中的元素数量相同，否则报错。- 参数:
x (
Var): 需要重塑的输入张量 Var。y (
Var): 作为参照形状的的输入张量 Var。
- 代码示例:
>>> x = jt.arange(4) >>> y = jt.array([[1,2],[3,4]]) >>> jt.view_as(x, y) jt.Var([[0 1] [2 3]], dtype=int32)
- 返回值:
重塑后的
Var, 数据来自x, 形状和y相同。