SparseSemiStructuredTensorCUSPARSELT

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

Бэкенд cuSPARSELt ожидает, что указанные элементы и метаданные будут храниться в одном тензоре: packed = [ указанные элементы исходного тензора | метаданные ] Для исходного тензора размера (m, k) мы ожидаем, что первые m * k // 2 элементов будут сохранёнными элементами. Остальная часть тензора — метаданные. Поскольку тензор только один, мы используем соответственно только атрибуты packed и packed_t.

cuSPARSELt также поддерживает объединение с транспонированием, необходимое для эффективного разреженного обучения 2:4, а также задание alg_id — конфигурации, влияющей на производительность matmul в зависимости от размеров matmul.

H

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

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

См. также

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

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: Версия abs(), выполняющая операцию на месте

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

absolute_() → Tensor: Версия absolute(), выполняющая операцию на месте. Псевдоним для abs_()

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

acos_() → Tensor: Версия acos(), выполняющая операцию на месте

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

acosh_() → Tensor: Версия acosh(), выполняющая операцию на месте

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

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

Если other — тензор, его форма other должна быть совместимой для широковещательного распространения с формой базового тензора.

См. torch.add()

add_(other, *, alpha=1) → Tensor: Версия add(), выполняющая операцию на месте

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

addbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor: Версия addbmm(), выполняющая операцию на месте

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

addcdiv_(tensor1, tensor2, *, value=1) → Tensor: Версия addcdiv(), выполняющая операцию на месте

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

addcmul_(tensor1, tensor2, *, value=1) → Tensor: Версия addcmul(), выполняющая операцию на месте

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

addmm_(mat1, mat2, *, beta=1, alpha=1) → Tensor: Версия addmm(), выполняющая операцию на месте

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

addmv_(mat, vec, *, beta=1, alpha=1) → Tensor: Версия addmv(), выполняющая операцию на месте

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

addr_(vec1, vec2, *, beta=1, alpha=1) → Tensor: Версия 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: Версия arccos(), выполняющая операцию на месте

arccosh()

acosh() -> Tensor

См. torch.arccosh()

arccosh_()

acosh_() -> Tensor

Версия arccosh(), выполняющая операцию на месте

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

arcsin_() → Tensor: Версия arcsin(), выполняющая операцию на месте

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

arcsinh_() → Tensor: Версия arcsinh(), выполняющая операцию на месте

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

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

arctan2_()

atan2_(other) -> Tensor

Версия arctan2(), выполняющая операцию на месте

arctan_() → Tensor: Версия arctan(), выполняющая операцию на месте

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

arctanh_(other) → Tensor: Версия 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: Версия 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: Версия asin(), выполняющая операцию на месте

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

asinh_() → Tensor: Версия asinh(), выполняющая операцию на месте

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

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

atan2_(other) → Tensor: Версия atan2(), выполняющая операцию на месте

atan_() → Tensor: Версия atan(), выполняющая операцию на месте

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

atanh_(other) → Tensor: Версия atanh(), выполняющая операцию на месте

backward(gradient=None, retain_graph=None, create_graph=False, inputs=None) [исходный код]

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

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

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

Примечание

Если вы выполняете прямые операции, создаёте 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] or dict[str, Tensor], необязательный) – Входные данные, относительно которых градиент будет накапливаться в .grad. Все остальные тензоры будут игнорироваться. Если параметр не задан, градиент накапливается во всех листовых тензорах, использованных для вычисления tensors. Также допускается словарь тензоров (например, dict(model.named_parameters())). По умолчанию — None.

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

baddbmm_(batch1, batch2, *, beta=1, alpha=1) → Tensor: Версия 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: Версия bitwise_and(), выполняющая операцию на месте

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

bitwise_left_shift_(other) → Tensor: Версия bitwise_left_shift(), изменяющая тензор на месте

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

bitwise_not_() → Tensor: Версия bitwise_not(), изменяющая тензор на месте

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

bitwise_or_() → Tensor: Версия bitwise_or(), изменяющая тензор на месте

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

bitwise_right_shift_(other) → Tensor: Версия bitwise_right_shift(), изменяющая тензор на месте

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

bitwise_xor_() → Tensor: Версия 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: Версия 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: Версия 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

Возвращает объединённую копию 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: Версия conj_physical(), изменяющая тензор на месте

const_data_ptr() → int

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

В отличие от data_ptr(), этот метод гарантированно обеспечивает доступ только для чтения и не инициирует материализацию при копировании при записи. Для обычных тензоров (без 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 должен быть совместимым для широковещательного распространения с тензором self. Они могут иметь разные типы данных или находиться на разных устройствах.

Параметры:

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

Примечание

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

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

copysign_(other) → Tensor: Версия copysign(), изменяющая тензор на месте

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

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

cos_() → Tensor: Версия cos(), изменяющая тензор на месте

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

cosh_() → Tensor: Версия 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 и исходный тензор находится в закреплённой памяти, копирование будет выполняться асинхронно относительно хоста. В противном случае аргумент не влияет на выполнение. По умолчанию: 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: Версия cumprod(), изменяющая тензор на месте

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

cumsum_(dim, dtype=None) → Tensor: Версия cumsum(), изменяющая тензор на месте

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

Примечание

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

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

deg2rad_() → Tensor: Версия deg2rad(), изменяющая тензор на месте

dense_dim() → int

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

Примечание

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

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

dequantize() → Tensor: Для квантованного тензора выполняет деквантование и возвращает тензор с деквантованными значениями типа float.

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

detach()

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

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

Этот метод также влияет на градиенты прямого режима AD; результат никогда не будет иметь градиентов прямого режима AD.

Примечание

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

detach_()

Отсоединяет тензор от графа, в котором он был создан, превращая его в листовой узел. Представления нельзя отсоединить на месте.

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: Версия digamma() с изменением на месте

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

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

Возвращает однозначно определяемый кортеж целых чисел, описывающий порядок измерений или физическую раскладку тензора 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: Версия div() с изменением на месте

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

divide_(value, *, rounding_mode=None) → Tensor: Версия 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: Версия eq() с изменением на месте

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

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

erf_() → Tensor: Версия erf() с изменением на месте

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

erfc_() → Tensor: Версия erfc() с изменением на месте

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

erfinv_() → Tensor: Версия erfinv() с изменением на месте

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

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

exp2_() → Tensor: Версия exp2() с изменением на месте

exp_() → Tensor: Версия exp() с изменением на месте

expand(*size) → Tensor

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

Значение -1 для размера измерения означает, что размер этого измерения не изменяется.

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

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

Примечание

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

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

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

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

Пример:

>>> 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: Версия expm1() с изменением на месте

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

$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, все измерения входного тензора должны иметь одинаковую длину. Эта функция изменяет входной тензор на месте и возвращает его.

Параметры:

fill_value (скаляр) – значение для заполнения
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: Версия 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: Версия float_power() с изменением на месте

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

floor_() → Tensor: Версия floor() с изменением на месте

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

floor_divide_(value) → Tensor: Версия floor_divide() с изменением на месте

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

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

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

fmod_(divisor) → Tensor: Версия fmod() с изменением на месте

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

frac_() → Tensor: Версия frac() с изменением на месте

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

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

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

gcd_(other) → Tensor: Версия gcd() с изменением на месте

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

ge_(other) → Tensor: Версия 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 эта функция возвращает порядковый номер устройства GPU, в котором находится тензор. Для тензоров CPU эта функция возвращает -1.

Пример:

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

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

grad_dtype

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

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

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

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

Пример:

>>> 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: Версия greater() с изменением на месте.

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

greater_equal_(other) → Tensor: Версия greater_equal() с изменением на месте.

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

gt_(other) → Tensor: Версия 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: Версия 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: Версия hypot(), изменяющая данные на месте

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

i0_() → Tensor: Версия i0(), изменяющая данные на месте

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

igamma_(other) → Tensor: Версия igamma(), изменяющая данные на месте

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

igammac_(other) → Tensor: Версия igammac(), изменяющая данные на месте

imag

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

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

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

Пример:

>>> 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) [исходный код]

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

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

Параметры:

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

Возвращает:

Первоклассный тензор с указанными связанными измерениями

index_add(dim, index, source, *, alpha=1) → Tensor: Версия 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; в противном случае будет вызвана ошибка.

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

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 для выбора; тип данных должен быть 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: Версия 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: Версия 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: Версия 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) – тензор того же типа данных, что и 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, для которых выполняется накопление, считаются заполненными нейтральными элементами редукции.

Для 3D-тензора с 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 для накопления; тип данных должен быть 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().

Примечание

Этот метод можно вызвать только для объединённого разреженного тензора. Подробности см. в 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() возвращает тензор CPU с типом данных 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 в объединённом виде, и 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.

Во время вызова backward() градиент grad заполняется только у листовых тензоров. Чтобы градиент 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, если Tensor является метатензором, и False в противном случае. Метатензоры похожи на обычные тензоры, но не содержат данных.

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

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

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

is_quantized: Равно True, если Tensor квантован, и False в противном случае.

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

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

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

Для тензоров CUDA результат всегда True.

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

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

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

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

is_xpu: Равно True, если Tensor хранится на 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) [исходный код]: См. 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: Версия lcm() с изменением на месте.

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

ldexp_(other) → Tensor: Версия ldexp() с изменением на месте.

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

le_(other) → Tensor: Версия le() с изменением на месте.

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

lerp_(end, weight) → Tensor: Версия lerp() с изменением на месте.

less()

lt(other) -> Tensor

См. torch.less().

less_(other) → Tensor: Версия less() с изменением на месте.

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

less_equal_(other) → Tensor: Версия less_equal() с изменением на месте.

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

lgamma_() → Tensor: Версия lgamma() с изменением на месте.

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

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

log10_() → Tensor: Версия log10() с изменением на месте.

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

log1p_() → Tensor: Версия log1p() с изменением на месте.

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

log2_() → Tensor: Версия log2() с изменением на месте.

log_() → Tensor: Версия 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: Версия logical_and() с изменением на месте.

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

logical_not_() → Tensor: Версия logical_not() с изменением на месте.

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

logical_or_() → Tensor: Версия logical_or() с изменением на месте.

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

logical_xor_() → Tensor: Версия logical_xor() с изменением на месте.

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

logit_() → Tensor: Версия 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, необязательный) – требуемый формат памяти возвращаемого Tensor. По умолчанию: torch.preserve_format.

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

lt_(other) → Tensor: Версия lt() с изменением на месте.

lu(pivot=True, get_infos=False) [исходный код]: См. torch.lu()

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

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

mT

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

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

map_(tensor, callable)

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

Функция callable должна иметь сигнатуру:

def callable(a, b) -> number

masked_fill(mask, value) → Tensor: Версия без изменения на месте метода torch.Tensor.masked_fill_()

masked_fill_(mask, value)

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

Параметры:

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

masked_scatter(mask, tensor) → Tensor

Версия без изменения на месте метода torch.Tensor.masked_scatter_()

Примечание

Входные данные self и mask выполняют широковещание.

Пример

>>> 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 и далее по порядку, по одному элементу для каждого вхождения True в mask. Форма mask должна поддерживать широковещание с формой базового тензора. Тензор 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) – значение в словаре состояния с ключом, соответствующим 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, необязательно) – целевое устройство MTIA. По умолчанию используется текущее устройство MTIA.
non_blocking (bool, необязательно) – если True и исходный объект находится в закреплённой памяти, копирование будет асинхронным относительно хоста. В противном случае аргумент не влияет на выполнение. По умолчанию: False.
memory_format (torch.memory_format, необязательно) – требуемый формат памяти возвращаемого тензора. По умолчанию: torch.preserve_format.

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

mul_(value) → Tensor: Версия mul() с изменением на месте.

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

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

multiply_(value) → Tensor: Версия multiply() с изменением на месте.

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

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

mvlgamma_(p) → Tensor: Версия 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: Версия 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: Версия ne() с изменением на месте.

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

neg_() → Tensor: Версия neg() с изменением на месте

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

negative_() → Tensor: Версия 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, необязательно) – требуемый тип возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.dtype, как у этого тензора.
device (torch.device, необязательно) – требуемое устройство возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.device, как у этого тензора.
requires_grad (bool, необязательно) – следует ли автограду записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, необязательно) – требуемый формат возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, необязательно) – если задано, возвращаемый тензор будет выделен в закреплённой памяти. Работает только для тензоров 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 и с шагами stride, заполненный неинициализированными данными. По умолчанию возвращаемый тензор имеет такие же torch.dtype и torch.device, что и этот тензор.

Параметры:

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

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

dtype (torch.dtype, необязательно) – требуемый тип возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.dtype, как у этого тензора.
device (torch.device, необязательно) – требуемое устройство возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.device, как у этого тензора.
requires_grad (bool, необязательно) – следует ли автограду записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, необязательно) – требуемый формат возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, необязательно) – если задано, возвращаемый тензор будет выделен в закреплённой памяти. Работает только для тензоров 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 (скаляр) – число, которым заполняется выходной тензор.

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

dtype (torch.dtype, необязательно) – требуемый тип возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.dtype, как у этого тензора.
device (torch.device, необязательно) – требуемое устройство возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.device, как у этого тензора.
requires_grad (bool, необязательно) – следует ли автограду записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, необязательно) – требуемый формат возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, необязательно) – если задано, возвращаемый тензор будет выделен в закреплённой памяти. Работает только для тензоров 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, необязательно) – требуемый тип возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.dtype, как у этого тензора.
device (torch.device, необязательно) – требуемое устройство возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.device, как у этого тензора.
requires_grad (bool, необязательно) – следует ли автограду записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, необязательно) – требуемый формат возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, необязательно) – если задано, возвращаемый тензор будет выделен в закреплённой памяти. Работает только для тензоров 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().

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

Если данные являются тензором x, new_tensor() считывает «данные» из переданного объекта и создаёт листовую переменную. Поэтому 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, необязательно) – требуемый тип возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.dtype, как у этого тензора.
device (torch.device, необязательно) – требуемое устройство возвращаемого тензора. По умолчанию: если значение равно None, используется такое же torch.device, как у этого тензора.
requires_grad (bool, необязательно) – следует ли автограду записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, необязательно) – требуемый формат возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, необязательно) – если задано, возвращаемый тензор будет выделен в закреплённой памяти. Работает только для тензоров 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, необязательно) – требуемый тип возвращаемого тензора. По умолчанию: если None, такой же torch.dtype, как у этого тензора.
device (torch.device, необязательно) – требуемое устройство возвращаемого тензора. По умолчанию: если None, такое же torch.device, как у этого тензора.
requires_grad (bool, необязательно) – следует ли autograd записывать операции над возвращаемым тензором. По умолчанию: False.
layout (torch.layout, необязательно) – требуемый формат возвращаемого тензора. По умолчанию: torch.strided.
pin_memory (bool, необязательно) – если задано, возвращаемый тензор будет выделен в закреплённой памяти. Работает только для тензоров 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: Версия 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: Версия not_equal(), изменяющая тензор на месте.

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

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

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

Если force равно False (значение по умолчанию), преобразование выполняется только в том случае, если тензор находится на CPU, не требует вычисления градиента, для него не установлен бит сопряжения, а его dtype и layout поддерживаются 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

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

Параметры:: dims (torch.Size, int..., tuple of int or list of 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: Копирует тензор в закреплённую память, если он ещё не закреплён. По умолчанию устройством закреплённой памяти будет текущий ускоритель.

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

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

polygamma_(n) → Tensor: Версия polygamma(), изменяющая тензор на месте

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

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

pow_(exponent) → Tensor: Версия pow(), изменяющая тензор на месте

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

classmethod prune_dense_static_sort(original_tensor, algorithm='') [источник]

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

Единственное функциональное отличие заключается в том, что cuSPARSELt сохраняет metadata и packed вместе в одном тензоре.

[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 cuSPARSELT semi-structured -> packed
[1 2 6 2]                       [0 0 6 2]

                                          -> pack to transposed cuSPARSELt      -> packed_t
                                             semi-structured representation

                                          -> compute swizzled bitmask           -> compressed_swizzled_bitmask

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

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

pruned = _sparse_semi_structured_tile(dense)
packed_cusparselt = torch._cslt_compress(pruned)
packed_t_cusparselt = torch._cslt_compress(pruned.t().contiguous())
bitmask = _compute_compressed_swizzled_bitmask(pruned)

SparseSemiStructuredTensorCUSPARSELT(
    dense.shape, packed_cutlass, None, packed_t_cutlass, None, bitmask
)

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

put(input, index, source, accumulate=False) → Tensor: Версия 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: Для тензора, квантованного линейным (аффинным) поканальным квантованием, возвращает тензор масштабов используемого квантователя. Число его элементов совпадает с размерностями тензора, соответствующими измерению (из q_per_channel_axis).

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

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

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

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

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

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

rad2deg_() → Tensor: Версия 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: Версия reciprocal(), изменяющая тензор на месте

record_stream(stream)

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

Примечание

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

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

Этот метод лучше всего подходит для случаев, когда вы предоставляете функцию, создавшую тензор во вспомогательном потоке, и хотите, чтобы пользователи могли работать с тензором, не задумываясь о безопасности потоков. Эти гарантии безопасности сопряжены с некоторыми затратами производительности и предсказуемости (аналогично компромиссу между GC и ручным управлением памятью), поэтому, если вы полностью управляете временем жизни своих тензоров, вместо этого можно вручную управлять событиями 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 и CUDACachingAllocator.

register_hook(hook) [источник]

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

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

hook(grad) -> Tensor or None

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

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

Примечание

Дополнительные сведения о том, когда выполняется этот хук и в каком порядке относительно других хуков, см. в разделе Выполнение хуков обратного прохода.

Пример:

>>> 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, этот хук работает с тензором, для которого требуется вычисление градиента, а не с самим градиентом. Хук может изменять аргумент Tensor на месте и обращаться к нему, в том числе к его полю .grad.

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

Примечание

Дополнительные сведения о том, когда выполняется этот хук и в каком порядке относительно других хуков, см. в разделе Выполнение хуков обратного прохода. Поскольку этот хук выполняется во время обратного прохода, он запускается в режиме no_grad (если только create_graph не равно True). При необходимости повторно включить autograd внутри хука можно с помощью torch.enable_grad().

Пример:

>>> 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: Версия remainder(), изменяющая тензор на месте

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

renorm_(p, dim, maxnorm) → Tensor: Версия renorm(), изменяющая тензор на месте

repeat(*repeats) → Tensor

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

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

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

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

Параметры:: repeat (torch.Size, int..., tuple of int or list of 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

Изменяет настройку записи операций для автоградиента: изменяет на месте атрибут requires_grad этого тензора. Возвращает этот тензор.

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

Параметры:: requires_grad (bool) – нужно ли автоградиенту записывать операции с этим тензором. По умолчанию: 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, но с указанной формой. Этот метод возвращает представление, если shape совместима с текущей формой. О случаях, когда можно вернуть представление, см. torch.Tensor.view().

См. torch.reshape()

Параметры:: shape (tuple из целых чисел или 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, а текущие шаги игнорируются (если только целевой размер не совпадает с текущим — в этом случае тензор остается без изменений). В большинстве случаев следует использовать view(), который проверяет непрерывность, или reshape(), который при необходимости копирует данные. Чтобы изменить размер на месте с пользовательскими шагами, см. set_().

Примечание

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

Параметры:

sizes (torch.Size или int...) – требуемый размер
memory_format (torch.memory_format, необязательный) – требуемый формат памяти тензора. По умолчанию: 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, необязательный) – требуемый формат памяти тензора. По умолчанию: 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(). Для листовых тензоров ничего не делает.

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: Версия round(), изменяющая тензор на месте

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

rsqrt_() → Tensor: Версия rsqrt(), изменяющая тензор на месте

scatter(dim, index, src) → Tensor: Версия torch.Tensor.scatter_(), не изменяющая исходный тензор

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

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

Для трехмерного тензора 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. Обратите внимание, что для NPU input и index не подвергаются широковещательному распространению, поэтому при работе на NPU input и index должны иметь одинаковое количество измерений. Во всех остальных случаях применяется стандартное широковещательное распространение.

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

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

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

Примечание

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

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

Для трехмерного тензора и редукции с помощью операции умножения 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 для тензора src устарел и будет удален в будущей версии PyTorch. Вместо него используйте scatter_reduce_(), поддерживающий больше вариантов редукции.

Параметры:

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

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

reduce (str, необязательный) – применяемая операция редукции: '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, необязательный) – применяемая операция редукции: '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: Версия torch.Tensor.scatter_add_(), не изменяющая исходный тензор

scatter_add_(dim, index, src) → Tensor

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

Для трехмерного тензора 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 эта операция может вести себя недетерминированно. Подробнее см. Воспроизводимость.

Примечание

Обратный проход реализован только для 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: Версия 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 включаются в редукцию.

Для трехмерного тензора с 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

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

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

Параметры:

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

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

sgn_() → Tensor: Версия 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_() [исходный код]

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

Ничего не делает, если базовое хранилище уже находится в разделяемой памяти или если это тензор CUDA. Размер тензоров в разделяемой памяти нельзя изменять.

Подробнее см. torch.UntypedStorage.share_memory_().

short(memory_format=torch.preserve_format) → Tensor

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

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

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

sigmoid_() → Tensor: Версия sigmoid() с изменением на месте

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

sign_() → Tensor: Версия sign() с изменением на месте

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

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

sin_() → Tensor: Версия sin() с изменением на месте

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

sinc_() → Tensor: Версия sinc() с изменением на месте

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

sinh_() → Tensor: Версия sinh() с изменением на месте

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

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

Параметры:: 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 не приведен к канонической форме. Поэтому, если такое поведение нежелательно, рекомендуется передать 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: Версия sqrt() с изменением на месте

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

square_() → Tensor: Версия square() с изменением на месте

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

squeeze_(dim=None) → Tensor: Версия 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

Возвращает шаг тензора self.

Шаг — это расстояние, на которое нужно переместиться, чтобы перейти от одного элемента к следующему в указанном измерении 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: Версия sub() с изменением на месте

subtract(other, *, alpha=1) → Tensor: См. torch.subtract().

subtract_(other, *, alpha=1) → Tensor: Версия subtract() с изменением на месте.

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

sum_to_size(*size) → Tensor

Суммирует тензор this до размера size. Размер size должен допускать broadcasting с размером тензора this.

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

svd(some=True, compute_uv=True): См. torch.svd()

swapaxes(axis0, axis1) → Tensor: См. torch.swapaxes()

swapaxes_(axis0, axis1) → Tensor: Версия swapaxes() с изменением на месте

swapdims(dim0, dim1) → Tensor: См. torch.swapdims()

swapdims_(dim0, dim1) → Tensor: Версия swapdims() с изменением на месте

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

t_() → Tensor: Версия t() с изменением на месте

take(indices) → Tensor: См. torch.take()

take_along_dim(indices, dim) → Tensor: См. torch.take_along_dim()

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

tan_() → Tensor: Версия tan() с изменением на месте

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

tanh_() → Tensor: Версия tanh() с изменением на месте

tensor_split(indices_or_sections, dim=0) → List of Tensors: См. torch.tensor_split()

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

to(*args, **kwargs) → Tensor

Выполняет преобразование типа данных и/или устройства тензора. 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. Это связано с тем, что градиенты могут требоваться только для тензоров с типами данных с плавающей запятой или комплексными типами.

Вызвать 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, функция по возможности пытается выполнить преобразование асинхронно относительно хоста. Это асинхронное поведение применяется как к закрепленной, так и к страничной памяти. Однако при использовании этой возможности следует соблюдать осторожность. Дополнительные сведения см. в руководстве по правильному использованию 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, функция по возможности пытается выполнить преобразование асинхронно относительно хоста. Это асинхронное поведение применяется как к закрепленной, так и к страничной памяти. Однако при использовании этой возможности следует соблюдать осторожность. Дополнительные сведения см. в руководстве по правильному использованию non_blocking и pin_memory. Если задано copy, новый тензор создается, даже если тензор уже соответствует требуемому преобразованию.

Примечание

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

Пример:

>>> 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

Возвращает разреженный тензор с указанными форматом хранения и размером блока. Если формат хранения self — strided, можно указать количество плотных измерений; в этом случае будет создан гибридный разреженный тензор с dense_dim плотными измерениями и self.dim() - 2 - dense_dim пакетным измерением.

Примечание

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

Параметры:

layout (torch.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) с заданным размером блока. Если 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) с заданным размером блока. Если 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-форматом хранения, работает только с двумерными тензорами. Если 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-форматом хранения, работает только с двумерными тензорами. Если 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: Версия transpose(), изменяющая тензор на месте

triangular_solve(A, upper=True, transpose=False, unitriangular=False): См. torch.triangular_solve()

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

tril_(diagonal=0) → Tensor: Версия tril(), изменяющая тензор на месте

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

triu_(diagonal=0) → Tensor: Версия triu(), изменяющая тензор на месте

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

true_divide_(value) → Tensor: Версия true_divide_(), изменяющая тензор на месте

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

trunc_() → Tensor: Версия trunc(), изменяющая тензор на месте

type(dtype=None, non_blocking=False, **kwargs) → str or Tensor

Возвращает тип, если dtype не задан, иначе приводит этот объект к указанному типу.

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

Параметры:

dtype (dtype или строка) – требуемый тип
non_blocking (bool) – если True и источник находится в закрепленной памяти, а назначение — на GPU, или наоборот, копирование выполняется асинхронно относительно хоста. В противном случае аргумент не влияет на результат.
**kwargs – для совместимости может содержать ключ async вместо аргумента non_blocking. Аргумент async устарел.

type_as(tensor) → Tensor

Возвращает этот тензор, приведенный к типу заданного тензора.

Если тензор уже имеет нужный тип, операция ничего не делает. Это эквивалентно self.type(tensor.type())

Параметры:: tensor (Tensor) – тензор, имеющий требуемый тип

unbind(dim=0) → seq: См. torch.unbind()

unflatten(dim, sizes) → Tensor [исходный код]: См. torch.unflatten().

unfold(dimension, size, step) → Tensor

Возвращает представление исходного тензора, содержащее все срезы размером size из тензора self по измерению dimension.

Шаг между двумя срезами задается параметром step.

Если sizedim — размер измерения dimension для self, размер измерения dimension в возвращаемом тензоре будет равен (sizedim - size) / step + 1.

К возвращаемому тензору добавляется дополнительное измерение размером size.

Параметры:

dimension (int) – измерение, по которому выполняется развертывание
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: Версия unsqueeze(), изменяющая тензор на месте

untyped_storage() → torch.UntypedStorage: Возвращает базовое хранилище UntypedStorage.

values() → Tensor

Возвращает тензор значений разреженного тензора COO.

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

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

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

Примечание

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

var(dim=None, *, correction=1, keepdim=False) → Tensor: См. torch.var()

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

view(*shape) → Tensor

Возвращает новый тензор с теми же данными, что и тензор self, но с другим shape.

Возвращаемый тензор использует те же данные и должен содержать такое же количество элементов, но может иметь другой размер. Чтобы получить представление тензора, новый размер представления должен быть совместим с исходными размером и шагом, то есть каждое измерение нового представления должно либо быть подпространством исходного измерения, либо охватывать только исходные измерения $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) – требуемый тип данных

Пример:

>>> 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: Версия xlogy() с изменением на месте

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

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

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

Параметры:

device (torch.device, необязательно) – целевое устройство XPU. По умолчанию используется текущее устройство XPU.
non_blocking (bool, необязательно) – если True и исходные данные находятся в закрепленной памяти, копирование будет асинхронным относительно хоста. В противном случае аргумент не влияет на работу. Значение по умолчанию: 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.SparseSemiStructuredTensorCUSPARSELT.html