torch.Tensor

Создано: 23 дек. 2016 г. | Последнее обновление: 11 июл. 2026 г.

torch.Tensor — это многомерная матрица, содержащая элементы одного типа данных. Дополнительные сведения о поддержке типов данных см. в разделе torch.dtype.

Создание и основные операции

Тензор можно создать из 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().
Чтобы создать тензор заданного размера, используйте операции создания тензоров torch.* (см. раздел Операции создания).
Чтобы создать тензор того же размера (и похожих типов), что и другой тензор, используйте операции создания тензоров torch.*_like (см. раздел Операции создания).
Чтобы создать тензор похожего типа, но другого размера, чем у другого тензора, используйте операции создания tensor.new_*.
Существует устаревший конструктор torch.Tensor, использование которого не рекомендуется. Вместо него используйте torch.tensor().

Tensor.__init__(self, data)

Этот конструктор устарел; вместо него рекомендуется использовать torch.tensor(). Поведение конструктора зависит от типа data.

Если data — это тензор, возвращается псевдоним исходного тензора. В отличие от torch.tensor(), этот конструктор отслеживает autograd и передает градиенты исходному тензору. Аргумент device не поддерживается для этого типа data.
Если data — это последовательность или вложенная последовательность, создается тензор с типом данных по умолчанию (обычно torch.float32), содержащий значения из последовательностей; при необходимости выполняется преобразование типов. Следует отметить, что это отличается от torch.tensor(): этот конструктор всегда создает тензор с типом данных с плавающей точкой, даже если все входные значения — целые числа.
Если data — это torch.Size, возвращается пустой тензор указанного размера.

Этот конструктор не поддерживает явное указание dtype или device возвращаемого тензора. Рекомендуется использовать torch.tensor(), который предоставляет такую возможность.

Аргументы:

data (array_like): тензор, на основе которого выполняется создание.

Именованные аргументы:

device (torch.device, optional): the desired device of returned tensor.: По умолчанию: если None, используется такое же значение torch.device, как у этого тензора.

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`	Равно `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)`.
`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.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_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
`Tensor.arccosh_`	acosh_() -> Tensor
`Tensor.cpu`	Возвращает копию этого объекта в памяти 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.const_data_ptr`	Возвращает адрес первого элемента тензора `self`.
`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_`	Заполняет главную диагональ тензора, имеющего не менее двух измерений.
`Tensor.fmax`	См. `torch.fmax()`
`Tensor.fmin`	См. `torch.fmin()`
`Tensor.diff`	См. `torch.diff()`
`Tensor.digamma`	См. `torch.digamma()`
`Tensor.digamma_`	Версия `digamma()`, изменяющая тензор на месте
`Tensor.dim`	Возвращает число измерений тензора `self`.
`Tensor.dim_order`	Возвращает однозначно определяемый кортеж целых чисел, описывающий порядок измерений или физическое расположение `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.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` элементами, взятыми из функции плотности вероятности (PDF):
`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.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.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`, если тензор использует разреженный формат хранения 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()`
`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.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.module_load`	Определяет способ преобразования `other` при загрузке в `self` с помощью `load_state_dict()`.
`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()` с изменением исходного тензора
`Tensor.nonzero`	См. `torch.nonzero()`
`Tensor.nonzero_static`	См. `torch.nonzero_static()`
`Tensor.norm`	См. `torch.linalg.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`	Возвращает представление тензора с переставленными измерениями.
`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.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()` с изменением на месте
`Tensor.record_stream`	Помечает тензор как использованный этим потоком.
`Tensor.register_hook`	Регистрирует хук обратного прохода.
`Tensor.register_post_accumulate_grad_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_`	Изменяет настройку записи операций над этим тензором в autograd: изменяет атрибут `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()`, изменяющая данные на месте
`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()`
`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`	`self.where(condition, y)` эквивалентно `torch.where(condition, self, y)`.
`Tensor.xlogy`	См. `torch.xlogy()`
`Tensor.xlogy_`	Версия `xlogy()`, выполняющая операцию на месте
`Tensor.xpu`	Возвращает копию этого объекта в памяти XPU.
`Tensor.zero_`	Заполняет `self` нулями.

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