jittor

jittor

这里是Jittor主模块的API文档,您可以通过import jittor来获取该模块。

class jittor.ExitHooks[源代码]

该类主要用于捕获程序退出时的退出码和异常信息。在 Jittor 中,该类经常被用于添加一些在程序结束时需要进行的操作,比如资源清理等。其使用方式主要是将需要进行的操作添加到 exit 方法中。Jittor 中定义了该类的全局对象 jt.hooks 供使用。

属性:
  • exit_code:程序退出时的退出码。默认值:None

  • exception:程序退出时的异常信息。默认值: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 类。

其派生类应实现 executegrad 两个方法,作用分别是执行前向计算和计算反向梯度。当使用自定义算子进行前向计算时,应调用类方法 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,]
bfloat16()[源代码]

将所有参数转换为bfloat16。

children() List[源代码]

返回子模块的列表。

cuda(device=None)[源代码]

将模块放置于cuda运行

eval()[源代码]

将模块设置为评估eval模式。

float16()[源代码]

将所有参数转换为float16。

float32()[源代码]

将所有参数转换为float32。

float64()[源代码]

将所有参数转换为float16。

float_auto()[源代码]

根据 jt.flags.auto_mixed_precision_level 和 jt.flags.amp_reg 自动将所有参数转换为 float16 或 float32。

is_training() bool[源代码]

返回模块是否处于training模式。

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
load_parameters(params)[源代码]

将参数加载到模块中。

参数:

params – 一个记录模型函数类名称和对应参数的字典。

load_state_dict(params) None[源代码]

从字典中加载模块的参数。

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)

remove_backward_hook()[源代码]

删除反向传播的输入和输出hook

remove_forward_hook()[源代码]

移除当前的前向钩子。

remove_pre_forward_hook()[源代码]

移除当前的预前向钩子。

requires_grad_(requires_grad=True)[源代码]

为所有参数和子模块设置 requires_grad。

save(path: str)[源代码]

将参数保存到文件中。

参数:

path (str) – path to save.

示例代码:

>>> class Net(nn.Module):
>>> ...
>>> net = Net()
>>> net.save('net.pkl')
>>> net.load('net.pkl')
train()[源代码]

将模块设置为评估training模式。

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 对象。如果输入的是数值,则创建的 Vardtype 为输入的数值类型,若是``numpy.ndarray`` ,则 Vardtypendarraydtype 为准;若输入为 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)[源代码]

对张量 xmaskTrue 的位置进行填充值 value。需要保证 mask 的形状必须和 x 相匹配。

参数:
  • x (jt.Var) : 输入的张量。

  • mask (bool Var) : 和 x 形状相同的布尔类型张量。

  • value (float) : 用于填充张量 x 中对应 maskTrue 的位置的值。

代码示例:
>>> 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\)

其中 xy 都是输入变量。

参数:
  • 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): xy 的乘法结果。它的形状和数据类型与输入变量 x 相同。

jittor.ne()

函数C++定义格式:

jt.Var not_equal(jt.Var x, jt.Var y)

两个张量中对应元素比较是否不相等,把结果布尔值放入输出张量的对应位置,也可以使用 != 运算符调用

参数:
  • x (Var): 输入数据

  • y (Var): 输入数据,形状与 x 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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)且 dtypex 保持一致

代码示例:
>>> 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)[源代码]

计算输入向量 xp 范数(默认为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),形状与 xy 相同

代码示例:
>>> 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,则将计算整个张量的方差。默认值: None

  • dims (tuple of int) : 计算方差的维度。如果dim和dims都为None,则将计算整个张量的方差。默认值: None

  • unbiased (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 相同

返回值:

xy 每对对应元素相加结果,形状与 xy 相同

代码示例:
>>> 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] 类型,表示 xdim 维度的最大和最小值的索引和实际值。如果 keepdimsTrue 则形状为 xdim 维的长度变成 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): 在哪个维度排序,负数表示从后往前数。默认值:-1

  • descending (bool): 是否降序排列,False表示升序排列。默认值:False

  • dtype (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'

返回值:

二元运算的结果,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

形状与 xy 相同的张量。 其元素为 xy 对应索引位置上元素的按位与结果。

代码示例:
>>> 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 相同

返回值:

形状与 xy 相同的张量。 xy 对应索引位置上元素的按位或结果。

代码示例:
>>> 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 相同

返回值:

形状与 xy 相同的张量。 xy 对应索引位置上元素的按位异或结果。

代码示例:
>>> 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 相同

返回值:

xy 每对对应元素相除结果,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

xy 每对对应元素相除结果,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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 相同

返回值:

xy 每对对应元素相除向下取整结果,形状与 xy 相同,输入数据类型是整数的情况下,会返回整数

代码示例:
>>> 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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示 xy 对应元素里是否 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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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): 被左移的张量,元素的数据类型是 int32int64

  • y (Var): 左移的位数张量,元素数据类型是 int32int64 ,形状与 x 相同

返回值:

形状与 xy 相同的张量,其元素为 xy 对应索引位置的元素计算左移操作的结果数

代码示例:
>>> 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 相同

返回值:

输出张量,形状与 xy 相同,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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 相同

返回值:

形状与 xy 相同的张量,元素数据类型为 bool 。其元素为 xy 对应索引位置上的元素进行逻辑与操作的结果,即:如果都为非零值或 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 相同

返回值:

形状与 xy 相同的张量,元素数据类型为 bool 。其元素为 xy 对应索引位置上的元素进行逻辑或操作的结果,即:如果两者有非零值或 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 相同

返回值:

形状与 xy 相同的张量,元素数据类型为 bool 。其元素为 xy 对应索引位置上的元素进行逻辑异或操作的结果,即:如果两者有且仅有一个为非零值或 True 则输出为 True ,否则为 False ,数据类型为 bool ,形状与 xy 相同

代码示例:
>>> 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,可选): 指定的维度,如果指定,则沿给定的维度进行缩减。默认值: None

  • keepdims_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 相同

返回值:

xy 每对对应元素中的较大者,形状与 xy 相同

代码示例:
>>> 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

返回值:

计算最小值的结果。如果 keepdimsTrue 则形状为 xdims 里给出的维度的长度变成 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 相同

返回值:

xy 每对对应元素中的较小者,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

xy 每对对应元素相除的余数,形状与 xy 相同。非零余数的符号和 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 相同

返回值:

xy 每对对应元素相乘结果,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

xy 每对对应元素相乘结果,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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

返回值:

计算聚合函数的结果。如果 keepdimsTrue 则形状为 xdims 里给出的维度的长度变成 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

返回值:

求和的结果。如果 keepdimsTrue 则形状为 xdims 里给出的维度的长度变成 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): 需要做异或操作的维度,默认值:None

  • keepdims(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,可选): 指定的维度,如果指定,则沿给定的维度进行缩减。默认值: None

  • keepdims_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): 被右移的张量,元素的数据类型是 int32int64

  • y (Var): 右移的位数张量,元素的数据类型是 int32int64 ,形状与 x 相同

返回值:

形状与 xy 相同的张量,其元素为 xy 对应索引位置的元素计算右移操作的结果数

代码示例:
>>> 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):剪裁的最小值。默认值:float64

  • right(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 变量的值。在操作中的 xy 可看作两个 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 相同

返回值:

xy 每对对应元素相减结果,形状与 xy 相同

代码示例:
>>> 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 相同

返回值:

xy 每对对应元素相减结果,形状与 xy 相同

代码示例:
>>> 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

返回值:

求和的结果。如果 keepdimsTrue 则形状为 xdims 里给出的维度的长度变成 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 对输入到目标的各个对齐方式的概率求和,得到一个对每个输入可微分的损失值。输入到目标的对齐应该是“多对一的”,因此目标序列长度被限制为不超过输入序列长度。

参考文献:
  1. 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

切块尽量均匀。如果 xdim 维的长度不是 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): 计算叉乘的向量所在的维度,要求 inputotherdim 维的长度都是 3。负数表示从后往前数。默认值:-1

返回值:

inputother 对应向量叉乘的结果,形状与 inputother 相同

代码示例:
>>> 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 一样

返回值:

ab 平方之和的平方根

代码示例:
>>> 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 里对应的每个张量,在 xdim 维对应的下标处加上这个张量

参数:
  • x (Var): 形状 (..., k, ...)

  • dim (int): 上面 xk 对应的是第几维

  • 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) ,其中 bc 上同, 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 时,则在输出中保持缩减的维度。默认为 False

  • keepdims (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)[源代码]

生成一个由 startend 等距的一维张量,其中共有 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,一个一维张量,包含在 startend 之间的等间隔步数。

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 相同

返回值:

形状与 xy 相同的张量,数据类型是 bool。其中每个索引位置的布尔值表示该索引对应的 xy 对应元素里是否 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): 计算向量范数所用的指数。默认值:2

  • dim (int or tuple[int, ...]): 被归一化的维度。默认值:1

  • eps (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,其中元素为从 0n - 1n 个整数。

参数:
  • n (int): 要生成的随机排列数组的长度。

  • dtype (str): 返回的张量中的数据类型,默认为 int32

代码示例:
>>> print(jt.randperm(7))
jt.Var([5 3 6 0 4 2 1], dtype=int32)
返回值:

一个从 0n-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): 在哪个维度上重复,负数表示从后往前数,默认为将向量扁平化后重复

返回值:

xdim 维度每个元素重复 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})\) 。默认值: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

  • format:保存的文件格式,默认由文件名扩展名确定

示例代码:
>>> 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')[源代码]

根据指定的索引 indexsrc 中的元素散布到输入数组 xdim 维度,返回修改后的 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,可选): 确定如何执行散布操作。此参数可以是 addmultiply

代码示例:
>>> 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 ,数组中的每个值表示对应的 valuessorted 中的索引位置。

代码示例:
>>> 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 ,则默认为输入的最后一维。如果指定参数 descendingTrue ,则按降序排序。如果指定参数``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 个元素。默认为 True

  • sorted (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, 维度需要大于等于 2

  • diagonal (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): 需要解除维度的var

  • dim (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 每个元素对应去重结果中的不重复元素下标。默认值:False

  • return_counts (bool): 是否返回去重结果中每个不重复元素在 input 里出现次数,必须同时指定 return_inverse=True 才有效。默认值:False

  • dim (int): 去重的维度,如果为 None 则将输入扁平化后再去重。默认值:None

返回值:
  • 如果 return_inverse 未指定,则返回 Var 为去重结果

  • 否则,如果 return_inversereturn_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 中的元素进行重排,使得 xy 的形状相同。注意,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 相同。