jittor.init

这里是Jittor的参数初始化模块的API文档，您可以通过from jittor import init来获取该模块。

jittor.init.calculate_gain(nonlinearity, param=None)

返回给定非线性函数的推荐增益值，值如下：

nonlinearity	gain
Linear / Identity	\(1\)
Conv{1,2,3}D	\(1\)
Sigmoid	\(1\)
Tanh	\(\displaystyle \frac{5}{3}\)
ReLU	\(\sqrt{2}\)
Leaky Relu	\(\displaystyle \sqrt{\frac{2}{1 + \text{negative_slope}^2}}\)
SELU	\(\displaystyle \frac{3}{4}\)

参数：

nonlinearity: 非线性函数（nn.functional 名称） param: 非线性函数的可选参数

代码示例：

>>> gain = nn.init.calculate_gain('leaky_relu', 0.2)  # leaky_relu with negative_slope=0.2

jittor.init.calculate_std(var, mode, nonlinearity, param=0.01)

计算标准差。

参数：

• var (Var): 输入Var

• mode (str): 模式，可选值为 fan_in 和 fan_out。默认值：fan_in

• nonlinearity (str): 非线性函数，可选值为 linear、conv1d、conv2d、conv3d、conv_transpose1d、conv_transpose2d、conv_transpose3d、sigmoid、tanh、relu 和 leaky_relu。默认值：linear

• param (float): 非线性函数的参数。默认值：0.01

代码示例：

>>> x = jt.random((2, 2))
jt.Var([[ 2.520024   -0.4921519 ]
                [-1.1624513  -0.62531066]], dtype=float32)
>>> jt.calculate_std(x)
0.7071067811865476

返回值：

标准差（float）

jittor.init.constant(shape, dtype='float32', value=0.0)

创建一个数值均为 value, 形状由可变参数 shape 确定， 默认填充 float32 类型的零值。

参数：

• shape (Tuple[int]): 整数序列，定义了输出的形状

• dtype (var.dtype, optional): 数据类型，默认为 float32

• value (int or float): 填充的数值

代码示例：

>>> init.constant(2)
jt.Var([0. 0.], dtype=float32)
>>> init.constant((2,3), "float32", 3.8)
>>> x
jt.Var([[3.8 3.8 3.8]
        [3.8 3.8 3.8]], dtype=float32)

返回值：

返回一个填充值为 value ，形状大小为 shape 的张量(Var)

jittor.init.constant_(var, value=0.0)

原地修改张量 var ，将其修改为数值均为 value 的张量，默认填充零值。

参数：

• var (Var): Var类型的张量

• value (int or float): 填充的数值

代码示例：

>>> x = jt.randn((3,2))
>>> x
jt.Var([[ 0.0335454  -0.18658346]
        [-0.53283346 -1.2073938 ]
        [-1.344916   -1.6093305 ]], dtype=float32)
>>> init.constant_(x, 3.8)
>>> x
>jt.Var([[3.8 3.8]
         [3.8 3.8]
         [3.8 3.8]], dtype=float32)

返回值：

就地修改 var ，返回一个填充值为 value ，形状和 var 相同的张量(Var)

jittor.init.eye(shape, dtype='float32')

创建一个形状为 shape 的单位矩阵。

单位矩阵的定义为： 对于任何 \(i, j (0 \le i, j < dim)\) ，当 \(i\) 等于 \(j\) 时，输出为 1 ；否则为 0 。

\[\begin{split}eye(i, j) = \begin{cases} 1, & \text{if } i = j \\ 0, & \text{else} \end{cases}\end{split}\]

参数：

• shape (int, Tuple[int]): 规定返回矩阵的形状，如果 shape 为整数， 那么返回的矩阵的形状为 (shape, shape)。

• dtype (dtype, 可选): 数据类型，默认为 float32

代码示例：

>>> init.eye(2)
jt.Var([[1. 0.]
        [0. 1.]], dtype=float32)
>>> init.eye((2, 3), dtype='int32')
jt.Var([[1 0 0]
        [0 1 0]], dtype=int32)

返回值：

返回一个单位矩阵

注意事项：

• shape 如果是整数序列，只能传入两个维度的长度，否则会引起异常

jittor.init.eye_(var)

原地修改矩阵 var，将其成为单位矩阵。

单位矩阵的定义为： 对于任何 \(i, j (0 \le i, j < dim)\) ，当 \(i\) 等于 \(j\) 时，输出为 1 ；否则为 0 。

\[\begin{split}eye(i, j) = \begin{cases} 1, & \text{if } i = j \\ 0, & \text{else} \end{cases}\end{split}\]

参数：

• var (Var): ``Var``类型的张量

代码示例：

>>> x = jt.randn((3,2))
>>> x
jt.Var([[-0.582047    1.1068922 ]
        [ 0.08440255 -0.86142904]
        [ 0.06269896 -0.979008  ]], dtype=float32)
>>> init.eye_(x)
>>> x
jt.Var([[1. 0.]
        [0. 1.]
        [0. 0.]], dtype=float32)

返回值：

返回一个形状和 var 相同的单位矩阵

jittor.init.fill(var, value=0.0)

原地修改张量 var ，将其修改为数值均为 value 的张量，默认填充零值。

参数：

• var (Var): Var类型的张量

• value (int or float): 填充的数值

代码示例：

>>> x = jt.randn((3,2))
>>> x
jt.Var([[ 0.0335454  -0.18658346]
        [-0.53283346 -1.2073938 ]
        [-1.344916   -1.6093305 ]], dtype=float32)
>>> init.constant_(x, 3.8)
>>> x
>jt.Var([[3.8 3.8]
         [3.8 3.8]
         [3.8 3.8]], dtype=float32)

返回值：

就地修改 var ，返回一个填充值为 value ，形状和 var 相同的张量(Var)

jittor.init.gauss(shape, dtype='float32', mean=0.0, std=1.0)

创建一个 Var，其形状由 shape 指定，数据类型为 dtype ， 元素值遵循均值为 mean 和标准差为 std 的高斯分布（正态分布）的张量。

\[out_i \sim \mathcal{N}(\text{mean}, \text{std}^2)\]

参数：

• shape (Tuple[int]): 整型序列，定义了输出的形状

• dtype (dtype): 数据类型，默认为 float32

• mean (float or Var, 可选): 高斯分布的均值， 默认值为 0.0

• std (float or Var, 可选): 高斯分布的标准差，默认值为 1.0

代码示例：

>>> init.gauss((3,2))
jt.Var([[-1.09277    -0.22924843]
        [-0.5264394  -0.13242662]
        [-1.1316705   1.2506602 ]], dtype=float32)
>>> init.gauss((2,2), 'float32', 0, 10)
jt.Var([[ 3.457805   5.8171034]
        [-1.6440934  2.1744032]], dtype=float32)

返回值：

返回一个数值符合高斯分布的 Var

注意事项：

• 确保指定的 std 是非负的，因为标准差不能是负数

jittor.init.gauss_(var, mean=0.0, std=1.0)

原地修改张量 var ，将其数值填充满足以均值为 mean 和标准差为 std 的高斯分布（正态分布）的随机数。

\[out_i \sim \mathcal{N}(\text{mean}, \text{std}^2)\]

参数：

• var (Var): 改变的 var

• mean (float or Var, 可选): 高斯分布的均值， 默认值为 0.0

• std (float or Var, 可选): 高斯分布的标准差，默认值为 1.0

代码示例：

>>> x = init.zero((3,3))
>>> x
jt.Var([[0. 0. 0.]
        [0. 0. 0.]
        [0. 0. 0.]], dtype=float32)
>>> init.gauss_(x, 0, 5.0)
>>> x
jt.Var([[-0.34221977 -8.056475    2.6251674 ]
        [-0.81275284  2.00393    -2.4397573 ]
        [ 0.7867035  -8.159389    7.100675  ]], dtype=float32)

返回值：

就地修改张量 var ，返回一个数值符合高斯分布的张量

jittor.init.invariant_uniform(shape, dtype='float32', mode='fan_in')

返回由 invariant_uniform 初始化的 Var。

参数：

• shape (int or Tuple[int]): 输出Var的形状

• dtype (str): 输出Var的 dtype ，默认 float32

• mode (str): 模式选择，应为 fan_in 或 fan_out。选择 'fan_in' 保留正向传递中权重方差的大小。选择 'fan_out' 保留反向传递中的大小。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> a = init.invariant_uniform_((2,2))
>>> print(a)
jt.Var([[ 0.08833592 -0.04776876]
                [-0.04776876  0.08833592]], dtype=float32)

返回值：

由 invariant_uniform 初始化的 Var。

jittor.init.invariant_uniform_(var, mode='fan_in')

使用不变均匀分布初始化 Var。

参数：

• var (Var): 用不变均匀分布初始化的Var

• mode (str): 模式选择，应为 fan_in 或 fan_out。选择 'fan_in' 保留正向传递中权重方差的大小。选择 'fan_out' 保留反向传递中的大小。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.invariant_uniform_(linear.weight)
>>> print(linear.weight)
jt.Var([[ 0.66421247 -0.74773896]
                [ 0.74773896  0.66421247]], dtype=float32)
>>> linear.weight.invariant_uniform_() # This is ok too

返回值：

由不变均匀分布初始化的 Var

jittor.init.kaiming_normal_(var, a=0, mode='fan_in', nonlinearity='leaky_relu')

将 Var 通过 kaiming normal 随机初始化。

参数:

• var (Var):需要被 kaiming normal 初始化的 Var

• a (float):此层后使用的整流器的负斜率（仅在非线性函数是 leaky_relu 时使用）。

• mode (str): 模式选择，应为 fan_in 或 fan_out。选择 'fan_in' 保留正向传递中权重方差的大小。选择 'fan_out' 保留反向传递中的大小。

• nonlinearity (str):此层后使用的非线性函数。默认值：leaky_ relu 。

代码示例:

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.kaiming_normal_(linear.weight)
>>> linear.weight

返回值：

由 kaiming uniform 随机初始化的 Var

jittor.init.kaiming_uniform_(var, a=0, mode='fan_in', nonlinearity='leaky_relu')

使用kaiming_uniform随机初始化Jittor Var。

参数：

• var (Var): 需要使用 kaiming uniform 随机初始化的 Var

• a (float): leaky_relu 的负斜率，默认为 0

• mode (str): 模式选择，应为 fan_in 或 fan_out。选择 'fan_in' 保留正向传递中权重方差的大小。选择 'fan_out' 保留反向传递中的大小。

• nonlinearity (str): 在此层之后使用的非线性，默认使用 leaky_relu 。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.kaiming_uniform_(linear.weight)
>>> print(linear.weight)
jt.Var([[-0.48337215  0.1855056 ]
                [-0.35389122 -0.07890949]], dtype=float32)
>>> linear.weight.kaiming_uniform_() # This is ok too

返回值：

由 kaiming uniform 随机初始化的 Var

jittor.init.one(shape, dtype='float32')

返回一个全为 1 的张量(Var)，形状由可变参数 shape 定义, 数据类型由可变参数 dtype 定义，默认类型 float32。

参数：

• shape (Tuple[int]): 整型序列，定义了输出的形状

• dtype (var.dtype, 可选): 数据类型，默认为 float32

代码示例：

>>> init.one((3, 4))
jt.Var([[1. 1. 1. 1.]
        [1. 1. 1. 1.]
        [1. 1. 1. 1.]], dtype=float32)
>>> init.one(5)
jt.Var([1. 1. 1. 1. 1.], dtype=float32)

返回值：

全为 1 的张量(Var)

jittor.init.one_(var)

原地修改张量 var ，将其数值全部填充为1，数据类型保持不变。

参数：

• var (Var): Var类型的张量

代码示例：

>>> x = jt.randn((3, 2))
>>> x
jt.Var([[ 0.8584159  -1.1204817 ]
        [ 0.5418147  -0.62170196]
        [-0.91137475 -0.13982968]], dtype=float32)
>>> init.one_(x)
>>> x
jt.Var([[1. 1.]
        [1. 1.]
        [1. 1.]], dtype=float32)

返回值：

就地修改张量 var ，返回一个数值全为1的张量

jittor.init.random_(var)

该函数将输入变量(var)重新赋值为随机值，生成的随机数范围在 0 到 1 之间。 参数:

• var(Var): 需要被重新赋值的变量

返回值:

Var: 重新赋值后的变量

代码示例：

>>> import jittor as jt
>>> x = jt.init.one(5)
>>> jt.init.random_(x)
>>> print(x)
jt.Var([0.9079071  0.1955278  0.2359613  0.8015607  0.83047885], dtype=float32)

jittor.init.relu_invariant_gauss(shape, dtype='float32', mode='fan_in')

返回由 relu_invariant_gauss 初始化的 Var。

参数：

• shape (int or Tuple[int]): 输出Var的形状

• dtype (str): 输出Var的 dtype ，默认 float32

• mode (str): 模式选择，应为 fan_in 或 fan_out。选择 'fan_in' 保留正向传递中权重方差的大小。选择 'fan_out' 保留反向传递中的大小。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> a = init.relu_invariant_gauss((2,2))
>>> print(a)
jt.Var([[ 0.30814755 -0.1328245 ]
                [-0.10410424 -0.01558159]], dtype=float32)

返回值：

由 relu_invariant_gauss 初始化的 Jittor Var

jittor.init.relu_invariant_gauss_(var, mode='fan_in')

用随机的 relu 不变高斯初始化 Var。

参数：

• var (Var): 要用随机 relu 不变高斯初始化的Var

• mode (str): 模式选择，应为 fan_in 或 fan_out。选择 'fan_in' 保留正向传递中权重方差的大小。选择 'fan_out' 保留反向传递中的大小。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.relu_invariant_gauss_(linear.weight)
>>> print(linear.weight)
jt.Var([[ 0.74033755 -0.74033755]
                [-0.74033755  0.74033755]], dtype=float32)
>>> linear.weight.relu_invariant_gauss_() # 这样也可以

返回值：

由随机 relu 不变高斯初始化的Var

jittor.init.trunc_normal_(var: Var, mean: float = 0.0, std: float = 1.0, a: float = -2.0, b: float = 2.0) → Var

将输入的 Var 用一个截断正态分布中的值填充。

具体而言，trunc_normal 函数采样的方法如下： 首先，根据指定的均值 mean 和标准差 std ，从正态分布中采样一个随机值 \(x\) 。 然后，对采样的随机值 \(x\) 进行截断操作，将其限制在指定的范围 [a, b] 内。具体而言，如果 \(x\) 小于下界 a ，则将它替换为 a ；如果x大于上界 b，则将它替换为 b。最后，将截断后的值作为初始化值赋给张量 var 的对应元素。

参数:

• var (Var): 一个 n 维的变量

• mean (float，可选): 正态分布的均值，默认值：0.0

• std (float，可选): 正态分布的标准差，默认值：1.0

• a (float，可选): 最小截断值，默认值：-2.0

• b (float，可选): 最大截断值，默认值： 2.0

代码示例:

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.trunc_normal_(linear.weight, std=.02)
>>> linear.weight    

返回值：

使用截断正态分布填充的输入变量(Var)

jittor.init.uniform(shape, dtype='float32', low=0, high=1)

创建一个张量，其形状由可变参数 shape 决定， 其数局类型由 dtype 决定， 其数值满足如下均匀分布：

\[out_i \sim \mathcal{U}(\text{low}, \text{high})\]

参数：

• shape (Tuple[int]): 整型序列，定义了输出的形状

• dtype (var.dtype, 可选): 数据类型，默认为 float32

• low (int or Var, 可选): 均匀分布的下界， 默认值为 0

• high (int or Var, 可选): 均匀分布的上界，默认值为 1

代码示例：

>>> init.uniform((3,2))
jt.Var([[0.82488173 0.7875814 ]
        [0.8802127  0.7350983 ]
        [0.79734576 0.9903714 ]], dtype=float32)
>>> init.uniform((2,2), 'float32', 0, 10)
jt.Var([[0.35382926 6.8104105 ]
        [2.5638878  1.2676293 ]], dtype=float32)

返回值：

返回一个数值符合均匀分布的张量

jittor.init.uniform_(var, low=0, high=1)

原地修改张量 var ，将其数值填充满足如下均匀分布的随机数：

\[out_i \sim \mathcal{U}(\text{low}, \text{high})\]

参数：

• var (Var): Var 类型的张量

• low (int or Var, 可选): 均匀分布的下界， 默认值为 0

• high (int or Var, 可选): 均匀分布的上界，默认值为 1

代码示例：

>>> x = jt.ones((3,2))
>>> x
jt.Var([[1. 1.]
        [1. 1.]
        [1. 1.]], dtype=float32)
>>> init.uniform_(x)
>>> x
jt.Var([[0.82488173 0.7875814 ]
        [0.8802127  0.7350983 ]
        [0.79734576 0.9903714 ]], dtype=float32)

返回值：

就地修改张量 var ，返回一个数值符合均匀分布的张量

jittor.init.xavier_gauss(shape, dtype='float32', gain=1.0)

返回由 xavier_gauss 初始化的 Var。结果 Var 的值将从 \(\mathcal N(-a, a)\) 中采样，其中

\[\text{std} = \text{gain} \times \sqrt{\frac{2}{\text{fan_in} + \text{fan_out}}}\]

参数：

• shape (int or Tuple[int]): 输出Var的形状

• dtype (str): 输出 Var 的 dtype ，默认 float32

• gain (float): 可选的缩放因子。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.xavier_gauss_(linear.weight, init.calculate_gain('relu'))
>>> print(linear.weight)
jt.Var([[ 0.27429324 -0.15574329]
                [-0.15574329 -0.27429324]], dtype=float32)
>>> linear.weight.xavier_gauss_() # This is ok too
jt.Var([[ 0.27429324 -0.15574329]
                [-0.15574329 -0.27429324]], dtype=float32)

返回值：

由 xavier_gauss 初始化的 Var

jittor.init.xavier_gauss_(var, gain=1.0)

返回由 xavier_gauss 初始化的 Var。结果 Var 的值将从 \(\mathcal N(-a, a)\) 中采样，其中

\[\text{std} = \text{gain} \times \sqrt{\frac{2}{\text{fan_in} + \text{fan_out}}}\]

参数：

• var (Var): 通过 xavier_guass 随机初始化的变量

• gain (float): 可选的缩放因子。

代码示例：

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.xavier_gauss_(linear.weight, init.calculate_gain('relu'))
>>> print(linear.weight)
jt.Var([[ 0.27429324 -0.15574329]
                [-0.15574329 -0.27429324]], dtype=float32)
>>> linear.weight.xavier_gauss_() # This is ok too
jt.Var([[ 0.27429324 -0.15574329]
                [-0.15574329 -0.27429324]], dtype=float32)

返回值：

由 xavier_gauss 初始化的 Var

jittor.init.xavier_uniform(shape, dtype='float32', gain=1.0)

返回由 xavier_uniform 初始化的 Var。结果 Var 的值将从 \(\mathcal U(-a, a)\) 中采样，其中

\[a = \text{gain} \times \sqrt{\frac{6}{\text{fan_in} + \text{fan_out}}}\]

参数:

• shape (int or Tuple[int]): 输出Var的形状

• dtype (str): 输出 Var 的 dtype ，默认 float32

• gain (float): 可选的缩放因子。

代码示例:

>>> from jittor import init
>>> from jittor import nn
>>> init.xavier_uniform((2,2), gain=init.calculate_gain('relu'))

返回值：

初始化后的 Var

jittor.init.xavier_uniform_(var, gain=1.0)

返回由 xavier_uniform 初始化的 Var。结果 Var 的值将从 \(\mathcal U(-a, a)\) 中采样，其中

\[a = \text{gain} \times \sqrt{\frac{6}{\text{fan_in} + \text{fan_out}}}\]

参数：

• var (Var): 通过 xavier_uniform 随机初始化的变量

• gain (float): 可选的缩放因子。

示例::

>>> from jittor import init
>>> from jittor import nn
>>> linear = nn.Linear(2,2)
>>> init.xavier_uniform_(linear.weight, init.calculate_gain('relu'))
>>> linear.weight

返回值：

返回初始化后的 var。

jittor.init.zero(shape, dtype='float32')

返回一个全为 0 的张量(Var)，形状由可变参数 shape 定义， 数据类型由 dtype 定义。如果不给定 dtype , 默认类型为 float32。

参数：

• shape (Tuple[int]): 整数序列，定义了输出的形状

• dtype (var.dtype，可选): 数据类型，默认为 float32

代码示例：

>>> init.zero((3,2), dtype='int32')
jt.Var([[0 0]
        [0 0]
        [0 0]], dtype=int32)

返回值：

全为 0 的张量(Var)

注意事项：

• 该函数和 jt.zeros() 用处一致

jittor.init.zero_(var)

原地修改张量 var ，将其修改为数值均为0的张量。

参数：

• var (Var): 输入的 Var

代码示例：

>>> x = jt.randn((3,2))
>>> x
jt.Var([[-1.1730903   0.21458259]
        [ 1.0399616   0.07660236]
        [-1.8453276  -0.95629567]], dtype=float32)
>>> init.zero_(x)
>>> x
jt.Var([[0. 0.]
        [0. 0.]
        [0. 0.]], dtype=float32)

返回值：

全为 0 的张量(Var)