| """Oasis 2D patch embedding.""" |
|
|
| from __future__ import annotations |
|
|
| import torch |
| import torch.nn as nn |
| import triton |
| import triton.language as tl |
|
|
| from ..L1.conv2d import Conv2d |
|
|
|
|
| @triton.jit |
| def _patch_embed_2x2_kernel( |
| x, |
| weight, |
| bias, |
| out, |
| N: tl.constexpr, |
| BM: tl.constexpr, |
| BN: tl.constexpr, |
| ): |
| pid_m = tl.program_id(0) |
| pid_n = tl.program_id(1) |
| m = pid_m * BM + tl.arange(0, BM) |
| oc = pid_n * BN + tl.arange(0, BN) |
|
|
| patch = m % 144 |
| batch = m // 144 |
| oh = patch // 16 |
| ow = patch % 16 |
| k = tl.arange(0, 64) |
| channel = k // 4 |
| pixel = k % 4 |
| ih = oh[:, None] * 2 + pixel[None, :] // 2 |
| iw = ow[:, None] * 2 + pixel[None, :] % 2 |
| x_off = ( |
| batch[:, None] * (16 * 18 * 32) |
| + channel[None, :] * (18 * 32) |
| + ih * 32 |
| + iw |
| ) |
| a = tl.load(x + x_off, mask=m[:, None] < N * 144, other=0.0) |
| b = tl.load( |
| weight + oc[None, :] * 64 + k[:, None], |
| mask=oc[None, :] < 1024, |
| other=0.0, |
| ) |
| |
| a_bits = a.to(tl.int32, bitcast=True) |
| b_bits = b.to(tl.int32, bitcast=True) |
| a_bits = (a_bits + 0xFFF + ((a_bits >> 13) & 1)) & -0x2000 |
| b_bits = (b_bits + 0xFFF + ((b_bits >> 13) & 1)) & -0x2000 |
| a_tf32 = a_bits.to(tl.float32, bitcast=True) |
| b_tf32 = b_bits.to(tl.float32, bitcast=True) |
| acc = tl.dot(a_tf32, b_tf32, input_precision="tf32") |
| acc += tl.load(bias + oc, mask=oc < 1024, other=0.0)[None, :] |
| tl.store( |
| out + m[:, None] * 1024 + oc[None, :], |
| acc, |
| mask=(m[:, None] < N * 144) & (oc[None, :] < 1024), |
| ) |
|
|
|
|
| @triton.jit |
| def _patch_embed_20x20_kernel( |
| x, |
| weight, |
| bias, |
| out, |
| BM: tl.constexpr, |
| BN: tl.constexpr, |
| BK: tl.constexpr, |
| ): |
| m = tl.program_id(0) * BM + tl.arange(0, BM) |
| oc = tl.program_id(1) * BN + tl.arange(0, BN) |
| oh = m // 32 |
| ow = m % 32 |
| acc = tl.zeros((BM, BN), tl.float32) |
|
|
| for k0 in range(0, 1200, BK): |
| k = k0 + tl.arange(0, BK) |
| channel = k // 400 |
| pixel = k % 400 |
| ih = oh[:, None] * 20 + pixel[None, :] // 20 |
| iw = ow[:, None] * 20 + pixel[None, :] % 20 |
| a = tl.load( |
| x + channel[None, :] * (360 * 640) + ih * 640 + iw, |
| mask=(m[:, None] < 576) & (k[None, :] < 1200), |
| other=0.0, |
| ) |
| b = tl.load( |
| weight + oc[None, :] * 1200 + k[:, None], |
| mask=(oc[None, :] < 1024) & (k[:, None] < 1200), |
| other=0.0, |
| ) |
| acc = tl.dot(a, b, acc, input_precision="tf32x3") |
|
|
| acc += tl.load(bias + oc, mask=oc < 1024, other=0.0)[None, :] |
| tl.store( |
| out + m[:, None] * 1024 + oc[None, :], |
| acc, |
| mask=(m[:, None] < 576) & (oc[None, :] < 1024), |
| ) |
|
|
|
|
| class OasisPatchEmbed(nn.Module): |
| def __init__( |
| self, |
| img_height: int = 256, |
| img_width: int = 256, |
| patch_size: int = 16, |
| in_chans: int = 3, |
| embed_dim: int = 768, |
| norm_layer=None, |
| flatten: bool = True, |
| ): |
| super().__init__() |
| self.img_size = (img_height, img_width) |
| self.patch_size = (patch_size, patch_size) |
| self.grid_size = (img_height // patch_size, img_width // patch_size) |
| self.num_patches = self.grid_size[0] * self.grid_size[1] |
| self.flatten = flatten |
| self.proj = Conv2d( |
| in_chans, |
| embed_dim, |
| kernel_size=self.patch_size, |
| stride=self.patch_size, |
| bias=True, |
| ) |
| self.norm = norm_layer(embed_dim) if norm_layer else None |
|
|
| def forward(self, x: torch.Tensor, random_sample: bool = False) -> torch.Tensor: |
| batch, channels, height, width = x.shape |
| if not random_sample and (height, width) != self.img_size: |
| raise AssertionError( |
| f"Input image size ({height}*{width}) doesn't match model {self.img_size}.", |
| ) |
| if ( |
| x.is_cuda |
| and x.dtype == torch.float32 |
| and x.is_contiguous() |
| and self.norm is None |
| and batch >= 3 |
| and channels == 16 |
| and (height, width) == (18, 32) |
| and self.patch_size == (2, 2) |
| and self.proj.out_channels == 1024 |
| ): |
| source = x |
| if self.flatten: |
| out = torch.empty( |
| (batch, 144, 1024), device=x.device, dtype=x.dtype |
| ) |
| else: |
| out = torch.empty( |
| (batch, 9, 16, 1024), device=x.device, dtype=x.dtype |
| ) |
| _patch_embed_2x2_kernel[ |
| (triton.cdiv(batch * 144, 32), triton.cdiv(1024, 64)) |
| ]( |
| x=source, |
| weight=self.proj.weight, |
| bias=self.proj.bias, |
| out=out, |
| N=batch, |
| BM=32, |
| BN=64, |
| num_warps=4, |
| num_stages=3, |
| ) |
| return out |
| if ( |
| x.is_cuda |
| and x.dtype == torch.float32 |
| and x.is_contiguous() |
| and self.norm is None |
| and batch == 1 |
| and channels == 3 |
| and (height, width) == (360, 640) |
| and self.patch_size == (20, 20) |
| and self.proj.out_channels == 1024 |
| ): |
| out = torch.empty((1, 576, 1024), device=x.device, dtype=x.dtype) |
| _patch_embed_20x20_kernel[ |
| (triton.cdiv(576, 32), triton.cdiv(1024, 128)) |
| ]( |
| x, |
| self.proj.weight, |
| self.proj.bias, |
| out, |
| BM=32, |
| BN=128, |
| BK=32, |
| num_warps=4, |
| num_stages=3, |
| ) |
| return out if self.flatten else out.reshape(1, 18, 32, 1024) |
| x = self.proj(x) |
| if self.flatten: |
| x = x.flatten(2).transpose(1, 2) |
| else: |
| x = x.permute(0, 2, 3, 1) |
| return self.norm(x) if self.norm is not None else x |
|
|
