| """Primitive tensor manipulation ops. |
| |
| L1 ops wrapping standard tensor utilities for use by L2+ composites. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| import triton |
| import triton.language as tl |
|
|
|
|
| @triton.jit |
| def _pad_16_kernel( |
| x, |
| out, |
| input_elements: tl.constexpr, |
| output_elements: tl.constexpr, |
| BLOCK_SIZE: tl.constexpr, |
| ): |
| offsets = tl.program_id(0) * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE) |
| values = tl.load(x + offsets, mask=offsets < input_elements, other=0) |
| tl.store(out + offsets, values, mask=offsets < output_elements) |
|
|
|
|
| class Pad(nn.Module): |
| """Functional padding op.""" |
|
|
| def forward( |
| self, x: torch.Tensor, pad: tuple[int, ...], value: float = 0.0, |
| ) -> torch.Tensor: |
| if value != 0.0 or tuple(pad) not in ((0, 16), (0, 0, 0, 16)): |
| return F.pad(x, pad, value=value) |
| if len(pad) == 2: |
| output_shape = (*x.shape[:-1], 384) |
| else: |
| output_shape = (*x.shape[:-2], 384, x.shape[-1]) |
| out = x.new_empty(output_shape) |
| output_elements = out.numel() |
| _pad_16_kernel[(triton.cdiv(output_elements, 1024),)]( |
| x, out, x.numel(), output_elements, BLOCK_SIZE=1024, |
| num_warps=8, |
| ) |
| return out |
|
|
|
|
| class OneHot(nn.Module): |
| """Functional one-hot encoding op.""" |
|
|
| def forward(self, x: torch.Tensor, num_classes: int) -> torch.Tensor: |
| return F.one_hot(x, num_classes) |
|
|
|
|
| class Cat(nn.Module): |
| """Tensor concatenation op.""" |
|
|
| def __init__(self, dim: int = 0): |
| super().__init__() |
| self.dim = dim |
|
|
| def forward(self, tensors: list[torch.Tensor] | tuple[torch.Tensor, ...]) -> torch.Tensor: |
| return torch.cat(tensors, dim=self.dim) |
|
|
|
|
| class Exp(nn.Module): |
| """Elementwise exponential op.""" |
|
|
| def forward(self, x: torch.Tensor) -> torch.Tensor: |
| return torch.exp(x) |
|
|
