操作

目录

操作#

array arange(double start, double stop, double step, Dtype dtype, StreamOrDevice s = {})#

一个 1D 数组，数字从 start 开始（可选），到 stop 停止，步长为 step（可选）。

array arange(double start, double stop, double step, StreamOrDevice s = {})#
array arange(double start, double stop, Dtype dtype, StreamOrDevice s = {})#
array arange(double start, double stop, StreamOrDevice s = {})#
array arange(double stop, Dtype dtype, StreamOrDevice s = {})#
array arange(double stop, StreamOrDevice s = {})#
array arange(int start, int stop, int step, StreamOrDevice s = {})#
array arange(int start, int stop, StreamOrDevice s = {})#
array arange(int stop, StreamOrDevice s = {})#
array linspace(double start, double stop, int num = 50, Dtype dtype = float32, StreamOrDevice s = {})#

一个 1D 数组，包含在范围 [start, stop] 内 num 个均匀间隔的数字。

array astype(array a, Dtype dtype, StreamOrDevice s = {})#

将数组转换为给定的数据类型。

array as_strided(array a, Shape shape, Strides strides, size_t offset, StreamOrDevice s = {})#

创建一个具有给定形状和步长的数组视图。

array copy(array a, StreamOrDevice s = {})#

复制另一个数组。

array full(Shape shape, array vals, Dtype dtype, StreamOrDevice s = {})#

用给定的值填充给定形状的数组。

array full(Shape shape, array vals, StreamOrDevice s = {})#
template<typename T>
array full(Shape shape, T val, Dtype dtype, StreamOrDevice s = {})#
template<typename T>
array full(Shape shape, T val, StreamOrDevice s = {})#
array zeros(const Shape &shape, Dtype dtype, StreamOrDevice s = {})#

用零填充给定形状的数组。

inline array zeros(const Shape &shape, StreamOrDevice s = {})#
array zeros_like(const array &a, StreamOrDevice s = {})#
array ones(const Shape &shape, Dtype dtype, StreamOrDevice s = {})#

用一填充给定形状的数组。

inline array ones(const Shape &shape, StreamOrDevice s = {})#
array ones_like(const array &a, StreamOrDevice s = {})#
array eye(int n, int m, int k, Dtype dtype, StreamOrDevice s = {})#

用指定对角线 k 上的 1 和其他地方的 0 填充给定形状 (n,m) 的数组。

inline array eye(int n, Dtype dtype, StreamOrDevice s = {})#
inline array eye(int n, int m, StreamOrDevice s = {})#
inline array eye(int n, int m, int k, StreamOrDevice s = {})#
inline array eye(int n, StreamOrDevice s = {})#
array identity(int n, Dtype dtype, StreamOrDevice s = {})#

创建一个形状为 (n,n) 的方阵，主对角线为 1，其他地方为 0。

inline array identity(int n, StreamOrDevice s = {})#
array tri(int n, int m, int k, Dtype type, StreamOrDevice s = {})#
inline array tri(int n, Dtype type, StreamOrDevice s = {})#
array tril(array x, int k = 0, StreamOrDevice s = {})#
array triu(array x, int k = 0, StreamOrDevice s = {})#
array reshape(const array &a, Shape shape, StreamOrDevice s = {})#

将数组重塑为给定的形状。

array unflatten(const array &a, int axis, Shape shape, StreamOrDevice s = {})#

将轴展开为给定的形状。

array flatten(const array &a, int start_axis, int end_axis = -1, StreamOrDevice s = {})#

展平范围 [start_axis, end_axis] 内的维度。

array flatten(const array &a, StreamOrDevice s = {})#

将数组展平为 1D。

array hadamard_transform(const array &a, std::optional<float> scale = std::nullopt, StreamOrDevice s = {})#

将数组乘以相应大小的 Hadamard 矩阵。

array squeeze(const array &a, const std::vector<int> &axes, StreamOrDevice s = {})#

在给定轴上移除单维度。

array squeeze(const array &a, int axis, StreamOrDevice s = {})#

在给定轴上移除单维度。

array squeeze(const array &a, StreamOrDevice s = {})#

移除所有单维度。

array expand_dims(const array &a, const std::vector<int> &axes, StreamOrDevice s = {})#

在给定轴上添加一个单维度。

array expand_dims(const array &a, int axis, StreamOrDevice s = {})#

在给定轴上添加一个单维度。

array slice(const array &a, Shape start, Shape stop, Shape strides, StreamOrDevice s = {})#

切片数组。

inline array slice(const array &a, std::initializer_list<int> start, Shape stop, Shape strides, StreamOrDevice s = {})#
array slice(const array &a, Shape start, Shape stop, StreamOrDevice s = {})#

以每个维度步长为 1 的方式切片数组。

array slice(const array &a, const array &start, std::vector<int> &axes, Shape slice_size, StreamOrDevice s = {})#

使用动态起始索引切片数组。

array slice_update(const array &src, const array &update, Shape start, Shape stop, Shape strides, StreamOrDevice s = {})#

从源数组更新切片。

array slice_update(const array &src, const array &update, Shape start, Shape stop, StreamOrDevice s = {})#

使用步长为 1 更新源数组的切片。

array slice_update(const array &src, const array &update, const array &start, std::vector<int> axes, StreamOrDevice s = {})#

使用动态起始索引更新源数组的切片。

std::vector<array> split(const array &a, int num_splits, int axis, StreamOrDevice s = {})#

沿给定轴将数组分割为子数组。

std::vector<array> split(const array &a, int num_splits, StreamOrDevice s = {})#
std::vector<array> split(const array &a, const Shape &indices, int axis, StreamOrDevice s = {})#
std::vector<array> split(const array &a, const Shape &indices, StreamOrDevice s = {})#
std::vector<array> meshgrid(const std::vector<array> &arrays, bool sparse = false, const std::string &indexing = "xy", StreamOrDevice s = {})#

从坐标向量生成坐标数组向量。

array clip(const array &a, const std::optional<array> &a_min = std::nullopt, const std::optional<array> &a_max = std::nullopt, StreamOrDevice s = {})#

裁剪（限制）数组中的值。

array concatenate(std::vector<array> arrays, int axis, StreamOrDevice s = {})#

沿给定轴拼接数组。

array concatenate(std::vector<array> arrays, StreamOrDevice s = {})#
array stack(const std::vector<array> &arrays, int axis, StreamOrDevice s = {})#

沿新轴堆叠数组。

array stack(const std::vector<array> &arrays, StreamOrDevice s = {})#
array repeat(const array &arr, int repeats, int axis, StreamOrDevice s = {})#

沿轴重复数组。

array repeat(const array &arr, int repeats, StreamOrDevice s = {})#
array tile(const array &arr, std::vector<int> reps, StreamOrDevice s = {})#
array transpose(const array &a, std::vector<int> axes, StreamOrDevice s = {})#

根据给定轴重排维度。

inline array transpose(const array &a, std::initializer_list<int> axes, StreamOrDevice s = {})#
array swapaxes(const array &a, int axis1, int axis2, StreamOrDevice s = {})#

交换数组的两个轴。

array moveaxis(const array &a, int source, int destination, StreamOrDevice s = {})#

移动数组的一个轴。

array pad(const array &a, const std::vector<int> &axes, const Shape &low_pad_size, const Shape &high_pad_size, const array &pad_value = array(0), const std::string &mode = "constant", StreamOrDevice s = {})#

使用常量值填充数组。

array pad(const array &a, const std::vector<std::pair<int, int>> &pad_width, const array &pad_value = array(0), const std::string &mode = "constant", StreamOrDevice s = {})#

沿所有轴使用常量值填充数组。

array pad(const array &a, const std::pair<int, int> &pad_width, const array &pad_value = array(0), const std::string &mode = "constant", StreamOrDevice s = {})#
array pad(const array &a, int pad_width, const array &pad_value = array(0), const std::string &mode = "constant", StreamOrDevice s = {})#
array transpose(const array &a, StreamOrDevice s = {})#

按逆序重排维度。

array broadcast_to(const array &a, const Shape &shape, StreamOrDevice s = {})#

将数组广播到给定形状。

std::vector<array> broadcast_arrays(const std::vector<array> &inputs, StreamOrDevice s = {})#

将数组向量相互广播。

array equal(const array &a, const array &b, StreamOrDevice s = {})#

返回逐元素 (a == b) 的布尔数组。

inline array operator==(const array &a, const array &b)#
template<typename T>
array operator==(T a, const array &b)#
template<typename T>
array operator==(const array &a, T b)#
array not_equal(const array &a, const array &b, StreamOrDevice s = {})#

返回逐元素 (a != b) 的布尔数组。

inline array operator!=(const array &a, const array &b)#
template<typename T>
array operator!=(T a, const array &b)#
template<typename T>
array operator!=(const array &a, T b)#
array greater(const array &a, const array &b, StreamOrDevice s = {})#

返回逐元素 (a > b) 的布尔数组。

inline array operator>(const array &a, const array &b)#
template<typename T>
array operator>(T a, const array &b)#
template<typename T>
array operator>(const array &a, T b)#
array greater_equal(const array &a, const array &b, StreamOrDevice s = {})#

返回逐元素 (a >= b) 的布尔数组。

inline array operator>=(const array &a, const array &b)#
template<typename T>
array operator>=(T a, const array &b)#
template<typename T>
array operator>=(const array &a, T b)#
array less(const array &a, const array &b, StreamOrDevice s = {})#

返回逐元素 (a < b) 的布尔数组。

inline array operator<(const array &a, const array &b)#
template<typename T>
array operator<(T a, const array &b)#
template<typename T>
array operator<(const array &a, T b)#
array less_equal(const array &a, const array &b, StreamOrDevice s = {})#

返回逐元素 (a <= b) 的布尔数组。

inline array operator<=(const array &a, const array &b)#
template<typename T>
array operator<=(T a, const array &b)#
template<typename T>
array operator<=(const array &a, T b)#
array array_equal(const array &a, const array &b, bool equal_nan, StreamOrDevice s = {})#

如果两个数组具有相同的形状和元素，则返回 True。

inline array array_equal(const array &a, const array &b, StreamOrDevice s = {})#
array isnan(const array &a, StreamOrDevice s = {})#
array isinf(const array &a, StreamOrDevice s = {})#
array isfinite(const array &a, StreamOrDevice s = {})#
array isposinf(const array &a, StreamOrDevice s = {})#
array isneginf(const array &a, StreamOrDevice s = {})#
array where(const array &condition, const array &x, const array &y, StreamOrDevice s = {})#

根据条件从 x 或 y 中选择。

array nan_to_num(const array &a, float nan = 0.0f, const std::optional<float> posinf = std::nullopt, const std::optional<float> neginf = std::nullopt, StreamOrDevice s = {})#

将 NaN 和无穷大替换为有限数。

array all(const array &a, bool keepdims, StreamOrDevice s = {})#

如果数组中的所有元素都为真（或非零），则返回真。

inline array all(const array &a, StreamOrDevice s = {})#
array allclose(const array &a, const array &b, double rtol = 1e-5, double atol = 1e-8, bool equal_nan = false, StreamOrDevice s = {})#

如果在指定容差范围内两个数组相等，则返回真。

array isclose(const array &a, const array &b, double rtol = 1e-5, double atol = 1e-8, bool equal_nan = false, StreamOrDevice s = {})#

返回一个布尔数组，指示两个数组元素在指定容差范围内是否相等。

array all(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴减少输入数组。

如果所有对应的输入都为真，则输出值为真。

array all(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴减少输入数组。

如果所有对应的输入都为真，则输出值为真。

array any(const array &a, bool keepdims, StreamOrDevice s = {})#

如果数组中有任何元素为真（或非零），则返回真。

inline array any(const array &a, StreamOrDevice s = {})#
array any(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴减少输入数组。

如果任何对应的输入都为真，则输出值为真。

array any(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴减少输入数组。

如果任何对应的输入都为真，则输出值为真。

array sum(const array &a, bool keepdims, StreamOrDevice s = {})#

对数组的元素求和。

inline array sum(const array &a, StreamOrDevice s = {})#
array sum(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

对沿给定轴的数组元素求和。

array sum(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

对沿给定轴的数组元素求和。

array mean(const array &a, bool keepdims, StreamOrDevice s = {})#

计算数组元素的平均值。

inline array mean(const array &a, StreamOrDevice s = {})#
array mean(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

计算沿给定轴的数组元素的平均值。

array mean(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

计算沿给定轴的数组元素的平均值。

array var(const array &a, bool keepdims, int ddof = 0, StreamOrDevice s = {})#

计算数组元素的方差。

inline array var(const array &a, StreamOrDevice s = {})#
array var(const array &a, const std::vector<int> &axes, bool keepdims = false, int ddof = 0, StreamOrDevice s = {})#

计算沿给定轴的数组元素的方差。

array var(const array &a, int axis, bool keepdims = false, int ddof = 0, StreamOrDevice s = {})#

计算沿给定轴的数组元素的方差。

array std(const array &a, bool keepdims, int ddof = 0, StreamOrDevice s = {})#

计算数组元素的标准差。

inline array std(const array &a, StreamOrDevice s = {})#
array std(const array &a, const std::vector<int> &axes, bool keepdims = false, int ddof = 0, StreamOrDevice s = {})#

计算沿给定轴的数组元素的标准差。

array std(const array &a, int axis, bool keepdims = false, int ddof = 0, StreamOrDevice s = {})#

计算沿给定轴的数组元素的标准差。

array prod(const array &a, bool keepdims, StreamOrDevice s = {})#

数组所有元素的乘积。

inline array prod(const array &a, StreamOrDevice s = {})#
array prod(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴的数组元素的乘积。

array prod(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴的数组元素的乘积。

array max(const array &a, bool keepdims, StreamOrDevice s = {})#

数组所有元素的最大值。

inline array max(const array &a, StreamOrDevice s = {})#
array max(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴的数组元素的最大值。

array max(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴的数组元素的最大值。

array min(const array &a, bool keepdims, StreamOrDevice s = {})#

数组所有元素的最小值。

inline array min(const array &a, StreamOrDevice s = {})#
array min(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴的数组元素的最小值。

array min(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

沿给定轴的数组元素的最小值。

array argmin(const array &a, bool keepdims, StreamOrDevice s = {})#

返回数组中最小值的索引。

inline array argmin(const array &a, StreamOrDevice s = {})#
array argmin(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

返回沿给定轴的最小值的索引。

array argmax(const array &a, bool keepdims, StreamOrDevice s = {})#

返回数组中最大值的索引。

inline array argmax(const array &a, StreamOrDevice s = {})#
array argmax(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

返回沿给定轴的最大值的索引。

array sort(const array &a, StreamOrDevice s = {})#

返回扁平化数组的排序副本。

array sort(const array &a, int axis, StreamOrDevice s = {})#

返回沿给定轴的数组的排序副本。

array argsort(const array &a, StreamOrDevice s = {})#

返回对展平数组进行排序的索引。

array argsort(const array &a, int axis, StreamOrDevice s = {})#

返回沿给定轴对数组进行排序的索引。

array partition(const array &a, int kth, StreamOrDevice s = {})#

返回展平数组的分区副本，使得第 kth 个较小的元素排在前面。

array partition(const array &a, int kth, int axis, StreamOrDevice s = {})#

返回沿给定轴的数组的分区副本，使得第 kth 个较小的元素排在前面。

array argpartition(const array &a, int kth, StreamOrDevice s = {})#

返回对展平数组进行分区的索引，使得第 kth 个较小的元素排在前面。

array argpartition(const array &a, int kth, int axis, StreamOrDevice s = {})#

返回沿给定轴对数组进行分区的索引，使得第 kth 个较小的元素排在前面。

array topk(const array &a, int k, StreamOrDevice s = {})#

返回展平数组中的前 k 个元素。

array topk(const array &a, int k, int axis, StreamOrDevice s = {})#

返回沿给定轴的数组中的前 k 个元素。

array logcumsumexp(const array &a, int axis, bool reverse = false, bool inclusive = true, StreamOrDevice s = {})#

数组的累积 logsumexp。

array logsumexp(const array &a, bool keepdims, StreamOrDevice s = {})#

数组所有元素的 logsumexp。

inline array logsumexp(const array &a, StreamOrDevice s = {})#
array logsumexp(const array &a, const std::vector<int> &axes, bool keepdims = false, StreamOrDevice s = {})#

数组元素沿给定轴的 logsumexp。

array logsumexp(const array &a, int axis, bool keepdims = false, StreamOrDevice s = {})#

数组元素沿给定轴的 logsumexp。

array abs(const array &a, StreamOrDevice s = {})#

数组元素的绝对值。

array negative(const array &a, StreamOrDevice s = {})#

对数组取反。

array operator-(const array &a)#
array sign(const array &a, StreamOrDevice s = {})#

数组元素的符号。

array logical_not(const array &a, StreamOrDevice s = {})#

数组的逻辑非。

array logical_and(const array &a, const array &b, StreamOrDevice s = {})#

两个数组的逻辑与。

array operator&&(const array &a, const array &b)#
array logical_or(const array &a, const array &b, StreamOrDevice s = {})#

两个数组的逻辑或。

array operator||(const array &a, const array &b)#
array reciprocal(const array &a, StreamOrDevice s = {})#

数组元素的倒数 (1/x)。

array add(const array &a, const array &b, StreamOrDevice s = {})#

两个数组相加。

array operator+(const array &a, const array &b)#
template<typename T>
array operator+(T a, const array &b)#
template<typename T>
array operator+(const array &a, T b)#
array subtract(const array &a, const array &b, StreamOrDevice s = {})#

两个数组相减。

array operator-(const array &a, const array &b)#
template<typename T>
array operator-(T a, const array &b)#
template<typename T>
array operator-(const array &a, T b)#
array multiply(const array &a, const array &b, StreamOrDevice s = {})#

两个数组相乘。

array operator*(const array &a, const array &b)#
template<typename T>
array operator*(T a, const array &b)#
template<typename T>
array operator*(const array &a, T b)#
array divide(const array &a, const array &b, StreamOrDevice s = {})#

两个数组相除。

array operator/(const array &a, const array &b)#
array operator/(double a, const array &b)#
array operator/(const array &a, double b)#
std::vector<array> divmod(const array &a, const array &b, StreamOrDevice s = {})#

计算元素的商和余数。

array floor_divide(const array &a, const array &b, StreamOrDevice s = {})#

计算整数除法。

等同于 doing floor(a / x)。

array remainder(const array &a, const array &b, StreamOrDevice s = {})#

计算元素除法的余数。

array operator%(const array &a, const array &b)#
template<typename T>
array operator%(T a, const array &b)#
template<typename T>
array operator%(const array &a, T b)#
array maximum(const array &a, const array &b, StreamOrDevice s = {})#

两个数组的元素级最大值。

array minimum(const array &a, const array &b, StreamOrDevice s = {})#

两个数组的元素级最小值。

array floor(const array &a, StreamOrDevice s = {})#

对数组元素取整（向下取整）。

array ceil(const array &a, StreamOrDevice s = {})#

对数组元素取整（向上取整）。

array square(const array &a, StreamOrDevice s = {})#

对数组元素求平方。

array exp(const array &a, StreamOrDevice s = {})#

数组元素的指数函数。

array sin(const array &a, StreamOrDevice s = {})#

数组元素的正弦。

array cos(const array &a, StreamOrDevice s = {})#

数组元素的余弦。

array tan(const array &a, StreamOrDevice s = {})#

数组元素的正切。

array arcsin(const array &a, StreamOrDevice s = {})#

数组元素的反正弦。

array arccos(const array &a, StreamOrDevice s = {})#

数组元素的反余弦。

array arctan(const array &a, StreamOrDevice s = {})#

数组元素的反正切。

array arctan2(const array &a, const array &b, StreamOrDevice s = {})#

两个数组比值的反正切。

array sinh(const array &a, StreamOrDevice s = {})#

数组元素的双曲正弦。

array cosh(const array &a, StreamOrDevice s = {})#

数组元素的双曲余弦。

array tanh(const array &a, StreamOrDevice s = {})#

数组元素的双曲正切。

array arcsinh(const array &a, StreamOrDevice s = {})#

数组元素的双曲反正弦。

array arccosh(const array &a, StreamOrDevice s = {})#

数组元素的双曲反余弦。

array arctanh(const array &a, StreamOrDevice s = {})#

数组元素的双曲反正切。

array degrees(const array &a, StreamOrDevice s = {})#

将数组元素从弧度转换为角度。

array radians(const array &a, StreamOrDevice s = {})#

将数组元素从角度转换为弧度。

array log(const array &a, StreamOrDevice s = {})#

数组元素的自然对数。

array log2(const array &a, StreamOrDevice s = {})#

数组元素的以 2 为底的对数。

array log10(const array &a, StreamOrDevice s = {})#

数组元素的以 10 为底的对数。

array log1p(const array &a, StreamOrDevice s = {})#

数组元素加一后的自然对数：log(1 + a)。

array logaddexp(const array &a, const array &b, StreamOrDevice s = {})#

数组元素的 log-add-exp：log(exp(a) + exp(b))。

array sigmoid(const array &a, StreamOrDevice s = {})#

数组的元素级逻辑 sigmoid：1 / (1 + exp(-x)。

array erf(const array &a, StreamOrDevice s = {})#

计算数组元素的误差函数。

array erfinv(const array &a, StreamOrDevice s = {})#

计算数组元素的逆误差函数。

array expm1(const array &a, StreamOrDevice s = {})#

计算数组元素的 expm1 函数。

array stop_gradient(const array &a, StreamOrDevice s = {})#

停止梯度流。

array round(const array &a, int decimals, StreamOrDevice s = {})#

对浮点数进行四舍五入。

inline array round(const array &a, StreamOrDevice s = {})#
array matmul(const array &a, const array &b, StreamOrDevice s = {})#

array matmul(const array &a, const array &b, StreamOrDevice s = {})#

矩阵相乘。

根据给定索引和切片聚集数组条目。

inline array gather(const array &a, const array &indices, int axis, const Shape &slice_sizes, StreamOrDevice s = {})#
array kron(const array &a, const array &b, StreamOrDevice s = {})#

计算两个数组的 Kronecker 积。

array take(const array &a, const array &indices, int axis, StreamOrDevice s = {})#

在指定轴上根据给定索引获取数组切片。

array take(const array &a, int index, int axis, StreamOrDevice s = {})#
array take(const array &a, const array &indices, StreamOrDevice s = {})#

在将数组视为扁平化的情况下，根据给定索引获取数组条目。

array take(const array &a, int index, StreamOrDevice s = {})#
array take_along_axis(const array &a, const array &indices, int axis, StreamOrDevice s = {})#

沿着轴根据给定索引获取数组条目。

array put_along_axis(const array &a, const array &indices, const array &values, int axis, StreamOrDevice s = {})#

沿着轴在给定索引处将值放入数组。

array scatter_add_axis(const array &a, const array &indices, const array &values, int axis, StreamOrDevice s = {})#

沿着轴在给定索引处将值添加到数组。

array scatter(const array &a, const std::vector<array> &indices, const array &updates, const std::vector<int> &axes, StreamOrDevice s = {})#

将更新散布到给定索引处。

参数 indices 和 axes 确定用 updates 中的值更新的 a 的位置。为简单起见，假设 indices 是 1 维的，indices[i] 是轴 axes[i] 上的索引，updates 中的值将应用于这些索引处。请注意，indices 中的每个数组都分配给一个相应的轴，因此 indices.size() == axes.size()。如果没有提供索引/轴对，则该轴上的索引假定为零。

请注意，updates 的秩必须等于广播后的 indices 的秩与 a 的秩之和。换句话说，假设 indices 中的数组具有相同的形状，则 updates.ndim() == indices[0].ndim() + a.ndim()。updates 的前导维度对应于索引，剩余的 a.ndim() 维度是将应用于 a 中给定位置的值。

例如

auto in = zeros({4, 4}, float32);
auto indices = array({2});
auto updates = reshape(arange(1, 3, float32), {1, 1, 2});
std::vector<int> axes{0};

auto out = scatter(in, {indices}, updates, axes);

将产生

array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [1, 2, 0, 0],
       [0, 0, 0, 0]], dtype=float32)

这将把两元素的行向量 [1, 2] 散布到 a 的 (2, 0) 位置开始。

向 indices 添加另一个元素将散布到 a 的另一个位置。我们还需要为新的索引添加另一个更新。

auto in = zeros({4, 4}, float32);
auto indices = array({2, 0});
auto updates = reshape(arange(1, 5, float32), {2, 1, 2});
std::vector<int> axes{0};

auto out = scatter(in, {indices}, updates, axes):

将产生

array([[3, 4, 0, 0],
       [0, 0, 0, 0],
       [1, 2, 0, 0],
       [0, 0, 0, 0]], dtype=float32)

要控制附加轴上的散布位置，请向 indices 添加另一个索引数组，并向 axes 添加另一个轴。

auto in = zeros({4, 4}, float32);
auto indices = std::vector{array({2, 0}), array({1, 2})};
auto updates = reshape(arange(1, 5, float32), {2, 1, 2});
std::vector<int> axes{0, 1};

auto out = scatter(in, indices, updates, axes);

将产生

array([[0, 0, 3, 4],
      [0, 0, 0, 0],
      [0, 1, 2, 0],
      [0, 0, 0, 0]], dtype=float32)

indices 中的项会一起广播。这意味着

auto indices = std::vector{array({2, 0}), array({1})};

等同于

auto indices = std::vector{array({2, 0}), array({1, 1})};

请注意，scatter 不对索引和更新执行边界检查。a 的越界访问是未定义的，通常会导致意外或无效的内存写入。

inline array scatter(const array &a, const array &indices, const array &updates, int axis, StreamOrDevice s = {})#
array scatter_add(const array &a, const std::vector<array> &indices, const array &updates, const std::vector<int> &axes, StreamOrDevice s = {})#

将更新散布并添加到给定索引处。

inline array scatter_add(const array &a, const array &indices, const array &updates, int axis, StreamOrDevice s = {})#
array scatter_prod(const array &a, const std::vector<array> &indices, const array &updates, const std::vector<int> &axes, StreamOrDevice s = {})#

将更新散布并求乘积到给定索引处。

inline array scatter_prod(const array &a, const array &indices, const array &updates, int axis, StreamOrDevice s = {})#
array scatter_max(const array &a, const std::vector<array> &indices, const array &updates, const std::vector<int> &axes, StreamOrDevice s = {})#

将更新散布并求最大值到给定线性索引处。

inline array scatter_max(const array &a, const array &indices, const array &updates, int axis, StreamOrDevice s = {})#
array scatter_min(const array &a, const std::vector<array> &indices, const array &updates, const std::vector<int> &axes, StreamOrDevice s = {})#

将更新散布并求最小值到给定线性索引处。

inline array scatter_min(const array &a, const array &indices, const array &updates, int axis, StreamOrDevice s = {})#
array sqrt(const array &a, StreamOrDevice s = {})#

计算数组元素的平方根。

array rsqrt(const array &a, StreamOrDevice s = {})#

计算数组元素的平方根和倒数。

array softmax(const array &a, const std::vector<int> &axes, bool precise = false, StreamOrDevice s = {})#

数组的 Softmax。

array softmax(const array &a, bool precise = false, StreamOrDevice s = {})#

数组的 Softmax。

inline array softmax(const array &a, int axis, bool precise = false, StreamOrDevice s = {})#

数组的 Softmax。

array power(const array &a, const array &b, StreamOrDevice s = {})#

将数组 a 的元素按元素计算 b 次幂。

array cumsum(const array &a, int axis, bool reverse = false, bool inclusive = true, StreamOrDevice s = {})#

数组的累积和。

array cumprod(const array &a, int axis, bool reverse = false, bool inclusive = true, StreamOrDevice s = {})#

数组的累积积。

array cummax(const array &a, int axis, bool reverse = false, bool inclusive = true, StreamOrDevice s = {})#

数组的累积最大值。

array cummin(const array &a, int axis, bool reverse = false, bool inclusive = true, StreamOrDevice s = {})#

数组的累积最小值。

array conv_general(array input, array weight, std::vector<int> stride = {}, std::vector<int> padding_lo = {}, std::vector<int> padding_hi = {}, std::vector<int> kernel_dilation = {}, std::vector<int> input_dilation = {}, int groups = 1, bool flip = false, StreamOrDevice s = {})#

使用过滤器进行通用卷积。

inline array conv_general(const array &input, const array &weight, std::vector<int> stride = {}, std::vector<int> padding = {}, std::vector<int> kernel_dilation = {}, std::vector<int> input_dilation = {}, int groups = 1, bool flip = false, StreamOrDevice s = {})#

使用过滤器进行通用卷积。

array conv1d(const array &input, const array &weight, int stride = 1, int padding = 0, int dilation = 1, int groups = 1, StreamOrDevice s = {})#

使用过滤器进行一维卷积

array conv2d(const array &input, const array &weight, const std::pair<int, int> &stride = {1, 1}, const std::pair<int, int> &padding = {0, 0}, const std::pair<int, int> &dilation = {1, 1}, int groups = 1, StreamOrDevice s = {})#

使用过滤器进行二维卷积

array conv3d(const array &input, const array &weight, const std::tuple<int, int, int> &stride = {1, 1, 1}, const std::tuple<int, int, int> &padding = {0, 0, 0}, const std::tuple<int, int, int> &dilation = {1, 1, 1}, int groups = 1, StreamOrDevice s = {})#

使用过滤器进行三维卷积

array conv_transpose1d(const array &input, const array &weight, int stride = 1, int padding = 0, int dilation = 1, int output_padding = 0, int groups = 1, StreamOrDevice s = {})#

带滤波器的 1D 转置卷积

array conv_transpose2d(const array &input, const array &weight, const std::pair<int, int> &stride = {1, 1}, const std::pair<int, int> &padding = {0, 0}, const std::pair<int, int> &dilation = {1, 1}, const std::pair<int, int> &output_padding = {0, 0}, int groups = 1, StreamOrDevice s = {})#

带滤波器的 2D 转置卷积

array conv_transpose3d(const array &input, const array &weight, const std::tuple<int, int, int> &stride = {1, 1, 1}, const std::tuple<int, int, int> &padding = {0, 0, 0}, const std::tuple<int, int, int> &dilation = {1, 1, 1}, const std::tuple<int, int, int> &output_padding = {0, 0, 0}, int groups = 1, StreamOrDevice s = {})#

带滤波器的 3D 转置卷积

array quantized_matmul(array x, array w, array scales, array biases, bool transpose = true, int group_size = 64, int bits = 4, StreamOrDevice s = {})#

量化矩阵乘法，将 x 与量化矩阵 w 相乘。

std::tuple<array, array, array> quantize(const array &w, int group_size = 64, int bits = 4, StreamOrDevice s = {})#

沿矩阵的最后一个轴进行量化。

array dequantize(const array &w, const array &scales, const array &biases, int group_size = 64, int bits = 4, StreamOrDevice s = {})#

对 quantize() 函数产生的矩阵进行反量化。

array gather_qmm(const array &x, const array &w, const array &scales, const array &biases, std::optional<array> lhs_indices = std::nullopt, std::optional<array> rhs_indices = std::nullopt, bool transpose = true, int group_size = 64, int bits = 4, bool sorted_indices = false, StreamOrDevice s = {})#

计算带有矩阵级 gather 的矩阵乘积。

array tensordot(const array &a, const array &b, const int axis = 2, StreamOrDevice s = {})#

返回张量 a 和 b 在多个维度上的收缩。

array tensordot(const array &a, const array &b, const std::vector<int> &axes_a, const std::vector<int> &axes_b, StreamOrDevice s = {})#
array outer(const array &a, const array &b, StreamOrDevice s = {})#

计算两个向量的外积。

array inner(const array &a, const array &b, StreamOrDevice s = {})#

计算两个向量的内积。

array addmm(array c, array a, array b, const float &alpha = 1.f, const float &beta = 1.f, StreamOrDevice s = {})#

计算 D = beta * C + alpha * (A @ B)

array block_masked_mm(array a, array b, int block_size, std::optional<array> mask_out = std::nullopt, std::optional<array> mask_lhs = std::nullopt, std::optional<array> mask_rhs = std::nullopt, StreamOrDevice s = {})#

计算带有块掩码的矩阵乘积。

array gather_mm(array a, array b, std::optional<array> lhs_indices = std::nullopt, std::optional<array> rhs_indices = std::nullopt, bool sorted_indices = false, StreamOrDevice s = {})#

计算带有矩阵级 gather 的矩阵乘积。

array diagonal(const array &a, int offset = 0, int axis1 = 0, int axis2 = 1, StreamOrDevice s = {})#

提取对角线或构造对角矩阵。

array diag(const array &a, int k = 0, StreamOrDevice s = {})#

从 2D 数组中提取对角线或创建对角矩阵。

array trace(const array &a, int offset, int axis1, int axis2, Dtype dtype, StreamOrDevice s = {})#

返回给定数组中沿指定对角线的总和。

array trace(const array &a, int offset, int axis1, int axis2, StreamOrDevice s = {})#
array trace(const array &a, StreamOrDevice s = {})#
std::vector<array> depends(const std::vector<array> &inputs, const std::vector<array> &dependencies)#

实现恒等函数，但允许注入对其他数组的依赖。

这确保了当此函数的输出被计算时，这些其他数组也已被计算。

array atleast_1d(const array &a, StreamOrDevice s = {})#

将数组转换为至少一维数组

std::vector<array> atleast_1d(const std::vector<array> &a, StreamOrDevice s = {})#
array atleast_2d(const array &a, StreamOrDevice s = {})#
std::vector<array> atleast_2d(const std::vector<array> &a, StreamOrDevice s = {})#
array atleast_3d(const array &a, StreamOrDevice s = {})#
std::vector<array> atleast_3d(const std::vector<array> &a, StreamOrDevice s = {})#
array number_of_elements(const array &a, std::vector<int> axes, bool inverted, Dtype dtype = int32, StreamOrDevice s = {})#

将沿某些轴的元素数量提取为一个标量数组。

用于允许依赖于形状的无形状编译（双关语）。

array conjugate(const array &a, StreamOrDevice s = {})#
array bitwise_and(const array &a, const array &b, StreamOrDevice s = {})#

按位与。

array operator&(const array &a, const array &b)#
array bitwise_or(const array &a, const array &b, StreamOrDevice s = {})#

按位或（包含性）。

array operator|(const array &a, const array &b)#
array bitwise_xor(const array &a, const array &b, StreamOrDevice s = {})#

按位异或。

array operator^(const array &a, const array &b)#
array left_shift(const array &a, const array &b, StreamOrDevice s = {})#

将位左移。

array operator<<(const array &a, const array &b)#
array right_shift(const array &a, const array &b, StreamOrDevice s = {})#

将位右移。

array operator>>(const array &a, const array &b)#
array bitwise_invert(const array &a, StreamOrDevice s = {})#

反转位。

array operator~(const array &a)#
array view(const array &a, const Dtype &dtype, StreamOrDevice s = {})#
array roll(const array &a, int shift, StreamOrDevice s = {})#

沿轴滚动元素并将其引入另一侧。

array roll(const array &a, const Shape &shift, StreamOrDevice s = {})#
array roll(const array &a, int shift, int axis, StreamOrDevice s = {})#
array roll(const array &a, int shift, const std::vector<int> &axes, StreamOrDevice s = {})#
array roll(const array &a, const Shape &shift, int axis, StreamOrDevice s = {})#
array roll(const array &a, const Shape &shift, const std::vector<int> &axes, StreamOrDevice s = {})#
array real(const array &a, StreamOrDevice s = {})#
array imag(const array &a, StreamOrDevice s = {})#
array contiguous(const array &a, bool allow_col_major = false, StreamOrDevice s = {})#
目录