Справочное руководство PyTorch torch

Пакет PyTorch содержит структуры данных для многомерных тензоров и определяет математические операции, выполняемые над этими тензорами. Кроме того, он предоставляет множество служебных инструментов для эффективной сериализации тензоров и произвольных типов данных, а также другие полезные утилиты.

Он также имеет версию для CUDA, которая позволяет выполнять тензорные вычисления на графических процессорах NVIDIA с вычислительной способностью >= 3.0.

Руководство по API torch PyTorch

Проверки типов тензоров

Функция	Описание
`torch.is_tensor(obj)`	Проверить`obj`является ли он тензором PyTorch.
`torch.is_storage(obj)`	Проверить`obj`является ли он объектом хранилища PyTorch.
`torch.is_complex(input)`	Проверить`input`является ли тип данных комплексным типом.
`torch.is_conj(input)`	Проверить`input`является ли он сопряжённым тензором.
`torch.is_floating_point(input)`	Проверить`input`является ли тип данных типом с плавающей запятой.
`torch.is_nonzero(input)`	Проверить`input`является ли он ненулевым одноэлементным тензором.
`torch.set_default_dtype(d)`	Установить тип данных с плавающей запятой по умолчанию в`d`。
`torch.get_default_dtype()`	Получить текущий тип данных с плавающей запятой по умолчанию`torch.dtype`。
`torch.set_default_device(device)`	Установить по умолчанию`torch.Tensor`выделенное устройство на`device`。
`torch.get_default_device()`	Получить по умолчанию`torch.Tensor`выделенное устройство.
`torch.set_default_tensor_type(tensor_type)`	Установить тип тензора по умолчанию в`tensor_type`。
`torch.numel(input)`	Return`input`общее число элементов в тензоре.
`torch.set_printoptions(...)`	Установить параметры печати тензоров.

Создание тензоров

Функция	Описание
`torch.tensor(data, dtype, device, requires_grad)`	Создать тензор из данных, копируя данные, без истории autograd.
`torch.as_tensor(data, dtype, device)`	Преобразовать данные в тензор, совместно используя данные и сохраняя историю autograd.
`torch.asarray(data, dtype, device)`	Преобразовать данные в тензорный массив.
`torch.from_numpy(ndarray)`	Создать тензор из массива NumPy (общая память).
`torch.from_dlpack(ext_tensor)`	Создать тензор PyTorch из тензора dlpack.
`torch.frombuffer(buffer, dtype, count, offset)`	Создать 1-D тензор из буфера.
`torch.zeros(*size, dtype, device, requires_grad)`	Создать тензор, заполненный нулями.
`torch.zeros_like(input, dtype, device, requires_grad)`	Создать тензор из всех нулей с той же формой, что и вход.
`torch.ones(*size, dtype, device, requires_grad)`	Создать тензор, заполненный единицами.
`torch.ones_like(input, dtype, device, requires_grad)`	Создать тензор из всех единиц с той же формой, что и вход.
`torch.empty(*size, dtype, device, requires_grad)`	Создать неинициализированный тензор.
`torch.empty_like(input, dtype, device, requires_grad)`	Создать неинициализированный тензор с той же формой, что и вход.
`torch.empty_strided(size, stride, dtype, device)`	Создать неинициализированный тензор с указанными шагами.
`torch.arange(start, end, step, dtype, device, requires_grad)`	Создать тензор арифметической последовательности.
`torch.range(start, end, step, dtype, device, requires_grad)`	Создать тензор арифметической последовательности, включающий конечное значение.
`torch.linspace(start, end, steps, dtype, device, requires_grad)`	Создать тензор равномерно распределённой последовательности.
`torch.logspace(start, end, steps, base, dtype, device, requires_grad)`	Создать тензор логарифмически распределённой последовательности.
`torch.eye(n, m, dtype, device, requires_grad)`	Создать единичную матрицу.
`torch.full(size, fill_value, dtype, device, requires_grad)`	Создать тензор, заполненный указанным значением.
`torch.full_like(input, fill_value, dtype, device, requires_grad)`	Создать тензор, заполненный значением и имеющий ту же форму, что и входной.
`torch.rand(*size, dtype, device, requires_grad)`	Создать равномерно распределённый случайный тензор (диапазон [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Создать равномерно распределённый случайный тензор с той же формой, что и входной.
`torch.randn(*size, dtype, device, requires_grad)`	Создать случайный тензор со стандартным нормальным распределением.
`torch.randn_like(input, dtype, device, requires_grad)`	Создать случайный тензор со стандартным нормальным распределением с той же формой, что и входной.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Создать случайный целочисленный тензор.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Создать случайный целочисленный тензор с той же формой, что и входной.
`torch.randperm(n, dtype, device, requires_grad)`	Создать случайную перестановку чисел от 0 до n-1.
`torch.sparse_coo_tensor(indices, values, size, dtype, device, requires_grad)`	В указанной`indices`позиции построить разреженный тензор COO.
`torch.sparse_csr_tensor(crow_indices, col_indices, values, size, dtype, device)`	Построить разреженный тензор CSR.
`torch.sparse_csc_tensor(ccol_indices, row_indices, values, size, dtype, device)`	Построить разреженный тензор CSC.
`torch.quantize_per_tensor(input, scale, zero_point, dtype)`	Создать квантованный тензор (по тензору).
`torch.quantize_per_channel(input, scales, zero_points, axis, dtype)`	Создать квантованный тензор (по каналам).
`torch.dequantize(input)`	Деквантовать тензор.
`torch.complex(real, imag)`	Создать комплексный тензор из действительной и мнимой частей.
`torch.polar(abs, angle)`	Создать комплексный тензор из полярных координат.
`torch.heaviside(input, values)`	Вычислить функцию Хевисайда.

Операции индексации, срезов, объединения и изменения

Функция	Описание
`torch.cat(tensors, dim, out)`	Конкатенировать тензоры вдоль указанной размерности.
`torch.concat(tensors, dim, out)`	Конкатенировать тензоры вдоль указанной размерности (то же, что cat).
`torch.concatenate(tensors, dim, out)`	Конкатенировать тензоры вдоль указанной размерности (то же, что cat).
`torch.stack(tensors, dim, out)`	Объединить тензоры в стек вдоль новой размерности.
`torch.split(tensor, split_size, dim)`	Разбить тензор вдоль указанной размерности.
`torch.chunk(tensor, chunks, dim)`	Разбить тензор на части вдоль указанной размерности.
`torch.reshape(input, shape)`	Изменить форму тензора.
`torch.transpose(input, dim0, dim1)`	Поменять местами два измерения тензора.
`torch.t(input)`	Транспонировать 2-D тензор.
`torch.squeeze(input, dim)`	Удалить измерение размера 1.
`torch.unsqueeze(input, dim)`	Вставить измерение размера 1 в указанную позицию.
`torch.permute(input, dims)`	Переставить измерения тензора.
`torch.movedim(input, source, destination)`	Переместить измерение тензора на новую позицию.
`torch.moveaxis(input, source, destination)`	Переместить ось тензора на новую позицию.
`torch.narrow(input, dim, start, length)`	Вернуть срез тензора.
`torch.narrow_copy(input, dim, start, length)`	Вернуть копию среза тензора.
`torch.select(input, dim, index)`	Выбрать срезы, соответствующие индексам вдоль указанного измерения.
`torch.slice_scatter(input, src, dim, start, end)`	Разбросать src по срезам input.
`torch.select_scatter(input, src, dim, index)`	Разбросать src в указанные индексные позиции.
`torch.diagonal_scatter(input, src, offset, dim1, dim2)`	Разбросать значения в диагональные позиции.
`torch.expand(input, size)`	Расширить размер тензора (копия представления).
`torch.expand_as(input, other)`	Расширить тензор до того же размера, что и other.
`torch.masked_select(input, mask)`	Выбрать элементы согласно логической маске.
`torch.index_select(input, dim, index)`	Выбрать элементы, соответствующие индексам вдоль указанного измерения.
`torch.gather(input, dim, index, sparse_grad)`	Собрать элементы по указанным индексам вдоль указанного измерения.
`torch.scatter(input, dim, index, src, reduce)`	будет`src`разбросать значения ... в`input`указанные позиции ...
`torch.scatter_add(input, dim, index, src)`	Добавить значения src в указанные позиции.
`torch.scatter_reduce(input, dim, index, src, reduce, include_self)`	Агрегировать значения src в указанные позиции указанным способом.
`torch.index_add(input, dim, index, source, alpha)`	Добавить source в позиции, заданные index.
`torch.index_copy(input, dim, index, source)`	Скопировать источник в позиции, указанные индексом.
`torch.index_reduce(input, dim, index, source, reduce, include_self)`	Агрегировать источник в позиции, указанные индексом, указанным способом.
`torch.take(input, index)`	Получить элемент в заданной позиции индекса.
`torch.take_along_dim(input, indices, dim)`	Получить элементы в позициях индекса вдоль указанного измерения.
`torch.nonzero(input)`	Вернуть индексы ненулевых элементов.
`torch.argwhere(input)`	Вернуть индексы элементов, удовлетворяющих условию.
`torch.where(condition, input, other)`	Вернуть элементы в соответствии с условием.
`torch.unbind(tensor, dim)`	Разделить на кортеж вдоль указанного измерения.
`torch.split_with_sizes(tensor, split_sizes, dim)`	Разделить тензор по размерам.
`torch.tensor_split(tensor, indices_or_sections, dim)`	Разделить тензор по индексам или по количеству сегментов.
`torch.hsplit(tensor, indices_or_sections)`	Разделить тензор по горизонтали.
`torch.vsplit(tensor, indices_or_sections)`	Разделить тензор по вертикали.
`torch.dsplit(tensor, indices_or_sections)`	Разделить тензор по глубине.
`torch.hstack(tensors, dim, out)`	Объединить тензоры по горизонтали.
`torch.vstack(tensors, out)`	Объединить тензоры по вертикали.
`torch.dstack(tensors, out)`	Объединить тензоры по глубине.
`torch.column_stack(tensors, out)`	Объединить тензоры по столбцам.
`torch.row_stack(tensors, out)`	Объединить тензоры по строкам (то же, что vstack).
`torch.tile(input, dims)`	Повторить тензор несколько раз.
`torch.repeat_interleave(input, repeats, dim)`	Повторить элементы вдоль указанного измерения.
`torch.flip(input, dims)`	Перевернуть тензор вдоль указанного измерения.
`torch.fliplr(input)`	Перевернуть тензор слева направо.
`torch.flipud(input)`	Перевернуть тензор сверху вниз.
`torch.rot90(input, k, dims)`	Повернуть тензор на 90 градусов.
`torch.linalg.matrix_transpose(input)`	Транспонирование матрицы.
`torch.adjoint(input)`	Возвращает сопряжённый тензор.
`torch.resolve_conj(input)`	Разрешает сопряжённый тензор.
`torch.resolve_neg(input)`	Разрешает отрицательный тензор.
`torch.view_as_real(input)`	Рассматривает комплексный тензор как вещественный тензор.
`torch.view_as_complex(input)`	Рассматривает вещественный тензор как комплексный тензор.
`torch.unravel_index(indices, shape)`	Преобразует плоские индексы в многомерные индексы.

Генерация случайных чисел

Функция	Описание
`torch.manual_seed(seed)`	Устанавливает начальное значение генератора случайных чисел (CPU).
`torch.seed()`	Устанавливает начальное значение генератора случайных чисел и возвращает новое начальное значение.
`torch.initial_seed()`	Возвращает текущее начальное значение генератора случайных чисел.
`torch.get_rng_state()`	Возвращает состояние генератора случайных чисел.
`torch.set_rng_state(state)`	Устанавливает состояние генератора случайных чисел.
`torch.rand(*size, dtype, device, requires_grad)`	Создать равномерно распределённый случайный тензор (диапазон [0, 1)).
`torch.rand_like(input, dtype, device, requires_grad)`	Создать равномерно распределённый случайный тензор с той же формой, что и входной.
`torch.randn(*size, dtype, device, requires_grad)`	Создать случайный тензор со стандартным нормальным распределением.
`torch.randn_like(input, dtype, device, requires_grad)`	Создать случайный тензор со стандартным нормальным распределением с той же формой, что и входной.
`torch.randint(low, high, size, dtype, device, requires_grad)`	Создать случайный целочисленный тензор.
`torch.randint_like(input, low, high, dtype, device, requires_grad)`	Создать случайный целочисленный тензор с той же формой, что и входной.
`torch.randperm(n, dtype, device, requires_grad)`	Создать случайную перестановку чисел от 0 до n-1.
`torch.bernoulli(input, *, generator)`	Генерирует случайные числа из распределения Бернулли.
`torch.multinomial(input, num_samples, replacement, generator)`	Мультиномиальная выборка.
`torch.normal(mean, std, out)`	Сгенерировать случайные числа из нормального распределения.
`torch.poisson(input, generator)`	Сгенерировать случайные числа из распределения Пуассона.

Сериализация

Функция	Описание
`torch.save(obj, f, pickle_module, pickle_protocol)`	Сохранить объект в файл.
`torch.load(f, map_location, pickle_module, weights_only)`	Загрузить объект из файла.

Управление градиентами

Функция	Описание
`torch.no_grad()`	Контекстный менеджер, отключающий вычисление градиентов.
`torch.enable_grad()`	Контекстный менеджер, включающий вычисление градиентов.
`torch.set_grad_enabled(grad)`	Установить, включено ли вычисление градиентов.
`torch.is_grad_enabled()`	Проверить, включено ли вычисление градиентов.
`torch.inference_mode()`	Контекстный менеджер для режима инференса (отключает градиенты и autograd).
`torch.is_inference_mode_enabled()`	Проверить, включен ли режим инференса.

Математические операции - поэлементные операции

Функция	Описание
`torch.abs(input, out)`	Поэлементное абсолютное значение.
`torch.absolute(input, out)`	Поэлементное абсолютное значение (то же, что abs).
`torch.acos(input, out)`	Поэлементный арккосинус.
`torch.arccos(input, out)`	Поэлементный арккосинус (то же, что acos).
`torch.acosh(input, out)`	Поэлементный обратный гиперболический косинус.
`torch.arccosh(input, out)`	Поэлементный обратный гиперболический косинус (то же, что acosh).
`torch.add(input, other, alpha, out)`	Поэлементное сложение (с необязательным масштабированием alpha).
`torch.addcdiv(input, tensor1, tensor2, value, out)`	Выполняет input + value * (tensor1 / tensor2).
`torch.addcmul(input, tensor1, tensor2, value, out)`	Выполняет input + value * (tensor1 * tensor2).
`torch.angle(input, out)`	Возвращает фазовый угол комплексного тензора.
`torch.asin(input, out)`	Поэлементный арксинус.
`torch.arcsin(input, out)`	Поэлементный арксинус (то же, что asin).
`torch.asinh(input, out)`	Поэлементный обратный гиперболический синус.
`torch.arcsinh(input, out)`	Поэлементный обратный гиперболический синус (то же, что asinh).
`torch.atan(input, out)`	Поэлементный арктангенс.
`torch.arctan(input, out)`	Поэлементный арктангенс (то же, что atan).
`torch.atan2(input, other, out)`	Поэлементный арктангенс с двумя аргументами.
`torch.arctan2(input, other, out)`	Поэлементный арктангенс с двумя аргументами (то же, что atan2).
`torch.atanh(input, out)`	Поэлементный обратный гиперболический тангенс.
`torch.arctanh(input, out)`	Поэлементный обратный гиперболический тангенс (то же, что atanh).
`torch.bitwise_not(input, out)`	Поэлементное побитовое НЕ.
`torch.bitwise_and(input, other, out)`	Поэлементное побитовое И.
`torch.bitwise_or(input, other, out)`	Поэлементное побитовое ИЛИ.
`torch.bitwise_xor(input, other, out)`	Поэлементный побитовый XOR.
`torch.bitwise_left_shift(input, other, out)`	Поэлементный сдвиг влево.
`torch.bitwise_right_shift(input, other, out)`	Поэлементный сдвиг вправо.
`torch.ceil(input, out)`	Поэлементное округление вверх.
`torch.clamp(input, min, max, out)`	Ограничивает значения тензора указанным диапазоном.
`torch.clip(input, min, max, out)`	Ограничивает значения тензора указанным диапазоном (то же, что clamp).
`torch.conj_physical(input, out)`	Поэлементное физическое сопряжение.
`torch.copysign(input, other, out)`	Поэлементное копирование знака.
`torch.cos(input, out)`	Поэлементный косинус.
`torch.cosh(input, out)`	Поэлементный гиперболический косинус.
`torch.deg2rad(input, out)`	Преобразует углы из градусов в радианы.
`torch.div(input, other, rounding_mode, out)`	Поэлементное деление.
`torch.divide(input, other, rounding_mode, out)`	Поэлементное деление (то же, что div).
`torch.digamma(input, out)`	Поэлементная дигамма-функция (логарифмическая производная).
`torch.erf(input, out)`	Поэлементная функция ошибок.
`torch.erfc(input, out)`	Поэлементная дополнительная функция ошибок.
`torch.erfinv(input, out)`	Поэлементная обратная функция ошибок.
`torch.exp(input, out)`	Поэлементная экспоненциальная функция.
`torch.exp2(input, out)`	Поэлементное возведение 2 в степень.
`torch.expm1(input, out)`	Поэлементное exp(x) - 1.
`torch.fake_quantize_per_channel_affine(input, scale, zero_point, axis, quant_min, quant_max)`	Имитирует поканальное квантование.
`torch.fake_quantize_per_tensor_affine(input, scale, zero_point, quant_min, quant_max)`	Имитирует по-тензорное квантование.
`torch.fix(input, out)`	Поэлементная целая часть (усечение в сторону нуля).
`torch.float_power(input, exponent, out)`	Поэлементное возведение в степень для чисел с плавающей запятой.
`torch.floor(input, out)`	Поэлементное округление вниз.
`torch.floor_divide(input, other, out)`	Поэлементное целочисленное деление.
`torch.fmod(input, other, out)`	Поэлементный остаток по модулю (остаток).
`torch.frac(input, out)`	Поэлементная дробная часть.
`torch.frexp(input, out)`	Разлагает числа с плавающей запятой на мантиссу и экспоненту.
`torch.gradient(input, dim, spacing, edge_order)`	Вычисляет градиент тензора.
`torch.imag(input, out)`	Возвращает мнимую часть комплексного тензора.
`torch.ldexp(input, other, out)`	Поэлементно вычисляет input * 2**other.
`torch.lerp(input, end, weight, out)`	Поэлементная линейная интерполяция.
`torch.lgamma(input, out)`	Поэлементный логарифм гамма-функции.
`torch.log(input, out)`	Поэлементный натуральный логарифм.
`torch.log10(input, out)`	Поэлементный логарифм по основанию 10.
`torch.log1p(input, out)`	Поэлементно вычисляет log(1 + x).
`torch.log2(input, out)`	Поэлементно вычисляет логарифм по основанию 2.
`torch.logaddexp(input, other, out)`	Поэлементно вычисляет log(exp(input) + exp(other)).
`torch.logaddexp2(input, other, out)`	Поэлементно вычисляет log2(2input + 2other).
`torch.logical_and(input, other, out)`	Поэлементное логическое И.
`torch.logical_not(input, out)`	Поэлементное логическое НЕ.
`torch.logical_or(input, other, out)`	Поэлементное логическое ИЛИ.
`torch.logical_xor(input, other, out)`	Поэлементное логическое исключающее ИЛИ.
`torch.logit(input, eps, out)`	Поэлементная функция logit.
`torch.hypot(input, other, out)`	Поэлементная функция hypot sqrt(input^2 + other^2).
`torch.i0(input, out)`	Поэлементная модифицированная функция Бесселя (первого рода, порядка 0).
`torch.igamma(input, other, out)`	Поэлементная неполная гамма-функция.
`torch.igammac(input, other, out)`	Поэлементная дополнительная неполная гамма-функция.
`torch.mul(input, other, out)`	Поэлементное умножение.
`torch.multiply(input, other, out)`	Поэлементное умножение (то же, что mul).
`torch.mvlgamma(input, p, out)`	Поэлементный логарифм многомерной гамма-функции.
`torch.nan_to_num(input, nan, posinf, neginf, out)`	Заменяет NaN указанным значением.
`torch.neg(input, out)`	Поэлементное отрицание.
`torch.negative(input, out)`	Поэлементное отрицание (то же, что neg).
`torch.nextafter(input, other, out)`	Поэлементно возвращает следующее представимое число с плавающей запятой.
`torch.polygamma(input, n, out)`	Поэлементная полигамма-функция.
`torch.positive(input, out)`	Поэлементное положительное значение.
`torch.pow(input, exponent, out)`	Поэлементное возведение в степень.
`torch.quantized_batch_norm(input, weight, bias, mean, var, eps, output_scale, output_zero_point)`	Квантованная пакетная нормализация.
`torch.quantized_max_pool1d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Квантованный max pooling (1D).
`torch.quantized_max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode)`	Квантованный max pooling (2D).
`torch.rad2deg(input, out)`	Преобразует углы из радиан в градусы.
`torch.real(input, out)`	Возвращает вещественную часть комплексного тензора.
`torch.reciprocal(input, out)`	Поэлементная обратная величина.
`torch.remainder(input, other, out)`	Поэлементный остаток.
`torch.round(input, decimals, out)`	Поэлементное округление до ближайшего целого.
`torch.rsqrt(input, out)`	Поэлементный обратный квадратный корень.
`torch.sigmoid(input, out)`	Поэлементная сигмоидная функция.
`torch.sign(input, out)`	Поэлементно возвращает знак (-1, 0, 1).
`torch.sgn(input, out)`	Поэлементно возвращает вектор знаков.
`torch.signbit(input, out)`	Поэлементно проверяет знаковый бит.
`torch.sin(input, out)`	Поэлементный синус.
`torch.sinc(input, out)`	Поэлементная функция sinc sin(pix)/(pix).
`torch.sinh(input, out)`	Поэлементный гиперболический синус.
`torch.softmax(input, dim, dtype)`	Поэлементная функция softmax.
`torch.sqrt(input, out)`	Поэлементный квадратный корень.
`torch.square(input, out)`	Поэлементное возведение в квадрат.
`torch.sub(input, other, alpha, out)`	Поэлементное вычитание.
`torch.subtract(input, other, alpha, out)`	Поэлементное вычитание (то же, что sub).
`torch.tan(input, out)`	Поэлементный тангенс.
`torch.tanh(input, out)`	Поэлементный гиперболический тангенс.
`torch.true_divide(input, other, out)`	Поэлементное истинное деление.
`torch.trunc(input, out)`	Поэлементное усечение (целая часть).
`torch.xlogy(input, other, out)`	Поэлементно вычисляет input * log(other).

Математические операции — операции редукции

Функция	Описание
`torch.argmax(input, dim, keepdim)`	Возвращает индекс максимального значения вдоль измерения.
`torch.argmin(input, dim, keepdim)`	Возвращает индекс минимального значения вдоль измерения.
`torch.amax(input, dim, keepdim, out)`	Возвращает максимальное значение вдоль измерения.
`torch.amin(input, dim, keepdim, out)`	Возвращает минимальное значение вдоль измерения.
`torch.aminmax(input, dim, keepdim, out)`	Возвращает минимальное и максимальное значения вдоль измерения.
`torch.all(input, dim, keepdim, out)`	Проверяет, все ли элементы равны True.
`torch.any(input, dim, keepdim, out)`	Проверяет, есть ли элементы, равные True.
`torch.max(input, dim, keepdim, out)`	Вычисляет максимум вдоль указанного измерения.
`torch.min(input, dim, keepdim, out)`	Вычисляет минимум вдоль указанного измерения.
`torch.dist(input, other, p)`	Вычисляет расстояние по p-норме между двумя тензорами.
`torch.logsumexp(input, dim, keepdim, out)`	Вычисляет log-sum-exp.
`torch.mean(input, dim, keepdim, out)`	Вычисляет среднее по указанной размерности.
`torch.nanmean(input, dim, keepdim, out)`	Вычисляет среднее по указанной размерности (игнорируя NaNs).
`torch.median(input, dim, keepdim, out)`	Вычисляет медиану по указанной размерности.
`torch.nanmedian(input, dim, keepdim, out)`	Вычисляет медиану по указанной размерности (игнорируя NaNs).
`torch.mode(input, dim, keepdim, out)`	Вычисляет моду по указанной размерности.
`torch.norm(input, p, dim, keepdim, out)`	Вычисляет p-норму.
`torch.nansum(input, dim, keepdim, out)`	Вычисляет сумму по указанной размерности (игнорируя NaNs).
`torch.prod(input, dim, keepdim, dtype, out)`	Вычисляет произведение по указанной размерности.
`torch.quantile(input, q, dim, keepdim, out, method)`	Вычисляет квантиль.
`torch.nanquantile(input, q, dim, keepdim, out, method)`	Вычисляет квантиль (игнорируя NaNs).
`torch.std(input, dim, unbiased, keepdim, out)`	Вычисляет стандартное отклонение.
`torch.std_mean(input, dim, unbiased, keepdim)`	Вычисляет стандартное отклонение и среднее.
`torch.sum(input, dim, keepdim, dtype, out)`	Вычисляет сумму вдоль указанной размерности.
`torch.unique(input, sorted, return_inverse, return_counts, dim)`	Возвращает уникальные элементы.
`torch.unique_consecutive(input, sorted, return_inverse, return_counts, dim)`	Возвращает последовательные уникальные элементы.
`torch.var(input, dim, unbiased, keepdim, out)`	Вычисляет дисперсию.
`torch.var_mean(input, dim, unbiased, keepdim)`	Вычисляет дисперсию и среднее.
`torch.count_nonzero(input, dim)`	Подсчитывает количество ненулевых элементов.
`torch.hash_tensor(input)`	Вычисляет хеш-значение тензора.

Математические операции — операции сравнения

Функция	Описание
`torch.allclose(input, other, rtol, atol, equal_nan)`	Проверяет, близки ли два тензора (все элементы).
`torch.argsort(input, dim, descending, stable)`	Возвращает индексы, которые сортируют тензор.
`torch.eq(input, other, out)`	Поэлементное сравнение на равенство.
`torch.equal(input, other)`	Проверяет, являются ли два тензора точно равными.
`torch.ge(input, other, out)`	Поэлементное сравнение «больше или равно».
`torch.greater_equal(input, other, out)`	Поэлементное сравнение «больше или равно» (то же, что ge).
`torch.gt(input, other, out)`	Поэлементное сравнение «больше».
`torch.greater(input, other, out)`	Поэлементное сравнение «больше» (то же, что gt).
`torch.isclose(input, other, rtol, atol, equal_nan)`	Проверяет, близки ли два тензора (поэлементно).
`torch.isfinite(input, out)`	Проверяет, являются ли значения конечными.
`torch.isin(elements, test_elements, assume_unique, invert)`	Проверяет, принадлежат ли элементы множеству.
`torch.isinf(input, out)`	Проверяет, являются ли значения бесконечными.
`torch.isposinf(input, out)`	Проверяет, являются ли значения положительной бесконечностью.
`torch.isneginf(input, out)`	Проверяет, являются ли значения отрицательной бесконечностью.
`torch.isnan(input, out)`	Проверяет, являются ли значения NaN.
`torch.isreal(input, out)`	Проверяет, являются ли значения вещественными.
`torch.kthvalue(input, k, dim, keepdim, out)`	Возвращает k-й наименьший элемент и его индекс.
`torch.le(input, other, out)`	Поэлементное сравнение на меньше или равно.
`torch.less_equal(input, other, out)`	Поэлементное сравнение на меньше или равно (то же, что le).
`torch.lt(input, other, out)`	Поэлементное сравнение на меньше.
`torch.less(input, other, out)`	Поэлементное сравнение на меньше (то же, что lt).
`torch.maximum(input, other, out)`	Поэлементный максимум.
`torch.minimum(input, other, out)`	Поэлементный минимум.
`torch.fmax(input, other, out)`	Поэлементный максимум (игнорируя NaN).
`torch.fmin(input, other, out)`	Поэлементный минимум (игнорируя NaN).
`torch.ne(input, other, out)`	Поэлементное сравнение на неравенство.
`torch.not_equal(input, other, out)`	Поэлементное сравнение на неравенство (то же, что ne).
`torch.sort(input, dim, descending, stable, out)`	Сортирует вдоль указанного измерения.
`torch.topk(input, k, dim, largest, sorted, out)`	Возвращает k наибольших элементов и их индексы.
`torch.msort(input, out)`	Сортирует вдоль последнего измерения (возвращает отсортированный тензор).

Математические операции — спектральные операции

Функция	Описание
`torch.stft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, return_complex)`	Кратковременное преобразование Фурье.
`torch.istft(input, n_fft, hop_length, win_length, window, center, normalized, onesided, length, return_complex)`	Обратное кратковременное преобразование Фурье.
`torch.bartlett_window(window_length, periodic, dtype, device)`	Окно Бартлетта.
`torch.blackman_window(window_length, periodic, dtype, device)`	Окно Блэкмана.
`torch.hamming_window(window_length, periodic, alpha, beta, dtype, device)`	Окно Хэмминга.
`torch.hann_window(window_length, periodic, dtype, device)`	Окно Ханна.
`torch.kaiser_window(window_length, periodic, beta, dtype, device)`	Окно Кайзера.

Математические операции — другие операции

Функция	Описание
`torch.atleast_1d(*tensors)`	Преобразует вход в тензор как минимум с 1 измерением.
`torch.atleast_2d(*tensors)`	Преобразует вход в тензор как минимум с 2 измерениями.
`torch.atleast_3d(*tensors)`	Преобразует вход в тензор как минимум с 3 измерениями.
`torch.bincount(input, weights, minlength)`	Подсчитывает количество вхождений неотрицательных целых чисел.
`torch.block_diag(*tensors)`	Строит блочно-диагональную матрицу из входного тензора.
`torch.broadcast_tensors(*tensors)`	Транслирует вход к общей форме.
`torch.broadcast_to(input, shape)`	Транслирует тензор к указанной форме.
`torch.broadcast_shapes(*shapes)`	Транслирует формы, чтобы они были совместимы для операций.
`torch.bucketize(input, boundaries, right)`	Сопоставляет вход индексам корзин.
`torch.cartesian_prod(*tensors)`	Вычисляет декартово произведение.
`torch.cdist(x1, x2, p, compute_mode)`	Вычисляет попарные расстояния.
`torch.clone(input, memory_format)`	Возвращает копию тензора.
`torch.combinations(input, r, with_replacement)`	Вычисляет сочетания.
`torch.corrcoef(input)`	Вычисляет матрицу коэффициентов корреляции.
`torch.cov(input, correction, fweights, aweights)`	Вычисляет ковариационную матрицу.
`torch.cross(input, dim, out)`	Вычисляет векторное произведение.
`torch.cummax(input, dim, out)`	Вычисляет накопленный максимум вдоль измерения.
`torch.cummin(input, dim, out)`	Вычисляет накопленный минимум вдоль измерения.
`torch.cumprod(input, dim, out)`	Вычисляет накопленное произведение вдоль измерения.
`torch.cumsum(input, dim, out, dtype)`	Вычисляет накопленную сумму вдоль измерения.
`torch.diag(input, diagonal, out)`	Создаёт диагональную матрицу или извлекает диагональ.
`torch.diag_embed(input, offset, dim1, dim2, out)`	Встраивает входные данные как диагональ.
`torch.diagflat(input, offset, out)`	Создаёт диагональную матрицу (уплощённый вход).
`torch.diagonal(input, offset, dim1, dim2, out)`	Извлекает диагональные элементы.
`torch.diff(input, n, dim, prepend, append, out)`	Вычисляет разность.
`torch.einsum(equation, *operands)`	Соглашение о суммировании Эйнштейна.
`torch.flatten(input, start_dim, end_dim, out)`	Разворачивает тензор.
`torch.ravel(input, out)`	Разворачивает в одномерный тензор.
`torch.kron(input, other, out)`	Вычисляет произведение Кронекера.
`torch.meshgrid(*tensors, indexing)`	Создаёт сетку.
`torch.lcm(input, other, out)`	Поэлементное наименьшее общее кратное.
`torch.logcumsumexp(input, dim, out)`	Кумулятивная log-sum-exp по измерению.
`torch.renorm(input, p, dim, maxnorm, out)`	Перенормирует к заданной норме.
`torch.roll(input, shifts, dims)`	Прокручивает элементы тензора.
`torch.searchsorted(sorted_sequence, values, side, sorter)`	Ищет позиции в отсортированной последовательности.
`torch.tensordot(a, b, dims)`	Вычисляет скалярное произведение тензоров.
`torch.trace(input, out)`	Вычисляет след матрицы.
`torch.tril(input, diagonal, out)`	Извлекает нижнюю треугольную матрицу.
`torch.tril_indices(row, column, offset, dtype, device, layout)`	Генерирует индексы нижнего треугольника.
`torch.triu(input, diagonal, out)`	Извлекает верхнюю треугольную матрицу.
`torch.triu_indices(row, column, offset, dtype, device, layout)`	Генерирует индексы верхнего треугольника.
`torch.unflatten(input, dim, sizes)`	Разворачивает тензор.
`torch.vander(x, N, increasing, out)`	Создаёт матрицу Вандермонда.

Линейная алгебра (BLAS и LAPACK)

Функция	Описание
`torch.addbmm(input, batch1, batch2, beta, alpha, out)`	Пакетное умножение-сложение матриц.
`torch.addmm(input, mat1, mat2, beta, alpha, out)`	Умножение-сложение матриц.
`torch.addmv(input, mat, vec, beta, alpha, out)`	Умножение-сложение матрицы и вектора.
`torch.addr(input, vec1, vec2, beta, alpha, out)`	Добавление внешнего произведения векторов.
`torch.baddbmm(input, batch1, batch2, beta, alpha, out)`	Пакетное матричное умножение-сложение (bmm + add).
`torch.bmm(input, mat2, out)`	Пакетное матричное умножение.
`torch.chain_matmul(*matrices)`	Цепочное матричное умножение.
`torch.cholesky(input, upper, out)`	Разложение Холецкого.
`torch.cholesky_inverse(input, upper, out)`	Обратная матрица через разложение Холецкого.
`torch.cholesky_solve(input, input2, upper, out)`	Решение линейных уравнений с помощью разложения Холецкого.
`torch.dot(input, other, out)`	Вычисляет скалярное произведение двух векторов.
`torch.geqrf(input, out)`	QR-разложение (geqrf).
`torch.ger(input, other, out)`	Вычисляет внешнее произведение векторов.
`torch.inner(input, other, out)`	Вычисляет внутреннее произведение.
`torch.inverse(input, out)`	Вычисляет обратную матрицу.
`torch.det(input, out)`	Вычисляет определитель матрицы.
`torch.logdet(input, out)`	Вычисляет логарифм определителя.
`torch.slogdet(input, out)`	Вычисляет знак и логарифм абсолютной величины определителя.
`torch.lu(input, pivot, get_infos, out)`	LU-разложение.
`torch.lu_solve(input, LU_data, LU_pivots, out)`	Решение с использованием LU-разложения.
`torch.lu_unpack(LU_data, LU_pivots, unpack_data, unpack_pivots)`	Распаковывает результат LU-разложения.
`torch.matmul(input, other, out)`	Умножение матриц (поддерживает разные размерности).
`torch.matrix_power(input, n, out)`	Возведение матрицы в степень.
`torch.matrix_exp(input, out)`	Матричная экспонента.
`torch.mm(input, mat2, out)`	Умножение матриц (2D).
`torch.mv(input, vec, out)`	Умножение матрицы на вектор.
`torch.orgqr(input, q, out)`	Восстанавливает Q из QR-разложения.
`torch.ormqr(input, mat, vec, left, transpose, out)`	Операция ormqr.
`torch.outer(input, other, out)`	Вычисляет внешнее произведение векторов.
`torch.pinverse(input, rcond, out)`	Вычисляет псевдообратную матрицу Мура — Пенроуза.
`torch.qr(input, out)`	QR-разложение.
`torch.svd(input, some, compute_uv, out)`	Сингулярное разложение.
`torch.svd_lowrank(input, q, niter, M)`	Низкоранговая SVD-аппроксимация.
`torch.pca_lowrank(input, q, center, niter)`	Низкоранговая PCA-аппроксимация.
`torch.lobpcg(input, K, B, X, M, P, max_iter, tol, debug, ortho_iparams, fpfloor)`	Решатель задачи на собственные значения LOBPCG.
`torch.trapz(y, x, dim, out)`	Трапециевидное интегрирование (устарело, используйте trapezoid).
`torch.trapezoid(y, x, dim, out)`	Трапециевидное интегрирование.
`torch.cumulative_trapezoid(y, x, dim, out)`	Кумулятивное трапециевидное интегрирование.
`torch.triangular_solve(input, A, upper, transpose, unitriangular, out)`	Решение системы с треугольной матрицей.
`torch.vdot(input, other, out)`	Вычисляет скалярное произведение векторов (с поддержкой комплексных чисел).

Управление устройством

Функция	Описание
`torch.cuda.is_available()`	Проверяет, доступна ли CUDA.
`torch.cuda.device_count()`	Возвращает количество устройств CUDA.
`torch.cuda.current_device()`	Возвращает индекс текущего устройства CUDA.
`torch.cuda.device(name)`	Создаёт объект устройства.
`torch.cuda.device_context(device)`	Создаёт контекст устройства.
`torch.device(device)`	Создаёт объект устройства (например,`'cpu'`или`'cuda:0'`）。
`torch.Tensor.to(device)`	Перемещает тензор на указанное устройство.
`torch.get_device_module(device_type)`	Получает модуль устройства (например, cuda, mps).

Параллельные вычисления

Функция	Описание
`torch.get_num_threads()`	Получает общее количество потоков для операций CPU.
`torch.set_num_threads(int)`	Задаёт количество потоков для операций CPU.
`torch.get_num_interop_threads()`	Получает количество потоков межоперационного параллелизма.
`torch.set_num_interop_threads(int)`	Задаёт количество потоков межоперационного параллелизма.

Вспомогательные функции

Функция	Описание
`torch.compiled_with_cxx11_abi()`	Проверяет, скомпилировано ли с ABI C++11.
`torch.result_type(tensor, other)`	Возвращает dtype результата операции.
`torch.can_cast(from_dtype, to_dtype)`	Проверяет, можно ли преобразовать типы данных.
`torch.promote_types(type1, type2)`	Возвращает повышенный тип данных.
`torch.use_deterministic_algorithms(mode, warn_only)`	Включает/выключает детерминированные алгоритмы.
`torch.are_deterministic_algorithms_enabled()`	Проверяет, включены ли детерминированные алгоритмы.
`torch.is_deterministic_algorithms_warn_only_enabled()`	Проверяет, находятся ли детерминированные алгоритмы в режиме предупреждения.
`torch.set_deterministic_debug_mode(debug_mode)`	Задаёт режим отладки детерминизма.
`torch.get_deterministic_debug_mode()`	Возвращает режим отладки детерминизма.
`torch.set_float32_matmul_precision(precision)`	Задаёт точность для умножения матриц float32.
`torch.get_float32_matmul_precision()`	Возвращает точность для умножения матриц float32.
`torch.set_warn_always(enabled)`	Задаёт, всегда ли отображать предупреждения.
`torch.is_warn_always_enabled()`	Проверяет, всегда ли отображаются предупреждения.
`torch.vmap(fn, in_dims, out_dims, randomness, chunk_size)`	Векторизованное отображение.
`torch._assert(condition, message)`	Проверка утверждений (внутреннее использование).
`torch.typename(t)`	Возвращает строковое представление типа.

Оптимизация компиляции

Функция	Описание
`torch.compile(model, backend, options, dynamic)`	Компилирует модель PyTorch для оптимизации.

Пример

import torch

# Создайте тензор
x = torch.tensor([1, 2, 3])
y = torch.zeros(2, 3)

# Математические операции
z = torch.add(x, 1) # Поэлементное сложение 1
print(z)

# Индексация и срезы
mask = x > 1
selected = torch.masked_select(x, mask)
print(selected)

# Управление устройствами
if torch.cuda.is_available():
device = torch.device('cuda')
x = x.to(device)
print(x.device)

# Операции с матрицами
a = torch.randn(3, 4)
b = torch.randn(4, 5)
c = torch.matmul(a, b)
print(c.shape)

# Вычисление градиента
x = torch.tensor([1., 2., 3.], requires_grad=True)
y = x.sum()
y.backward()
print(x.grad)

Вывод:

tensor([2, 3, 4])
tensor([2, 3])

Для получения более подробной информации, пожалуйста, обратитесь кОфициальной документации PyTorch。

Другие расширения