Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion clean/dx12/compare.py
Original file line number Diff line number Diff line change
Expand Up @@ -68,7 +68,7 @@
"expand_c96", "d1p12/swin_block_c64_add_dec0_nc", "w64/post_tf_f32_p12_diet_vsit"}
# The native backend (--backend d3d12) runs the D3D12 fusions of WG_D3D12_FUSION (default: runtime.cpp's
# kDefaultD3d12Fusion, mirrored here), which replace some launches (kernels/fused_swin.hlsl, fused_bneck.hlsl, fused_dec.hlsl).
DEFAULT_D3D12_FUSION = "pm,xe,mb,rv,xo,xd,lc,ll" # lc, ll: Model L only
DEFAULT_D3D12_FUSION = "pm,xe,mb,rv,xo,xd,lc,ll,le" # lc, ll, le: Model L only


def d3d12_fusion():
Expand Down
49 changes: 49 additions & 0 deletions clean/dx12/hlsl/l_lin_px.hlsli
Original file line number Diff line number Diff line change
@@ -0,0 +1,49 @@
// SPDX-License-Identifier: MIT
// Model L's two input linears for one pixel per lane (issue #89; clean/l/kernels/l_ops.hip linear_32_32<RELU = true>,
// then <RELU = false>), D3D12 only, shared by l_linear_32_32_fused (kernels/l_ops_linear.hlsl) and the encoder block
// with the linears as its prologue (kernels/swin_block.hlsl, SW_SRC 3). Lane (t, h) of a 16-pixel tile: its pixel's q
// fragments xf[kc] = q's bytes at pix * 32 + 16 h + 8 kc (FP8); output tile m = x2's channels 16 h + 8 m .. + 7.
// Blob (enc0.Win1 / enc0.Win2): bias tile vector (rows R_L(32)), then fragments [mt < 2][kc < 2], rows R_L(32), K order
// K_L(32) (clean/l/FORMATS.md).
#ifndef L_LIN_PX_HLSLI
#define L_LIN_PX_HLSLI

// the blob's bias tile vectors and weight fragments of lane (t, h)
void lin_blob(uint wb, uint lane, uint hh, out v8f bias[2], out uint2 fr[2][2])
{
[unroll] for (uint mt = 0; mt < 2u; ++mt) {
bias[mt] = wg_load8f(wb, (hh * 8u + mt * 16u) * 4u);
[unroll] for (uint kc2 = 0; kc2 < 2u; ++kc2) fr[mt][kc2] = wg_ld64(wb, 128u + (mt * 2u + kc2) * 256u + lane * 8u);
}
}

// output tile m before the rounding: b + W x
v8f lin_acc(v8f bias, uint2 fr[2], uint2 xf[2])
{
v8f acc = bias;
acc = wg_wmma_fp8(fr[0], xf[0], acc);
return wg_wmma_fp8(fr[1], xf[1], acc);
}

// Both linears: x2's FP16 tiles y[m] (8 halves each) of the lane's pixel from its q fragments xf. x1 stays in
// registers: the relu linear's lane (t, h) holds x1's channels 16 h + 8 m .. + 7 as the two FP8 fragments that the f16
// linear's lane (t, h) takes as its K blocks kc = m. The conversions by the driver's instructions (wg_platform.hlsli:
// the same bits as the software wg_rn16 / wg_pack_q8; wave-uniform control flow only): RN16 = v_cvt_f16_f32 then the
// exact widening, the pack v_cvt_pk_fp8_f32 after the clamp; FP16(RN16(acc)) = FP16(acc), one conversion (rounding to
// FP16 is idempotent, NaN payloads included).
void lin_pair(uint2 xf[2], v8f bias[2], uint2 fr[2][2], v8f bias2[2], uint2 fr2[2][2], out uint4 y[2])
{
uint2 x1[2];
[unroll] for (uint m1 = 0; m1 < 2u; ++m1) {
const uint4 h = wg_to_f16_ags(lin_acc(bias[m1], fr[m1], xf));
v8f r;
[unroll] for (uint j = 0; j < 4u; ++j) {
r.v[2 * j] = wg_fmax(wg_h2f_lo(h[j]), 0.0f);
r.v[2 * j + 1] = wg_fmax(wg_h2f_hi(h[j]), 0.0f);
}
x1[m1] = wg_pack_q8_ags(r);
}
[unroll] for (uint m = 0; m < 2u; ++m) y[m] = wg_to_f16_ags(lin_acc(bias2[m], fr2[m], x1));
}

#endif
4 changes: 4 additions & 0 deletions clean/dx12/kernel_sets.json
Original file line number Diff line number Diff line change
Expand Up @@ -254,6 +254,10 @@
"l_swin_block_c32_dec_nc",
"l_swin.co"
],
[
"l_swin_block_c32_enc_lin_nc",
"-"
],
[
"l_swin_block_c32_enc_nc",
"l_swin.co"
Expand Down
29 changes: 28 additions & 1 deletion clean/dx12/kernels/fused_swin.hlsl
Original file line number Diff line number Diff line change
Expand Up @@ -472,6 +472,30 @@ void sw_load_halo_f16(uint base, int pr, int pc, int W, uint hh, out v8f f[KC])
f[k].v[4] = wg_h2f_lo(q.z); f[k].v[5] = wg_h2f_hi(q.z); f[k].v[6] = wg_h2f_lo(q.w); f[k].v[7] = wg_h2f_hi(q.w);
}
}
#elif SW_SRC == 3
#if SW_C != 32
#error "SW_SRC 3: Model L's encoder block (C = 32)"
#endif
#include "l_lin_px.hlsli"
// LHaloLinSrc: the values of LHaloF16Src without the x2 map: the member at grid position (pr, pc) is pixel
// (pr + 2) (W + 4) + pc + 2 of the FP8 q halo map, through l_linear_32_32_fused's arithmetic (lane (t, h) = that
// kernel's lane of the pixel; every lane runs it, also for outside members: wave-uniform control flow)
void sw_load_halo_lin(uint base, int pr, int pc, int W, uint lane, uint hh, out v8f f[KC])
{
const uint pix = (uint)((pr + 2) * (W + 4) + pc + 2);
uint2 xq[2];
[unroll] for (uint kc = 0; kc < 2u; ++kc) xq[kc] = wg_ld64(base, pix * 32u + hh * 16u + 8u * kc);
v8f b1[2], b2[2];
uint2 f1[2][2], f2[2][2];
lin_blob(linW1, lane, hh, b1, f1);
lin_blob(linW2, lane, hh, b2, f2);
uint4 y[2];
lin_pair(xq, b1, f1, b2, f2, y);
[unroll] for (uint k = 0; k < KC; ++k) {
f[k].v[0] = wg_h2f_lo(y[k].x); f[k].v[1] = wg_h2f_hi(y[k].x); f[k].v[2] = wg_h2f_lo(y[k].y); f[k].v[3] = wg_h2f_hi(y[k].y);
f[k].v[4] = wg_h2f_lo(y[k].z); f[k].v[5] = wg_h2f_hi(y[k].z); f[k].v[6] = wg_h2f_lo(y[k].w); f[k].v[7] = wg_h2f_hi(y[k].w);
}
}
#elif SW_SRC == 2
// LCoarseFp8Src: a member outside the grid takes the mirrored 2 x 2 group (mirror of the group index) and keeps its
// sub-pixel; the byte offset of the lane's half of that pixel
Expand Down Expand Up @@ -722,6 +746,9 @@ WG_KERNEL(SW_ENTRY)
#elif SW_SRC == 1
v8f xf[KC];
sw_load_halo_f16(x, pr, pc, W, hh, xf);
#elif SW_SRC == 3
v8f xf[KC];
sw_load_halo_lin(x, pr, pc, W, lane, hh, xf);
#elif SW_SRC == 2
load_frags_g(x, sw_coarse_src(pr, pc, H, W, hh), xa);
#elif SW_PM
Expand Down Expand Up @@ -786,7 +813,7 @@ WG_KERNEL(SW_ENTRY)
v8f acc[KC];
{
[unroll] for (uint k = 0; k < KC; ++k) {
#if SW_SRC == 1
#if SW_SRC == 1 || SW_SRC == 3
acc[k] = xf[k];
#else
acc[k] = sw_unpack_fp8(xa[k]);
Expand Down
3 changes: 3 additions & 0 deletions clean/dx12/kernels/fused_swin_gen.py
Original file line number Diff line number Diff line change
Expand Up @@ -70,6 +70,9 @@
uint coefA, coefC, coefL, coefW; // pointers: l_coef_pack12's A, C, latent and coefficient blob (out_p unused)
int coefRw, coefRh; // the render rectangle
#endif
#if SW_SRC == 3
uint linW1, linW2; // pointers: enc0.Win1, enc0.Win2 (x = the FP8 q halo map)
#endif
WG_ARGS_END"""
ARGS_NEW = """#ifndef SW_PM
#define SW_PM 0
Expand Down
22 changes: 4 additions & 18 deletions clean/dx12/kernels/l_ops_linear.hlsl
Original file line number Diff line number Diff line change
Expand Up @@ -38,24 +38,9 @@ WG_ARGS_BEGIN
int npix;
WG_ARGS_END

#if LIN_FUSED // (helpers of the fused kernel only: the pair keeps its own code and DXIL)
// the blob's bias tile vectors and weight fragments of lane (t, h)
void lin_blob(uint wb, uint lane, uint hh, out v8f bias[2], out uint2 fr[2][2])
{
[unroll] for (uint mt = 0; mt < 2u; ++mt) {
bias[mt] = wg_load8f(wb, (hh * 8u + mt * 16u) * 4u);
[unroll] for (uint kc2 = 0; kc2 < 2u; ++kc2) fr[mt][kc2] = wg_ld64(wb, 128u + (mt * 2u + kc2) * 256u + lane * 8u);
}
}

// output tile m before the rounding: b + W x
v8f lin_acc(v8f bias, uint2 fr[2], uint2 xf[2])
{
v8f acc = bias;
acc = wg_wmma_fp8(fr[0], xf[0], acc);
return wg_wmma_fp8(fr[1], xf[1], acc);
}

#if LIN_FUSED // (helpers of the fused kernel only, shared with the encoder block's prologue: the pair keeps its own
// code and DXIL)
#include "l_lin_px.hlsli"
#endif

#if LIN_FUSED
Expand Down Expand Up @@ -97,6 +82,7 @@ WG_KERNEL(l_linear_32_32_f16)
// conversion (rounding to FP16 is idempotent, NaN payloads included)
[unroll] for (uint m = 0; m < 2u; ++m)
wg_st128(y, ((uint)pk * 32u + hh * 16u + 8u * m) * 2u, wg_to_f16_ags(lin_acc(bias2[m], fr2[m], x1)));
// (hlsl/l_lin_px.hlsli lin_pair is this code for the encoder block's prologue; kept inline here: the kernel's DXIL)
#else
// (the pair's own code, unchanged)
[unroll] for (uint mt = 0; mt < 2u; ++mt) {
Expand Down
5 changes: 5 additions & 0 deletions clean/dx12/kernels/l_swin.hlsl
Original file line number Diff line number Diff line change
Expand Up @@ -13,9 +13,14 @@
// reads first the rows of x2 the linears wrote last, and its last-written rows of x3 are the
// ones l_project_gather reads first (more cache hits at both hand-offs)
// l_swin_block_c32_dec_nc the decoder block: FP8 map in with the token-grid mirror (SW_SRC 2), FP16 out (SW_OUT_F16)
// l_swin_block_c32_enc_lin_nc D3D12 only: the encoder block with the two input linears as its prologue (SW_SRC 3;
// byte for byte the pair l_linear_32_32_fused -> _enc_nc, which stays the fallback route):
// the FP8 q halo map in, x2 neither written nor read. Arguments: _enc_nc's (x = q), then
// enc0.Win1, enc0.Win2
//
// @wg-kernel l_swin_block_c32_nc co=l_swin.co block=256 wave=32 args=p,p,p,p,u,u,u,u defines=SW_C=32,SW_HEADS=2,SW_MLP=128,SW_ADD=0,SW_SAFE=1,SW_ECL=0,SW_HPU=8,SW_GELU=0,SW_ENTRY_OVERRIDE=l_swin_block_c32_nc
// @wg-kernel l_swin_block_c32_enc_nc co=l_swin.co block=256 wave=32 args=p,p,p,p,u,u,u,u defines=SW_C=32,SW_HEADS=2,SW_MLP=128,SW_ADD=0,SW_SAFE=1,SW_ECL=0,SW_HPU=8,SW_GELU=3,SW_GELU_PAT=13333,SW_SRC=1,SW_ENTRY_OVERRIDE=l_swin_block_c32_enc_nc,WG_REV_ORDER=1
// @wg-kernel l_swin_block_c32_enc_lin_nc co=- block=256 wave=32 args=p,p,p,p,u,u,u,u,p,p defines=SW_C=32,SW_HEADS=2,SW_MLP=128,SW_ADD=0,SW_SAFE=1,SW_ECL=0,SW_HPU=8,SW_GELU=3,SW_GELU_PAT=13333,SW_SRC=3,SW_ENTRY_OVERRIDE=l_swin_block_c32_enc_lin_nc,WG_REV_ORDER=1
// @wg-kernel l_swin_block_c32_dec_nc co=l_swin.co block=256 wave=32 args=p,p,p,p,u,u,u,u defines=SW_C=32,SW_HEADS=2,SW_MLP=128,SW_ADD=0,SW_SAFE=1,SW_ECL=0,SW_HPU=8,SW_GELU=1,SW_SRC=2,SW_OUT_F16=1,SW_ENTRY_OVERRIDE=l_swin_block_c32_dec_nc
// l_swin_block_c32_dec_coef12_nc D3D12 only: the decoder block with l_coef_pack12 as its epilogue (SW_OUT_COEF12;
// byte for byte the pair _dec_nc -> l_coef_pack12, which stays the fallback route);
Expand Down
37 changes: 35 additions & 2 deletions clean/dx12/kernels/swin_block.hlsl
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,10 @@
// SW_SRC gather source (HIP's SRC hook; plain blocks only): 0 the FP8 map at the mirrored member
// (default); 1 Model L's encoder block, an FP16 halo map [H + 4][W + 4][C] read directly at
// (pr + 2, pc + 2) (LHaloF16Src); 2 Model L's decoder block, the FP8 map with the token-grid
// mirror, sub-pixel kept (LCoarseFp8Src)
// mirror, sub-pixel kept (LCoarseFp8Src); 3 (D3D12 only) Model L's encoder block with
// its two input linears as the prologue: the FP8 q halo map [H + 4][W + 4][32] at the same
// position through the linears (hlsl/l_lin_px.hlsli), the FP16 values mode 1 reads from x2,
// in registers (the x2 map is neither written nor read)
// SW_OUT_F16 1: the output is RN16(x2) as an FP16 map [H][W][C] (Model L's decoder block, LStoreF16Epi)
// SW_OUT_COEF12 1 (with SW_OUT_F16, C = 32): instead of the FP16 map, l_coef_pack12 of it as the epilogue:
// the lane that holds a pixel's channels 0..15 (hh = 0) runs hlsl/l_coef_px.hlsli on those
Expand All @@ -37,6 +40,9 @@ WG_ARGS_BEGIN
uint coefA, coefC, coefL, coefW; // pointers: l_coef_pack12's A, C, latent and coefficient blob (out_p unused)
int coefRw, coefRh; // the render rectangle
#endif
#if SW_SRC == 3
uint linW1, linW2; // pointers: enc0.Win1, enc0.Win2 (x = the FP8 q halo map)
#endif
WG_ARGS_END

// ---- BlockLayout<C, HEADS, MLP> (FORMATS.md, "Swin block section") ---------------------------------------------------
Expand Down Expand Up @@ -432,6 +438,30 @@ void sw_load_halo_f16(uint base, int pr, int pc, int W, uint hh, out v8f f[KC])
f[k].v[4] = wg_h2f_lo(q.z); f[k].v[5] = wg_h2f_hi(q.z); f[k].v[6] = wg_h2f_lo(q.w); f[k].v[7] = wg_h2f_hi(q.w);
}
}
#elif SW_SRC == 3
#if SW_C != 32
#error "SW_SRC 3: Model L's encoder block (C = 32)"
#endif
#include "l_lin_px.hlsli"
// LHaloLinSrc: the values of LHaloF16Src without the x2 map: the member at grid position (pr, pc) is pixel
// (pr + 2) (W + 4) + pc + 2 of the FP8 q halo map, through l_linear_32_32_fused's arithmetic (lane (t, h) = that
// kernel's lane of the pixel; every lane runs it, also for outside members: wave-uniform control flow)
void sw_load_halo_lin(uint base, int pr, int pc, int W, uint lane, uint hh, out v8f f[KC])
{
const uint pix = (uint)((pr + 2) * (W + 4) + pc + 2);
uint2 xq[2];
[unroll] for (uint kc = 0; kc < 2u; ++kc) xq[kc] = wg_ld64(base, pix * 32u + hh * 16u + 8u * kc);
v8f b1[2], b2[2];
uint2 f1[2][2], f2[2][2];
lin_blob(linW1, lane, hh, b1, f1);
lin_blob(linW2, lane, hh, b2, f2);
uint4 y[2];
lin_pair(xq, b1, f1, b2, f2, y);
[unroll] for (uint k = 0; k < KC; ++k) {
f[k].v[0] = wg_h2f_lo(y[k].x); f[k].v[1] = wg_h2f_hi(y[k].x); f[k].v[2] = wg_h2f_lo(y[k].y); f[k].v[3] = wg_h2f_hi(y[k].y);
f[k].v[4] = wg_h2f_lo(y[k].z); f[k].v[5] = wg_h2f_hi(y[k].z); f[k].v[6] = wg_h2f_lo(y[k].w); f[k].v[7] = wg_h2f_hi(y[k].w);
}
}
#elif SW_SRC == 2
// LCoarseFp8Src: a member outside the grid takes the mirrored 2 x 2 group (mirror of the group index) and keeps its
// sub-pixel; the byte offset of the lane's half of that pixel
Expand Down Expand Up @@ -596,6 +626,9 @@ WG_KERNEL(SW_ENTRY)
#elif SW_SRC == 1
v8f xf[KC];
sw_load_halo_f16(x, pr, pc, W, hh, xf);
#elif SW_SRC == 3
v8f xf[KC];
sw_load_halo_lin(x, pr, pc, W, lane, hh, xf);
#elif SW_SRC == 2
load_frags_g(x, sw_coarse_src(pr, pc, H, W, hh), xa);
#else
Expand Down Expand Up @@ -627,7 +660,7 @@ WG_KERNEL(SW_ENTRY)
v8f acc[KC];
{
[unroll] for (uint k = 0; k < KC; ++k) {
#if SW_SRC == 1
#if SW_SRC == 1 || SW_SRC == 3
acc[k] = xf[k];
#else
acc[k] = sw_unpack_fp8(xa[k]);
Expand Down
1 change: 1 addition & 0 deletions clean/dx12/vgpr_limits.json
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@
"_doc": "build_dx12.py VGPR check: the RGA (gfx1201) USED_VGPRs bound of every Swin / bottleneck kernel (a name with a swin_ part). Each bound is the largest count that keeps the kernel's present occupancy: VGPR file 1536 per SIMD lane, granule 8, a 256-lane wave32 workgroup = 4 waves on each of a CU's 2 SIMDs, so 2 workgroups per CU need <= 192, 3 need <= 128 (a 128-lane workgroup = 2 waves per SIMD: 4 per CU need <= 192). A kernel over its bound fails the build (a merge or an edit lost a workgroup per CU: swin_block_c96_add_xe_* at 215 VGPRs ran 1 per CU, +38 us per frame at 1440p Q). A new Swin / bottleneck kernel needs an entry. WG_DX12_VGPR_CHECK=0 skips the check.",
"l_swin_block_c32_nc": 96,
"l_swin_block_c32_enc_nc": 96,
"l_swin_block_c32_enc_lin_nc": 96,
"l_swin_block_c32_dec_nc": 96,
"l_swin_block_c32_dec_coef12_nc": 96,
"swin_block_c64_nc": 192,
Expand Down
5 changes: 3 additions & 2 deletions clean/l/FORMATS.md
Original file line number Diff line number Diff line change
Expand Up @@ -23,8 +23,8 @@ Every map is `[rows][cols][C]`, channel fastest, as Model M's feature maps (`cle
| Map | Shape | Element | Written by | Read by |
|---|---|---|---|---|
| `q` | `[fh + 4][fw + 4][32]` halo | FP8: values 0..19, bytes 20..31 zero | `lev/input_encoder` | `l_linear_32_32_relu` |
| `x1` | `[fh + 4][fw + 4][32]` halo | FP8 (not stored by `l_linear_32_32_fused`) | `l_linear_32_32_relu` | `l_linear_32_32_f16` |
| `x2` | `[fh + 4][fw + 4][32]` halo | **FP16** (64 bytes per pixel) | `l_linear_32_32_f16` | `l_swin_block_c32_enc` |
| `x1` | `[fh + 4][fw + 4][32]` halo | FP8 (not stored by `l_linear_32_32_fused` or `l_swin_block_c32_enc_lin_nc`) | `l_linear_32_32_relu` | `l_linear_32_32_f16` |
| `x2` | `[fh + 4][fw + 4][32]` halo | **FP16** (64 bytes per pixel; not stored by `l_swin_block_c32_enc_lin_nc`) | `l_linear_32_32_f16` | `l_swin_block_c32_enc` |
| `x3` | `[fh][fw][32]` | FP8 | `l_swin_block_c32_enc` | `l_project_gather` |
| `enc0.features` | `[fh/2][fw/2][64]` | FP8 | `l_project_gather` | enc1 (Model M's stage) |
| m_near, m_far, m_center | as Model M | as Model M | `lev/input_encoder` | as Model M |
Expand Down Expand Up @@ -80,6 +80,7 @@ workgroup, in raster order of their map.
| `l_linear_32_32_f16` | exists (GPU-checked) | `x, y, w, npix` | as above | y = RN16(b + W x), FP8 -> **FP16**. w = `enc0.Win2` |
| `l_linear_32_32_fused` | exists (GPU-checked), D3D12 only | `x, y, w1, w2, npix` | as above | the two above in one kernel, `x1` kept in registers: the same bytes in `y` (`x2`), `x1` not stored. x = `q`, y = `x2` in two different buffers. w1 = `enc0.Win1`, w2 = `enc0.Win2`. The native D3D12 frame runs it in place of the two (fusion `ll`, on by default); without `ll` or without the kernel in the build, the two run |
| `l_swin_block_c32_enc[_nc]` | exists (GPU-checked) | `x, xadd (null), out, w, H, W, ox, oy` | ceil(nwin / 8), nwin = ceil((W + ox) / 4) ceil((H + oy) / 4) | the encoder block. x = `x2` (FP16 halo map; member at grid (gx, gy) read at map pixel (gy + 2, gx + 2)). out = `x3` (FP8, grid only). H = fh, W = fw. (ox, oy) = `window_offsets["first"]` for the frame parity. w = `enc0_block` |
| `l_swin_block_c32_enc_lin_nc` | exists (GPU-checked), D3D12 only | the encoder block's, then `w1, w2` | as the encoder block | the encoder block with the two input linears as its prologue: the same bytes in `x3`, `x1` and `x2` not stored. x = `q` (FP8 halo map; member at grid (gx, gy) read at map pixel (gy + 2, gx + 2), the linears run on it in registers). w1 = `enc0.Win1`, w2 = `enc0.Win2`. The native D3D12 frame runs it in place of the linears and the block (fusion `le`, on by default); without `le` or without the kernel in the build, the linears (fused with `ll`) and the block run |
| `l_project_gather` | exists (GPU-checked) | `x, features, w, tw, th` | ceil(tw th / 128), tw = fw / 2, th = fh / 2 | token (r, c) gathers pixels (2r + p / 2, 2c + p % 2), p = 0..3, as channels 32 p + i. Running FP16 sum per group of 32 from the bias, clamp +-6.28125, FP8 -> `enc0.features`. w = `enc0.project` |
| `l_dec_project` | exists (GPU-checked) | `z, y, w, tw, th` | ceil(tw th / 128) | per token of dec1's output z [th][tw][64]: 128 outputs (two RN16 groups of 32 inputs, then FP8). Output 32 s + k goes to pixel (2r + s / 2, 2c + s % 2), channel k, of `y`. w = `dec0.project` |
| `l_swin_block_c32_dec[_nc]` | exists (GPU-checked) | `x, xadd (null), out, w, H, W, ox, oy` | as the encoder block | the decoder block. x = `y` (FP8). A member outside the grid takes token-grid mirrored pixels with the sub-pixel kept. out = `y2` (**FP16**). (ox, oy) = `window_offsets["second"]`. w = `dec0_block` |
Expand Down
Loading
Loading