torch.Tensor

A torch.Tensor is a multi-dimensional matrix containing elements of a single data type.

Типы данных

Torch определяет 10 типов тензоров с вариантами для CPU и GPU, которые представлены следующим образом:

Тип данных	dtype	Тензор CPU	Тензор GPU
32-битное число с плавающей точкой	`torch.float32` или `torch.float`	`torch.FloatTensor`	`torch.cuda.FloatTensor`
64-битное число с плавающей точкой	`torch.float64` или `torch.double`	`torch.DoubleTensor`	`torch.cuda.DoubleTensor`
16-битное число с плавающей точкой [1]	`torch.float16` или `torch.half`	`torch.HalfTensor`	`torch.cuda.HalfTensor`
16-битное число с плавающей точкой [2]	`torch.bfloat16`	`torch.BFloat16Tensor`	`torch.cuda.BFloat16Tensor`
32-битное комплексное число	`torch.complex32` или `torch.chalf`
64-битное комплексное число	`torch.complex64` или `torch.cfloat`
128-битное комплексное число	`torch.complex128` или `torch.cdouble`
8-битное целое число (без знака)	`torch.uint8`	`torch.ByteTensor`	`torch.cuda.ByteTensor`
8-битное целое число (со знаком)	`torch.int8`	`torch.CharTensor`	`torch.cuda.CharTensor`
16-битное целое число (со знаком)	`torch.int16` или `torch.short`	`torch.ShortTensor`	`torch.cuda.ShortTensor`
32-битное целое число (со знаком)	`torch.int32` или `torch.int`	`torch.IntTensor`	`torch.cuda.IntTensor`
64-битное целое число (со знаком)	`torch.int64` или `torch.long`	`torch.LongTensor`	`torch.cuda.LongTensor`
Булево	`torch.bool`	`torch.BoolTensor`	`torch.cuda.BoolTensor`
Квантованное 8-битное целое число (без знака)	`torch.quint8`	`torch.ByteTensor`	/
Квантованное 8-битное целое число (со знаком)	`torch.qint8`	`torch.CharTensor`	/
Квантованное 32-битное целое число (со знаком)	`torch.qint32`	`torch.IntTensor`	/
Квантованное 4-битное целое число (без знака) [3]	`torch.quint4x2`	`torch.ByteTensor`	/

torch.Tensor — псевдоним для типа тензора по умолчанию (torch.FloatTensor).

Инициализация и основные операции

Тензор можно создать из Python-списка или последовательности, используя конструктор torch.tensor():

>>> torch.tensor([[1., -1.], [1., -1.]])
tensor([[ 1.0000, -1.0000],
        [ 1.0000, -1.0000]])
>>> torch.tensor(np.array([[1, 2, 3], [4, 5, 6]]))
tensor([[ 1,  2,  3],
        [ 4,  5,  6]])

Предупреждение

torch.tensor() всегда копирует data. Если у вас есть тензор data и вы хотите изменить только флаг requires_grad, используйте requires_grad_() или detach(), чтобы избежать копирования. Если у вас есть массив NumPy и вы хотите избежать копирования, используйте torch.as_tensor().

Тензор определенного типа можно создать, передав torch.dtype и/или torch.device в конструктор или операцию создания тензора:

>>> torch.zeros([2, 4], dtype=torch.int32)
tensor([[ 0,  0,  0,  0],
        [ 0,  0,  0,  0]], dtype=torch.int32)
>>> cuda0 = torch.device('cuda:0')
>>> torch.ones([2, 4], dtype=torch.float64, device=cuda0)
tensor([[ 1.0000,  1.0000,  1.0000,  1.0000],
        [ 1.0000,  1.0000,  1.0000,  1.0000]], dtype=torch.float64, device='cuda:0')

Дополнительную информацию о создании тензоров см. в разделе Операции создания

Содержание тензора можно получить и изменить с помощью индексации и срезов Python:

>>> x = torch.tensor([[1, 2, 3], [4, 5, 6]])
>>> print(x[1][2])
tensor(6)
>>> x[0][1] = 8
>>> print(x)
tensor([[ 1,  8,  3],
        [ 4,  5,  6]])

Используйте torch.Tensor.item(), чтобы получить число Python из тензора, содержащего одно значение:

>>> x = torch.tensor([[1]])
>>> x
tensor([[ 1]])
>>> x.item()
1
>>> x = torch.tensor(2.5)
>>> x
tensor(2.5000)
>>> x.item()
2.5

Дополнительную информацию об индексации см. в разделе Операции индексации, срезов, объединения, изменения

Тензор можно создать с requires_grad=True, чтобы torch.autograd записывал операции над ним для автоматического дифференцирования.

>>> x = torch.tensor([[1., -1.], [1., 1.]], requires_grad=True)
>>> out = x.pow(2).sum()
>>> out.backward()
>>> x.grad
tensor([[ 2.0000, -2.0000],
        [ 2.0000,  2.0000]])

Каждый тензор имеет связанный torch.Storage, который хранит его данные. Класс тензора также предоставляет многомерный, сдвинутый вид хранилища и определяет числовые операции над ним.

Примечание

Дополнительную информацию о представлениях тензоров см. в разделе Представления тензоров.

Примечание

Дополнительную информацию об атрибутах torch.dtype, torch.device и torch.layout тензора torch.Tensor см. в разделе Атрибуты тензора.

Примечание

Методы, которые изменяют тензор на месте, помечены суффиксом подчеркивания. Например, torch.FloatTensor.abs_() вычисляет абсолютное значение на месте и возвращает измененный тензор, а torch.FloatTensor.abs() вычисляет результат в новом тензоре.

Примечание

Чтобы изменить устройство (torch.device) и/или тип данных (torch.dtype) существующего тензора, используйте метод to() тензора.

Предупреждение

Текущая реализация torch.Tensor вводит избыточное использование памяти, поэтому она может привести к неожиданно высокому использованию памяти в приложениях с множеством мелких тензоров. Если это ваш случай, рассмотрите возможность использования одной большой структуры.

Ссылка на класс тензора

class torch.Tensor

Существует несколько основных способов создания тензора, в зависимости от вашего случая использования.

Чтобы создать тензор с предварительно существующими данными, используйте torch.tensor().
Чтобы создать тензор с заданным размером, используйте torch.* операции создания тензоров (см. Операции создания).
Чтобы создать тензор с таким же размером (и аналогичными типами) как другой тензор, используйте torch.*_like операции создания тензоров (см. Операции создания).
Чтобы создать тензор с похожим типом, но другим размером, чем другой тензор, используйте tensor.new_* операции создания.

Tensor.T

Возвращает представление этого тензора с обратным порядком измерений.

Если n является числом измерений в x, x.T эквивалентно x.permute(n-1, n-2, ..., 0).

Предупреждение

Использование Tensor.T() для тензоров размерности, отличной от 2, для изменения их формы устарело и в будущей версии вызовет ошибку. Рассмотрите использование mT для транспонирования партий матриц или x.permute(*torch.arange(x.ndim - 1, -1, -1)) для изменения порядка измерений тензора.

Tensor.H

Возвращает представление матрицы (двумерного тензора) с сопряжением и транспонированием.

x.H эквивалентно x.transpose(0, 1).conj() для комплексных матриц и x.transpose(0, 1) для вещественных матриц.

См. также

mH: Атрибут, также работающий с партиями матриц.

Tensor.mT

Возвращает представление этого тензора с транспонированными двумя последними измерениями.

x.mT эквивалентно x.transpose(-2, -1).

Tensor.mH: Обращение к этому свойству эквивалентно вызову adjoint().

`Tensor.new_tensor`	Возвращает новый тензор с `data` в качестве данных тензора.
`Tensor.new_full`	Возвращает тензор размера `size` заполненный `fill_value`.
`Tensor.new_empty`	Возвращает тензор размера `size` заполненный неинициализированными данными.
`Tensor.new_ones`	Возвращает тензор размера `size` заполненный `1`.
`Tensor.new_zeros`	Возвращает тензор размера `size` заполненный `0`.
`Tensor.is_cuda`	Истина, если тензор хранится на GPU, `False` в противном случае.
`Tensor.is_quantized`	Истина, если тензор квантован, `False` в противном случае.
`Tensor.is_meta`	Истина, если тензор является мета-тензором, `False` в противном случае.
`Tensor.device`	Это `torch.device`, где находится этот тензор.
`Tensor.grad`	Этот атрибут по умолчанию `None` и становится тензором при первом вызове `backward()` для вычисления градиентов для `self`.
`Tensor.ndim`	Псевдоним для `dim()`
`Tensor.real`	Возвращает новый тензор, содержащий действительные значения тензора `self` для тензора со сложными значениями.
`Tensor.imag`	Возвращает новый тензор, содержащий мнимые значения тензора `self`.
`Tensor.abs`	См. `torch.abs()`
`Tensor.abs_`	Внутрипроцессная версия `abs()`
`Tensor.absolute`	Псевдоним для `abs()`
`Tensor.absolute_`	Внутрипроцессная версия `absolute()` Псевдоним для `abs_()`
`Tensor.acos`	См. `torch.acos()`
`Tensor.acos_`	Внутрипроцессная версия `acos()`
`Tensor.arccos`	См. `torch.arccos()`
`Tensor.arccos_`	Внутрипроцессная версия `arccos()`
`Tensor.add`	Добавить скаляр или тензор к тензору `self`.
`Tensor.add_`	Внутрипроцессная версия `add()`
`Tensor.addbmm`	См. `torch.addbmm()`
`Tensor.addbmm_`	Внутрипроцессная версия `addbmm()`
`Tensor.addcdiv`	См. `torch.addcdiv()`
`Tensor.addcdiv_`	Внутрипроцессная версия `addcdiv()`
`Tensor.addcmul`	См. `torch.addcmul()`
`Tensor.addcmul_`	Внутрипроцессная версия `addcmul()`
`Tensor.addmm`	См. `torch.addmm()`
`Tensor.addmm_`	Внутрипроцессная версия `addmm()`
`Tensor.sspaddmm`	См. `torch.sspaddmm()`
`Tensor.addmv`	См. `torch.addmv()`
`Tensor.addmv_`	Внутрипроцессная версия `addmv()`
`Tensor.addr`	См. `torch.addr()`
`Tensor.addr_`	Внутрипроцессная версия `addr()`

`Tensor.adjoint`	Псевдоним для `adjoint()`
`Tensor.allclose`	См. `torch.allclose()`
`Tensor.amax`	См. `torch.amax()`
`Tensor.amin`	См. `torch.amin()`
`Tensor.aminmax`	См. `torch.aminmax()`
`Tensor.angle`	См. `torch.angle()`
`Tensor.apply_`	Применяет функцию `callable` к каждому элементу в тензоре, заменяя каждый элемент значением, возвращенным `callable`.
`Tensor.argmax`	См. `torch.argmax()`
`Tensor.argmin`	См. `torch.argmin()`
`Tensor.argsort`	См. `torch.argsort()`
`Tensor.argwhere`	См. `torch.argwhere()`
`Tensor.asin`	См. `torch.asin()`
`Tensor.asin_`	Метод для выполнения операции `asin()` на месте.
`Tensor.arcsin`	См. `torch.arcsin()`
`Tensor.arcsin_`	Метод для выполнения операции `arcsin()` на месте.
`Tensor.as_strided`	См. `torch.as_strided()`
`Tensor.atan`	См. `torch.atan()`
`Tensor.atan_`	Метод для выполнения операции `atan()` на месте.
`Tensor.arctan`	См. `torch.arctan()`
`Tensor.arctan_`	Метод для выполнения операции `arctan()` на месте.
`Tensor.atan2`	См. `torch.atan2()`
`Tensor.atan2_`	Метод для выполнения операции `atan2()` на месте.
`Tensor.arctan2`	См. `torch.arctan2()`
`Tensor.arctan2_`	atan2_(other) -> Tensor
`Tensor.all`	См. `torch.all()`
`Tensor.any`	См. `torch.any()`
`Tensor.backward`	Вычисляет градиент текущего тензора по отношению к
`Tensor.baddbmm`	См. `torch.baddbmm()`
`Tensor.baddbmm_`	Метод для выполнения операции `baddbmm()` на месте.
`Tensor.bernoulli`	Возвращает тензор результата, где каждый $\texttt{result[i]}$ независимо сэмплируется из $\text{Bernoulli}(\texttt{self[i]})$ .
`Tensor.bernoulli_`	Заполняет каждое место в `self` независимым сэмплом из $\text{Bernoulli}(\texttt{p})$ .
`Tensor.bfloat16`	`self.bfloat16()` эквивалентно `self.to(torch.bfloat16)`.
`Tensor.bincount`	См. `torch.bincount()`

`Tensor.bitwise_not`	См. `torch.bitwise_not()`
`Tensor.bitwise_not_`	Функция замены на месте для `bitwise_not()`
`Tensor.bitwise_and`	См. `torch.bitwise_and()`
`Tensor.bitwise_and_`	Функция замены на месте для `bitwise_and()`
`Tensor.bitwise_or`	См. `torch.bitwise_or()`
`Tensor.bitwise_or_`	Функция замены на месте для `bitwise_or()`
`Tensor.bitwise_xor`	См. `torch.bitwise_xor()`
`Tensor.bitwise_xor_`	Функция замены на месте для `bitwise_xor()`
`Tensor.bitwise_left_shift`	См. `torch.bitwise_left_shift()`
`Tensor.bitwise_left_shift_`	Функция замены на месте для `bitwise_left_shift()`
`Tensor.bitwise_right_shift`	См. `torch.bitwise_right_shift()`
`Tensor.bitwise_right_shift_`	Функция замены на месте для `bitwise_right_shift()`
`Tensor.bmm`	См. `torch.bmm()`
`Tensor.bool`	Эквивалентно `self.to(torch.bool)`.
`Tensor.byte`	Эквивалентно `self.to(torch.uint8)`.
`Tensor.broadcast_to`	См. `torch.broadcast_to()`.
`Tensor.cauchy_`	Заполняет тензор числами, сгенерированными из распределения Коши:
`Tensor.ceil`	См. `torch.ceil()`
`Tensor.ceil_`	Функция замены на месте для `ceil()`
`Tensor.char`	Эквивалентно `self.to(torch.int8)`.
`Tensor.cholesky`	См. `torch.cholesky()`
`Tensor.cholesky_inverse`	См. `torch.cholesky_inverse()`
`Tensor.cholesky_solve`	См. `torch.cholesky_solve()`
`Tensor.chunk`	См. `torch.chunk()`
`Tensor.clamp`	См. `torch.clamp()`
`Tensor.clamp_`	Функция замены на месте для `clamp()`
`Tensor.clip`	Псевдоним для `clamp()`.
`Tensor.clip_`	Псевдоним для `clamp_()`.
`Tensor.clone`	См. `torch.clone()`
`Tensor.contiguous`	Возвращает непрерывный в памяти тензор, содержащий те же данные, что и тензор `self`.
`Tensor.copy_`	Копирует элементы из `src` в тензор `self` и возвращает `self`.
`Tensor.conj`	См. `torch.conj()`
`Tensor.conj_physical`	См. `torch.conj_physical()`
`Tensor.conj_physical_`	Функция замены на месте для `conj_physical()`

`Tensor.resolve_conj`	См. `torch.resolve_conj()`
`Tensor.resolve_neg`	См. `torch.resolve_neg()`
`Tensor.copysign`	См. `torch.copysign()`
`Tensor.copysign_`	Реализация метода `copysign()` на месте
`Tensor.cos`	См. `torch.cos()`
`Tensor.cos_`	Реализация метода `cos()` на месте
`Tensor.cosh`	См. `torch.cosh()`
`Tensor.cosh_`	Реализация метода `cosh()` на месте
`Tensor.corrcoef`	См. `torch.corrcoef()`
`Tensor.count_nonzero`	См. `torch.count_nonzero()`
`Tensor.cov`	См. `torch.cov()`
`Tensor.acosh`	См. `torch.acosh()`
`Tensor.acosh_`	Реализация метода `acosh()` на месте
`Tensor.arccosh`	acosh() -> Тензор
`Tensor.arccosh_`	acosh_() -> Тензор
`Tensor.cpu`	Возвращает копию объекта в оперативной памяти процессора.
`Tensor.cross`	См. `torch.cross()`
`Tensor.cuda`	Возвращает копию объекта в памяти CUDA.
`Tensor.logcumsumexp`	См. `torch.logcumsumexp()`
`Tensor.cummax`	См. `torch.cummax()`
`Tensor.cummin`	См. `torch.cummin()`
`Tensor.cumprod`	См. `torch.cumprod()`
`Tensor.cumprod_`	Реализация метода `cumprod()` на месте
`Tensor.cumsum`	См. `torch.cumsum()`
`Tensor.cumsum_`	Реализация метода `cumsum()` на месте
`Tensor.chalf`	`self.chalf()` эквивалентно `self.to(torch.complex32)`.
`Tensor.cfloat`	`self.cfloat()` эквивалентно `self.to(torch.complex64)`.
`Tensor.cdouble`	`self.cdouble()` эквивалентно `self.to(torch.complex128)`.
`Tensor.data_ptr`	Возвращает адрес первого элемента тензора `self`.
`Tensor.deg2rad`	См. `torch.deg2rad()`
`Tensor.dequantize`	Для квантованного тензора, деквантизует его и возвращает деквантизованный плавающий тензор.
`Tensor.det`	См. `torch.det()`
`Tensor.dense_dim`	Возвращает количество плотных измерений в разреженном тензоре `self`.
`Tensor.detach`	Возвращает новый тензор, откреплённый от текущей графы.
`Tensor.detach_`	Открепляет тензор от графы, которая его создала, делая его листом.
`Tensor.diag`	См. `torch.diag()`
`Tensor.diag_embed`	См. `torch.diag_embed()`
`Tensor.diagflat`	См. `torch.diagflat()`

`Tensor.diagonal`	См. `torch.diagonal()`
`Tensor.diagonal_scatter`	См. `torch.diagonal_scatter()`
`Tensor.fill_diagonal_`	Заполняет главную диагональ тензора, имеющего по крайней мере 2 измерения.
`Tensor.fmax`	См. `torch.fmax()`
`Tensor.fmin`	См. `torch.fmin()`
`Tensor.diff`	См. `torch.diff()`
`Tensor.digamma`	См. `torch.digamma()`
`Tensor.digamma_`	Реализация метода `digamma()` на месте.
`Tensor.dim`	Возвращает количество измерений тензора `self`.
`Tensor.dist`	См. `torch.dist()`
`Tensor.div`	См. `torch.div()`
`Tensor.div_`	Реализация метода `div()` на месте.
`Tensor.divide`	См. `torch.divide()`
`Tensor.divide_`	Реализация метода `divide()` на месте.
`Tensor.dot`	См. `torch.dot()`
`Tensor.double`	Эквивалентно `self.to(torch.float64)`.
`Tensor.dsplit`	См. `torch.dsplit()`
`Tensor.element_size`	Возвращает размер одного элемента в байтах.
`Tensor.eq`	См. `torch.eq()`
`Tensor.eq_`	Реализация метода `eq()` на месте.
`Tensor.equal`	См. `torch.equal()`
`Tensor.erf`	См. `torch.erf()`
`Tensor.erf_`	Реализация метода `erf()` на месте.
`Tensor.erfc`	См. `torch.erfc()`
`Tensor.erfc_`	Реализация метода `erfc()` на месте.
`Tensor.erfinv`	См. `torch.erfinv()`
`Tensor.erfinv_`	Реализация метода `erfinv()` на месте.
`Tensor.exp`	См. `torch.exp()`
`Tensor.exp_`	Реализация метода `exp()` на месте.
`Tensor.expm1`	См. `torch.expm1()`
`Tensor.expm1_`	Реализация метода `expm1()` на месте.
`Tensor.expand`	Возвращает новую версию тензора `self` с расширенными одиночными измерениями до большего размера.
`Tensor.expand_as`	Расширяет этот тензор до размера, совпадающего с размером `other`.
`Tensor.exponential_`	Заполняет тензор `self` элементами, сгенерированными из экспоненциального распределения:
`Tensor.fix`	См. `torch.fix()`.
`Tensor.fix_`	Реализация метода `fix()` на месте.
`Tensor.fill_`	Заполняет тензор `self` заданным значением.

`Tensor.flatten`	См. `torch.flatten()`
`Tensor.flip`	См. `torch.flip()`
`Tensor.fliplr`	См. `torch.fliplr()`
`Tensor.flipud`	См. `torch.flipud()`
`Tensor.float`	Эквивалентно `self.to(torch.float32)`.
`Tensor.float_power`	См. `torch.float_power()`
`Tensor.float_power_`	Метод по месту для `float_power()`
`Tensor.floor`	См. `torch.floor()`
`Tensor.floor_`	Метод по месту для `floor()`
`Tensor.floor_divide`	См. `torch.floor_divide()`
`Tensor.floor_divide_`	Метод по месту для `floor_divide()`
`Tensor.fmod`	См. `torch.fmod()`
`Tensor.fmod_`	Метод по месту для `fmod()`
`Tensor.frac`	См. `torch.frac()`
`Tensor.frac_`	Метод по месту для `frac()`
`Tensor.frexp`	См. `torch.frexp()`
`Tensor.gather`	См. `torch.gather()`
`Tensor.gcd`	См. `torch.gcd()`
`Tensor.gcd_`	Метод по месту для `gcd()`
`Tensor.ge`	См. `torch.ge()`.
`Tensor.ge_`	Метод по месту для `ge()`.
`Tensor.greater_equal`	См. `torch.greater_equal()`.
`Tensor.greater_equal_`	Метод по месту для `greater_equal()`.
`Tensor.geometric_`	Заполняет `self` тензор элементами, взятыми из геометрического распределения:
`Tensor.geqrf`	См. `torch.geqrf()`
`Tensor.ger`	См. `torch.ger()`
`Tensor.get_device`	Для тензоров CUDA эта функция возвращает порядковый номер устройства GPU, на котором находится тензор.
`Tensor.gt`	См. `torch.gt()`.
`Tensor.gt_`	Метод по месту для `gt()`.
`Tensor.greater`	См. `torch.greater()`.
`Tensor.greater_`	Метод по месту для `greater()`.
`Tensor.half`	Эквивалентно `self.to(torch.float16)`.
`Tensor.hardshrink`	См. `torch.nn.functional.hardshrink()`
`Tensor.heaviside`	См. `torch.heaviside()`
`Tensor.histc`	См. `torch.histc()`
`Tensor.histogram`	См. `torch.histogram()`

`Tensor.hsplit`	См. `torch.hsplit()`
`Tensor.hypot`	См. `torch.hypot()`
`Tensor.hypot_`	Реализация в режиме «на месте» для `hypot()`
`Tensor.i0`	См. `torch.i0()`
`Tensor.i0_`	Реализация в режиме «на месте» для `i0()`
`Tensor.igamma`	См. `torch.igamma()`
`Tensor.igamma_`	Реализация в режиме «на месте» для `igamma()`
`Tensor.igammac`	См. `torch.igammac()`
`Tensor.igammac_`	Реализация в режиме «на месте» для `igammac()`
`Tensor.index_add_`	Накопление элементов `alpha` умноженных на `source` в тензор `self`, добавляя к индексам в указанном порядке из `index`.
`Tensor.index_add`	Вариант вне «на места» для `torch.Tensor.index_add_()`.
`Tensor.index_copy_`	Копирует элементы из `tensor` в тензор `self`, выбирая индексы в порядке, заданном в `index`.
`Tensor.index_copy`	Вариант вне «на места» для `torch.Tensor.index_copy_()`.
`Tensor.index_fill_`	Заполняет элементы тензора `self` значением `value`, выбирая индексы в порядке, заданном в `index`.
`Tensor.index_fill`	Вариант вне «на места» для `torch.Tensor.index_fill_()`.
`Tensor.index_put_`	Размещает значения из тензора `values` в тензор `self` с помощью индексов, указанных в `indices` (который является кортежем тензоров).
`Tensor.index_put`	Вариант вне «на места» для `index_put_()`.
`Tensor.index_reduce_`	Накопление элементов `source` в тензор `self` путем накопления к индексам в заданном порядке из `index` с помощью операции уменьшения, заданной параметром `reduce`.
`Tensor.index_reduce`
`Tensor.index_select`	См. `torch.index_select()`
`Tensor.indices`	Возвращает индексный тензор разреженного тензора COO.
`Tensor.inner`	См. `torch.inner()`.
`Tensor.int`	`self.int()` эквивалентно `self.to(torch.int32)`.
`Tensor.int_repr`	Для квантованного тензора `self.int_repr()` возвращает тензор CPU с типом данных uint8_t, хранящий основанные значения uint8_t данного тензора.
`Tensor.inverse`	См. `torch.inverse()`
`Tensor.isclose`	См. `torch.isclose()`
`Tensor.isfinite`	См. `torch.isfinite()`
`Tensor.isinf`	См. `torch.isinf()`
`Tensor.isposinf`	См. `torch.isposinf()`
`Tensor.isneginf`	См. `torch.isneginf()`
`Tensor.isnan`	См. `torch.isnan()`
`Tensor.is_contiguous`	Возвращает True, если тензор `self` непрерывен в памяти в порядке, заданном форматированием памяти.
`Tensor.is_complex`	Возвращает True, если тип данных `self` является комплексным типом данных.
`Tensor.is_conj`	Возвращает True, если бит сопряжения для `self` установлен в true.

`Tensor.is_floating_point`	Возвращает True, если тип данных `self` является типом с плавающей точкой.
`Tensor.is_inference`	См. `torch.is_inference()`
`Tensor.is_leaf`	Все тензоры, у которых `requires_grad` является `False`, по умолчанию будут лист-тензорами.
`Tensor.is_pinned`	Возвращает true, если этот тензор находится в закреплённой памяти.
`Tensor.is_set_to`	Возвращает True, если оба тензора указывают на одну и ту же память (тот же хранилище, смещение, размер и шаг).
`Tensor.is_shared`	Проверяет, находится ли тензор в общей памяти.
`Tensor.is_signed`	Возвращает True, если тип данных `self` является типом со знаком.
`Tensor.is_sparse`	Является `True`, если тензор использует разреженную схему хранения, `False` в противном случае.
`Tensor.istft`	См. `torch.istft()`
`Tensor.isreal`	См. `torch.isreal()`
`Tensor.item`	Возвращает значение этого тензора как стандартное число Python.
`Tensor.kthvalue`	См. `torch.kthvalue()`
`Tensor.lcm`	См. `torch.lcm()`
`Tensor.lcm_`	Метод замены для `lcm()`
`Tensor.ldexp`	См. `torch.ldexp()`
`Tensor.ldexp_`	Метод замены для `ldexp()`
`Tensor.le`	См. `torch.le()`.
`Tensor.le_`	Метод замены для `le()`.
`Tensor.less_equal`	См. `torch.less_equal()`.
`Tensor.less_equal_`	Метод замены для `less_equal()`.
`Tensor.lerp`	См. `torch.lerp()`
`Tensor.lerp_`	Метод замены для `lerp()`
`Tensor.lgamma`	См. `torch.lgamma()`
`Tensor.lgamma_`	Метод замены для `lgamma()`
`Tensor.log`	См. `torch.log()`
`Tensor.log_`	Метод замены для `log()`
`Tensor.logdet`	См. `torch.logdet()`
`Tensor.log10`	См. `torch.log10()`
`Tensor.log10_`	Метод замены для `log10()`
`Tensor.log1p`	См. `torch.log1p()`
`Tensor.log1p_`	Метод замены для `log1p()`
`Tensor.log2`	См. `torch.log2()`
`Tensor.log2_`	Метод замены для `log2()`
`Tensor.log_normal_`	Заполняет `self` тензор числами, сгенерированными из лог-нормального распределения, параметризованного заданным средним значением $\mu$ и стандартным отклонением $\sigma$ .
`Tensor.logaddexp`	См. `torch.logaddexp()`

`Tensor.logaddexp2`	См. `torch.logaddexp2()`
`Tensor.logsumexp`	См. `torch.logsumexp()`
`Tensor.logical_and`	См. `torch.logical_and()`
`Tensor.logical_and_`	Метод замены местами, соответствующий `logical_and()`
`Tensor.logical_not`	См. `torch.logical_not()`
`Tensor.logical_not_`	Метод замены местами, соответствующий `logical_not()`
`Tensor.logical_or`	См. `torch.logical_or()`
`Tensor.logical_or_`	Метод замены местами, соответствующий `logical_or()`
`Tensor.logical_xor`	См. `torch.logical_xor()`
`Tensor.logical_xor_`	Метод замены местами, соответствующий `logical_xor()`
`Tensor.logit`	См. `torch.logit()`
`Tensor.logit_`	Метод замены местами, соответствующий `logit()`
`Tensor.long`	Эквивалентно `self.to(torch.int64)`.
`Tensor.lt`	См. `torch.lt()`.
`Tensor.lt_`	Метод замены местами, соответствующий `lt()`.
`Tensor.less`	lt(other) -> Tensor
`Tensor.less_`	Метод замены местами, соответствующий `less()`.
`Tensor.lu`	См. `torch.lu()`
`Tensor.lu_solve`	См. `torch.lu_solve()`
`Tensor.as_subclass`	Создаёт экземпляр `cls` с тем же указателем данных, что и `self`.
`Tensor.map_`	Применяет `callable` к каждому элементу тензора `self` и заданному `tensor`, сохраняя результаты в тензоре `self`.
`Tensor.masked_scatter_`	Копирует элементы из тензора `source` в тензор `self` в позиции, где `mask` равно True.
`Tensor.masked_scatter`	Версия без замены местами метода `torch.Tensor.masked_scatter_()`
`Tensor.masked_fill_`	Заполняет элементы тензора `self` значением `value` там, где `mask` равно True.
`Tensor.masked_fill`	Версия без замены местами метода `torch.Tensor.masked_fill_()`
`Tensor.masked_select`	См. `torch.masked_select()`
`Tensor.matmul`	См. `torch.matmul()`
`Tensor.matrix_power`	Примечание `matrix_power()` устарел, используйте `torch.linalg.matrix_power()`.
`Tensor.matrix_exp`	См. `torch.matrix_exp()`
`Tensor.max`	См. `torch.max()`
`Tensor.maximum`	См. `torch.maximum()`
`Tensor.mean`	См. `torch.mean()`
`Tensor.nanmean`	См. `torch.nanmean()`

`Tensor.median`	См. `torch.median()`
`Tensor.nanmedian`	См. `torch.nanmedian()`
`Tensor.min`	См. `torch.min()`
`Tensor.minimum`	См. `torch.minimum()`
`Tensor.mm`	См. `torch.mm()`
`Tensor.smm`	См. `torch.smm()`
`Tensor.mode`	См. `torch.mode()`
`Tensor.movedim`	См. `torch.movedim()`
`Tensor.moveaxis`	См. `torch.moveaxis()`
`Tensor.msort`	См. `torch.msort()`
`Tensor.mul`	См. `torch.mul()`.
`Tensor.mul_`	Метод-модификатор для `mul()`.
`Tensor.multiply`	См. `torch.multiply()`.
`Tensor.multiply_`	Метод-модификатор для `multiply()`.
`Tensor.multinomial`	См. `torch.multinomial()`
`Tensor.mv`	См. `torch.mv()`
`Tensor.mvlgamma`	См. `torch.mvlgamma()`
`Tensor.mvlgamma_`	Метод-модификатор для `mvlgamma()`
`Tensor.nansum`	См. `torch.nansum()`
`Tensor.narrow`	См. `torch.narrow()`
`Tensor.narrow_copy`	См. `torch.narrow_copy()`.
`Tensor.ndimension`	Псевдоним для `dim()`
`Tensor.nan_to_num`	См. `torch.nan_to_num()`.
`Tensor.nan_to_num_`	Метод-модификатор для `nan_to_num()`.
`Tensor.ne`	См. `torch.ne()`.
`Tensor.ne_`	Метод-модификатор для `ne()`.
`Tensor.not_equal`	См. `torch.not_equal()`.
`Tensor.not_equal_`	Метод-модификатор для `not_equal()`.
`Tensor.neg`	См. `torch.neg()`
`Tensor.neg_`	Метод-модификатор для `neg()`
`Tensor.negative`	См. `torch.negative()`
`Tensor.negative_`	Метод-модификатор для `negative()`
`Tensor.nelement`	Псевдоним для `numel()`
`Tensor.nextafter`	См. `torch.nextafter()`
`Tensor.nextafter_`	Метод-модификатор для `nextafter()`

END_OF_DOCUMENT_MARKER

`Tensor.nonzero`	См. `torch.nonzero()`
`Tensor.norm`	См. `torch.norm()`
`Tensor.normal_`	Заполняет тензор `self` элементами, сэмплированными из нормального распределения, заданного параметрами `mean` и `std`.
`Tensor.numel`	См. `torch.numel()`
`Tensor.numpy`	Возвращает тензор в виде массива NumPy `ndarray`.
`Tensor.orgqr`	См. `torch.orgqr()`
`Tensor.ormqr`	См. `torch.ormqr()`
`Tensor.outer`	См. `torch.outer()`.
`Tensor.permute`	См. `torch.permute()`
`Tensor.pin_memory`	Копирует тензор в закреплённую память, если он не закреплён.
`Tensor.pinverse`	См. `torch.pinverse()`
`Tensor.polygamma`	См. `torch.polygamma()`
`Tensor.polygamma_`	Функция с заменой в месте для `polygamma()`
`Tensor.positive`	См. `torch.positive()`
`Tensor.pow`	См. `torch.pow()`
`Tensor.pow_`	Функция с заменой в месте для `pow()`
`Tensor.prod`	См. `torch.prod()`
`Tensor.put_`	Копирует элементы из `source` в позиции, указанные в `index`.
`Tensor.qr`	См. `torch.qr()`
`Tensor.qscheme`	Возвращает схему квантования данного QТензора.
`Tensor.quantile`	См. `torch.quantile()`
`Tensor.nanquantile`	См. `torch.nanquantile()`
`Tensor.q_scale`	Для тензора, квантованного линейным (аффинным) квантованием, возвращает масштаб базового квантозатора.
`Tensor.q_zero_point`	Для тензора, квантованного линейным (аффинным) квантованием, возвращает значение zero_point базового квантозатора.
`Tensor.q_per_channel_scales`	Для тензора, квантованного линейным (аффинным) канальным квантованием, возвращает тензор масштабов базового квантозатора.
`Tensor.q_per_channel_zero_points`	Для тензора, квантованного линейным (аффинным) канальным квантованием, возвращает тензор значений zero_point базового квантозатора.
`Tensor.q_per_channel_axis`	Для тензора, квантованного линейным (аффинным) канальным квантованием, возвращает индекс измерения, по которому применяется канальное квантование.
`Tensor.rad2deg`	См. `torch.rad2deg()`
`Tensor.random_`	Заполняет тензор `self` числами, сэмплированными из дискретного равномерного распределения по `[from, to - 1]`.
`Tensor.ravel`	см. `torch.ravel()`
`Tensor.reciprocal`	См. `torch.reciprocal()`
`Tensor.reciprocal_`	Функция с заменой в месте для `reciprocal()`
`Tensor.record_stream`	Гарантирует, что память тензора не будет повторно использована для другого тензора, пока не завершится вся текущая работа, помещённая в `stream`.
`Tensor.register_hook`	Регистрирует обратную функцию.
`Tensor.remainder`	См. `torch.remainder()`
`Tensor.remainder_`	Функция с заменой в месте для `remainder()`

`Tensor.renorm`	См. `torch.renorm()`
`Tensor.renorm_`	Встроенная версия `renorm()`
`Tensor.repeat`	Повторяет этот тензор вдоль указанных измерений.
`Tensor.repeat_interleave`	См. `torch.repeat_interleave()`.
`Tensor.requires_grad`	Равен `True`, если для этого тензора требуется вычисление градиентов, `False` в противном случае.
`Tensor.requires_grad_`	Изменяет, если автограду следует записывать операции над этим тензором: устанавливает атрибут `requires_grad` этого тензора на месте.
`Tensor.reshape`	Возвращает тензор с теми же данными и количеством элементов, что и `self`, но с указанной формой.
`Tensor.reshape_as`	Возвращает этот тензор в той же форме, что и `other`.
`Tensor.resize_`	Изменяет размер тензора `self` до указанного размера.
`Tensor.resize_as_`	Изменяет размер тензора `self` на тот же размер, что и указанный `tensor`.
`Tensor.retain_grad`	Включает возможность заполнения `grad` этого тензора во время `backward()`.
`Tensor.retains_grad`	Равен `True`, если этот тензор не является листом, и его `grad` включен для заполнения во время `backward()`, `False` в противном случае.
`Tensor.roll`	См. `torch.roll()`
`Tensor.rot90`	См. `torch.rot90()`
`Tensor.round`	См. `torch.round()`
`Tensor.round_`	Встроенная версия `round()`
`Tensor.rsqrt`	См. `torch.rsqrt()`
`Tensor.rsqrt_`	Встроенная версия `rsqrt()`
`Tensor.scatter`	Внешняя версия `torch.Tensor.scatter_()`
`Tensor.scatter_`	Записывает все значения из тензора `src` в `self` по индексам, указанным в тензоре `index`.
`Tensor.scatter_add_`	Добавляет все значения из тензора `src` в `self` по индексам, указанным в тензоре `index`, аналогично `scatter_()`.
`Tensor.scatter_add`	Внешняя версия `torch.Tensor.scatter_add_()`
`Tensor.scatter_reduce_`	Применяет уменьшение к всем значениям из тензора `src` по индексам, указанным в тензоре `index`, в тензоре `self` с помощью заданного уменьшения, определенного аргументом `reduce` (`"sum"`, `"prod"`, `"mean"`, `"amax"`, `"amin"`).
`Tensor.scatter_reduce`	Внешняя версия `torch.Tensor.scatter_reduce_()`
`Tensor.select`	См. `torch.select()`
`Tensor.select_scatter`	См. `torch.select_scatter()`
`Tensor.set_`	Устанавливает базовое хранилище, размер и шаги.
`Tensor.share_memory_`	Перемещает базовое хранилище в общую память.
`Tensor.short`	`self.short()` эквивалентно `self.to(torch.int16)`.
`Tensor.sigmoid`	См. `torch.sigmoid()`
`Tensor.sigmoid_`	Встроенная версия `sigmoid()`
`Tensor.sign`	См. `torch.sign()`
`Tensor.sign_`	Встроенная версия `sign()`
`Tensor.signbit`	См. `torch.signbit()`

`Tensor.sgn`	См. `torch.sgn()`
`Tensor.sgn_`	Операция `sgn()` на месте.
`Tensor.sin`	См. `torch.sin()`
`Tensor.sin_`	Операция `sin()` на месте.
`Tensor.sinc`	См. `torch.sinc()`
`Tensor.sinc_`	Операция `sinc()` на месте.
`Tensor.sinh`	См. `torch.sinh()`
`Tensor.sinh_`	Операция `sinh()` на месте.
`Tensor.asinh`	См. `torch.asinh()`
`Tensor.asinh_`	Операция `asinh()` на месте.
`Tensor.arcsinh`	См. `torch.arcsinh()`
`Tensor.arcsinh_`	Операция `arcsinh()` на месте.
`Tensor.size`	Возвращает размер `self` тензора.
`Tensor.slogdet`	См. `torch.slogdet()`
`Tensor.slice_scatter`	См. `torch.slice_scatter()`
`Tensor.sort`	См. `torch.sort()`
`Tensor.split`	См. `torch.split()`
`Tensor.sparse_mask`	Возвращает новый разреженный тензор со значениями из строченного тензора `self`, отфильтрованные по индексам разреженного тензора `mask`.
`Tensor.sparse_dim`	Возвращает количество разреженных измерений в разреженном тензоре `self`.
`Tensor.sqrt`	См. `torch.sqrt()`
`Tensor.sqrt_`	Операция `sqrt()` на месте.
`Tensor.square`	См. `torch.square()`
`Tensor.square_`	Операция `square()` на месте.
`Tensor.squeeze`	См. `torch.squeeze()`
`Tensor.squeeze_`	Операция `squeeze()` на месте.
`Tensor.std`	См. `torch.std()`
`Tensor.stft`	См. `torch.stft()`
`Tensor.storage`	Возвращает базовое хранилище.
`Tensor.storage_offset`	Возвращает смещение тензора в базовом хранилище в терминах элементов хранилища (а не байтов).
`Tensor.storage_type`	Возвращает тип базового хранилища.
`Tensor.stride`	Возвращает шаг `self` тензора.
`Tensor.sub`	См. `torch.sub()`.
`Tensor.sub_`	Операция `sub()` на месте.
`Tensor.subtract`	См. `torch.subtract()`.
`Tensor.subtract_`	Операция `subtract()` на месте.
`Tensor.sum`	См. `torch.sum()`

`Tensor.sum_to_size`	Суммирование тензора к заданному размеру.
`Tensor.svd`	См. `torch.svd()`
`Tensor.swapaxes`	См. `torch.swapaxes()`
`Tensor.swapdims`	См. `torch.swapdims()`
`Tensor.symeig`	См. `torch.symeig()`
`Tensor.t`	См. `torch.t()`
`Tensor.t_`	Метод для изменения тензора на месте (in-place) аналогично `t()`.
`Tensor.tensor_split`	См. `torch.tensor_split()`
`Tensor.tile`	См. `torch.tile()`
`Tensor.to`	Преобразование типа и/или устройства тензора.
`Tensor.to_mkldnn`	Возвращает копию тензора в формате `torch.mkldnn`.
`Tensor.take`	См. `torch.take()`
`Tensor.take_along_dim`	См. `torch.take_along_dim()`
`Tensor.tan`	См. `torch.tan()`
`Tensor.tan_`	Метод для изменения тензора на месте (in-place) аналогично `tan()`
`Tensor.tanh`	См. `torch.tanh()`
`Tensor.tanh_`	Метод для изменения тензора на месте (in-place) аналогично `tanh()`
`Tensor.atanh`	См. `torch.atanh()`
`Tensor.atanh_`	Метод для изменения тензора на месте (in-place) аналогично `atanh()`
`Tensor.arctanh`	См. `torch.arctanh()`
`Tensor.arctanh_`	Метод для изменения тензора на месте (in-place) аналогично `arctanh()`
`Tensor.tolist`	Возвращает тензор в виде (вложенного) списка.
`Tensor.topk`	См. `torch.topk()`
`Tensor.to_dense`	Создаёт копию тензора в плотной форме (strided), если `self` не является тензором в плотной форме (strided), в противном случае возвращает `self`.
`Tensor.to_sparse`	Возвращает копию тензора в разреженной форме.
`Tensor.to_sparse_csr`	Преобразует тензор в формат сжатого хранения строк (CSR).
`Tensor.to_sparse_csc`	Преобразует тензор в формат сжатого хранения столбцов (CSC).
`Tensor.to_sparse_bsr`	Преобразует тензор CSR в формат сжатого хранения блочных строк (BSR) заданного размера блока.
`Tensor.to_sparse_bsc`	Преобразует тензор CSR в формат сжатого хранения блочных столбцов (BSC) заданного размера блока.
`Tensor.trace`	См. `torch.trace()`
`Tensor.transpose`	См. `torch.transpose()`
`Tensor.transpose_`	Метод для изменения тензора на месте (in-place) аналогично `transpose()`
`Tensor.triangular_solve`	См. `torch.triangular_solve()`
`Tensor.tril`	См. `torch.tril()`
`Tensor.tril_`	Метод для изменения тензора на месте (in-place) аналогично `tril()`
`Tensor.triu`	См. `torch.triu()`
`Tensor.triu_`	Метод для изменения тензора на месте (in-place) аналогично `triu()`

END_OF_DOCUMENT_MARKER

`Tensor.true_divide`	См. `torch.true_divide()`
`Tensor.true_divide_`	Встроенная версия `true_divide_()`
`Tensor.trunc`	См. `torch.trunc()`
`Tensor.trunc_`	Встроенная версия `trunc()`
`Tensor.type`	Возвращает тип, если `dtype` не задан, в противном случае преобразует этот объект к указанному типу.
`Tensor.type_as`	Возвращает этот тензор, преобразованный к типу заданного тензора.
`Tensor.unbind`	См. `torch.unbind()`
`Tensor.unflatten`	См. `torch.unflatten()`.
`Tensor.unfold`	Возвращает представление исходного тензора, содержащего все срезы размером `size` из тензора `self` в измерении `dimension`.
`Tensor.uniform_`	Заполняет тензор `self` числами, сгенерированными из непрерывного равномерного распределения:
`Tensor.unique`	Возвращает уникальные элементы входного тензора.
`Tensor.unique_consecutive`	Удаляет все, кроме первого элемента, из каждой последовательной группы эквивалентных элементов.
`Tensor.unsqueeze`	См. `torch.unsqueeze()`
`Tensor.unsqueeze_`	Встроенная версия `unsqueeze()`
`Tensor.values`	Возвращает тензор значений разреженного тензора COO.
`Tensor.var`	См. `torch.var()`
`Tensor.vdot`	См. `torch.vdot()`
`Tensor.view`	Возвращает новый тензор с теми же данными, что и тензор `self`, но с другим `shape`.
`Tensor.view_as`	Представляет этот тензор таким же размером, как `other`.
`Tensor.vsplit`	См. `torch.vsplit()`
`Tensor.where`	`self.where(condition, y)` эквивалентно `torch.where(condition, self, y)`.
`Tensor.xlogy`	См. `torch.xlogy()`
`Tensor.xlogy_`	Встроенная версия `xlogy()`
`Tensor.zero_`	Заполняет тензор `self` нулями.

© 2024, PyTorch Contributors
PyTorch has a BSD-style license, as found in the LICENSE file.
https://pytorch.org/docs/1.13/tensors.html