torchoutil.nn.functional.new module

arange(
end: int | float | bool,
*,
out: Tensor | None = None,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor1D[source]
arange(
start: int | float | bool,
end: int | float | bool,
*,
out: Tensor | None = None,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor1D
arange(
start: int | float | bool,
end: int | float | bool,
step: int | float | bool,
*,
out: Tensor | None = None,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor1D
arange(
end: int | float | bool,
*,
out: Tensor | None = None,
dtype: dtype | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor1D
arange(
start: int | float | bool,
end: int | float | bool,
*,
out: Tensor | None = None,
dtype: dtype | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor1D
arange(
start: int | float | bool,
end: int | float | bool,
step: int | float | bool,
*,
out: Tensor | None = None,
dtype: dtype | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor1D
empty(
size: Sequence[Never],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor0D[source]
empty(
size: Tuple[int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
empty(
size: Tuple[int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
empty(
size: Tuple[int, int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
empty(
size0: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
empty(
size0: int,
size1: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
empty(
size0: int,
size1: int,
size2: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
memory_format: memory_format | None = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
full(
size: Sequence[Never],
fill_value: bool,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → BoolTensor0D[source]
full(
size: Tuple[int],
fill_value: bool,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → BoolTensor1D
full(
size: Tuple[int, int],
fill_value: bool,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → BoolTensor2D
full(
size: Tuple[int, int, int],
fill_value: bool,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → BoolTensor3D
full(
size: Sequence[Never],
fill_value: int,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → LongTensor0D
full(
size: Tuple[int],
fill_value: int,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → LongTensor1D
full(
size: Tuple[int, int],
fill_value: int,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → LongTensor2D
full(
size: Tuple[int, int, int],
fill_value: int,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → LongTensor3D
full(
size: Sequence[Never],
fill_value: float,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor0D
full(
size: Tuple[int],
fill_value: float,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor1D
full(
size: Tuple[int, int],
fill_value: float,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor2D
full(
size: Tuple[int, int, int],
fill_value: float,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor3D
full(
size: Sequence[Never],
fill_value: complex,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → CFloatTensor0D
full(
size: Tuple[int],
fill_value: complex,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → CFloatTensor1D
full(
size: Tuple[int, int],
fill_value: complex,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → CFloatTensor2D
full(
size: Tuple[int, int, int],
fill_value: complex,
*,
dtype: Literal[None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → CFloatTensor3D
full(
size: Sequence[Never],
fill_value: bool | int | float | complex,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor0D
full(
size: Tuple[int],
fill_value: bool | int | float | complex,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
full(
size: Tuple[int, int],
fill_value: bool | int | float | complex,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
full(
size: Tuple[int, int, int],
fill_value: bool | int | float | complex,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
ones(
size: Sequence[Never],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor0D[source]
ones(
size: Tuple[int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
ones(
size: Tuple[int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
ones(
size: Tuple[int, int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
ones(
size0: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
ones(
size0: int,
size1: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
ones(
size0: int,
size1: int,
size2: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
rand(
size: Sequence[Never],
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor0D[source]
rand(
size: Tuple[int],
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor1D
rand(
size: Tuple[int, int],
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor2D
rand(
size: Tuple[int, int, int],
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor3D
rand(
size0: int,
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor1D
rand(
size0: int,
size1: int,
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor2D
rand(
size0: int,
size1: int,
size2: int,
/,
*,
dtype: Literal['float', 'float32', None] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → FloatTensor3D
rand(
size: Sequence[Never],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor0D
rand(
size: Tuple[int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
rand(
size: Tuple[int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
rand(
size: Tuple[int, int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
rand(
size0: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
rand(
size0: int,
size1: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
rand(
size0: int,
size1: int,
size2: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
randint(
low: int,
high: int,
size: Tuple[()],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: Literal[None, 'long', 'int64'] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor0D[source]
randint(
low: int,
high: int,
size: Tuple[int],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: Literal[None, 'long', 'int64'] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor1D
randint(
low: int,
high: int,
size: Tuple[int, int],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: Literal[None, 'long', 'int64'] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor2D
randint(
low: int,
high: int,
size: Tuple[int, int, int],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: Literal[None, 'long', 'int64'] = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → LongTensor3D
randint(
low: int,
high: int,
size: Tuple[()],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: dtype | str | None | Literal['default'] | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor0D
randint(
low: int,
high: int,
size: Tuple[int],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: dtype | str | None | Literal['default'] | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor1D
randint(
low: int,
high: int,
size: Tuple[int, int],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: dtype | str | None | Literal['default'] | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor2D
randint(
low: int,
high: int,
size: Tuple[int, int, int],
*,
generator: Generator | None | Literal['default'] | int = None,
dtype: dtype | str | None | Literal['default'] | DTypeEnum,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
requires_grad: bool = False,
pin_memory: bool = False,
) → Tensor3D
randperm(
n: int,
*,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
dtype: Literal[None, 'long', 'int64'] = 'long',
layout: layout | None = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → LongTensor1D[source]
randperm(
n: int,
*,
generator: Generator | None | Literal['default'] | int = None,
out: Tensor | None = None,
dtype: dtype | str | None | Literal['default'] | DTypeEnum,
layout: layout | None = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
zeros(
size: Sequence[Never],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor0D[source]
zeros(
size: Tuple[int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
zeros(
size: Tuple[int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
zeros(
size: Tuple[int, int, int],
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D
zeros(
size0: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor1D
zeros(
size0: int,
size1: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor2D
zeros(
size0: int,
size1: int,
size2: int,
/,
*,
dtype: dtype | None | Literal['default'] | str | DTypeEnum = None,
device: device | None | Literal['default', 'cuda_if_available'] | str | int = None,
out: Tensor | None = None,
layout: layout | None = None,
pin_memory: bool | None = False,
requires_grad: bool | None = False,
) → Tensor3D