| """ |
| New layers for CCFM: LatentEmbedder and LatentDecoder. |
| Analogous to LatentForcing's dino_embedder (BottleneckPatchEmbed) and |
| final_layer_dino + dh_blocks_dino. |
| """ |
|
|
| import torch |
| import torch.nn as nn |
|
|
|
|
| class LatentEmbedder(nn.Module): |
| """ |
| Projects per-gene scGPT features (B, G, scgpt_dim) to (B, G, d_model). |
| Analogous to LatentForcing's dino_embedder (BottleneckPatchEmbed with kernel=1). |
| Uses a bottleneck projection: scgpt_dim -> bottleneck_dim -> d_model. |
| """ |
|
|
| def __init__(self, scgpt_dim: int = 512, bottleneck_dim: int = 128, d_model: int = 128): |
| super().__init__() |
| self.proj = nn.Sequential( |
| nn.Linear(scgpt_dim, bottleneck_dim), |
| nn.GELU(), |
| nn.Linear(bottleneck_dim, d_model), |
| ) |
|
|
| def forward(self, z: torch.Tensor) -> torch.Tensor: |
| """z: (B, G, scgpt_dim) -> (B, G, d_model)""" |
| return self.proj(z) |
|
|
|
|
| class LatentDecoderBlock(nn.Module): |
| """ |
| A simple transformer-like block for the latent decoder head. |
| Uses AdaLN conditioning (analogous to LatentForcing's dh_blocks_dino). |
| """ |
|
|
| def __init__(self, hidden_size: int, num_heads: int = 4, mlp_ratio: float = 4.0, |
| hidden_size_c: int = None): |
| super().__init__() |
| hidden_size_c = hidden_size_c or hidden_size |
| self.norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) |
| self.attn = nn.MultiheadAttention(hidden_size, num_heads, batch_first=True) |
| self.norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6) |
| mlp_hidden = int(hidden_size * mlp_ratio) |
| self.mlp = nn.Sequential( |
| nn.Linear(hidden_size, mlp_hidden), |
| nn.GELU(), |
| nn.Linear(mlp_hidden, hidden_size), |
| ) |
| self.adaLN_modulation = nn.Sequential( |
| nn.SiLU(), |
| nn.Linear(hidden_size_c, 6 * hidden_size, bias=True), |
| ) |
|
|
| def forward(self, x: torch.Tensor, c: torch.Tensor) -> torch.Tensor: |
| """ |
| x: (B, G, hidden_size) |
| c: (B, hidden_size_c) — conditioning vector |
| """ |
| shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = ( |
| self.adaLN_modulation(c).chunk(6, dim=1) |
| ) |
| |
| h = self.norm1(x) |
| h = h * (1 + scale_msa.unsqueeze(1)) + shift_msa.unsqueeze(1) |
| h = self.attn(h, h, h)[0] |
| x = x + gate_msa.unsqueeze(1) * h |
| |
| h = self.norm2(x) |
| h = h * (1 + scale_mlp.unsqueeze(1)) + shift_mlp.unsqueeze(1) |
| h = self.mlp(h) |
| x = x + gate_mlp.unsqueeze(1) * h |
| return x |
|
|
|
|
| class LatentDecoder(nn.Module): |
| """ |
| Decodes backbone output (B, G, d_model) back to (B, G, scgpt_dim). |
| Analogous to LatentForcing's final_layer_dino + dh_blocks_dino. |
| """ |
|
|
| def __init__(self, d_model: int = 128, scgpt_dim: int = 512, |
| dh_depth: int = 2, num_heads: int = 4, |
| hidden_size_c: int = None): |
| super().__init__() |
| hidden_size_c = hidden_size_c or d_model |
|
|
| self.dh_proj = nn.Linear(d_model, d_model) |
|
|
| if dh_depth > 0: |
| self.dh_blocks = nn.ModuleList([ |
| LatentDecoderBlock(d_model, num_heads=num_heads, hidden_size_c=hidden_size_c) |
| for _ in range(dh_depth) |
| ]) |
| else: |
| self.dh_blocks = nn.ModuleList() |
|
|
| self.final = nn.Sequential( |
| nn.LayerNorm(d_model), |
| nn.Linear(d_model, d_model), |
| nn.GELU(), |
| nn.Linear(d_model, scgpt_dim), |
| ) |
|
|
| def forward(self, x: torch.Tensor, c: torch.Tensor) -> torch.Tensor: |
| """ |
| x: (B, G, d_model) — backbone output |
| c: (B, d_model) — conditioning vector |
| Returns: (B, G, scgpt_dim) |
| """ |
| h = self.dh_proj(x) |
| for block in self.dh_blocks: |
| h = block(h, c) |
| return self.final(h) |
|
|
