Inference Playground

All models

Select a model concept to open its architecture, playground, or kernels.

Search models

Qwen 3.8 27B

Qwen 3.8 27B architecture

# Qwen3.8 27B architecture

import torch
from torch import nn

class Qwen3Attention(nn.Module):
    def __init__(self, dim, heads, head_dim):
        super().__init__()
        self.heads = heads
        self.head_dim = head_dim
        self.q_proj = nn.Linear(dim, heads * head_dim, bias=False)
        self.k_proj = nn.Linear(dim, heads * head_dim, bias=False)
        self.v_proj = nn.Linear(dim, heads * head_dim, bias=False)
        self.out_proj = nn.Linear(heads * head_dim, dim, bias=False)

def forward(self, x, rotary):
        bsz, seqlen, dim = x.shape
        q = self.q_proj(x).view(bsz, seqlen, self.heads, self.head_dim)
        k = self.k_proj(x).view(bsz, seqlen, self.heads, self.head_dim)
        v = self.v_proj(x).view(bsz, seqlen, self.heads, self.head_dim)

q, k = rotary(q, k)
        attn = torch.nn.functional.scaled_dot_product_attention(
            q.transpose(1, 2),
            k.transpose(1, 2),
            v.transpose(1, 2),
        )

return self.out_proj(attn.transpose(1, 2).reshape(bsz, seqlen, -1))

class Qwen3FeedForward(nn.Module):
    def __init__(self, dim, hidden_dim):
        super().__init__()
        self.gate_proj = nn.Linear(dim, hidden_dim, bias=False)
        self.up_proj = nn.Linear(dim, hidden_dim, bias=False)
        self.down_proj = nn.Linear(hidden_dim, dim, bias=False)

def forward(self, x):
        return self.down_proj(
            nn.functional.silu(self.gate_proj(x)) * self.up_proj(x)
        )

cURL request

⌘/Ctrl + Enter

Qwen 3.8 27B cURL request

Response

Ready

Run this request.

Raw response

No response yet.

Qwen 3.8 27B Triton kernel

Qwen Image 2.1

Qwen Image 2.1 architecture

# Qwen Image 2.1 architecture

import torch
from torch import nn

class QwenImagePatchEmbed(nn.Module):
    def __init__(self, in_channels=3, dim=1280, patch_size=2):
        super().__init__()
        self.proj = nn.Conv2d(
            in_channels,
            dim,
            kernel_size=patch_size,
            stride=patch_size,
        )

def forward(self, x):
        x = self.proj(x)
        return x.flatten(2).transpose(1, 2)

class QwenImageTransformerBlock(nn.Module):
    def __init__(self, dim, heads, mlp_ratio=4):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attn = nn.MultiheadAttention(dim, heads, batch_first=True)
        self.norm2 = nn.LayerNorm(dim)
        hidden = dim * mlp_ratio
        self.mlp = nn.Sequential(
            nn.Linear(dim, hidden),
            nn.GELU(),
            nn.Linear(hidden, dim),
        )

def forward(self, x, context):
        residual = x
        x = self.norm1(x)
        x, _ = self.attn(x, context, context, need_weights=False)
        x = residual + x

residual = x
        x = self.norm2(x)
        return residual + self.mlp(x)

cURL request

⌘/Ctrl + Enter

Qwen Image 2.1 cURL request

Response

Ready

Run this request.

Raw response

No response yet.

Qwen Image 2.1 Triton kernel

# Qwen Image 3x3 convolution kernel

import triton
import triton.language as tl

@triton.jit
def qwen_image_conv2d_kernel(
    input_ptr,
    weight_ptr,
    output_ptr,
    batch,
    in_channels,
    out_channels,
    height,
    width,
    kernel_size,
    stride_h,
    stride_w,
    BLOCK_N: tl.constexpr,
    BLOCK_K: tl.constexpr,
):
    pid_n = tl.program_id(0)
    pid_h = tl.program_id(1)
    pid_w = tl.program_id(2)

n = pid_n
    h = pid_h * stride_h
    w = pid_w * stride_w

acc = tl.zeros((BLOCK_N,), dtype=tl.float32)

for c in range(in_channels):
        for kh in range(kernel_size):
            for kw in range(kernel_size):
                ih = h + kh
                iw = w + kw
                if ih < height and iw < width:
                    x = tl.load(
                        input_ptr
                        + n * in_channels * height * width
                        + c * height * width
                        + ih * width
                        + iw
                    ).to(tl.float32)

for oc in range(BLOCK_N):
                        weight = tl.load(
                            weight_ptr
                            + (oc * in_channels + c) * kernel_size * kernel_size
                            + kh * kernel_size
                            + kw
                        ).to(tl.float32)

acc += x * weight

for oc in range(BLOCK_N):
        tl.store(
            output_ptr
            + n * out_channels * height * width
            + oc * height * width
            + h * width
            + w,
            acc[oc],
        )

YuE 2 3B

YuE 2 3B architecture

cURL request

⌘/Ctrl + Enter

YuE 2 3B cURL request

Response

Ready

Run this request.

Raw response

No response yet.

YuE 2 3B Triton kernel

Minimax H3 Singularity

Minimax H3 Singularity architecture

cURL request

⌘/Ctrl + Enter

Minimax H3 Singularity cURL request

Response

Ready

Run this request.

Raw response

No response yet.

Minimax H3 Singularity Triton kernel

# Minimax temporal pooling kernel

import triton
import triton.language as tl

@triton.jit
def minimax_temporal_pool_kernel(
    input_ptr,
    output_ptr,
    batch,
    channels,
    depth,
    height,
    width,
    kernel_size,
    stride,
    BLOCK_C: tl.constexpr,
):
    pid_b = tl.program_id(0)
    pid_d = tl.program_id(1)
    pid_c = tl.program_id(2)

acc = tl.zeros((BLOCK_C,), dtype=tl.float32)

for kd in range(kernel_size):
        d = pid_d * stride + kd
        if d < depth:
            for c in range(channels):
                value = tl.load(
                    input_ptr
                    + pid_b * channels * depth * height * width
                    + c * depth * height * width
                    + d * height * width
                ).to(tl.float32)
                acc += value

for c in range(BLOCK_C):
        tl.store(
            output_ptr
            + pid_b * channels * depth * height * width
            + c * depth * height * width
            + pid_d * stride * height * width,
            acc[c] / kernel_size,
        )

GLM OCR

GLM OCR architecture

# GLM OCR architecture

import torch
from torch import nn

class GLMOCRVisionEncoder(nn.Module):
    def __init__(self, dim=1024, depth=24, heads=16):
        super().__init__()
        self.patch_embed = nn.Conv2d(3, dim, kernel_size=16, stride=16)
        self.blocks = nn.ModuleList([
            nn.TransformerEncoderLayer(
                d_model=dim,
                nhead=heads,
                dim_feedforward=dim * 4,
                activation="gelu",
                batch_first=True,
                norm_first=True,
            )
            for _ in range(depth)
        ])

def forward(self, image):
        x = self.patch_embed(image)
        return self.blocks[0](x.flatten(2).transpose(1, 2))

class GLMOCRTextDecoder(nn.Module):
    def __init__(self, vocab_size, dim=1024):
        super().__init__()
        self.token_emb = nn.Embedding(vocab_size, dim)
        self.decoder = nn.TransformerDecoder(
            nn.TransformerDecoderLayer(
                d_model=dim,
                nhead=16,
                dim_feedforward=dim * 4,
                activation="gelu",
                batch_first=True,
                norm_first=True,
            ),
            num_layers=6,
        )
        self.head = nn.Linear(dim, vocab_size, bias=False)

def forward(self, image_tokens, text_tokens):
        memory = image_tokens
        x = self.token_emb(text_tokens)
        return self.head(self.decoder(x, memory))

cURL request

⌘/Ctrl + Enter

GLM OCR cURL request

Response

Ready

Run this request.

Raw response

No response yet.

GLM OCR Triton kernel

DeepSeek OCR

DeepSeek OCR architecture

# DeepSeek OCR architecture

import torch
from torch import nn

class DeepSeekOCRVisionTower(nn.Module):
    def __init__(self, dim=1280, depth=32, heads=16):
        super().__init__()
        self.patch_embed = nn.Conv2d(3, dim, kernel_size=14, stride=14)
        self.blocks = nn.ModuleList([
            nn.TransformerEncoderLayer(
                d_model=dim,
                nhead=heads,
                dim_feedforward=dim * 4,
                activation="gelu",
                batch_first=True,
                norm_first=True,
            )
            for _ in range(depth)
        ])

def forward(self, image):
        x = self.patch_embed(image)
        return x.flatten(2).transpose(1, 2)

class DeepSeekOCRDecoder(nn.Module):
    def __init__(self, vocab_size, dim=1280):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, dim)
        self.decoder = nn.TransformerDecoder(
            nn.TransformerDecoderLayer(
                d_model=dim,
                nhead=16,
                dim_feedforward=dim * 4,
                activation="gelu",
                batch_first=True,
                norm_first=True,
            ),
            num_layers=8,
        )
        self.output = nn.Linear(dim, vocab_size, bias=False)

def forward(self, vision_tokens, text_tokens):
        x = self.embedding(text_tokens)
        return self.output(self.decoder(x, vision_tokens))

cURL request

⌘/Ctrl + Enter

DeepSeek OCR cURL request

Response

Ready

Run this request.

Raw response

No response yet.

DeepSeek OCR Triton kernel

No models match that search.