torch.Tensor

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

Типы данных

Torch defines 10 tensor types with CPU and GPU variants, которые представлены ниже:

Тип данных	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`	/

1: Иногда обозначается как binary16: использует 1 бит для знака, 5 бит для порядка и 10 бит для мантиссы. Полезно, когда важна точность в ущерб диапазону.
2: Иногда обозначается как Brain Floating Point: использует 1 бит для знака, 8 бит для порядка и 7 бит для мантиссы. Полезно, когда важен диапазон, так как имеет такое же количество битов порядка, как float32.
3: Квантизованное 4-битное целое число хранится как 8-битное целое число со знаком. В настоящее время поддерживается только в операции EmbeddingBag.

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

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

Тензор можно создать из Python list или последовательности, используя конструктор 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 вносит избыточные расходы на память, что может привести к неожиданно высокому потреблению памяти в приложениях с множеством очень маленьких тензоров. Если это ваш случай, рассмотрите использование одной большой структуры.

Справочник по классу Tensor

class torch.Tensor

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

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

END_OF_DOCUMENT_MARKER

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)) для изменения размерности тензора.

END_OF_DOCUMENT_MARKER

Tensor.H

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

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`	Будет `True`, если тензор хранится на GPU, `False` в противном случае.
`Tensor.is_quantized`	Будет `True`, если тензор квантован, `False` в противном случае.
`Tensor.is_meta`	Будет `True`, если тензор — мета-тензор, `False` в противном случае.
`Tensor.device`	Устройство `torch.device`, на котором находится этот тензор.
`Tensor.grad`	Это свойство по умолчанию `None` и становится тензором в первый раз, когда вызов `backward()` вычисляет градиенты для `self`.
`Tensor.ndim`	Псевдоним для `dim()`
`Tensor.real`	Возвращает новый тензор, содержащий вещественные значения тензора `self` для входного тензора с комплексными значениями.
`Tensor.imag`	Возвращает новый тензор, содержащий мнимые значения тензора `self`.
`Tensor.nbytes`	Возвращает количество байтов, потребляемых «представлением» элементов тензора, если тензор не использует схему хранения разреженных данных.
`Tensor.itemsize`	Псевдоним для `element_size()`
`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)`.

END_OF_DOCUMENT_MARKER

Tensor.bincount

См. torch.bincount()

END_OF_DOCUMENT_MARKER

`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.bool()` эквивалентно `self.to(torch.bool)`.
`Tensor.byte`	`self.byte()` эквивалентно `self.to(torch.uint8)`.
`Tensor.broadcast_to`	См. `torch.broadcast_to()`.
`Tensor.cauchy_`	Заполняет тензор числами, сгенерированными из распределения Коши:
`Tensor.ceil`	См. `torch.ceil()`
`Tensor.ceil_`	Метод заменяющий на месте `ceil()`
`Tensor.char`	`self.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()`

END_OF_DOCUMENT_MARKER

`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`	Возвращает адрес первого элемента тензора в памяти.
`Tensor.deg2rad`	См. `torch.deg2rad()`
`Tensor.dequantize`	Для квантизованного тензора, деквантизует его и возвращает тензор с плавающей точкой.
`Tensor.det`	См. `torch.det()`
`Tensor.dense_dim`	Возвращает количество плотных измерений в разреженном тензоре.
`Tensor.detach`	Возвращает новый тензор, отключенный от текущей вычислительной графы.
`Tensor.detach_`	Отключает тензор от вычислительной графы, которая его создала, превращая его в лист.
`Tensor.diag`	См. `torch.diag()`
`Tensor.diag_embed`	См. `torch.diag_embed()`
`Tensor.diagflat`	См. `torch.diagflat()`

END_OF_DOCUMENT_MARKER

`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`	Возвращает количество измерений тензора.
`Tensor.dim_order`	Возвращает кортеж целых чисел, описывающий порядок измерений или физическую структуру тензора.
`Tensor.dist`	См. `torch.dist()`
`Tensor.div`	См. `torch.div()`
`Tensor.div_`	Метод-обёртка для `div()` (работает на месте).
`Tensor.divide`	См. `torch.divide()`
`Tensor.divide_`	Метод-обёртка для `divide()` (работает на месте).
`Tensor.dot`	См. `torch.dot()`
`Tensor.double`	Эквивалентно `eq()`.
`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`	Возвращает новый вид тензора с расширенными размерами одиночных измерений.
`Tensor.expand_as`	Расширяет тензор до размера тензора.
`Tensor.exponential_`	Заполняет тензор элементами, сгенерированными из экспоненциального распределения:
`Tensor.fix`	См. `torch.fix()`.
`Tensor.fix_`	Метод-обёртка для `fix()` (работает на месте).

Tensor.fill_

Заполняет тензор заданным значением.

`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()`

END_OF_DOCUMENT_MARKER

`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 — тип с плавающей точкой.

END_OF_DOCUMENT_MARKER

`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`, если тензор использует схему хранения COO для разреженных тензоров, `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()`

END_OF_DOCUMENT_MARKER

`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()`

END_OF_DOCUMENT_MARKER

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_`	Метод, выполняющий операцию над исходным массивом (inplace) `mul()`.
`Tensor.multiply`	См. `torch.multiply()`.
`Tensor.multiply_`	Метод, выполняющий операцию над исходным массивом (inplace) `multiply()`.
`Tensor.multinomial`	См. `torch.multinomial()`
`Tensor.mv`	См. `torch.mv()`
`Tensor.mvlgamma`	См. `torch.mvlgamma()`
`Tensor.mvlgamma_`	Метод, выполняющий операцию над исходным массивом (inplace) `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_`	Метод, выполняющий операцию над исходным массивом (inplace) `nan_to_num()`.
`Tensor.ne`	См. `torch.ne()`.
`Tensor.ne_`	Метод, выполняющий операцию над исходным массивом (inplace) `ne()`.
`Tensor.not_equal`	См. `torch.not_equal()`.
`Tensor.not_equal_`	Метод, выполняющий операцию над исходным массивом (inplace) `not_equal()`.
`Tensor.neg`	См. `torch.neg()`
`Tensor.neg_`	Метод, выполняющий операцию над исходным массивом (inplace) `neg()`
`Tensor.negative`	См. `torch.negative()`
`Tensor.negative_`	Метод, выполняющий операцию над исходным массивом (inplace) `negative()`
`Tensor.nelement`	Псевдоним для `numel()`
`Tensor.nextafter`	См. `torch.nextafter()`
`Tensor.nextafter_`	Метод, выполняющий операцию над исходным массивом (inplace) `nextafter()`
`Tensor.nonzero`	См. `torch.nonzero()`

Tensor.norm

См. torch.norm()

`Tensor.normal_`	Заполняет тензор элементами, сгенерированными из нормального распределения, параметризованного `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()` в режиме in-place.
`Tensor.positive`	См. `torch.positive()`
`Tensor.pow`	См. `torch.pow()`
`Tensor.pow_`	Функция `pow()` в режиме in-place.
`Tensor.prod`	См. `torch.prod()`
`Tensor.put_`	Копирует элементы из `source` в позиции, указанные `index`.
`Tensor.qr`	См. `torch.qr()`
`Tensor.qscheme`	Возвращает схему квантования данного QTensor.
`Tensor.quantile`	См. `torch.quantile()`
`Tensor.nanquantile`	См. `torch.nanquantile()`
`Tensor.q_scale`	Для тензора, квантованного линейным (аффинным) квантованием, возвращает масштаб базового квантователя.
`Tensor.q_zero_point`	Для тензора, квантованного линейным (аффинным) квантованием, возвращает смещение базового квантователя.
`Tensor.q_per_channel_scales`	Для тензора, квантованного линейным (аффинным) квантованием по каналам, возвращает тензор масштабов базового квантователя.
`Tensor.q_per_channel_zero_points`	Для тензора, квантованного линейным (аффинным) квантованием по каналам, возвращает тензор смещений базового квантователя.
`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()` в режиме in-place.
`Tensor.record_stream`	Убеждается, что память тензора не используется повторно для другого тензора до тех пор, пока не завершится вся текущая работа, помещённая в очередь на `stream`.
`Tensor.register_hook`	Регистрирует обратный хук.
`Tensor.register_post_accumulate_grad_hook`	Регистрирует обратный хук, выполняющийся после накопления градиента.
`Tensor.remainder`	См. `torch.remainder()`
`Tensor.remainder_`	Функция `remainder()` в режиме in-place.
`Tensor.renorm`	См. `torch.renorm()`

END_OF_DOCUMENT_MARKER

`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.shape`	Возвращает размер тензора `self`.
`Tensor.size`	Возвращает размер тензора `self`.
`Tensor.slogdet`	См. `torch.slogdet()`
`Tensor.slice_scatter`	См. `torch.slice_scatter()`
`Tensor.softmax`	Псевдоним для `torch.nn.functional.softmax()`.
`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`	Возвращает базовое хранилище `TypedStorage`.
`Tensor.untyped_storage`	Возвращает базовое хранилище `UntypedStorage`.
`Tensor.storage_offset`	Возвращает смещение тензора `self` в базовом хранилище в единицах элементов хранилища.
`Tensor.storage_type`	Возвращает тип базового хранилища.
`Tensor.stride`	Возвращает шаг тензора `self`.
`Tensor.sub`	См. `torch.sub()`.
`Tensor.sub_`	Метод для изменения значения на месте, эквивалентный `sub()`

END_OF_DOCUMENT_MARKER

Tensor.subtract

См. torch.subtract().

`Tensor.subtract_`	Временная версия `subtract()`.
`Tensor.sum`	См. `torch.sum()`
`Tensor.sum_to_size`	Сумма `this` тензора до `size`.
`Tensor.svd`	См. `torch.svd()`
`Tensor.swapaxes`	См. `torch.swapaxes()`
`Tensor.swapdims`	См. `torch.swapdims()`
`Tensor.t`	См. `torch.t()`
`Tensor.t_`	Временная версия `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_`	Временная версия `tan()`
`Tensor.tanh`	См. `torch.tanh()`
`Tensor.tanh_`	Временная версия `tanh()`
`Tensor.atanh`	См. `torch.atanh()`
`Tensor.atanh_`	Временная версия `atanh()`
`Tensor.arctanh`	См. `torch.arctanh()`
`Tensor.arctanh_`	Временная версия `arctanh()`
`Tensor.tolist`	Возвращает тензор как (вложенный) список.
`Tensor.topk`	См. `torch.topk()`
`Tensor.to_dense`	Создает перемещаемую копию `self` если `self` не является перемещаемым тензором, в противном случае возвращает `self`.
`Tensor.to_sparse`	Возвращает разреженную копию тензора.
`Tensor.to_sparse_csr`	Преобразует тензор в формат сжатого хранения строк (CSR).
`Tensor.to_sparse_csc`	Преобразует тензор в формат сжатого хранения столбцов (CSC).
`Tensor.to_sparse_bsr`	Преобразует тензор в формат сжатого хранения блочных строк (BSR) заданного размера блока.
`Tensor.to_sparse_bsc`	Преобразует тензор в формат сжатого хранения блочных столбцов (BSC) заданного размера блока.
`Tensor.trace`	См. `torch.trace()`
`Tensor.transpose`	См. `torch.transpose()`
`Tensor.transpose_`	Временная версия `transpose()`
`Tensor.triangular_solve`	См. `torch.triangular_solve()`
`Tensor.tril`	См. `torch.tril()`
`Tensor.tril_`	Временная версия `tril()`
`Tensor.triu`	См. `torch.triu()`

END_OF_DOCUMENT_MARKER

`Tensor.triu_`	Вместо `triu()` — метод выполняется на месте.
`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`	Эквивалентно `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/2.1/tensors.html