SparseSemiStructuredTensorCUTLASS

class torch.sparse.semi_structured.SparseSemiStructuredTensorCUTLASS(shape, packed, meta, packed_t, meta_t, compressed_swizzled_bitmask, fuse_transpose_cusparselt=False, alg_id_cusparselt=0, requires_grad=False) [исходный код]

Этот класс реализует полуструктурированную разреженность для бэкенда CUTLASS.

В этой реализации указанные элементы и метаданные хранятся отдельно, в packed и meta соответственно.

Когда установлен _FORCE_CUTLASS или когда cuSPARSELt недоступен, этот подкласс вызывает _sparse_semi_structured_(mm|addmm) и sparse_semi_structured_from_dense для преобразования в сжатый формат.

H

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

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

См. также

mH: Атрибут, который также работает с пакетами (batches) матриц.

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

abs() → Tensor: См. torch.abs()

abs_() → Tensor: In-place версия abs()

absolute() → Tensor: Псевдоним для abs()

absolute_() → Tensor: In-place версия absolute() Псевдоним для abs_()

acos() → Tensor: См. torch.acos()

acos_() → Tensor: In-place версия acos()

acosh() → Tensor: См. torch.acosh()

acosh_() → Tensor: In-place версия acosh()

add(other, *, alpha=1) → Tensor

Добавляет скаляр или тензор к тензору self. Если указаны и alpha, и other, каждый элемент other масштабируется с помощью alpha перед использованием.

Когда other является тензором, форма other должна быть транслируемой (broadcastable) с формой базового тензора

См. torch.add()

add_(other, *, alpha=1) → Tensor: In-place версия add()

addbmm(batch1, batch2, *, beta=1, alpha=1) → Tensor: См. torch.addbmm()

addbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor: In-place версия addbmm()

addcdiv(tensor1, tensor2, *, value=1) → Tensor: См. torch.addcdiv()

addcdiv_(tensor1, tensor2, *, value=1) → Tensor: In-place версия addcdiv()

addcmul(tensor1, tensor2, *, value=1) → Tensor: См. torch.addcmul()

addcmul_(tensor1, tensor2, *, value=1) → Tensor: In-place версия addcmul()

addmm(mat1, mat2, *, beta=1, alpha=1) → Tensor: См. torch.addmm()

addmm_(mat1, mat2, *, beta=1, alpha=1) → Tensor: In-place версия addmm()

addmv(mat, vec, *, beta=1, alpha=1) → Tensor: См. torch.addmv()

addmv_(mat, vec, *, beta=1, alpha=1) → Tensor: In-place версия addmv()

addr(vec1, vec2, *, beta=1, alpha=1) → Tensor: См. torch.addr()

addr_(vec1, vec2, *, beta=1, alpha=1) → Tensor: In-place версия addr()

adjoint() → Tensor: Псевдоним для adjoint()

all(dim=None, keepdim=False) → Tensor: См. torch.all()

allclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) → Tensor: См. torch.allclose()

amax(dim=None, keepdim=False) → Tensor: См. torch.amax()

amin(dim=None, keepdim=False) → Tensor: См. torch.amin()

aminmax(*, dim=None, keepdim=False) -> (Tensor min, Tensor max): См. torch.aminmax()

angle() → Tensor: См. torch.angle()

any(dim=None, keepdim=False) → Tensor: См. torch.any()

apply_(callable) → Tensor: Применяет функцию callable к каждому элементу в тензоре, заменяя каждый элемент значением, возвращаемым callable.

Примечание

Эта функция работает только с тензорами CPU и не должна использоваться в участках кода, требующих высокой производительности.

arccos() → Tensor: См. torch.arccos()

arccos_() → Tensor: In-place версия arccos()

arccosh()

acosh() -> Tensor

См. torch.arccosh()

arccosh_()

acosh_() -> Tensor

In-place версия arccosh()

arcsin() → Tensor: См. torch.arcsin()

arcsin_() → Tensor: In-place версия arcsin()

arcsinh() → Tensor: См. torch.arcsinh()

arcsinh_() → Tensor: In-place версия arcsinh()

arctan() → Tensor: См. torch.arctan()

arctan2(other) → Tensor: См. torch.arctan2()

arctan2_()

atan2_(other) -> Tensor

In-place версия arctan2()

arctan_() → Tensor: In-place версия arctan()

arctanh() → Tensor: См. torch.arctanh()

arctanh_(other) → Tensor: In-place версия arctanh()

argmax(dim=None, keepdim=False) → LongTensor: См. torch.argmax()

argmin(dim=None, keepdim=False) → LongTensor: См. torch.argmin()

argsort(dim=-1, descending=False) → LongTensor: См. torch.argsort()

argwhere() → Tensor: См. torch.argwhere()

as_strided(size, stride, storage_offset=None) → Tensor: См. torch.as_strided()

as_strided_(size, stride, storage_offset=None) → Tensor: In-place версия as_strided()

as_strided_scatter(src, size, stride, storage_offset=None) → Tensor: См. torch.as_strided_scatter()

as_subclass(cls) → Tensor: Создает экземпляр cls с тем же указателем данных, что и self. Изменения в выводе отражают изменения в self, и вывод остается прикрепленным к графу autograd. cls должен быть подклассом Tensor.

asin() → Tensor: См. torch.asin()

asin_() → Tensor: In-place версия asin()

asinh() → Tensor: См. torch.asinh()

asinh_() → Tensor: In-place версия asinh()

atan() → Tensor: См. torch.atan()

atan2(other) → Tensor: См. torch.atan2()

atan2_(other) → Tensor: In-place версия atan2()

atan_() → Tensor: In-place версия atan()

atanh() → Tensor: См. torch.atanh()

atanh_(other) → Tensor: In-place версия atanh()

backward(gradient=None, retain_graph=None, create_graph=False, inputs=None) [источник]

Вычисляет градиент текущего тензора относительно листьев графа.

Дифференцирование графа выполняется по цепному правилу. Если тензор нескалярный (т. е. его данные содержат более одного элемента) и требует вычисления градиента, функция дополнительно требует указания gradient. Это должен быть тензор соответствующего типа и формы, представляющий градиент дифференцируемой функции относительно self.

Эта функция накапливает градиенты в листьях — вам может потребоваться обнулить атрибуты .grad или установить их в None перед ее вызовом. См. раздел Структуры градиента по умолчанию для получения подробной информации о расположении накопленных градиентов в памяти.

Примечание

Если вы запускаете какие-либо прямые операции (forward ops), создаете gradient и/или вызываете backward в контексте пользовательского потока CUDA, см. раздел Семантика потоков для обратных проходов.

Примечание

Когда передаются inputs и данный вход не является листом, текущая реализация вызовет его grad_fn (хотя это строго не требуется для получения этих градиентов). Это деталь реализации, на которую пользователю не следует полагаться. См. pytorch/pytorch#60521 для получения более подробной информации.

Параметры:

gradient (Tensor, необязательно) – Градиент дифференцируемой функции относительно self. Этот аргумент может быть опущен, если self является скаляром. По умолчанию: None.
retain_graph (bool, необязательно) – Если False, граф, используемый для вычисления градиентов, будет освобожден; если True, он будет сохранен. По умолчанию None, и в этом случае значение выводится из create_graph (т. е. граф сохраняется только тогда, когда запрошено отслеживание производных более высокого порядка). Обратите внимание, что практически во всех случаях установка этого параметра в True не требуется и часто этого можно избежать гораздо более эффективным способом.
create_graph (bool, необязательно) – Если True, будет построен граф производной, что позволит вычислять произведения производных более высокого порядка. По умолчанию: False.
inputs (Sequence[Tensor] или dict[str, Tensor], необязательно) – Входы, относительно которых градиент будет накоплен в .grad. Все остальные тензоры будут проигнорированы. Если не указано, градиент накапливается во всех листовых тензорах (leaf Tensors), которые использовались для вычисления tensors. Словарь тензоров (например, dict(model.named_parameters())) также поддерживается. По умолчанию: None.

baddbmm(batch1, batch2, *, beta=1, alpha=1) → Tensor: См. torch.baddbmm()

baddbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor: In-place версия baddbmm()

bernoulli(*, generator=None) → Tensor

Возвращает результирующий тензор, где каждый $\texttt{result[i]}$ независимо выбирается из $\text{Bernoulli}(\texttt{self[i]})$ . self должен иметь тип с плавающей запятой dtype, и результат будет иметь тот же dtype.

См. torch.bernoulli()

bernoulli_(p=0.5, *, generator=None) → Tensor

Заполняет каждую позицию self независимой выборкой из $\text{Bernoulli}(\texttt{p})$ . self может иметь целочисленный dtype.

p должен быть либо скаляром, либо тензором, содержащим вероятности, используемые для генерации бинарного случайного числа.

Если это тензор, $\text{i}^{th}$ элемент тензора self будет установлен в значение, выбранное из $\text{Bernoulli}(\texttt{p\_tensor[i]})$ . В этом случае p должен иметь тип с плавающей запятой dtype.

См. также bernoulli() и torch.bernoulli()

bfloat16(memory_format=torch.preserve_format) → Tensor

self.bfloat16() эквивалентно self.to(torch.bfloat16). См. to().

Параметры:: memory_format (torch.memory_format, необязательно) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

bincount(weights=None, minlength=0) → Tensor: См. torch.bincount()

bitwise_and() → Tensor: См. torch.bitwise_and()

bitwise_and_() → Tensor: In-place версия bitwise_and()

bitwise_left_shift(other) → Tensor: См. torch.bitwise_left_shift()

bitwise_left_shift_(other) → Tensor: In-place версия bitwise_left_shift()

bitwise_not() → Tensor: См. torch.bitwise_not()

bitwise_not_() → Tensor: In-place версия функции bitwise_not()

bitwise_or() → Tensor: См. torch.bitwise_or()

bitwise_or_() → Tensor: In-place версия функции bitwise_or()

bitwise_right_shift(other) → Tensor: См. torch.bitwise_right_shift()

bitwise_right_shift_(other) → Tensor: In-place версия функции bitwise_right_shift()

bitwise_xor() → Tensor: См. torch.bitwise_xor()

bitwise_xor_() → Tensor: In-place версия функции bitwise_xor()

bmm(batch2) → Tensor: См. torch.bmm()

bool(memory_format=torch.preserve_format) → Tensor

self.bool() эквивалентно self.to(torch.bool). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

broadcast_to(shape) → Tensor: См. torch.broadcast_to().

byte(memory_format=torch.preserve_format) → Tensor

self.byte() эквивалентно self.to(torch.uint8). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

cauchy_(median=0, sigma=1, *, generator=None) → Tensor: Заполняет тензор числами, сгенерированными из распределения Коши:

$f(x) = \dfrac{1}{\pi} \dfrac{\sigma}{(x - \text{median})^2 + \sigma^2}$

Примечание

Сигма ( $\sigma$ ) используется для обозначения параметра масштаба в распределении Коши.

cdouble(memory_format=torch.preserve_format) → Tensor

self.cdouble() эквивалентно self.to(torch.complex128). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

ceil() → Tensor: См. torch.ceil()

ceil_() → Tensor: In-place версия функции ceil()

cfloat(memory_format=torch.preserve_format) → Tensor

self.cfloat() эквивалентно self.to(torch.complex64). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

chalf(memory_format=torch.preserve_format) → Tensor

self.chalf() эквивалентно self.to(torch.complex32). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

char(memory_format=torch.preserve_format) → Tensor

self.char() эквивалентно self.to(torch.int8). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

cholesky_inverse(upper=False) → Tensor: См. torch.cholesky_inverse()

cholesky_solve(input2, upper=False) → Tensor: См. torch.cholesky_solve()

chunk(chunks, dim=0) → List of Tensors: См. torch.chunk()

clamp(min=None, max=None) → Tensor: См. torch.clamp()

clamp_(min=None, max=None) → Tensor: In-place версия функции clamp()

clip(min=None, max=None) → Tensor: Псевдоним для clamp().

clip_(min=None, max=None) → Tensor: Псевдоним для clamp_().

clone(*, memory_format=torch.preserve_format) → Tensor: См. torch.clone()

coalesce() → Tensor

Возвращает объединенную (coalesced) копию self, если self является необъединенным тензором.

Возвращает self, если self является объединенным тензором.

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

Вызывает ошибку, если self не является разреженным COO-тензором.

col_indices() → IntTensor

Возвращает тензор, содержащий индексы столбцов тензора self, когда self является разреженным CSR-тензором с разметкой sparse_csr. Тензор col_indices строго имеет форму (self.nnz()) и тип int32 или int64. При использовании подпрограмм MKL, таких как умножение разреженных матриц, необходимо использовать индексацию int32, чтобы избежать понижения точности и возможной потери информации.

Пример:

>>> csr = torch.eye(5,5).to_sparse_csr()
>>> csr.col_indices()
tensor([0, 1, 2, 3, 4], dtype=torch.int32)

conj() → Tensor: См. torch.conj()

conj_physical() → Tensor: См. torch.conj_physical()

conj_physical_() → Tensor: In-place версия функции conj_physical()

const_data_ptr() → int

Возвращает адрес первого элемента тензора self.

В отличие от data_ptr(), этот доступ гарантированно предназначен только для чтения и не вызывает материализацию механизма копирования при записи (copy-on-write). Для обычных тензоров (не COW) возвращаемое значение идентично значению data_ptr().

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

Возвращенный указатель не должен использоваться для изменения данных тензора. Используйте data_ptr(), когда необходим доступ для записи.

contiguous(memory_format=torch.contiguous_format) → Tensor

Возвращает непрерывный в памяти тензор, содержащий те же данные, что и тензор self. Если тензор self уже находится в указанном формате памяти, эта функция возвращает тензор self.

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.contiguous_format.

copy_(src, non_blocking=False) → Tensor

Копирует элементы из src в тензор self и возвращает self.

Тензор src должен быть транслируемым (broadcastable) относительно тензора self. Он может иметь другой тип данных или находиться на другом устройстве.

Параметры:

src (Tensor) – исходный тензор, из которого происходит копирование
non_blocking (bool, опционально) – если True и данное копирование происходит между CPU и GPU, оно может выполняться асинхронно по отношению к хосту. В остальных случаях этот аргумент не имеет эффекта. По умолчанию: False

Примечание

Когда non_blocking имеет значение True и копирование запускается в нестандартном потоке CUDA, вызывающая сторона несет ответственность за надлежащую синхронизацию между потоками. Требуемый шаблон см. в разделе Потоки CUDA.

copysign(other) → Tensor: См. torch.copysign()

copysign_(other) → Tensor: In-place версия функции copysign()

corrcoef() → Tensor: См. torch.corrcoef()

cos() → Tensor: См. torch.cos()

cos_() → Tensor: In-place версия функции cos()

cosh() → Tensor: См. torch.cosh()

cosh_() → Tensor: In-place версия функции cosh()

count_nonzero(dim=None) → Tensor: См. torch.count_nonzero()

cov(*, correction=1, fweights=None, aweights=None) → Tensor: См. torch.cov()

cpu(memory_format=torch.preserve_format) → Tensor

Возвращает копию этого объекта в памяти CPU.

Если данный объект уже находится в памяти CPU, копирование не выполняется и возвращается исходный объект.

Параметры:: memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

cross(other, dim=None) → Tensor: См. torch.cross()

crow_indices() → IntTensor

Возвращает тензор, содержащий сжатые индексы строк тензора self, когда self является разреженным CSR-тензором с разметкой sparse_csr. Тензор crow_indices строго имеет форму (self.size(0) + 1) и тип int32 или int64. При использовании подпрограмм MKL, таких как умножение разреженных матриц, необходимо использовать индексацию int32, чтобы избежать понижения точности и возможной потери информации.

Пример:

>>> csr = torch.eye(5,5).to_sparse_csr()
>>> csr.crow_indices()
tensor([0, 1, 2, 3, 4, 5], dtype=torch.int32)

cuda(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

Возвращает копию этого объекта в памяти CUDA.

Если данный объект уже находится в памяти CUDA и на правильном устройстве, копирование не выполняется и возвращается исходный объект.

Параметры:

device (torch.device, опционально) – целевое GPU-устройство. По умолчанию используется текущее устройство CUDA.
non_blocking (bool, опционально) – если True и источник находится в закрепленной (pinned) памяти, копирование будет асинхронным по отношению к хосту. В противном случае аргумент не имеет эффекта. По умолчанию: False.
memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

cummax(dim): См. torch.cummax()

cummin(dim): См. torch.cummin()

cumprod(dim, dtype=None) → Tensor: См. torch.cumprod()

cumprod_(dim, dtype=None) → Tensor: In-place версия функции cumprod()

cumsum(dim, dtype=None) → Tensor: См. torch.cumsum()

cumsum_(dim, dtype=None) → Tensor: In-place версия функции cumsum()

data_ptr() → int: Возвращает адрес первого элемента тензора self.

Примечание

Если тензор является тензором типа "копирование при записи" (например, созданным с помощью _lazy_clone()), вызов этого метода приведет к материализации копии. Используйте const_data_ptr(), если вам нужен доступ к указателю на данные только для чтения.

deg2rad() → Tensor: См. torch.deg2rad()

deg2rad_() → Tensor: In-place версия функции deg2rad()

dense_dim() → int

Возвращает количество плотных измерений в разреженном тензоре self.

Примечание

Возвращает len(self.shape), если self не является разреженным тензором.

См. также Tensor.sparse_dim() и гибридные тензоры.

dequantize() → Tensor: Принимает квантованный тензор, деквантует его и возвращает деквантованный тензор с плавающей запятой.

det() → Tensor: См. torch.det()

detach()

Возвращает новый тензор, отделенный от текущего графа.

Результат никогда не будет требовать вычисления градиента.

Этот метод также влияет на градиенты прямого режима автодифференцирования (forward mode AD), и результат никогда не будет содержать градиентов прямого режима AD.

Примечание

Возвращаемый тензор использует то же хранилище, что и исходный. Изменения на месте (in-place) любого из них будут отражаться на другом и могут вызывать ошибки при проверках корректности.

detach_()

Отделяет тензор от создавшего его графа, делая его листовым (leaf). Представления (views) не могут быть отделены на месте.

device: Это torch.device, на котором расположен данный тензор.

diag(diagonal=0) → Tensor: См. torch.diag()

diag_embed(offset=0, dim1=-2, dim2=-1) → Tensor: См. torch.diag_embed()

diagflat(offset=0) → Tensor: См. torch.diagflat()

diagonal(offset=0, dim1=0, dim2=1) → Tensor: См. torch.diagonal()

diagonal_scatter(src, offset=0, dim1=0, dim2=1) → Tensor: См. torch.diagonal_scatter()

diff(n=1, dim=-1, prepend=None, append=None) → Tensor: См. torch.diff()

digamma() → Tensor: См. torch.digamma()

digamma_() → Tensor: In-place версия digamma()

dim() → int: Возвращает количество измерений тензора self.

dim_order(ambiguity_check=False) → tuple [исходный код]

Возвращает однозначно определенный кортеж целых чисел, описывающий порядок измерений (dim order) или физическое расположение self в памяти.

Порядок измерений представляет то, как измерения расположены в памяти плотных тензоров, начиная с самого внешнего и заканчивая самым внутренним измерением.

Обратите внимание, что порядок измерений не всегда может быть определен однозначно. Если ambiguity_check имеет значение True, эта функция вызывает RuntimeError, когда порядок измерений не может быть однозначно определен; если ambiguity_check является списком форматов памяти, эта функция вызывает RuntimeError, когда тензор не может быть интерпретирован ровно в один из заданных форматов памяти или его невозможно однозначно определить. Если ambiguity_check имеет значение False, функция вернет один из допустимых порядков измерений без проверки его уникальности. В противном случае будет вызвано исключение TypeError.

Параметры:: ambiguity_check (bool или List[torch.memory_format]) – Метод проверки неоднозначности порядка измерений.

Примеры:

>>> torch.empty((2, 3, 5, 7)).dim_order()
(0, 1, 2, 3)
>>> torch.empty((2, 3, 5, 7)).transpose(1, 2).dim_order()
(0, 2, 1, 3)
>>> torch.empty((2, 3, 5, 7), memory_format=torch.channels_last).dim_order()
(0, 2, 3, 1)
>>> torch.empty((1, 2, 3, 4)).dim_order()
(0, 1, 2, 3)
>>> try:
...     torch.empty((1, 2, 3, 4)).dim_order(ambiguity_check=True)
... except RuntimeError as e:
...     print(e)
The tensor does not have unique dim order, or cannot map to exact one of the given memory formats.
>>> torch.empty((1, 2, 3, 4)).dim_order(
...     ambiguity_check=[torch.contiguous_format, torch.channels_last]
... )  # It can be mapped to contiguous format
(0, 1, 2, 3)
>>> try:
...     torch.empty((1, 2, 3, 4)).dim_order(ambiguity_check="ILLEGAL") # type: ignore[arg-type]
... except TypeError as e:
...     print(e)
The ambiguity_check argument must be a bool or a list of memory formats.

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

API тензора dim_order является экспериментальным и может быть изменено.

dist(other, p=2) → Tensor: См. torch.dist()

div(value, *, rounding_mode=None) → Tensor: См. torch.div()

div_(value, *, rounding_mode=None) → Tensor: In-place версия div()

divide(value, *, rounding_mode=None) → Tensor: См. torch.divide()

divide_(value, *, rounding_mode=None) → Tensor: In-place версия divide()

dot(other) → Tensor: См. torch.dot()

double(memory_format=torch.preserve_format) → Tensor

self.double() эквивалентно self.to(torch.float64). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – требуемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

dsplit(split_size_or_sections) → List of Tensors: См. torch.dsplit()

element_size() → int

Возвращает размер отдельного элемента в байтах.

Пример:

>>> torch.tensor([]).element_size()
4
>>> torch.tensor([], dtype=torch.uint8).element_size()
1

eq(other) → Tensor: См. torch.eq()

eq_(other) → Tensor: In-place версия eq()

equal(other) → bool: См. torch.equal()

erf() → Tensor: См. torch.erf()

erf_() → Tensor: In-place версия erf()

erfc() → Tensor: См. torch.erfc()

erfc_() → Tensor: In-place версия erfc()

erfinv() → Tensor: См. torch.erfinv()

erfinv_() → Tensor: In-place версия erfinv()

exp() → Tensor: См. torch.exp()

exp2() → Tensor: См. torch.exp2()

exp2_() → Tensor: In-place версия exp2()

exp_() → Tensor: In-place версия exp()

expand(*size) → Tensor

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

Передача -1 в качестве размера измерения означает сохранение размера этого измерения без изменений.

Тензор также может быть расширен до большего числа измерений, при этом новые измерения будут добавлены в начало. Для новых измерений размер не может быть установлен в -1.

Расширение тензора не выделяет новую память, а лишь создает новое представление существующего тензора, в котором измерение размера 1 расширяется до большего размера путем установки stride в 0. Любое измерение размера 1 можно расширить до произвольного значения без выделения новой памяти.

Примечание

Операции над расширенным представлением все еще могут выделять память, если им требуется материализовать расширенные значения. Например, изменение dtype после expand() может привести к выделению памяти под полную расширенную форму.

Параметры:: *size (torch.Size или int...) – требуемый расширенный размер

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

Несколько элементов расширенного тензора могут ссылаться на одну и ту же ячейку памяти. В результате операции in-place (особенно векторизованные) могут приводить к некорректному поведению. Если вам необходимо выполнять запись в тензоры, сначала клонируйте их.

Пример:

>>> x = torch.tensor([[1], [2], [3]])
>>> x.size()
torch.Size([3, 1])
>>> x.expand(3, 4)
tensor([[ 1,  1,  1,  1],
        [ 2,  2,  2,  2],
        [ 3,  3,  3,  3]])
>>> x.expand(-1, 4)   # -1 means not changing the size of that dimension
tensor([[ 1,  1,  1,  1],
        [ 2,  2,  2,  2],
        [ 3,  3,  3,  3]])

expand_as(other) → Tensor

Расширяет данный тензор до того же размера, что и other. self.expand_as(other) эквивалентно self.expand(other.size()).

Дополнительную информацию о expand см. в expand().

Параметры:: other (torch.Tensor) – Результирующий тензор имеет тот же размер, что и other.

expm1() → Tensor: См. torch.expm1()

expm1_() → Tensor: In-place версия expm1()

exponential_(lambd=1, *, generator=None) → Tensor: Заполняет тензор self элементами, полученными из функции плотности вероятности (PDF):

$f(x) = \lambda e^{-\lambda x}, x > 0$

Примечание

В теории вероятностей экспоненциальное распределение поддерживается на интервале [0, $\inf$ ) (т. е. $x >= 0$ ), что означает возможность выборки нуля из экспоненциального распределения. Однако torch.Tensor.exponential_() не производит выборку нуля, что означает, что его фактический носитель — интервал (0, $\inf$ ).

Обратите внимание, что torch.distributions.exponential.Exponential() поддерживается на интервале [0, $\inf$ ) и может производить выборку нуля.

fill_(value) → Tensor: Заполняет тензор self указанным значением.

fill_diagonal_(fill_value, wrap=False) → Tensor

Заполняет главную диагональ тензора, имеющего как минимум 2 измерения. При dims>2 все измерения входного тензора должны иметь одинаковую длину. Эта функция изменяет входной тензор на месте (in-place) и возвращает его.

Параметры:

fill_value (Scalar) – значение для заполнения
wrap (bool, опционально) – перенос диагонали после N столбцов для высоких матриц. По умолчанию: False

Пример:

>>> a = torch.zeros(3, 3)
>>> a.fill_diagonal_(5)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.]])
>>> b = torch.zeros(7, 3)
>>> b.fill_diagonal_(5)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]])
>>> c = torch.zeros(7, 3)
>>> c.fill_diagonal_(5, wrap=True)
tensor([[5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.],
        [0., 0., 0.],
        [5., 0., 0.],
        [0., 5., 0.],
        [0., 0., 5.]])

fix() → Tensor: См. torch.fix().

fix_() → Tensor: In-place версия fix()

flatten(start_dim=0, end_dim=-1) → Tensor: См. torch.flatten()

flip(dims) → Tensor: См. torch.flip()

fliplr() → Tensor: См. torch.fliplr()

flipud() → Tensor: См. torch.flipud()

float(memory_format=torch.preserve_format) → Tensor

self.float() эквивалентно self.to(torch.float32). См. to().

Параметры:: memory_format (torch.memory_format, опционально) – требуемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

float_power(exponent) → Tensor: См. torch.float_power()

float_power_(exponent) → Tensor: In-place версия float_power()

floor() → Tensor: См. torch.floor()

floor_() → Tensor: In-place версия floor()

floor_divide(value) → Tensor: См. torch.floor_divide()

floor_divide_(value) → Tensor: In-place версия floor_divide()

fmax(other) → Tensor: См. torch.fmax()

fmin(other) → Tensor: См. torch.fmin()

fmod(divisor) → Tensor: См. torch.fmod()

fmod_(divisor) → Tensor: In-place версия fmod()

frac() → Tensor: См. torch.frac()

frac_() → Tensor: In-place версия frac()

frexp(input) -> (Tensor mantissa, Tensor exponent): См. torch.frexp()

gather(dim, index) → Tensor: См. torch.gather()

gcd(other) → Tensor: См. torch.gcd()

gcd_(other) → Tensor: In-place версия gcd()

ge(other) → Tensor: См. torch.ge().

ge_(other) → Tensor: In-place версия ge().

geometric_(p, *, generator=None) → Tensor: Заполняет тензор self элементами, полученными из геометрического распределения:

$P(X=k) = (1 - p)^{k - 1} p, k = 1, 2, ...$

Примечание

torch.Tensor.geometric_() считает, что k-е испытание является первым успехом, поэтому формирует выборку из $\{1, 2, \ldots\}$ , тогда как для torch.distributions.geometric.Geometric() первым успехом является $(k+1)$ -е испытание, поэтому формируется выборка из $\{0, 1, \ldots\}$ .

geqrf(): См. torch.geqrf()

ger(vec2) → Tensor: См. torch.ger()

get_device() -> Device ordinal (Integer)

Для тензоров CUDA эта функция возвращает порядковый номер устройства (device ordinal) GPU, на котором находится тензор. Для тензоров CPU эта функция возвращает -1.

Пример:

>>> x = torch.randn(3, 4, 5, device='cuda:0')
>>> x.get_device()
0
>>> x.cpu().get_device()
-1

grad: Этот атрибут по умолчанию равен None и становится объектом Tensor при первом вызове backward(), вычисляющем градиенты для self. Затем атрибут будет содержать вычисленные градиенты, а последующие вызовы backward() будут накапливать (добавлять) градиенты в него.

grad_dtype

Допустимый тип данных dtype для :attr:grad этого тензора.

:attr:grad_dtype может быть установлен в конкретный dtype или None. По умолчанию — t.grad_dtype == t.dtype. Если значение отлично от None, механизм autograd приводит входящие градиенты к этому dtype. Этот атрибут доступен для чтения и изменения только для листовых тензоров (leaf tensors).

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

Используйте с осторожностью. Расхождение типов данных dtype тензора и его градиента может нарушить работу нижестоящих систем, которые предполагают их совпадение.

Пример:

>>> x = torch.tensor([1.0, 2.0], requires_grad=True)
>>> x.grad_dtype
torch.float32

>>> x.grad_dtype = torch.float16
>>> x.grad_dtype
torch.float16

>>> # Allow any gradient dtype
>>> x.grad_dtype = None
>>> x.grad_dtype

greater(other) → Tensor: См. torch.greater().

greater_(other) → Tensor: In-place версия greater().

greater_equal(other) → Tensor: См. torch.greater_equal().

greater_equal_(other) → Tensor: In-place версия greater_equal().

gt(other) → Tensor: См. torch.gt().

gt_(other) → Tensor: In-place версия gt().

half(memory_format=torch.preserve_format) → Tensor

self.half() эквивалентно self.to(torch.float16). См. to().

Параметры:: memory_format (torch.memory_format, optional) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

hardshrink(lambd=0.5) → Tensor: См. torch.nn.functional.hardshrink()

heaviside(values) → Tensor: См. torch.heaviside()

heaviside_(values) → Tensor: In-place версия heaviside()

histc(bins=100, min=0, max=0) → Tensor: См. torch.histc()

histogram(input, bins, *, range=None, weight=None, density=False): См. torch.histogram()

hsplit(split_size_or_sections) → List of Tensors: См. torch.hsplit()

hypot(other) → Tensor: См. torch.hypot()

hypot_(other) → Tensor: In-place версия hypot()

i0() → Tensor: См. torch.i0()

i0_() → Tensor: In-place версия i0()

igamma(other) → Tensor: См. torch.igamma()

igamma_(other) → Tensor: In-place версия igamma()

igammac(other) → Tensor: См. torch.igammac()

igammac_(other) → Tensor: In-place версия igammac()

imag

Возвращает новый тензор, содержащий мнимые значения тензора self. Возвращаемый тензор и self используют одно и то же базовое хранилище.

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

imag() поддерживается только для тензоров с комплексными типами данных (dtypes).

Пример:

>>> x=torch.randn(4, dtype=torch.cfloat)
>>> x
tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
>>> x.imag
tensor([ 0.3553, -0.7896, -0.0633, -0.8119])

index(positions, dims) [исходный код]

Индексирует обычный тензор путем связывания указанных позиций с объектами dims.

Это преобразует обычный тензор в тензор первого класса путем связывания указанных позиционных измерений с объектами Dim.

Параметры:

positions – Кортеж позиций измерений для связывания
dims – Объекты Dim или кортеж объектов Dim для связывания

Возвращает:

Тензор первого класса со связанными указанными измерениями

index_add(dim, index, source, *, alpha=1) → Tensor: Out-of-place версия torch.Tensor.index_add_().

index_add_(dim, index, source, *, alpha=1) → Tensor

Накапливает элементы alpha, умноженные на source, в тензор self путем добавления к индексам в порядке, указанном в index. Например, если dim == 0, index[i] == j и alpha=-1, то i-я строка source вычитается из j-й строки self.

Измерение dim тензора source должно иметь тот же размер, что и длина index (которое должно быть вектором), а все остальные измерения должны совпадать с self, иначе возникнет ошибка.

Для трехмерного тензора результат вычисляется следующим образом:

self[index[i], :, :] += alpha * src[i, :, :]  # if dim == 0
self[:, index[i], :] += alpha * src[:, i, :]  # if dim == 1
self[:, :, index[i]] += alpha * src[:, :, i]  # if dim == 2

Примечание

Эта операция может вести себя недетерминированно при передаче тензоров на устройстве CUDA. См. раздел Воспроизводимость для получения дополнительной информации.

Параметры:

dim (int) – измерение, по которому производится индексация
index (Tensor) – индексы тензора source для выборки, должны иметь тип данных (dtype) либо torch.int64, либо torch.int32
source (Tensor) – тензор, содержащий добавляемые значения

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

alpha (Number) – скалярный множитель для source

Пример:

>>> x = torch.ones(5, 3)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2])
>>> x.index_add_(0, index, t)
tensor([[  2.,   3.,   4.],
        [  1.,   1.,   1.],
        [  8.,   9.,  10.],
        [  1.,   1.,   1.],
        [  5.,   6.,   7.]])
>>> x.index_add_(0, index, t, alpha=-1)
tensor([[  1.,   1.,   1.],
        [  1.,   1.,   1.],
        [  1.,   1.,   1.],
        [  1.,   1.,   1.],
        [  1.,   1.,   1.]])

index_copy(dim, index, tensor2) → Tensor: Out-of-place версия torch.Tensor.index_copy_().

index_copy_(dim, index, tensor) → Tensor

Копирует элементы tensor в тензор self путем выбора индексов в порядке, указанном в index. Например, если dim == 0 и index[i] == j, то i-я строка tensor копируется в j-ю строку self.

Измерение dim тензора tensor должно иметь тот же размер, что и длина index (которое должно быть вектором), а все остальные измерения должны совпадать с self, иначе возникнет ошибка.

Примечание

Если index содержит повторяющиеся элементы, несколько элементов из tensor будут скопированы по одному и тому же индексу в self. Результат является недетерминированным, поскольку зависит от того, какое копирование произошло последним.

Параметры:

dim (int) – измерение, по которому производится индексация
index (LongTensor) – индексы тензора tensor для выборки
tensor (Tensor) – тензор, содержащий копируемые значения

Пример:

>>> x = torch.zeros(5, 3)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2])
>>> x.index_copy_(0, index, t)
tensor([[ 1.,  2.,  3.],
        [ 0.,  0.,  0.],
        [ 7.,  8.,  9.],
        [ 0.,  0.,  0.],
        [ 4.,  5.,  6.]])

index_fill(dim, index, value) → Tensor: Out-of-place версия torch.Tensor.index_fill_().

index_fill_(dim, index, value) → Tensor

Заполняет элементы тензора self значением value, выбирая индексы в порядке, указанном в index.

Параметры:

dim (int) – измерение, по которому производится индексация
index (LongTensor) – индексы тензора self для заполнения
value (float) – значение для заполнения

Пример:

>>> x = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=torch.float)
>>> index = torch.tensor([0, 2])
>>> x.index_fill_(1, index, -1)
tensor([[-1.,  2., -1.],
        [-1.,  5., -1.],
        [-1.,  8., -1.]])

index_put(indices, values, accumulate=False) → Tensor: Out-place версия index_put_().

index_put_(indices, values, accumulate=False) → Tensor

Помещает значения из тензора values в тензор self с использованием индексов, указанных в indices (который представляет собой кортеж тензоров). Выражение tensor.index_put_(indices, values) эквивалентно tensor[indices] = values. Возвращает self.

Если accumulate равно True, элементы из values добавляются к self. Если accumulate равно False, поведение не определено, если индексы содержат повторяющиеся элементы.

Параметры:

indices (tuple of LongTensor) – тензоры, используемые для индексации в self.
values (Tensor) – тензор того же типа данных (dtype), что и self.
accumulate (bool) – следует ли накапливать значения в self

index_reduce_(dim, index, source, reduce, *, include_self=True) → Tensor

Накапливает элементы source в тензор self путем накопления по индексам в порядке, указанном в index, с использованием операции редукции, заданной аргументом reduce. Например, если dim == 0, index[i] == j, reduce == prod и include_self == True, то i-я строка source умножается на j-ю строку self. Если include_self="True", значения тензора self включаются в редукцию, в противном случае строки в тензоре self, в которые производится накопление, обрабатываются так, как если бы они были заполнены нейтральными элементами операции редукции (reduction identities).

Для трехмерного тензора с reduce="prod" и include_self=True результат вычисляется следующим образом:

self[index[i], :, :] *= src[i, :, :]  # if dim == 0
self[:, index[i], :] *= src[:, i, :]  # if dim == 1
self[:, :, index[i]] *= src[:, :, i]  # if dim == 2

Примечание

Эта функция поддерживает только тензоры с плавающей запятой.

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

Эта функция находится в стадии бета-тестирования и может измениться в ближайшем будущем.

Параметры:

dim (int) – измерение, по которому производится индексация
index (Tensor) – индексы тензора self для накопления, должны иметь тип данных (dtype) либо torch.int64, либо torch.int32
source (FloatTensor) – тензор, содержащий накапливаемые значения
reduce (str) – применяемая операция редукции ("prod", "mean", "amax", "amin")

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

include_self (bool) – включаются ли элементы тензора self в редукцию

Пример:

>>> x = torch.empty(5, 3).fill_(2)
>>> t = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=torch.float)
>>> index = torch.tensor([0, 4, 2, 0])
>>> x.index_reduce_(0, index, t, 'prod')
tensor([[20., 44., 72.],
        [ 2.,  2.,  2.],
        [14., 16., 18.],
        [ 2.,  2.,  2.],
        [ 8., 10., 12.]])
>>> x = torch.empty(5, 3).fill_(2)
>>> x.index_reduce_(0, index, t, 'prod', include_self=False)
tensor([[10., 22., 36.],
        [ 2.,  2.,  2.],
        [ 7.,  8.,  9.],
        [ 2.,  2.,  2.],
        [ 4.,  5.,  6.]])

index_select(dim, index) → Tensor: См. torch.index_select()

indices() → Tensor

Возвращает тензор индексов разреженного тензора COO.

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

Вызывает ошибку, если self не является разреженным тензором COO.

См. также Tensor.values().

Примечание

Этот метод можно вызывать только для объединенного (coalesced) разреженного тензора. Подробности см. в Tensor.coalesce().

inner(other) → Tensor: См. torch.inner().

int(memory_format=torch.preserve_format) → Tensor

self.int() эквивалентно self.to(torch.int32). См. to().

Параметры:: memory_format (torch.memory_format, optional) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

int_repr() → Tensor: Для квантованного тензора self.int_repr() возвращает тензор ЦП с типом данных uint8_t, в котором хранятся базовые значения uint8_t исходного тензора.

inverse() → Tensor: См. torch.inverse()

ipu(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

Возвращает копию этого объекта в памяти IPU.

Если этот объект уже находится в памяти IPU и на правильном устройстве, копирование не выполняется и возвращается исходный объект.

Параметры:

device (torch.device, optional) – Целевое устройство IPU. По умолчанию используется текущее устройство IPU.
non_blocking (bool, optional) – Если True и источник находится в закрепленной памяти, копирование будет асинхронным по отношению к хосту. В противном случае аргумент не имеет эффекта. По умолчанию: False.
memory_format (torch.memory_format, optional) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

is_coalesced() → bool

Возвращает True, если self является разреженным тензором COO, который является объединенным (coalesced), иначе False.

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

Вызывает ошибку, если self не является разреженным тензором COO.

См. coalesce() и необъединенные тензоры.

is_complex() → bool: Возвращает True, если тип данных self является комплексным типом данных.

is_conj() → bool: Возвращает True, если бит сопряжения self установлен в true.

is_contiguous(memory_format=torch.contiguous_format) → bool

Возвращает True, если тензор self непрерывен в памяти в порядке, заданном форматом памяти.

Параметры:: memory_format (torch.memory_format, optional) – Задает порядок выделения памяти. По умолчанию: torch.contiguous_format.

is_cpu: Равно True, если тензор хранится на CPU, иначе False.

is_cuda: Равно True, если тензор хранится на GPU, иначе False.

is_floating_point() → bool: Возвращает True, если тип данных self является типом данных с плавающей запятой.

is_inference() → bool: См. torch.is_inference()

is_ipu: Равно True, если тензор хранится на IPU, иначе False.

is_leaf

Все тензоры, у которых requires_grad равно False, по соглашению являются листовыми тензорами.

Тензоры, у которых requires_grad равно True, будут листовыми тензорами, если они были созданы пользователем. Это означает, что они не являются результатом операции, и поэтому grad_fn равно None.

Только у листовых тензоров заполняется поле grad во время вызова backward(). Чтобы заполнить grad для нелистовых тензоров, можно использовать retain_grad().

Пример:

>>> a = torch.rand(10, requires_grad=True)
>>> a.is_leaf
True
>>> b = torch.rand(10, requires_grad=True).cuda()
>>> b.is_leaf
False
# b was created by the operation that cast a cpu Tensor into a cuda Tensor
>>> c = torch.rand(10, requires_grad=True) + 2
>>> c.is_leaf
False
# c was created by the addition operation
>>> d = torch.rand(10).cuda()
>>> d.is_leaf
True
# d does not require gradients and so has no operation creating it (that is tracked by the autograd engine)
>>> e = torch.rand(10).cuda().requires_grad_()
>>> e.is_leaf
True
# e requires gradients and has no operations creating it
>>> f = torch.rand(10, requires_grad=True, device="cuda")
>>> f.is_leaf
True
# f requires grad, has no operation creating it

is_meta: Равно True, если тензор является мета-тензором, иначе False. Мета-тензоры похожи на обычные тензоры, но они не несут данных.

is_mps: Равно True, если тензор хранится на устройстве MPS, иначе False.

is_neg() → bool: Возвращает True, если отрицательный бит self установлен в true.

is_pinned(): Возвращает True, если этот тензор находится в закрепленной (pinned) памяти. По умолчанию устройством, в памяти которого он закреплен, является текущий ускоритель.

is_quantized: Равно True, если тензор квантован, иначе False.

is_set_to(tensor) → bool: Возвращает True, если оба тензора указывают на одну и ту же область памяти (одинаковое хранилище, смещение, размер и шаг (stride)).

is_shared() [source]

Проверяет, находится ли тензор в разделяемой памяти.

Для CUDA-тензоров это значение всегда равно True.

is_signed() → bool: Возвращает True, если тип данных self является знаковым типом данных.

is_sparse: Равно True, если тензор использует формат хранения sparse COO, иначе False.

is_sparse_csr: Равно True, если тензор использует формат хранения sparse CSR, иначе False.

is_xla: Равно True, если тензор хранится на устройстве XLA, иначе False.

is_xpu: Равно True, если тензор хранится на XPU, иначе False.

isclose(other, rtol=1e-05, atol=1e-08, equal_nan=False) → Tensor: См. torch.isclose()

isfinite() → Tensor: См. torch.isfinite()

isinf() → Tensor: См. torch.isinf()

isnan() → Tensor: См. torch.isnan()

isneginf() → Tensor: См. torch.isneginf()

isposinf() → Tensor: См. torch.isposinf()

isreal() → Tensor: См. torch.isreal()

istft(n_fft, hop_length=None, win_length=None, window=None, center=True, normalized=False, onesided=None, length=None, return_complex=False) [source]: См. torch.istft()

item() → number

Возвращает значение этого тензора в виде стандартного числа Python. Это работает только для тензоров с одним элементом. В остальных случаях см. tolist().

Эта операция недифференцируема.

Пример:

>>> x = torch.tensor([1.0])
>>> x.item()
1.0

itemsize: Псевдоним для element_size()

kron(other) → Tensor: См. torch.kron()

kthvalue(k, dim=None, keepdim=False): См. torch.kthvalue()

lcm(other) → Tensor: См. torch.lcm()

lcm_(other) → Tensor: In-place версия lcm()

ldexp(other) → Tensor: См. torch.ldexp()

ldexp_(other) → Tensor: In-place версия ldexp()

le(other) → Tensor: См. torch.le().

le_(other) → Tensor: In-place версия le().

lerp(end, weight) → Tensor: См. torch.lerp()

lerp_(end, weight) → Tensor: In-place версия lerp()

less()

lt(other) -> Tensor

См. torch.less().

less_(other) → Tensor: In-place версия less().

less_equal(other) → Tensor: См. torch.less_equal().

less_equal_(other) → Tensor: In-place версия less_equal().

lgamma() → Tensor: См. torch.lgamma()

lgamma_() → Tensor: In-place версия lgamma()

log() → Tensor: См. torch.log()

log10() → Tensor: См. torch.log10()

log10_() → Tensor: In-place версия log10()

log1p() → Tensor: См. torch.log1p()

log1p_() → Tensor: In-place версия log1p()

log2() → Tensor: См. torch.log2()

log2_() → Tensor: In-place версия log2()

log_() → Tensor: In-place версия log()

log_normal_(mean=1, std=2, *, generator=None): Заполняет тензор self числами, выбранными из логнормального распределения, параметризованного заданным средним значением $\mu$ и стандартным отклонением $\sigma$ . Обратите внимание, что mean и std являются средним значением и стандартным отклонением базового нормального распределения, а не результирующего распределения:

$f(x) = \dfrac{1}{x \sigma \sqrt{2\pi}}\ e^{-\frac{(\ln x - \mu)^2}{2\sigma^2}}$

logaddexp(other) → Tensor: См. torch.logaddexp()

logaddexp2(other) → Tensor: См. torch.logaddexp2()

logcumsumexp(dim) → Tensor: См. torch.logcumsumexp()

logdet() → Tensor: См. torch.logdet()

logical_and() → Tensor: См. torch.logical_and()

logical_and_() → Tensor: In-place версия logical_and()

logical_not() → Tensor: См. torch.logical_not()

logical_not_() → Tensor: In-place версия logical_not()

logical_or() → Tensor: См. torch.logical_or()

logical_or_() → Tensor: In-place версия logical_or()

logical_xor() → Tensor: См. torch.logical_xor()

logical_xor_() → Tensor: In-place версия logical_xor()

logit() → Tensor: См. torch.logit()

logit_() → Tensor: In-place версия logit()

logsumexp(dim, keepdim=False) → Tensor: См. torch.logsumexp()

long(memory_format=torch.preserve_format) → Tensor

self.long() эквивалентно self.to(torch.int64). См. to().

Параметры:: memory_format (torch.memory_format, необязательно) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

lt(other) → Tensor: См. torch.lt().

lt_(other) → Tensor: In-place версия lt().

lu(pivot=True, get_infos=False) [source]: См. torch.lu()

lu_solve(LU_data, LU_pivots) → Tensor: См. torch.lu_solve()

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

mT

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

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

map_(tensor, callable)

Применяет callable к каждому элементу тензора self и заданного tensor и сохраняет результаты в тензор self. Тензор self и заданный tensor должны быть совместимы по broadcasting.

callable должна иметь следующую сигнатуру:

def callable(a, b) -> number

masked_fill(mask, value) → Tensor: Out-of-place версия torch.Tensor.masked_fill_()

masked_fill_(mask, value)

Заполняет элементы тензора self значением value там, где mask равно True. Форма mask должна быть совместима по broadcasting с формой базового тензора.

Параметры:

mask (BoolTensor) – логическая маска
value (float) – значение для заполнения

masked_scatter(mask, tensor) → Tensor

Out-of-place версия torch.Tensor.masked_scatter_()

Примечание

Входные данные self и mask поддерживают трансляцию (broadcast).

Пример

>>> self = torch.tensor([0, 0, 0, 0, 0])
>>> mask = torch.tensor(
...     [[0, 0, 0, 1, 1], [1, 1, 0, 1, 1]],
...     dtype=torch.bool,
... )
>>> source = torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
>>> self.masked_scatter(mask, source)
tensor([[0, 0, 0, 0, 1],
        [2, 3, 0, 4, 5]])

masked_scatter_(mask, source)

Копирует элементы из source в тензор self в позиции, где mask имеет значение True. Элементы из source копируются в self, начиная с позиции 0 в source и продолжая по порядку один за другим для каждого вхождения, где mask равно True. Форма mask должна быть совместима по broadcasting с формой базового тензора. source должен содержать не меньше элементов, чем количество единиц в mask.

Параметры:

mask (BoolTensor) – логическая маска
source (Tensor) – тензор, из которого копируются элементы

Примечание

mask воздействует на тензор self, а не на переданный тензор source.

Пример

>>> self = torch.tensor([[0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])
>>> mask = torch.tensor(
...     [[0, 0, 0, 1, 1], [1, 1, 0, 1, 1]],
...     dtype=torch.bool,
... )
>>> source = torch.tensor([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
>>> self.masked_scatter_(mask, source)
tensor([[0, 0, 0, 0, 1],
        [2, 3, 0, 4, 5]])

masked_select(mask) → Tensor: См. torch.masked_select()

matmul(tensor2) → Tensor: См. torch.matmul()

matrix_exp() → Tensor: См. torch.matrix_exp()

matrix_power(n) → Tensor: Примечание

matrix_power() устарел, используйте вместо него torch.linalg.matrix_power().

Псевдоним для torch.linalg.matrix_power()

max(dim=None, keepdim=False): См. torch.max()

maximum(other) → Tensor: См. torch.maximum()

mean(dim=None, keepdim=False, *, dtype=None) → Tensor: См. torch.mean()

median(dim=None, keepdim=False): См. torch.median()

min(dim=None, keepdim=False): См. torch.min()

minimum(other) → Tensor: См. torch.minimum()

mm(mat2) → Tensor: См. torch.mm()

mode(dim=None, keepdim=False): См. torch.mode()

module_load(other, assign=False) [исходный код]

Определяет, как преобразовывать other при загрузке в self в load_state_dict().

Используется, когда get_swap_module_params_on_conversion() равен True.

Ожидается, что self является параметром или буфером в nn.Module, а other — значением в словаре состояния с соответствующим ключом; этот метод определяет, как переназначается other перед заменой на self с помощью swap_tensors() в load_state_dict().

Примечание

Этот метод всегда должен возвращать новый объект, отличный от self или other. Например, реализация по умолчанию возвращает self.copy_(other).detach(), если assign равен False, или other.detach(), если assign равен True.

Параметры:

other (Tensor) – значение в state dict с ключом, соответствующим self
assign (bool) – аргумент assign, переданный в nn.Module.load_state_dict()

moveaxis(source, destination) → Tensor: См. torch.moveaxis()

movedim(source, destination) → Tensor: См. torch.movedim()

msort() → Tensor: См. torch.msort()

mtia(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

Возвращает копию этого объекта в памяти MTIA.

Если этот объект уже находится в памяти MTIA и на правильном устройстве, копирование не выполняется и возвращается исходный объект.

Параметры:

device (torch.device, optional) – Целевое устройство MTIA. По умолчанию — текущее устройство MTIA.
non_blocking (bool, optional) – Если True и источник находится в закрепленной памяти (pinned memory), копирование будет асинхронным по отношению к хосту. В противном случае аргумент не имеет эффекта. По умолчанию: False.
memory_format (torch.memory_format, optional) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

mul(value) → Tensor: См. torch.mul().

mul_(value) → Tensor: In-place версия mul().

multinomial(num_samples, replacement=False, *, generator=None) → Tensor: См. torch.multinomial()

multiply(value) → Tensor: См. torch.multiply().

multiply_(value) → Tensor: In-place версия multiply().

mv(vec) → Tensor: См. torch.mv()

mvlgamma(p) → Tensor: См. torch.mvlgamma()

mvlgamma_(p) → Tensor: In-place версия mvlgamma()

nan_to_num(nan=0.0, posinf=None, neginf=None) → Tensor: См. torch.nan_to_num().

nan_to_num_(nan=0.0, posinf=None, neginf=None) → Tensor: In-place версия nan_to_num().

nanmean(dim=None, keepdim=False, *, dtype=None) → Tensor: См. torch.nanmean()

nanmedian(dim=None, keepdim=False): См. torch.nanmedian()

nanquantile(q, dim=None, keepdim=False, *, interpolation='linear') → Tensor: См. torch.nanquantile()

nansum(dim=None, keepdim=False, dtype=None) → Tensor: См. torch.nansum()

narrow(dimension, start, length) → Tensor: См. torch.narrow().

narrow_copy(dimension, start, length) → Tensor: См. torch.narrow_copy().

nbytes: Возвращает количество байт, потребляемых «представлением» элементов тензора, если тензор не использует разреженную структуру хранения. Определяется как numel() * element_size()

ndim: Псевдоним для dim()

ndimension() → int: Псевдоним для dim()

ne(other) → Tensor: См. torch.ne().

ne_(other) → Tensor: In-place версия ne().

neg() → Tensor: См. torch.neg()

neg_() → Tensor: In-place версия neg()

negative() → Tensor: См. torch.negative()

negative_() → Tensor: In-place версия negative()

nelement() → int: Псевдоним для numel()

new_empty(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

Возвращает тензор размера size, заполненный неинициализированными данными. По умолчанию возвращаемый тензор имеет те же torch.dtype и torch.device, что и этот тензор.

Параметры:

size (int...) – список, кортеж или torch.Size целых чисел, определяющих форму выходного тензора.

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

dtype (torch.dtype, optional) – желаемый тип возвращаемого тензора. По умолчанию: если None, совпадает с torch.dtype этого тензора.
device (torch.device, optional) – желаемое устройство возвращаемого тензора. По умолчанию: если None, совпадает с torch.device этого тензора.
requires_grad (bool, optional) – должен ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, optional) – желаемая структура размещения (layout) возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, optional) – если установлено, возвращаемый тензор будет выделен в закрепленной памяти (pinned memory). Работает только для тензоров CPU. По умолчанию: False.

Пример:

>>> tensor = torch.ones(())
>>> tensor.new_empty((2, 3))
tensor([[ 5.8182e-18,  4.5765e-41, -1.0545e+30],
        [ 3.0949e-41,  4.4842e-44,  0.0000e+00]])

new_empty_strided(size, stride, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

Возвращает тензор размера size и шагами (strides) stride, заполненный неинициализированными данными. По умолчанию возвращаемый тензор имеет те же torch.dtype и torch.device, что и этот тензор.

Параметры:

size (int...) – список, кортеж или torch.Size целых чисел, определяющих форму выходного тензора.

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

dtype (torch.dtype, optional) – желаемый тип возвращаемого тензора. По умолчанию: если None, совпадает с torch.dtype этого тензора.
device (torch.device, optional) – желаемое устройство возвращаемого тензора. По умолчанию: если None, совпадает с torch.device этого тензора.
requires_grad (bool, optional) – должен ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, optional) – желаемая структура размещения (layout) возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, optional) – если установлено, возвращаемый тензор будет выделен в закрепленной памяти (pinned memory). Работает только для тензоров CPU. По умолчанию: False.

Пример:

>>> tensor = torch.ones(())
>>> tensor.new_empty_strided((2, 3), (3, 1))
tensor([[ 5.8182e-18,  4.5765e-41, -1.0545e+30],
        [ 3.0949e-41,  4.4842e-44,  0.0000e+00]])

new_full(size, fill_value, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

Возвращает тензор размера size, заполненный fill_value. По умолчанию возвращаемый тензор имеет те же torch.dtype и torch.device, что и этот тензор.

Параметры:

fill_value (scalar) – число для заполнения выходного тензора.

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

dtype (torch.dtype, optional) – желаемый тип возвращаемого тензора. По умолчанию: если None, совпадает с torch.dtype этого тензора.
device (torch.device, optional) – желаемое устройство возвращаемого тензора. По умолчанию: если None, совпадает с torch.device этого тензора.
requires_grad (bool, optional) – должен ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, optional) – желаемая структура размещения (layout) возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, optional) – если установлено, возвращаемый тензор будет выделен в закрепленной памяти (pinned memory). Работает только для тензоров CPU. По умолчанию: False.

Пример:

>>> tensor = torch.ones((2,), dtype=torch.float64)
>>> tensor.new_full((3, 4), 3.141592)
tensor([[ 3.1416,  3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416,  3.1416],
        [ 3.1416,  3.1416,  3.1416,  3.1416]], dtype=torch.float64)

new_ones(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

Возвращает тензор размера size, заполненный 1. По умолчанию возвращаемый тензор имеет те же torch.dtype и torch.device, что и этот тензор.

Параметры:

size (int...) – список, кортеж или torch.Size целых чисел, определяющих форму выходного тензора.

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

dtype (torch.dtype, optional) – желаемый тип возвращаемого тензора. По умолчанию: если None, совпадает с torch.dtype этого тензора.
device (torch.device, optional) – желаемое устройство возвращаемого тензора. По умолчанию: если None, совпадает с torch.device этого тензора.
requires_grad (bool, optional) – должен ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, optional) – желаемая структура размещения (layout) возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, optional) – если установлено, возвращаемый тензор будет выделен в закрепленной памяти (pinned memory). Работает только для тензоров CPU. По умолчанию: False.

Пример:

>>> tensor = torch.tensor((), dtype=torch.int32)
>>> tensor.new_ones((2, 3))
tensor([[ 1,  1,  1],
        [ 1,  1,  1]], dtype=torch.int32)

new_tensor(data, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

Возвращает новый тензор с data в качестве данных тензора. По умолчанию возвращаемый тензор имеет те же torch.dtype и torch.device, что и этот тензор.

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

new_tensor() всегда копирует data. Если у вас есть тензор data и вы хотите избежать копирования, используйте torch.Tensor.requires_grad_() или torch.Tensor.detach(). Если у вас есть массив numpy и вы хотите избежать копирования, используйте torch.from_numpy().

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

Когда data является тензором x, new_tensor() считывает «данные» из того, что ему передано, и конструирует листовую переменную (leaf variable). Поэтому tensor.new_tensor(x) эквивалентно x.detach().clone(), а tensor.new_tensor(x, requires_grad=True) эквивалентно x.detach().clone().requires_grad_(True). Рекомендуются эквиваленты с использованием detach() и clone().

Параметры:

data (array_like) – Возвращаемый тензор копирует data.

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

dtype (torch.dtype, optional) – желаемый тип возвращаемого тензора. По умолчанию: если None, совпадает с torch.dtype этого тензора.
device (torch.device, optional) – желаемое устройство возвращаемого тензора. По умолчанию: если None, совпадает с torch.device этого тензора.
requires_grad (bool, optional) – должен ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, optional) – желаемая структура размещения (layout) возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, optional) – если установлено, возвращаемый тензор будет выделен в закрепленной памяти (pinned memory). Работает только для тензоров CPU. По умолчанию: False.

Пример:

>>> tensor = torch.ones((2,), dtype=torch.int8)
>>> data = [[0, 1], [2, 3]]
>>> tensor.new_tensor(data)
tensor([[ 0,  1],
        [ 2,  3]], dtype=torch.int8)

new_zeros(size, *, dtype=None, device=None, requires_grad=False, layout=torch.strided, pin_memory=False) → Tensor

Возвращает тензор размера size, заполненный 0. По умолчанию возвращаемый тензор имеет те же torch.dtype и torch.device, что и этот тензор.

Параметры:

size (int...) – список, кортеж или torch.Size целых чисел, определяющих форму выходного тензора.

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

dtype (torch.dtype, optional) – желаемый тип возвращаемого тензора. По умолчанию: если None, совпадает с torch.dtype этого тензора.
device (torch.device, optional) – желаемое устройство возвращаемого тензора. По умолчанию: если None, совпадает с torch.device этого тензора.
requires_grad (bool, optional) – должен ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, optional) – желаемая структура размещения (layout) возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, optional) – если установлено, возвращаемый тензор будет выделен в закрепленной памяти (pinned memory). Работает только для тензоров CPU. По умолчанию: False.

Пример:

>>> tensor = torch.tensor((), dtype=torch.float64)
>>> tensor.new_zeros((2, 3))
tensor([[ 0.,  0.,  0.],
        [ 0.,  0.,  0.]], dtype=torch.float64)

nextafter(other) → Tensor: См. torch.nextafter()

nextafter_(other) → Tensor: In-place версия nextafter()

nonzero() → LongTensor: См. torch.nonzero()

nonzero_static(*, size, fill_value=-1) → LongTensor: См. torch.nonzero_static()

norm(p='fro', dim=None, keepdim=False, dtype=None) [исходный код]: См. torch.linalg.norm()

normal_(mean=0, std=1, *, generator=None) → Tensor: Заполняет тензор self элементами, выбранными из нормального распределения, параметризованного mean и std.

not_equal(other) → Tensor: См. torch.not_equal().

not_equal_(other) → Tensor: In-place версия not_equal().

numel() → int: См. torch.numel()

numpy(*, force=False) → numpy.ndarray

Возвращает тензор в виде NumPy ndarray.

Если force равно False (по умолчанию), преобразование выполняется только в том случае, если тензор находится на CPU, не требует градиента, не имеет установленного бита сопряжения и имеет тип данных и раскладку, поддерживаемые NumPy. Возвращаемый ndarray и тензор будут использовать общее хранилище, поэтому изменения в тензоре отразятся на ndarray, и наоборот.

Если force равно True, это эквивалентно вызову t.detach().cpu().resolve_conj().resolve_neg().numpy(). Если тензор находится не на CPU или установлен бит сопряжения или отрицания, тензор не будет разделять хранилище с возвращаемым ndarray. Установка force в True может быть полезным сокращением.

Параметры:: force (bool) – если True, ndarray может быть копией тензора, а не всегда разделять память; значение по умолчанию — False.

orgqr(input2) → Tensor: См. torch.orgqr()

ormqr(input2, input3, left=True, transpose=False) → Tensor: См. torch.ormqr()

outer(vec2) → Tensor: См. torch.outer().

permute(*dims) → Tensor

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

Параметры:: dims (torch.Size, int..., tuple из int или list из int) – желаемый порядок измерений.

Пример

>>> x = torch.randn(2, 3, 5)
>>> x.size()
torch.Size([2, 3, 5])
>>> x.permute(2, 0, 1).size()
torch.Size([5, 2, 3])

pin_memory() → Tensor: Копирует тензор в закрепленную память (pinned memory), если он еще не закреплен. По умолчанию устройством закрепленной памяти будет текущий акселератор.

pinverse() → Tensor: См. torch.pinverse()

polygamma(n) → Tensor: См. torch.polygamma()

polygamma_(n) → Tensor: In-place версия polygamma()

positive() → Tensor: См. torch.positive()

pow(exponent) → Tensor: См. torch.pow()

pow_(exponent) → Tensor: In-place версия pow()

prod(dim=None, keepdim=False, dtype=None) → Tensor: См. torch.prod()

classmethod prune_dense_static_sort(original_tensor, algorithm='') [исходный код]

Эта функция принимает необрезанный (unpruned) плотный тензор и выполняет (безветвевую) статическую сортировку по тайлу 4x4.

Она жадно выбирает наибольшие значения в тайле, соблюдая ограничение разреженности 2:4 как по строкам, так и по столбцам. Алгоритм, используемый для прореживания (pruning) матрицы, реализован в _sparse_semi_structured_tile.

Затем она создает упакованный (packed) тензор и метатензор для сжатого разреженного представления прореженного плотного тензора. Она также вычисляет тензоры packed_t и meta_t для сжатого разреженного представления транспонированного прореженного плотного тензора. Поскольку мы не можем транспонировать сжатые представления, мы сохраняем оба тензора для прямого (fw) и обратного (bw) проходов соответственно.

Наконец, эта функция также вычисляет сжатую переупорядоченную (swizzled) битовую маску, которая кодирует шаблон разреженности. Ее можно использовать в обратном проходе для маскирования градиентов.

[9 1 7 4]                       [9 0 7 0]
[1 2 3 0]                       [0 2 0 0]
[8 3 5 4] -> prune 4x4 tile  -> [8 0 0 4] -> pack to CUTLASS semi-structured -> packed
[1 2 6 2]                       [0 0 6 2]                                    -> metadata

                                          -> pack to transposed CUTLASS      -> packed_t
                                             semi-structured representation  -> metadata_t

                                          -> compute swizzled bitmask        -> compressed_swizzled_bitmask

Эквивалентный код PyTorch для создания тех же пяти выходных данных из плотного тензора приведен ниже:

from torch.sparse import SparseSemiStructuredTensorCUTLASS
from torch.sparse._semi_structured_conversions import (
    _sparse_semi_structured_tile,
    _compute_compressed_swizzled_bitmask,
)

pruned = _sparse_semi_structured_tile(dense)
packed_cutlass, meta_cutlass = sparse_semi_structured_from_dense_cutlass(
    pruned
)
packed_t_cutlass, meta_t_cutlass = (
    sparse_semi_structured_from_dense_cutlass(pruned.t().contiguous())
)
bitmask = _compute_compressed_swizzled_bitmask(pruned)

SparseSemiStructuredTensorCUTLASS(
    dense.shape,
    packed_cutlass,
    meta_cutlass,
    packed_t_cutlass,
    meta_t_cutlass,
    bitmask,
)

Тип возвращаемого значения:: SparseSemiStructuredTensor

put(input, index, source, accumulate=False) → Tensor: Out-of-place версия torch.Tensor.put_(). input соответствует self в torch.Tensor.put_().

put_(index, source, accumulate=False) → Tensor

Копирует элементы из source в позиции, указанные index. Для целей индексации тензор self рассматривается так, как если бы он был одномерным тензором.

index и source должны иметь одинаковое количество элементов, но не обязательно одинаковую форму.

Если accumulate равно True, элементы в source прибавляются к self. Если accumulate равно False, поведение не определено, если index содержит повторяющиеся элементы.

Параметры:

index (LongTensor) – индексы в self
source (Tensor) – тензор, содержащий значения для копирования
accumulate (bool, необязательно) – накапливать ли значения в self. По умолчанию: False

Пример:

>>> src = torch.tensor([[4, 3, 5],
...                     [6, 7, 8]])
>>> src.put_(torch.tensor([1, 3]), torch.tensor([9, 10]))
tensor([[  4,   9,   5],
        [ 10,   7,   8]])

q_per_channel_axis() → int: Для тензора, квантованного с помощью линейного (аффинного) поканального квантования, возвращает индекс измерения, к которому применяется поканальное квантование.

q_per_channel_scales() → Tensor: Для тензора, квантованного с помощью линейного (аффинного) поканального квантования, возвращает тензор масштабов (scales) базового квантователя. Количество его элементов совпадает с соответствующим измерением (из q_per_channel_axis) тензора.

q_per_channel_zero_points() → Tensor: Для тензора, квантованного с помощью линейного (аффинного) поканального квантования, возвращает тензор нулевых точек (zero_points) базового квантователя. Количество его элементов совпадает с соответствующим измерением (из q_per_channel_axis) тензора.

q_scale() → float: Для тензора, квантованного с помощью линейного (аффинного) квантования, возвращает масштаб (scale) базового квантователя quantizer().

q_zero_point() → int: Для тензора, квантованного с помощью линейного (аффинного) квантования, возвращает нулевую точку (zero_point) базового квантователя quantizer().

qscheme() → torch.qscheme: Возвращает схему квантования заданного QTensor.

quantile(q, dim=None, keepdim=False, *, interpolation='linear') → Tensor: См. torch.quantile()

rad2deg() → Tensor: См. torch.rad2deg()

rad2deg_() → Tensor: In-place версия rad2deg()

random_(from=0, to=None, *, generator=None) → Tensor: Заполняет тензор self числами, выбранными из дискретного равномерного распределения на [from, to - 1]. Если диапазон не указан, значения обычно ограничены только типом данных тензора self. Однако для типов с плавающей запятой, если диапазон не указан, он будет равен [0, 2^mantissa], чтобы гарантировать представимость каждого значения. Например, torch.tensor(1, dtype=torch.double).random_() будет равномерным на [0, 2^53].

ravel() → Tensor: см. torch.ravel()

real

Возвращает новый тензор, содержащий действительные значения тензора self для комплекснозначного входного тензора. Возвращаемый тензор и self используют общее базовое хранилище.

Возвращает self, если self является вещественным тензором.

Пример:

>>> x=torch.randn(4, dtype=torch.cfloat)
>>> x
tensor([(0.3100+0.3553j), (-0.5445-0.7896j), (-1.6492-0.0633j), (-0.0638-0.8119j)])
>>> x.real
tensor([ 0.3100, -0.5445, -1.6492, -0.0638])

reciprocal() → Tensor: См. torch.reciprocal()

reciprocal_() → Tensor: In-place версия reciprocal()

record_stream(stream)

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

Примечание

Кэширующий аллокатор осведомлен только о том потоке, в котором тензор был выделен. Благодаря этому он уже корректно управляет жизненным циклом тензоров только в одном потоке. Но если тензор используется в потоке, отличном от исходного потока создания, аллокатор может неожиданно переиспользовать память. Вызов этого метода сообщает аллокатору, какие потоки использовали тензор.

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

Этот метод лучше всего подходит для сценариев, в которых вы предоставляете функцию, создающую тензор в побочном потоке, и хотите, чтобы пользователи могли использовать тензор, не задумываясь о потокобезопасности при работе с ним. Эти гарантии безопасности сопряжены с определенными затратами производительности и предсказуемости (аналогично компромиссу между сборкой мусора и ручным управлением памятью), поэтому, если вы полностью контролируете жизненный цикл своих тензоров, вы можете вместо этого вручную управлять событиями CUDA, чтобы отпала необходимость в вызове этого метода. В частности, при вызове этого метода при последующих выделениях памяти аллокатор будет опрашивать записанный поток, чтобы проверить, завершились ли уже все операции; потенциально может возникнуть состояние гонки с вычислениями в побочном потоке и недетерминированное повторное использование памяти (или отказ в нем) для выделения.

Вы можете безопасно использовать тензоры, выделенные в побочных потоках, без record_stream(); вы должны вручную убедиться, что любые использования тензора в потоках, отличных от потока создания, синхронизированы обратно с потоком создания до освобождения тензора. Поскольку кэширующий аллокатор CUDA гарантирует, что память будет повторно использоваться только в том же потоке создания, этого достаточно, чтобы записи при будущих повторных выделениях памяти откладывались до завершения операций в других потоках. (Как ни парадоксально, вы можете заметить, что со стороны CPU память тензора уже перераспределена, хотя ядра CUDA со старым тензором все еще выполняются. Это нормально, поскольку операции CUDA с новым тензором будут корректно ожидать завершения старых операций, так как все они находятся в одном и том же потоке.)

Конкретно это выглядит следующим образом:

with torch.cuda.stream(s0):
    x = torch.zeros(N)

s1.wait_stream(s0)
with torch.cuda.stream(s1):
    y = some_comm_op(x)

... some compute on s0 ...

# synchronize creation stream s0 to side stream s1
# before deallocating x
s0.wait_stream(s1)
del x

Обратите внимание, что при принятии решения о том, когда выполнять s0.wait_stream(s1), требуется осмотрительность. В частности, если бы мы ожидали сразу после some_comm_op, в побочном потоке не было бы никакого смысла; это было бы эквивалентно выполнению some_comm_op на s0. Вместо этого синхронизацию следует размещать в некоторый подходящий, более поздний момент времени, когда ожидается завершение работы побочного потока s1. Это место обычно определяется с помощью профилирования, например, с использованием трейсов Chrome, созданных torch.autograd.profiler.profile.export_chrome_trace(). Если разместить ожидание слишком рано, работа в s0 будет заблокирована до завершения s1, препятствуя дальнейшему совмещению передачи данных и вычислений. Если разместить ожидание слишком поздно, вы будете использовать больше памяти, чем строго необходимо (поскольку держите x активным дольше). Конкретный пример того, как это руководство может применяться на практике, см. в этой публикации: FSDP and CUDACachingAllocator.

register_hook(hook) [исходный код]

Регистрирует хук обратного прохода (backward hook).

Хук будет вызываться каждый раз при вычислении градиента относительно тензора. Хук должен иметь следующую сигнатуру:

hook(grad) -> Tensor or None

Хук не должен изменять свой аргумент, но может при необходимости возвращать новый градиент, который будет использоваться вместо grad.

Эта функция возвращает дескриптор с методом handle.remove(), который удаляет хук из модуля.

Примечание

См. раздел Backward Hooks execution для получения дополнительной информации о том, когда выполняется этот хук и как его выполнение упорядочено относительно других хуков.

Пример:

>>> v = torch.tensor([0., 0., 0.], requires_grad=True)
>>> h = v.register_hook(lambda grad: grad * 2)  # double the gradient
>>> v.backward(torch.tensor([1., 2., 3.]))
>>> v.grad

 2
 4
 6
[torch.FloatTensor of size (3,)]

>>> h.remove()  # removes the hook

register_post_accumulate_grad_hook(hook) [исходный код]

Регистрирует хук обратного прохода, который выполняется после накопления градиентов.

Хук будет вызван после того, как все градиенты для тензора будут накоплены, что означает, что поле .grad у этого тензора было обновлено. Хук post accumulate grad применим ТОЛЬКО к листовым тензорам (тензорам без поля .grad_fn). Регистрация этого хука на нелистовом тензоре приведет к ошибке!

Хук должен иметь следующую сигнатуру:

hook(param: Tensor) -> None

Обратите внимание, что в отличие от других хуков autograd, этот хук работает с тензором, требующим градиента, а не с самим градиентом. Хук может in-place изменять и получать доступ к своему аргументу Tensor, включая его поле .grad.

Эта функция возвращает дескриптор с методом handle.remove(), который удаляет хук из модуля.

Примечание

См. раздел Backward Hooks execution для получения дополнительной информации о том, когда выполняется этот хук и как его выполнение упорядочено относительно других хуков. Поскольку этот хук выполняется во время обратного прохода, он будет выполняться в режиме no_grad (если только create_graph не установлен в True). При необходимости вы можете использовать torch.enable_grad() для повторного включения autograd внутри хука.

Пример:

>>> v = torch.tensor([0., 0., 0.], requires_grad=True)
>>> lr = 0.01
>>> # simulate a simple SGD update
>>> h = v.register_post_accumulate_grad_hook(lambda p: p.add_(p.grad, alpha=-lr))
>>> v.backward(torch.tensor([1., 2., 3.]))
>>> v
tensor([-0.0100, -0.0200, -0.0300], requires_grad=True)

>>> h.remove()  # removes the hook

remainder(divisor) → Tensor: См. torch.remainder()

remainder_(divisor) → Tensor: In-place версия remainder()

renorm(p, dim, maxnorm) → Tensor: См. torch.renorm()

renorm_(p, dim, maxnorm) → Tensor: In-place версия renorm()

repeat(*repeats) → Tensor

Повторяет этот тензор вдоль указанных измерений.

В отличие от expand(), эта функция копирует данные тензора.

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

repeat() ведет себя иначе, чем numpy.repeat, но больше похож на numpy.tile. Оператор, аналогичный numpy.repeat, см. в torch.repeat_interleave().

Параметры:: repeat (torch.Size, int..., tuple из int или list из int) – Количество повторений этого тензора вдоль каждого измерения

Пример:

>>> x = torch.tensor([1, 2, 3])
>>> x.repeat(4, 2)
tensor([[ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3],
        [ 1,  2,  3,  1,  2,  3]])
>>> x.repeat(4, 2, 1).size()
torch.Size([4, 2, 3])

repeat_interleave(repeats, dim=None, *, output_size=None) → Tensor: См. torch.repeat_interleave().

requires_grad: Равно True, если для этого тензора необходимо вычислять градиенты, в противном случае — False.

Примечание

Тот факт, что для тензора необходимо вычислять градиенты, не означает, что атрибут grad будет заполнен, подробнее см. в is_leaf.

requires_grad_(requires_grad=True) → Tensor

Изменяет флаг, определяющий, должен ли autograd записывать операции над этим тензором: устанавливает атрибут requires_grad этого тензора in-place. Возвращает этот тензор.

Основной сценарий использования метода requires_grad_() — указать autograd начать запись операций над тензором tensor. Если у tensor значение requires_grad=False (поскольку он был получен через DataLoader или требовал предварительной обработки или инициализации), tensor.requires_grad_() настраивает autograd на запись операций над tensor.

Параметры:: requires_grad (bool) – Должен ли autograd записывать операции над этим тензором. По умолчанию: True.

Пример:

>>> # Let's say we want to preprocess some saved weights and use
>>> # the result as new weights.
>>> saved_weights = [0.1, 0.2, 0.3, 0.25]
>>> loaded_weights = torch.tensor(saved_weights)
>>> weights = preprocess(loaded_weights)  # some function
>>> weights
tensor([-0.5503,  0.4926, -2.1158, -0.8303])

>>> # Now, start to record operations done to weights
>>> weights.requires_grad_()
>>> out = weights.pow(2).sum()
>>> out.backward()
>>> weights.grad
tensor([-1.1007,  0.9853, -4.2316, -1.6606])

reshape(*shape) → Tensor

Возвращает тензор с теми же данными и количеством элементов, что и self, но с указанной формой. Этот метод возвращает представление (view), если shape совместима с текущей формой. См. torch.Tensor.view(), чтобы узнать, когда возможно возвращение представления.

См. torch.reshape()

Параметры:: shape (tuple of ints or int...) – желаемая форма

reshape_as(other) → Tensor

Возвращает данный тензор той же формы, что и other. self.reshape_as(other) эквивалентно self.reshape(other.sizes()). Этот метод возвращает представление, если other.sizes() совместима с текущей формой. См. torch.Tensor.view(), чтобы узнать, когда возможно возвращение представления.

Пожалуйста, обратитесь к reshape() для получения дополнительной информации о reshape.

Параметры:: other (torch.Tensor) – Результирующий тензор имеет ту же форму, что и other.

resize_(*sizes, memory_format=torch.contiguous_format) → Tensor

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

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

Это низкоуровневый метод. Хранилище интерпретируется как C-непрерывное, игнорируя текущие шаги (strides) (за исключением случая, когда целевой размер равен текущему размеру — тогда тензор остается без изменений). В большинстве случаев рекомендуется использовать view(), который проверяет непрерывность, или reshape(), который при необходимости копирует данные. Для изменения размера на месте (in-place) с пользовательскими шагами см. set_().

Примечание

Если и torch.use_deterministic_algorithms(), и torch.utils.deterministic.fill_uninitialized_memory установлены в True, новые элементы инициализируются для предотвращения недетерминированного поведения при использовании результата в качестве входных данных для операции. Значения с плавающей точкой и комплексные значения устанавливаются в NaN, а целочисленные значения — в максимальное значение.

Параметры:

sizes (torch.Size or int...) – желаемый размер
memory_format (torch.memory_format, optional) – желаемый формат памяти Tensor. По умолчанию: torch.contiguous_format. Обратите внимание, что формат памяти self не изменится, если self.size() совпадает с sizes.

Пример:

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

resize_as_(tensor, memory_format=torch.contiguous_format) → Tensor

Изменяет размер тензора self до размера указанного tensor. Это эквивалентно self.resize_(tensor.size()).

Параметры:: memory_format (torch.memory_format, optional) – желаемый формат памяти Tensor. По умолчанию: torch.contiguous_format. Обратите внимание, что формат памяти self не изменится, если self.size() совпадает с tensor.size().

resolve_conj() → Tensor: См. torch.resolve_conj()

resolve_neg() → Tensor: См. torch.resolve_neg()

retain_grad() → None: Позволяет заполнять grad для этого тензора во время backward(). Для листовых тензоров это пустая операция (no-op).

retains_grad: Имеет значение True, если этот тензор не является листовым и для него разрешено заполнение grad во время backward(), иначе False.

roll(shifts, dims) → Tensor: См. torch.roll()

rot90(k, dims) → Tensor: См. torch.rot90()

round(decimals=0) → Tensor: См. torch.round()

round_(decimals=0) → Tensor: In-place версия round()

rsqrt() → Tensor: См. torch.rsqrt()

rsqrt_() → Tensor: In-place версия rsqrt()

scatter(dim, index, src) → Tensor: Out-of-place версия torch.Tensor.scatter_()

scatter_(dim, index, src, *, reduce=None) → Tensor

Записывает все значения из тензора src в self по индексам, указанным в тензоре index. Для каждого значения в src его выходной индекс определяется его индексом в src для dimension != dim и соответствующим значением в index для dimension = dim.

Для 3-D тензора self обновляется следующим образом:

self[index[i][j][k]][j][k] = src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] = src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] = src[i][j][k]  # if dim == 2

Это операция, обратная процессу, описанному в gather().

Также требуется, чтобы index.size(d) <= src.size(d) для всех измерений d и чтобы index.size(d) <= self.size(d) для всех измерений d != dim. Обратите внимание, что input и index не транслируются относительно друг друга для NPU, поэтому при выполнении на NPU тензоры input и index должны иметь одинаковое количество измерений. Во всех остальных случаях происходит стандартная трансляция (broadcasting).

Кроме того, как и для gather(), значения index должны находиться в диапазоне от 0 до self.size(dim) - 1 включительно.

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

Когда индексы не уникальны, поведение является недетерминированным (одно из значений из src будет выбрано произвольно), а градиент будет некорректным (он распространится на все позиции в источнике, соответствующие одному и тому же индексу)!

Примечание

Обратный проход реализован только для src.shape == index.shape.

Кроме того, метод принимает необязательный аргумент reduce, позволяющий задать операцию редукции, которая применяется ко всем значениям из тензора src при записи в self по индексам, указанным в index. Для каждого значения в src операция редукции применяется к индексу в self, который задается его индексом в src для dimension != dim и соответствующим значением в index для dimension = dim.

Для 3-D тензора и редукции с использованием операции умножения self обновляется следующим образом:

self[index[i][j][k]][j][k] *= src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] *= src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] *= src[i][j][k]  # if dim == 2

Редукция с помощью операции сложения аналогична использованию scatter_add_().

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

Аргумент reduce с Tensor src устарел и будет удален в будущих версиях PyTorch. Пожалуйста, используйте scatter_reduce_() для получения дополнительных возможностей редукции.

Параметры:

dim (int) – ось, вдоль которой выполняется индексация
index (LongTensor) – индексы рассеиваемых элементов; могут быть пустыми или иметь ту же размерность, что и src. Если тензор пуст, операция возвращает self без изменений.
src (Tensor) – исходный элемент(ы) для рассеивания.

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

reduce (str, optional) – применяемая операция редукции, может быть либо 'add', либо 'multiply'.

Пример:

>>> src = torch.arange(1, 11).reshape((2, 5))
>>> src
tensor([[ 1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10]])
>>> index = torch.tensor([[0, 1, 2, 0]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_(0, index, src)
tensor([[1, 0, 0, 4, 0],
        [0, 2, 0, 0, 0],
        [0, 0, 3, 0, 0]])
>>> index = torch.tensor([[0, 1, 2], [0, 1, 4]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_(1, index, src)
tensor([[1, 2, 3, 0, 0],
        [6, 7, 0, 0, 8],
        [0, 0, 0, 0, 0]])

>>> torch.full((2, 4), 2.).scatter_(1, torch.tensor([[2], [3]]),
...            1.23, reduce='multiply')
tensor([[2.0000, 2.0000, 2.4600, 2.0000],
        [2.0000, 2.0000, 2.0000, 2.4600]])
>>> torch.full((2, 4), 2.).scatter_(1, torch.tensor([[2], [3]]),
...            1.23, reduce='add')
tensor([[2.0000, 2.0000, 3.2300, 2.0000],
        [2.0000, 2.0000, 2.0000, 3.2300]])

scatter_(dim, index, value, *, reduce=None) → Tensor:

Записывает значение из value в self по индексам, указанным в тензоре index. Эта операция эквивалентна предыдущей версии, где тензор src полностью заполнен значением value.

Параметры:

dim (int) – ось, вдоль которой выполняется индексация
index (LongTensor) – индексы рассеиваемых элементов; могут быть либо пустыми, либо иметь ту же размерность, что и src. Если тензор пуст, операция возвращает self без изменений.
value (Scalar) – значение для рассеивания.

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

reduce (str, optional) – применяемая операция редукции, может быть либо 'add', либо 'multiply'.

Пример:

>>> index = torch.tensor([[0, 1]])
>>> value = 2
>>> torch.zeros(3, 5).scatter_(0, index, value)
tensor([[2., 0., 0., 0., 0.],
        [0., 2., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])

scatter_add(dim, index, src) → Tensor: Out-of-place версия torch.Tensor.scatter_add_()

scatter_add_(dim, index, src) → Tensor

Прибавляет все значения из тензора src к self по индексам, указанным в тензоре index, аналогично scatter_(). Каждое значение в src прибавляется к позиции с индексом в self, который определяется его индексом в src для dimension != dim и соответствующим значением в index для dimension = dim.

Для 3-D тензора self обновляется следующим образом:

self[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2

self, index и src должны иметь одинаковое количество измерений. Также требуется, чтобы index.size(d) <= src.size(d) для всех измерений d и чтобы index.size(d) <= self.size(d) для всех измерений d != dim. Обратите внимание, что index и src не транслируются. Если index пуст, всегда возвращается исходный тензор без дальнейшей проверки на ошибки.

Примечание

Эта операция может вести себя недетерминированно при передаче тензоров на устройстве CUDA. Дополнительные сведения см. в разделе Reproducibility.

Примечание

Обратный проход реализован только для src.shape == index.shape.

Параметры:

dim (int) – ось, вдоль которой выполняется индексация
index (LongTensor) – индексы элементов для рассеивания и сложения; могут быть либо пустыми, либо иметь ту же размерность, что и src. Если тензор пуст, операция возвращает self без изменений.
src (Tensor) – исходные элементы для рассеивания и сложения

Пример:

>>> src = torch.ones((2, 5))
>>> index = torch.tensor([[0, 1, 2, 0, 0]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_add_(0, index, src)
tensor([[1., 0., 0., 1., 1.],
        [0., 1., 0., 0., 0.],
        [0., 0., 1., 0., 0.]])
>>> index = torch.tensor([[0, 1, 2, 0, 0], [0, 1, 2, 2, 2]])
>>> torch.zeros(3, 5, dtype=src.dtype).scatter_add_(0, index, src)
tensor([[2., 0., 0., 1., 1.],
        [0., 2., 0., 0., 0.],
        [0., 0., 2., 1., 1.]])

scatter_reduce(dim, index, src, reduce, *, include_self=True) → Tensor: Out-of-place версия torch.Tensor.scatter_reduce_()

scatter_reduce_(dim, index, src, reduce, *, include_self=True) → Tensor

Выполняет редукцию всех значений из тензора src по индексам, указанным в тензоре index, в тензор self с использованием редукции, определенной с помощью аргумента reduce ("sum", "prod", "mean", "amax", "amin"). Для каждого значения в src выполняется редукция в индекс в self, который определяется его индексом в src для dimension != dim и соответствующим значением в index для dimension = dim. Если include_self="True", значения из тензора self включаются в редукцию.

Для 3-D тензора с reduce="sum" и include_self=True результат рассчитывается следующим образом:

self[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
self[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2

Примечание

Обратный проход реализован только для src.shape == index.shape.

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

Эта функция находится на стадии бета-тестирования и может измениться в ближайшем будущем.

Параметры:

dim (int) – ось, вдоль которой выполняется индексация
index (LongTensor) – индексы элементов для рассеивания и редукции.
src (Tensor) – исходные элементы для рассеивания и редукции
reduce (str) – операция редукции, применяемая для неуникальных индексов ("sum", "prod", "mean", "amax", "amin")
include_self (bool) – включаются ли элементы из тензора self в редукцию

Пример:

>>> src = torch.tensor([1., 2., 3., 4., 5., 6.])
>>> index = torch.tensor([0, 1, 0, 1, 2, 1])
>>> input = torch.tensor([1., 2., 3., 4.])
>>> input.scatter_reduce(0, index, src, reduce="sum")
tensor([5., 14., 8., 4.])
>>> input.scatter_reduce(0, index, src, reduce="sum", include_self=False)
tensor([4., 12., 5., 4.])
>>> input2 = torch.tensor([5., 4., 3., 2.])
>>> input2.scatter_reduce(0, index, src, reduce="amax")
tensor([5., 6., 5., 2.])
>>> input2.scatter_reduce(0, index, src, reduce="amax", include_self=False)
tensor([3., 6., 5., 2.])

select(dim, index) → Tensor: См. torch.select()

select_scatter(src, dim, index) → Tensor: См. torch.select_scatter()

set_(source=None, storage_offset=0, size=None, stride=None) → Tensor

Задает базовое хранилище, размер и шаги (strides). Если source является тензором, тензор self будет использовать то же самое хранилище и иметь тот же размер и шаги, что и source. Изменения элементов в одном тензоре будут отражаться в другом.

Если source является Storage, метод задает базовое хранилище, смещение, размер и шаг.

Параметры:

source (Tensor or Storage) – используемый тензор или хранилище
storage_offset (int, optional) – смещение в хранилище
size (torch.Size, optional) – желаемый размер. По умолчанию совпадает с размером источника.
stride (tuple, optional) – желаемый шаг. По умолчанию используются C-непрерывные шаги.

sgn() → Tensor: См. torch.sgn()

sgn_() → Tensor: In-place версия sgn()

shape

Возвращает размер тензора self. Псевдоним для size.

См. также Tensor.size().

Пример:

>>> t = torch.empty(3, 4, 5)
>>> t.size()
torch.Size([3, 4, 5])
>>> t.shape
torch.Size([3, 4, 5])

share_memory_() [source]

Перемещает базовое хранилище в разделяемую память.

Это пустая операция (no-op), если базовое хранилище уже находится в разделяемой памяти, а также для тензоров CUDA. Размер тензоров в разделяемой памяти не может быть изменен.

См. torch.UntypedStorage.share_memory_() для получения более подробной информации.

short(memory_format=torch.preserve_format) → Tensor

self.short() эквивалентно self.to(torch.int16). См. to().

Параметры:: memory_format (torch.memory_format, optional) – желаемый формат памяти возвращаемого Tensor. По умолчанию: torch.preserve_format.

sigmoid() → Tensor: См. torch.sigmoid()

sigmoid_() → Tensor: In-place версия sigmoid()

sign() → Tensor: См. torch.sign()

sign_() → Tensor: In-place версия sign()

signbit() → Tensor: См. torch.signbit()

sin() → Tensor: См. torch.sin()

sin_() → Tensor: In-place версия sin()

sinc() → Tensor: См. torch.sinc()

sinc_() → Tensor: In-place версия sinc()

sinh() → Tensor: См. torch.sinh()

sinh_() → Tensor: In-place версия sinh()

size(dim=None) → torch.Size or int

Возвращает размер тензора self. Если dim не указан, возвращаемое значение представляет собой torch.Size, подкласс tuple. Если указан dim, возвращает целое число (int), содержащее размер этого измерения.

Параметры:: dim (int, необязательно) – Измерение, для которого необходимо получить размер.

Пример:

>>> t = torch.empty(3, 4, 5)
>>> t.size()
torch.Size([3, 4, 5])
>>> t.size(dim=1)
4

slice_scatter(src, dim=0, start=None, end=None, step=1) → Tensor: См. torch.slice_scatter()

slogdet(): См. torch.slogdet()

smm(mat) → Tensor: См. torch.smm()

softmax(dim) → Tensor: Псевдоним для torch.nn.functional.softmax().

sort(dim=-1, descending=False): См. torch.sort()

sparse_dim() → int

Возвращает количество разреженных измерений в разреженном тензоре self.

Примечание

Возвращает 0, если self не является разреженным тензором.

См. также Tensor.dense_dim() и гибридные тензоры.

sparse_mask(mask) → Tensor

Возвращает новый разреженный тензор со значениями из страйдового тензора self, отфильтрованными по индексам разреженного тензора mask. Значения разреженного тензора mask игнорируются. Тензоры self и mask должны иметь одинаковую форму.

Примечание

Возвращаемый разреженный тензор может содержать дублирующиеся значения, если mask не объединен (coalesced). Поэтому рекомендуется передать mask.coalesce(), если такое поведение нежелательно.

Примечание

Возвращаемый разреженный тензор имеет те же индексы, что и разреженный тензор mask, даже если соответствующие значения в self являются нулями.

Параметры:: mask (Tensor) – разреженный тензор, индексы которого используются в качестве фильтра

Пример:

>>> nse = 5
>>> dims = (5, 5, 2, 2)
>>> I = torch.cat([torch.randint(0, dims[0], size=(nse,)),
...                torch.randint(0, dims[1], size=(nse,))], 0).reshape(2, nse)
>>> V = torch.randn(nse, dims[2], dims[3])
>>> S = torch.sparse_coo_tensor(I, V, dims).coalesce()
>>> D = torch.randn(dims)
>>> D.sparse_mask(S)
tensor(indices=tensor([[0, 0, 0, 2],
                       [0, 1, 4, 3]]),
       values=tensor([[[ 1.6550,  0.2397],
                       [-0.1611, -0.0779]],

                      [[ 0.2326, -1.0558],
                       [ 1.4711,  1.9678]],

                      [[-0.5138, -0.0411],
                       [ 1.9417,  0.5158]],

                      [[ 0.0793,  0.0036],
                       [-0.2569, -0.1055]]]),
       size=(5, 5, 2, 2), nnz=4, layout=torch.sparse_coo)

sparse_resize_(size, sparse_dim, dense_dim) → Tensor

Изменяет размер разреженного тензора self до желаемого размера и количества разреженных и плотных измерений.

Примечание

Если количество указанных элементов в self равно нулю, тогда size, sparse_dim и dense_dim могут иметь любой размер и быть положительными целыми числами, такими что len(size) == sparse_dim + dense_dim.

Однако, если в self указан один или несколько элементов, каждое измерение в size не должно быть меньше соответствующего измерения self, sparse_dim должно быть равно количеству разреженных измерений в self, а dense_dim должно быть равно количеству плотных измерений в self.

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

Вызывает ошибку, если self не является разреженным тензором.

Параметры:

size (torch.Size) – желаемый размер. Если self является непустым разреженным тензором, желаемый размер не может быть меньше исходного размера.
sparse_dim (int) – количество разреженных измерений
dense_dim (int) – количество плотных измерений

sparse_resize_and_clear_(size, sparse_dim, dense_dim) → Tensor

Удаляет все указанные элементы из разреженного тензора self и изменяет размер self до желаемого размера и количества разреженных и плотных измерений.

Параметры:

size (torch.Size) – желаемый размер.
sparse_dim (int) – количество разреженных измерений
dense_dim (int) – количество плотных измерений

split(split_size, dim=0) [исходный код]: См. torch.split()

sqrt() → Tensor: См. torch.sqrt()

sqrt_() → Tensor: In-place версия sqrt()

square() → Tensor: См. torch.square()

square_() → Tensor: In-place версия square()

squeeze(dim=None) → Tensor: См. torch.squeeze()

squeeze_(dim=None) → Tensor: In-place версия squeeze()

sspaddmm(mat1, mat2, *, beta=1, alpha=1) → Tensor: См. torch.sspaddmm()

std(dim=None, *, correction=1, keepdim=False) → Tensor: См. torch.std()

stft(n_fft, hop_length=None, win_length=None, window=None, center=True, pad_mode='reflect', normalized=False, onesided=None, return_complex=None, align_to_window=None) [исходный код]: См. torch.stft()

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

Сигнатура этой функции изменилась в версии 0.4.1. Вызов с предыдущей сигнатурой может привести к ошибке или вернуть некорректный результат.

storage() → torch.TypedStorage [исходный код]: Возвращает базовое TypedStorage.

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

TypedStorage устарело. Оно будет удалено в будущем, и UntypedStorage останется единственным классом хранилища. Чтобы получить доступ к UntypedStorage напрямую, используйте Tensor.untyped_storage().

storage_offset() → int

Возвращает смещение тензора self в базовом хранилище в виде количества элементов хранилища (не байтов).

Пример:

>>> x = torch.tensor([1, 2, 3, 4, 5])
>>> x.storage_offset()
0
>>> x[3:].storage_offset()
3

storage_type() → type [исходный код]: Возвращает тип базового хранилища.

stride(dim) → tuple or int

Возвращает шаг (stride) тензора self.

Шаг (stride) — это смещение, необходимое для перехода от одного элемента к следующему в указанном измерении dim. Если аргумент не передан, возвращается кортеж всех шагов. В противном случае возвращается целочисленное значение в качестве шага в конкретном измерении dim.

Параметры:: dim (int, необязательно) – требуемое измерение, для которого необходим шаг

Пример:

>>> x = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
>>> x.stride()
(5, 1)
>>> x.stride(0)
5
>>> x.stride(-1)
1

sub(other, *, alpha=1) → Tensor: См. torch.sub().

sub_(other, *, alpha=1) → Tensor: In-place версия sub()

subtract(other, *, alpha=1) → Tensor: См. torch.subtract().

subtract_(other, *, alpha=1) → Tensor: In-place версия subtract().

sum(dim=None, keepdim=False, dtype=None) → Tensor: См. torch.sum()

sum_to_size(*size) → Tensor

Суммирует тензор this до размера size. size должен поддерживать транслирование к размеру тензора this.

Параметры:: size (int...) – последовательность целых чисел, определяющая форму выходного тензора.

svd(some=True, compute_uv=True): См. torch.svd()

swapaxes(axis0, axis1) → Tensor: См. torch.swapaxes()

swapaxes_(axis0, axis1) → Tensor: In-place версия swapaxes()

swapdims(dim0, dim1) → Tensor: См. torch.swapdims()

swapdims_(dim0, dim1) → Tensor: In-place версия swapdims()

t() → Tensor: См. torch.t()

t_() → Tensor: In-place версия t()

take(indices) → Tensor: См. torch.take()

take_along_dim(indices, dim) → Tensor: См. torch.take_along_dim()

tan() → Tensor: См. torch.tan()

tan_() → Tensor: In-place версия tan()

tanh() → Tensor: См. torch.tanh()

tanh_() → Tensor: In-place версия tanh()

tensor_split(indices_or_sections, dim=0) → List of Tensors: См. torch.tensor_split()

tile(dims) → Tensor: См. torch.tile()

to(*args, **kwargs) → Tensor

Выполняет преобразование dtype и/или устройства (device) тензора. torch.dtype и torch.device выводятся из аргументов self.to(*args, **kwargs).

Примечание

Если тензор self уже имеет правильные torch.dtype и torch.device, возвращается self. В противном случае возвращаемый тензор является копией self с требуемыми torch.dtype и torch.device.

Примечание

Если self требует градиентов (requires_grad=True), но указанный целевой dtype является целочисленным типом, возвращаемый тензор неявно установит requires_grad=False. Это связано с тем, что требовать градиенты могут только тензоры с типами данных с плавающей запятой или комплексными dtypes.

Ниже приведены способы вызова to:

to(dtype, non_blocking=False, copy=False, memory_format=torch.preserve_format) → Tensor

Возвращает тензор с указанным dtype

Параметры:: memory_format (torch.memory_format, необязательно): желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

Примечание

В соответствии с правилами преобразования типов C++, при преобразовании значения с плавающей запятой в целочисленный тип дробная часть усекается. Если усеченное значение не помещается в целевой тип (например, приведение torch.inf к torch.long), поведение является неопределенным, и результат может отличаться на разных платформах.

to(device=None, dtype=None, non_blocking=False, copy=False, memory_format=torch.preserve_format) → Tensor

Возвращает тензор с указанным device и (необязательно) dtype. Если dtype равно None, предполагается, что оно равно self.dtype. Когда для non_blocking задано True, функция пытается выполнить преобразование асинхронно по отношению к хосту, если это возможно. Это асинхронное поведение применимо как к pinned, так и к постраничной (pageable) памяти. Тем не менее при использовании этой функции рекомендуется соблюдать осторожность. Дополнительную информацию см. в руководстве по правильному использованию non_blocking и pin_memory. Если задан copy, создается новый тензор, даже если тензор уже соответствует требуемому преобразованию.

Параметры:: memory_format (torch.memory_format, необязательно): желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

to(other, non_blocking=False, copy=False) → Tensor: Возвращает тензор с теми же torch.dtype и torch.device, что и у тензора other. Когда для non_blocking задано True, функция пытается выполнить преобразование асинхронно по отношению к хосту, если это возможно. Это асинхронное поведение применимо как к pinned, так и к постраничной (pageable) памяти. Тем не менее при использовании этой функции рекомендуется соблюдать осторожность. Дополнительную информацию см. в руководстве по правильному использованию non_blocking и pin_memory. Если задан copy, создается новый тензор, даже если тензор уже соответствует требуемому преобразованию.

Примечание

Когда non_blocking равно True и преобразование выполняется в потоке CUDA, отличном от потока по умолчанию, вызывающая сторона отвечает за корректную межпотоковую синхронизацию. См. раздел CUDA streams для получения сведений о необходимом паттерне.

Пример:

>>> tensor = torch.randn(2, 2)  # Initially dtype=float32, device=cpu
>>> tensor.to(torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64)

>>> cuda0 = torch.device('cuda:0')
>>> tensor.to(cuda0)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], device='cuda:0')

>>> tensor.to(cuda0, dtype=torch.float64)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')

>>> other = torch.randn((), dtype=torch.float64, device=cuda0)
>>> tensor.to(other, non_blocking=True)
tensor([[-0.5044,  0.0005],
        [ 0.3310, -0.0584]], dtype=torch.float64, device='cuda:0')

to_mkldnn() → Tensor: Возвращает копию тензора в макете torch.mkldnn.

to_padded_tensor(padding, output_size=None) → Tensor: См. to_padded_tensor()

to_sparse(sparseDims) → Tensor

Возвращает разреженную копию тензора. PyTorch поддерживает разреженные тензоры в координатном формате.

Параметры:: sparseDims (int, необязательно) – количество разреженных измерений, которые следует включить в новый разреженный тензор

Пример:

>>> d = torch.tensor([[0, 0, 0], [9, 0, 10], [0, 0, 0]])
>>> d
tensor([[ 0,  0,  0],
        [ 9,  0, 10],
        [ 0,  0,  0]])
>>> d.to_sparse()
tensor(indices=tensor([[1, 1],
                       [0, 2]]),
       values=tensor([ 9, 10]),
       size=(3, 3), nnz=2, layout=torch.sparse_coo)
>>> d.to_sparse(1)
tensor(indices=tensor([[1]]),
       values=tensor([[ 9,  0, 10]]),
       size=(3, 3), nnz=1, layout=torch.sparse_coo)

to_sparse(*, layout=None, blocksize=None, dense_dim=None) → Tensor

Возвращает разреженный тензор с указанным макетом и размером блока (blocksize). Если self является strided-тензором, можно указать количество плотных измерений, и будет создан гибридный разреженный тензор с dense_dim плотными измерениями и self.dim() - 2 - dense_dim пакетным измерением.

Примечание

Если параметры layout и blocksize у self совпадают с указанными layout и blocksize, возвращается self. В противном случае возвращается разреженная копия тензора self.

Параметры:

layout (torch.layout, необязательно) – Желаемый разреженный макет (layout). Один из torch.sparse_coo, torch.sparse_csr, torch.sparse_csc, torch.sparse_bsr или torch.sparse_bsc. По умолчанию: если None, torch.sparse_coo.
blocksize (list, tuple, torch.Size, необязательно) – Размер блока результирующего тензора BSR или BSC. Для других макетов указание размера блока, отличного от None, приведет к исключению RuntimeError. Размер блока должен быть кортежем длины два, элементы которого делят нацело два разреженных измерения.
dense_dim (int, необязательно) – Количество плотных измерений результирующего CSR, CSC, BSR или BSC тензора. Этот аргумент следует использовать только в том случае, если self является strided-тензором, и его значение должно быть от 0 до размерности тензора self минус два.

Пример:

>>> x = torch.tensor([[1, 0], [0, 0], [2, 3]])
>>> x.to_sparse(layout=torch.sparse_coo)
tensor(indices=tensor([[0, 2, 2],
                       [0, 0, 1]]),
       values=tensor([1, 2, 3]),
       size=(3, 2), nnz=3, layout=torch.sparse_coo)
>>> x.to_sparse(layout=torch.sparse_bsr, blocksize=(1, 2))
tensor(crow_indices=tensor([0, 1, 1, 2]),
       col_indices=tensor([0, 0]),
       values=tensor([[[1, 0]],
                      [[2, 3]]]), size=(3, 2), nnz=2, layout=torch.sparse_bsr)
>>> x.to_sparse(layout=torch.sparse_bsr, blocksize=(2, 1))
RuntimeError: Tensor size(-2) 3 needs to be divisible by blocksize[0] 2
>>> x.to_sparse(layout=torch.sparse_csr, blocksize=(3, 1))
RuntimeError: to_sparse for Strided to SparseCsr conversion does not use specified blocksize

>>> x = torch.tensor([[[1], [0]], [[0], [0]], [[2], [3]]])
>>> x.to_sparse(layout=torch.sparse_csr, dense_dim=1)
tensor(crow_indices=tensor([0, 1, 1, 3]),
       col_indices=tensor([0, 0, 1]),
       values=tensor([[1],
                      [2],
                      [3]]), size=(3, 2, 1), nnz=3, layout=torch.sparse_csr)

to_sparse_bsc(blocksize, dense_dim) → Tensor

Преобразует тензор в формат хранения блочно-разреженных столбцов (BSC) заданного размера блока blocksize. Если self является strided-тензором, можно указать количество плотных измерений, и будет создан гибридный BSC-тензор с dense_dim плотными измерениями и self.dim() - 2 - dense_dim пакетным измерением.

Параметры:

blocksize (list, tuple, torch.Size, необязательно) – Размер блока результирующего тензора BSC. Размер блока должен быть кортежем длины два, элементы которого делят нацело два разреженных измерения.
dense_dim (int, необязательно) – Количество плотных измерений результирующего BSC-тензора. Этот аргумент следует использовать только в том случае, если self является strided-тензором, и его значение должно быть от 0 до размерности тензора self минус два.

Пример:

>>> dense = torch.randn(10, 10)
>>> sparse = dense.to_sparse_csr()
>>> sparse_bsc = sparse.to_sparse_bsc((5, 5))
>>> sparse_bsc.row_indices()
tensor([0, 1, 0, 1])

>>> dense = torch.zeros(4, 3, 1)
>>> dense[0:2, 0] = dense[0:2, 2] = dense[2:4, 1] = 1
>>> dense.to_sparse_bsc((2, 1), 1)
tensor(ccol_indices=tensor([0, 1, 2, 3]),
       row_indices=tensor([0, 1, 0]),
       values=tensor([[[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]]]), size=(4, 3, 1), nnz=3,
       layout=torch.sparse_bsc)

to_sparse_bsr(blocksize, dense_dim) → Tensor

Преобразует тензор в формат хранения блочно-разреженных строк (BSR) заданного размера блока blocksize. Если self является strided-тензором, можно указать количество плотных измерений, и будет создан гибридный BSR-тензор с dense_dim плотными измерениями и self.dim() - 2 - dense_dim пакетным измерением.

Параметры:

blocksize (list, tuple, torch.Size, необязательно) – Размер блока результирующего тензора BSR. Размер блока должен быть кортежем длины два, элементы которого делят нацело два разреженных измерения.
dense_dim (int, необязательно) – Количество плотных измерений результирующего BSR-тензора. Этот аргумент следует использовать только в том случае, если self является strided-тензором, и его значение должно быть от 0 до размерности тензора self минус два.

Пример:

>>> dense = torch.randn(10, 10)
>>> sparse = dense.to_sparse_csr()
>>> sparse_bsr = sparse.to_sparse_bsr((5, 5))
>>> sparse_bsr.col_indices()
tensor([0, 1, 0, 1])

>>> dense = torch.zeros(4, 3, 1)
>>> dense[0:2, 0] = dense[0:2, 2] = dense[2:4, 1] = 1
>>> dense.to_sparse_bsr((2, 1), 1)
tensor(crow_indices=tensor([0, 2, 3]),
       col_indices=tensor([0, 2, 1]),
       values=tensor([[[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]],


                      [[[1.]],

                       [[1.]]]]), size=(4, 3, 1), nnz=3,
       layout=torch.sparse_bsr)

to_sparse_coo() [исходный код]

Преобразует тензор в координатный формат.

Примеры:

>>> dense = torch.randn(5, 5)
>>> sparse = dense.to_sparse_coo()
>>> sparse._nnz()
25

to_sparse_csc() → Tensor

Преобразует тензор в формат сжатого хранения по столбцам (CSC). За исключением strided-тензоров, работает только с двумерными (2D) тензорами. Если self является strided-тензором, можно указать количество плотных измерений, и будет создан гибридный CSC-тензор с dense_dim плотными измерениями и self.dim() - 2 - dense_dim пакетным измерением.

Параметры:: dense_dim (int, необязательно) – Количество плотных измерений результирующего CSC-тензора. Этот аргумент следует использовать только в том случае, если self является strided-тензором, и его значение должно быть от 0 до размерности тензора self минус два.

Пример:

>>> dense = torch.randn(5, 5)
>>> sparse = dense.to_sparse_csc()
>>> sparse._nnz()
25

>>> dense = torch.zeros(3, 3, 1, 1)
>>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
>>> dense.to_sparse_csc(dense_dim=2)
tensor(ccol_indices=tensor([0, 1, 2, 3]),
       row_indices=tensor([0, 2, 1]),
       values=tensor([[[1.]],

                      [[1.]],

                      [[1.]]]), size=(3, 3, 1, 1), nnz=3,
       layout=torch.sparse_csc)

to_sparse_csr(dense_dim=None) → Tensor

Преобразует тензор в формат сжатого хранения по строкам (CSR). За исключением strided-тензоров, работает только с двумерными (2D) тензорами. Если self является strided-тензором, можно указать количество плотных измерений, и будет создан гибридный CSR-тензор с dense_dim плотными измерениями и self.dim() - 2 - dense_dim пакетным измерением.

Параметры:: dense_dim (int, необязательно) – Количество плотных измерений результирующего CSR-тензора. Этот аргумент следует использовать только в том случае, если self является strided-тензором, и его значение должно быть от 0 до размерности тензора self минус два.

Пример:

>>> dense = torch.randn(5, 5)
>>> sparse = dense.to_sparse_csr()
>>> sparse._nnz()
25

>>> dense = torch.zeros(3, 3, 1, 1)
>>> dense[0, 0] = dense[1, 2] = dense[2, 1] = 1
>>> dense.to_sparse_csr(dense_dim=2)
tensor(crow_indices=tensor([0, 1, 2, 3]),
       col_indices=tensor([0, 2, 1]),
       values=tensor([[[1.]],

                      [[1.]],

                      [[1.]]]), size=(3, 3, 1, 1), nnz=3,
       layout=torch.sparse_csr)

tolist() → list or number

Возвращает тензор в виде (вложенного) списка. Для скаляров возвращается стандартное число Python, как и в случае с item(). При необходимости тензоры сначала автоматически перемещаются на CPU.

Эта операция не является дифференцируемой.

Примеры:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803

topk(k, dim=None, largest=True, sorted=True): См. torch.topk()

trace() → Tensor: См. torch.trace()

transpose(dim0, dim1) → Tensor: См. torch.transpose()

transpose_(dim0, dim1) → Tensor: In-place версия transpose()

triangular_solve(A, upper=True, transpose=False, unitriangular=False): См. torch.triangular_solve()

tril(diagonal=0) → Tensor: См. torch.tril()

tril_(diagonal=0) → Tensor: In-place версия tril()

triu(diagonal=0) → Tensor: См. torch.triu()

triu_(diagonal=0) → Tensor: In-place версия triu()

true_divide(value) → Tensor: См. torch.true_divide()

true_divide_(value) → Tensor: In-place версия true_divide_()

trunc() → Tensor: См. torch.trunc()

trunc_() → Tensor: In-place версия trunc()

type(dtype=None, non_blocking=False, **kwargs) → str or Tensor

Возвращает тип, если dtype не предоставлен, иначе приводит этот объект к указанному типу.

Если объект уже имеет правильный тип, копирование не выполняется и возвращается исходный объект.

Параметры:

dtype (dtype или string) – Желаемый тип
non_blocking (bool) – Если True, а источник находится в pinned-памяти, а целевой объект — на GPU, или наоборот, копирование выполняется асинхронно по отношению к хосту. В противном случае аргумент не имеет эффекта.
**kwargs – Для совместимости может содержать ключ async вместо аргумента non_blocking. Аргумент async устарел (deprecated).

type_as(tensor) → Tensor

Возвращает этот тензор, приведенный к типу указанного тензора.

Это пустая операция (no-op), если тензор уже имеет правильный тип. Это эквивалентно self.type(tensor.type())

Параметры:: tensor (Tensor) – тензор, имеющий требуемый тип

unbind(dim=0) → seq: См. torch.unbind()

unflatten(dim, sizes) → Tensor [исходный код]: См. torch.unflatten().

unfold(dimension, size, step) → Tensor

Возвращает представление (view) исходного тензора, которое содержит все срезы размера size из тензора self по измерению dimension.

Шаг между двумя срезами задается параметром step.

Если sizedim — это размер измерения dimension для self, размер измерения dimension в возвращаемом тензоре будет равен (sizedim - size) / step + 1.

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

Параметры:

dimension (int) – измерение, по которому происходит развертывание (unfolding)
size (int) – размер каждого развертываемого среза
step (int) – шаг между каждым срезом

Пример:

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

uniform_(from=0, to=1, *, generator=None) → Tensor: Заполняет тензор self числами, выбранными из непрерывного равномерного распределения:

$f(x) = \dfrac{1}{\text{to} - \text{from}}$

unique(sorted=True, return_inverse=False, return_counts=False, dim=None) [исходный код]

Возвращает уникальные элементы входного тензора.

См. torch.unique()

unique_consecutive(return_inverse=False, return_counts=False, dim=None) [исходный код]

Исключает все элементы, кроме первого, из каждой последовательной группы эквивалентных элементов.

См. torch.unique_consecutive()

unsafe_chunk(chunks, dim=0) → List of Tensors: См. torch.unsafe_chunk()

unsafe_split(split_size, dim=0) → List of Tensors: См. torch.unsafe_split()

unsqueeze(dim) → Tensor: См. torch.unsqueeze()

unsqueeze_(dim) → Tensor: In-place версия unsqueeze()

untyped_storage() → torch.UntypedStorage: Возвращает базовое хранилище UntypedStorage.

values() → Tensor

Возвращает тензор значений разреженного COO-тензора.

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

Вызывает ошибку, если self не является разреженным COO-тензором.

См. также Tensor.indices().

Примечание

var(dim=None, *, correction=1, keepdim=False) → Tensor: См. torch.var()

vdot(other) → Tensor: См. torch.vdot()

view(*shape) → Tensor

Возвращает новый тензор с теми же данными, что и тензор self, но с другой формой shape.

Возвращаемый тензор разделяет те же данные и должен иметь то же количество элементов, но может иметь другой размер. Для того чтобы тензор можно было представить в виде представления (view), новый размер представления должен быть совместим с его исходным размером и шагом (stride), то есть каждое новое измерение представления должно быть либо подпространством исходного измерения, либо охватывать только исходные измерения $d, d+1, \dots, d+k$ , удовлетворяющие следующему условию, аналогичному условию непрерывности: $\forall i = d, \dots, d+k-1$ ,

\text{stride}[i] = \text{stride}[i+1] \times \text{size}[i+1]

В противном случае будет невозможно представить тензор self в виде shape без его копирования (например, с помощью contiguous()). Если неясно, может ли быть выполнена операция view(), рекомендуется использовать reshape(), которая возвращает представление, если формы совместимы, и копирует (эквивалентно вызову contiguous()) в противном случае.

Параметры:: shape (torch.Size или int...) – желаемый размер

Пример:

>>> x = torch.randn(4, 4)
>>> x.size()
torch.Size([4, 4])
>>> y = x.view(16)
>>> y.size()
torch.Size([16])
>>> z = x.view(-1, 8)  # the size -1 is inferred from other dimensions
>>> z.size()
torch.Size([2, 8])

>>> a = torch.randn(1, 2, 3, 4)
>>> a.size()
torch.Size([1, 2, 3, 4])
>>> b = a.transpose(1, 2)  # Swaps 2nd and 3rd dimension
>>> b.size()
torch.Size([1, 3, 2, 4])
>>> c = a.view(1, 3, 2, 4)  # Does not change tensor layout in memory
>>> c.size()
torch.Size([1, 3, 2, 4])
>>> torch.equal(b, c)
False

view(dtype) → Tensor

Возвращает новый тензор с теми же данными, что и тензор self, но с другим dtype.

Если размер элемента dtype отличается от размера элемента self.dtype, то размер последнего измерения выходных данных будет масштабирован пропорционально. Например, если размер элемента dtype в два раза больше размера элемента self.dtype, то каждая пара элементов в последнем измерении self будет объединена, а размер последнего измерения выходных данных будет в два раза меньше, чем у self. Если размер элемента dtype в два раза меньше размера элемента self.dtype, то каждый элемент в последнем измерении self будет разделен на два, а размер последнего измерения выходных данных будет в два раза больше, чем у self. Для того чтобы это было возможно, должны выполняться следующие условия:

self.dim() должно быть больше 0.
self.stride(-1) должно быть равно 1.

Кроме того, если размер элемента dtype больше размера элемента self.dtype, также должны выполняться следующие условия:

self.size(-1) должно делиться на отношение размеров элементов типов данных.
self.storage_offset() должно делиться на отношение размеров элементов типов данных.
Шаги всех измерений, кроме последнего, должны делиться на отношение размеров элементов типов данных.

Если хотя бы одно из приведенных выше условий не выполняется, генерируется ошибка.

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

Эта перегрузка не поддерживается TorchScript, и её использование в программе Torchscript приведёт к неопределённому поведению.

Параметры:: dtype (torch.dtype) – желаемый dtype

Пример:

>>> x = torch.randn(4, 4)
>>> x
tensor([[ 0.9482, -0.0310,  1.4999, -0.5316],
        [-0.1520,  0.7472,  0.5617, -0.8649],
        [-2.4724, -0.0334, -0.2976, -0.8499],
        [-0.2109,  1.9913, -0.9607, -0.6123]])
>>> x.dtype
torch.float32

>>> y = x.view(torch.int32)
>>> y
tensor([[ 1064483442, -1124191867,  1069546515, -1089989247],
        [-1105482831,  1061112040,  1057999968, -1084397505],
        [-1071760287, -1123489973, -1097310419, -1084649136],
        [-1101533110,  1073668768, -1082790149, -1088634448]],
    dtype=torch.int32)
>>> y[0, 0] = 1000000000
>>> x
tensor([[ 0.0047, -0.0310,  1.4999, -0.5316],
        [-0.1520,  0.7472,  0.5617, -0.8649],
        [-2.4724, -0.0334, -0.2976, -0.8499],
        [-0.2109,  1.9913, -0.9607, -0.6123]])

>>> x.view(torch.cfloat)
tensor([[ 0.0047-0.0310j,  1.4999-0.5316j],
        [-0.1520+0.7472j,  0.5617-0.8649j],
        [-2.4724-0.0334j, -0.2976-0.8499j],
        [-0.2109+1.9913j, -0.9607-0.6123j]])
>>> x.view(torch.cfloat).size()
torch.Size([4, 2])

>>> x.view(torch.uint8)
tensor([[  0, 202, 154,  59, 182, 243, 253, 188, 185, 252, 191,  63, 240,  22,
           8, 191],
        [227, 165,  27, 190, 128,  72,  63,  63, 146, 203,  15,  63,  22, 106,
          93, 191],
        [205,  59,  30, 192, 112, 206,   8, 189,   7,  95, 152, 190,  12, 147,
          89, 191],
        [ 43, 246,  87, 190, 235, 226, 254,  63, 111, 240, 117, 191, 177, 191,
          28, 191]], dtype=torch.uint8)
>>> x.view(torch.uint8).size()
torch.Size([4, 16])

view_as(other) → Tensor

Отображает данный тензор с тем же размером, что и у other. self.view_as(other) эквивалентно self.view(other.size()).

Дополнительную информацию о view см. в view().

Параметры:: other (torch.Tensor) – Результирующий тензор имеет тот же размер, что и other.

vsplit(split_size_or_sections) → List of Tensors: См. torch.vsplit()

where(condition, y) → Tensor: self.where(condition, y) эквивалентно torch.where(condition, self, y). См. torch.where()

xlogy(other) → Tensor: См. torch.xlogy()

xlogy_(other) → Tensor: In-place версия xlogy()

xpu(device=None, non_blocking=False, memory_format=torch.preserve_format) → Tensor

Возвращает копию этого объекта в памяти XPU.

Если данный объект уже находится в памяти XPU и на правильном устройстве, копирование не выполняется и возвращается исходный объект.

Параметры:

device (torch.device, опционально) – Целевое устройство XPU. По умолчанию используется текущее устройство XPU.
non_blocking (bool, опционально) – Если True и источник находится в закрепленной памяти (pinned memory), копирование будет асинхронным по отношению к хосту. В противном случае аргумент не имеет эффекта. По умолчанию: False.
memory_format (torch.memory_format, опционально) – желаемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

zero_() → Tensor: Заполняет тензор self нулями.

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