File size: 9,870 Bytes
c388140
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
from __future__ import annotations

import math
from dataclasses import dataclass
from typing import Iterable, List, Sequence, Tuple

import torch
from torch import nn
from torch.nn import functional as F


def _num_groups(channels: int, max_groups: int = 32) -> int:
    """
    GroupNorm 组数必须能整除 channels;这里自动选择合适组数。
    """
    for g in range(min(max_groups, channels), 0, -1):
        if channels % g == 0:
            return g
    return 1


class SinusoidalTimeEmbedding(nn.Module):
    """
    将离散 timestep 映射到连续 embedding(sin/cos)。
    """

    def __init__(self, dim: int):
        super().__init__()
        self.dim = dim

    def forward(self, t: torch.Tensor) -> torch.Tensor:
        half = self.dim // 2
        # 频率:exp(-log(10000) * i/(half-1))
        freqs = torch.exp(
            -math.log(10000.0) * torch.arange(0, half, device=t.device, dtype=torch.float32) / max(half - 1, 1)
        )
        args = t.float().unsqueeze(1) * freqs.unsqueeze(0)
        emb = torch.cat([torch.sin(args), torch.cos(args)], dim=1)
        if self.dim % 2 == 1:
            emb = F.pad(emb, (0, 1))
        return emb


class ResBlock(nn.Module):
    """
    ResNet block(带 time embedding 注入),避免对 16×16 不友好的过深/过度下采样。
    """

    def __init__(self, in_ch: int, out_ch: int, time_emb_dim: int, dropout: float = 0.0):
        super().__init__()
        self.in_ch = in_ch
        self.out_ch = out_ch

        self.norm1 = nn.GroupNorm(_num_groups(in_ch), in_ch)
        self.conv1 = nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1)

        self.time_proj = nn.Sequential(
            nn.SiLU(),
            nn.Linear(time_emb_dim, out_ch),
        )

        self.norm2 = nn.GroupNorm(_num_groups(out_ch), out_ch)
        self.dropout = nn.Dropout(dropout) if dropout > 0 else nn.Identity()
        self.conv2 = nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1)

        self.skip = nn.Identity() if in_ch == out_ch else nn.Conv2d(in_ch, out_ch, kernel_size=1)

    def forward(self, x: torch.Tensor, t_emb: torch.Tensor) -> torch.Tensor:
        h = self.conv1(F.silu(self.norm1(x)))
        # time embedding 以 bias 的形式注入到 feature map
        h = h + self.time_proj(t_emb).unsqueeze(-1).unsqueeze(-1)
        h = self.conv2(self.dropout(F.silu(self.norm2(h))))
        return h + self.skip(x)


class AttentionBlock(nn.Module):
    """
    轻量自注意力(用于 8×8 / 4×4 等小分辨率特征图)。
    """

    def __init__(self, channels: int, num_heads: int = 4):
        super().__init__()
        if channels % num_heads != 0:
            # 保守处理:无法整除就退化为 1 head,避免运行时报错
            num_heads = 1
        self.channels = channels
        self.num_heads = num_heads
        self.head_dim = channels // num_heads

        self.norm = nn.GroupNorm(_num_groups(channels), channels)
        self.qkv = nn.Conv2d(channels, channels * 3, kernel_size=1)
        self.proj = nn.Conv2d(channels, channels, kernel_size=1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        b, c, h, w = x.shape
        n = h * w
        qkv = self.qkv(self.norm(x))
        q, k, v = qkv.chunk(3, dim=1)

        # (b, heads, head_dim, n)
        q = q.reshape(b, self.num_heads, self.head_dim, n)
        k = k.reshape(b, self.num_heads, self.head_dim, n)
        v = v.reshape(b, self.num_heads, self.head_dim, n)

        # 注意力:softmax(q^T k / sqrt(d))
        scale = 1.0 / math.sqrt(self.head_dim)
        attn = torch.einsum("bhdn,bhdm->bhnm", q * scale, k)  # (b, heads, n, n)
        attn = torch.softmax(attn, dim=-1)
        out = torch.einsum("bhnm,bhdm->bhdn", attn, v)  # (b, heads, head_dim, n)
        out = out.reshape(b, c, h, w)
        out = self.proj(out)
        return x + out


class Downsample(nn.Module):
    """
    stride=2 卷积下采样(对小分辨率更友好、可学习)。
    """

    def __init__(self, channels: int):
        super().__init__()
        self.conv = nn.Conv2d(channels, channels, kernel_size=3, stride=2, padding=1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.conv(x)


class Upsample(nn.Module):
    """
    最近邻上采样 + 卷积。
    """

    def __init__(self, channels: int):
        super().__init__()
        self.conv = nn.Conv2d(channels, channels, kernel_size=3, padding=1)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = F.interpolate(x, scale_factor=2.0, mode="nearest")
        return self.conv(x)


@dataclass(frozen=True)
class UNet16Config:
    """
    16×16 专用 UNet 配置。
    """

    in_channels: int = 3
    out_channels: int = 3  # 预测 eps,通道数与输入一致
    base_channels: int = 64
    channel_mults: Tuple[int, ...] = (1, 2, 2)  # 16->8->4,避免过度下采样
    num_res_blocks: int = 2
    attn_resolutions: Tuple[int, ...] = (8, 4)  # 小分辨率加注意力更划算
    dropout: float = 0.0
    time_emb_dim: int = 256
    # 文本条件向量维度(与 time_emb_dim 对齐最简单)
    cond_dim: int = 256


class UNet16(nn.Module):
    """
    小型 UNet(epsilon-predictor),适配 16×16 输入。
    """

    def __init__(self, cfg: UNet16Config):
        super().__init__()
        self.cfg = cfg

        self.time_embed = nn.Sequential(
            SinusoidalTimeEmbedding(cfg.time_emb_dim),
            nn.Linear(cfg.time_emb_dim, cfg.time_emb_dim * 4),
            nn.SiLU(),
            nn.Linear(cfg.time_emb_dim * 4, cfg.time_emb_dim),
        )
        self.cond_proj = nn.Identity() if cfg.cond_dim == cfg.time_emb_dim else nn.Linear(cfg.cond_dim, cfg.time_emb_dim)

        self.in_conv = nn.Conv2d(cfg.in_channels, cfg.base_channels, kernel_size=3, padding=1)

        # Down path(按 level 显式组织,避免小分辨率下采样/上采样位置出错)
        ch = cfg.base_channels
        self.down_resblocks = nn.ModuleList()
        self.down_attn = nn.ModuleList()
        self.downsamples = nn.ModuleList()

        skip_chs: List[int] = []
        resolution = 16  # 纹理固定为 16×16
        for level, mult in enumerate(cfg.channel_mults):
            out_ch = cfg.base_channels * mult
            level_res = nn.ModuleList()
            level_attn = nn.ModuleList()
            for _ in range(cfg.num_res_blocks):
                level_res.append(ResBlock(ch, out_ch, cfg.time_emb_dim, dropout=cfg.dropout))
                ch = out_ch
                level_attn.append(AttentionBlock(ch) if resolution in cfg.attn_resolutions else nn.Identity())
                skip_chs.append(ch)
            self.down_resblocks.append(level_res)
            self.down_attn.append(level_attn)
            if level != len(cfg.channel_mults) - 1:
                self.downsamples.append(Downsample(ch))
                resolution //= 2

        # Mid
        self.mid_block1 = ResBlock(ch, ch, cfg.time_emb_dim, dropout=cfg.dropout)
        self.mid_attn = AttentionBlock(ch)
        self.mid_block2 = ResBlock(ch, ch, cfg.time_emb_dim, dropout=cfg.dropout)

        # Up path(从最深层开始逐级上采样)
        self.up_resblocks = nn.ModuleList()
        self.up_attn = nn.ModuleList()
        self.upsamples = nn.ModuleList()

        # 当前 resolution 对应最深层(例如 4×4)
        # down 部分循环结束后,resolution 已被更新到最深层
        for level, mult in reversed(list(enumerate(cfg.channel_mults))):
            out_ch = cfg.base_channels * mult
            level_res = nn.ModuleList()
            level_attn = nn.ModuleList()
            for _ in range(cfg.num_res_blocks):
                skip_ch = skip_chs.pop()
                level_res.append(ResBlock(ch + skip_ch, out_ch, cfg.time_emb_dim, dropout=cfg.dropout))
                ch = out_ch
                level_attn.append(AttentionBlock(ch) if resolution in cfg.attn_resolutions else nn.Identity())
            self.up_resblocks.append(level_res)
            self.up_attn.append(level_attn)
            if level != 0:
                self.upsamples.append(Upsample(ch))
                resolution *= 2

        self.out_norm = nn.GroupNorm(_num_groups(ch), ch)
        self.out_conv = nn.Conv2d(ch, cfg.out_channels, kernel_size=3, padding=1)

    def forward(self, x: torch.Tensor, t: torch.Tensor, cond: torch.Tensor | None = None) -> torch.Tensor:
        """
        输入:
        - x: (B, C, 16, 16) 的噪声图
        - t: (B,) 的 timestep(int64)
        - cond: (B, cond_dim) 的条件向量(可选;为空则无条件)
        输出:
        - eps_pred: (B, C, 16, 16)
        """
        t_emb = self.time_embed(t)
        if cond is not None:
            t_emb = t_emb + self.cond_proj(cond)
        h = self.in_conv(x)

        skips: List[torch.Tensor] = []
        for level in range(len(self.cfg.channel_mults)):
            for i in range(self.cfg.num_res_blocks):
                h = self.down_resblocks[level][i](h, t_emb)
                h = self.down_attn[level][i](h)
                skips.append(h)
            if level < len(self.downsamples):
                h = self.downsamples[level](h)

        h = self.mid_block1(h, t_emb)
        h = self.mid_attn(h)
        h = self.mid_block2(h, t_emb)

        # up_resblocks/up_attn 的顺序是从最深层到最浅层
        for level in range(len(self.cfg.channel_mults)):
            for i in range(self.cfg.num_res_blocks):
                skip = skips.pop()
                h = torch.cat([h, skip], dim=1)
                h = self.up_resblocks[level][i](h, t_emb)
                h = self.up_attn[level][i](h)
            if level < len(self.upsamples):
                h = self.upsamples[level](h)

        h = self.out_conv(F.silu(self.out_norm(h)))
        return h