EXP

infer/lib/predictors/RMVPE/RMVPE.py

@@ -0,0 +1,110 @@
+import os
+import sys
+import torch
+
+import numpy as np
+import torch.nn.functional as F
+
+sys.path.append(os.getcwd())
+
+from main.library.predictors.RMVPE.mel import MelSpectrogram
+
+N_MELS, N_CLASS = 128, 360
+
+class RMVPE:
+    def __init__(self, model_path, is_half, device=None, providers=None, onnx=False, hpa=False):
+        self.onnx = onnx
+
+        if self.onnx:
+            import onnxruntime as ort
+
+            sess_options = ort.SessionOptions()
+            sess_options.log_severity_level = 3
+            self.model = ort.InferenceSession(model_path, sess_options=sess_options, providers=providers)
+        else:
+            from main.library.predictors.RMVPE.e2e import E2E
+            model = E2E(4, 1, (2, 2), 5, 4, 1, 16, hpa=hpa)
+
+            model.load_state_dict(torch.load(model_path, map_location="cpu", weights_only=True))
+            model.eval()
+            if is_half: model = model.half()
+            self.model = model.to(device)
+
+        self.device = device
+        self.is_half = is_half
+        self.mel_extractor = MelSpectrogram(N_MELS, 16000, 1024, 160, None, 30, 8000).to(device)
+        cents_mapping = 20 * np.arange(N_CLASS) + 1997.3794084376191
+        self.cents_mapping = np.pad(cents_mapping, (4, 4))
+
+    def mel2hidden(self, mel, chunk_size = 32000):
+        with torch.no_grad():
+            n_frames = mel.shape[-1]
+            mel = F.pad(mel, (0, 32 * ((n_frames - 1) // 32 + 1) - n_frames), mode="reflect")
+
+            output_chunks = []
+            pad_frames = mel.shape[-1]
+
+            for start in range(0, pad_frames, chunk_size):
+                mel_chunk = mel[..., start:min(start + chunk_size, pad_frames)]
+                assert mel_chunk.shape[-1] % 32 == 0
+
+                if self.onnx:
+                    mel_chunk = mel_chunk.cpu().numpy().astype(np.float32)
+
+                    out_chunk = torch.as_tensor(
+                        self.model.run(
+                            [self.model.get_outputs()[0].name], 
+                            {self.model.get_inputs()[0].name: mel_chunk}
+                        )[0], 
+                        device=self.device
+                    )
+                else: 
+                    if self.is_half: mel_chunk = mel_chunk.half()
+                    out_chunk = self.model(mel_chunk)
+
+                output_chunks.append(out_chunk)
+
+            hidden = torch.cat(output_chunks, dim=1)
+            return hidden[:, :n_frames]
+
+    def decode(self, hidden, thred=0.03):
+        f0 = 10 * (2 ** (self.to_local_average_cents(hidden, thred=thred) / 1200))
+        f0[f0 == 10] = 0
+
+        return f0
+
+    def infer_from_audio(self, audio, thred=0.03):
+        hidden = self.mel2hidden(
+            self.mel_extractor(
+                torch.from_numpy(audio).float().to(self.device).unsqueeze(0), center=True
+            )
+        )
+
+        return self.decode(
+            hidden.squeeze(0).cpu().numpy().astype(np.float32), 
+            thred=thred
+        )
+    
+    def infer_from_audio_with_pitch(self, audio, thred=0.03, f0_min=50, f0_max=1100):
+        f0 = self.infer_from_audio(audio, thred)
+        f0[(f0 < f0_min) | (f0 > f0_max)] = 0  
+
+        return f0
+
+    def to_local_average_cents(self, salience, thred=0.05):
+        center = np.argmax(salience, axis=1)
+        salience = np.pad(salience, ((0, 0), (4, 4)))
+        center += 4
+        todo_salience, todo_cents_mapping = [], []
+        starts = center - 4
+        ends = center + 5
+
+        for idx in range(salience.shape[0]):
+            todo_salience.append(salience[:, starts[idx] : ends[idx]][idx])
+            todo_cents_mapping.append(self.cents_mapping[starts[idx] : ends[idx]])
+
+        todo_salience = np.array(todo_salience)
+        devided = np.sum(todo_salience * np.array(todo_cents_mapping), 1) / np.sum(todo_salience, 1)
+        devided[np.max(salience, axis=1) <= thred] = 0
+
+        return devided

infer/lib/predictors/RMVPE/deepunet.py

@@ -0,0 +1,351 @@
+import os
+import sys
+
+import torch
+
+import torch.nn as nn
+
+sys.path.append(os.getcwd())
+
+from main.library.predictors.RMVPE.yolo import YOLO13Encoder, YOLO13FullPADDecoder, HyperACE
+
+class ConvBlockRes(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels, 
+        momentum=0.01
+    ):
+        super(ConvBlockRes, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(
+                in_channels=in_channels, 
+                out_channels=out_channels, 
+                kernel_size=(3, 3), 
+                stride=(1, 1), 
+                padding=(1, 1), 
+                bias=False
+            ), 
+            nn.BatchNorm2d(
+                out_channels, 
+                momentum=momentum
+            ), 
+            nn.ReLU(), 
+            nn.Conv2d(
+                in_channels=out_channels, 
+                out_channels=out_channels, 
+                kernel_size=(3, 3), 
+                stride=(1, 1), 
+                padding=(1, 1), 
+                bias=False
+            ), 
+            nn.BatchNorm2d(
+                out_channels, 
+                momentum=momentum
+            ), 
+            nn.ReLU()
+        )
+
+        if in_channels != out_channels:
+            self.shortcut = nn.Conv2d(in_channels, out_channels, (1, 1))
+            self.is_shortcut = True
+        else: self.is_shortcut = False
+
+    def forward(self, x):
+        return (
+            self.conv(x) + self.shortcut(x)
+        ) if self.is_shortcut else (
+            self.conv(x) + x
+        )
+
+class ResEncoderBlock(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels, 
+        kernel_size, 
+        n_blocks=1, 
+        momentum=0.01
+    ):
+        super(ResEncoderBlock, self).__init__()
+        self.n_blocks = n_blocks
+        self.conv = nn.ModuleList()
+        self.conv.append(
+            ConvBlockRes(
+                in_channels, 
+                out_channels, 
+                momentum
+            )
+        )
+
+        for _ in range(n_blocks - 1):
+            self.conv.append(
+                ConvBlockRes(
+                    out_channels, 
+                    out_channels, 
+                    momentum
+                )
+            )
+
+        self.kernel_size = kernel_size
+        if self.kernel_size is not None: self.pool = nn.AvgPool2d(kernel_size=kernel_size)
+
+    def forward(self, x):
+        for i in range(self.n_blocks):
+            x = self.conv[i](x)
+
+        if self.kernel_size is not None: return x, self.pool(x)
+        else: return x
+
+class Encoder(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        in_size, 
+        n_encoders, 
+        kernel_size, 
+        n_blocks, 
+        out_channels=16, 
+        momentum=0.01
+    ):
+        super(Encoder, self).__init__()
+        self.n_encoders = n_encoders
+        self.bn = nn.BatchNorm2d(in_channels, momentum=momentum)
+        self.layers = nn.ModuleList()
+
+        for _ in range(self.n_encoders):
+            self.layers.append(
+                ResEncoderBlock(
+                    in_channels, 
+                    out_channels, 
+                    kernel_size, 
+                    n_blocks, 
+                    momentum=momentum
+                )
+            )
+
+            in_channels = out_channels
+            out_channels *= 2
+            in_size //= 2
+            
+        self.out_size = in_size
+        self.out_channel = out_channels
+
+    def forward(self, x):
+        concat_tensors = []
+        x = self.bn(x)
+
+        for layer in self.layers:
+            t, x = layer(x)
+            concat_tensors.append(t)
+
+        return x, concat_tensors
+
+class Intermediate(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels, 
+        n_inters, 
+        n_blocks, 
+        momentum=0.01
+    ):
+        super(Intermediate, self).__init__()
+        self.layers = nn.ModuleList()
+        self.layers.append(
+            ResEncoderBlock(
+                in_channels, 
+                out_channels, 
+                None, 
+                n_blocks, 
+                momentum
+            )
+        )
+
+        for _ in range(n_inters - 1):
+            self.layers.append(
+                ResEncoderBlock(
+                    out_channels, 
+                    out_channels, 
+                    None, 
+                    n_blocks, 
+                    momentum
+                )
+            )
+
+    def forward(self, x):
+        for layer in self.layers:
+            x = layer(x)
+
+        return x
+
+class ResDecoderBlock(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels, 
+        stride, 
+        n_blocks=1, 
+        momentum=0.01
+    ):
+        super(ResDecoderBlock, self).__init__()
+        out_padding = (0, 1) if stride == (1, 2) else (1, 1)
+        self.conv1 = nn.Sequential(
+            nn.ConvTranspose2d(
+                in_channels=in_channels, 
+                out_channels=out_channels, 
+                kernel_size=(3, 3), 
+                stride=stride, 
+                padding=(1, 1), 
+                output_padding=out_padding, 
+                bias=False
+            ), 
+            nn.BatchNorm2d(
+                out_channels, 
+                momentum=momentum
+            ), 
+            nn.ReLU()
+        )
+
+        self.conv2 = nn.ModuleList()
+        self.conv2.append(
+            ConvBlockRes(
+                out_channels * 2, 
+                out_channels, 
+                momentum
+            )
+        )
+
+        for _ in range(n_blocks - 1):
+            self.conv2.append(
+                ConvBlockRes(
+                    out_channels, 
+                    out_channels, 
+                    momentum
+                )
+            )
+
+    def forward(self, x, concat_tensor):
+        x = torch.cat((self.conv1(x), concat_tensor), dim=1)
+        for conv2 in self.conv2:
+            x = conv2(x)
+
+        return x
+
+class Decoder(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        n_decoders, 
+        stride, 
+        n_blocks, 
+        momentum=0.01
+    ):
+        super(Decoder, self).__init__()
+        self.layers = nn.ModuleList()
+
+        for _ in range(n_decoders):
+            out_channels = in_channels // 2
+            self.layers.append(
+                ResDecoderBlock(
+                    in_channels, 
+                    out_channels, 
+                    stride, 
+                    n_blocks, 
+                    momentum
+                )
+            )
+            in_channels = out_channels
+
+    def forward(self, x, concat_tensors):
+        for i, layer in enumerate(self.layers):
+            x = layer(x, concat_tensors[-1 - i])
+
+        return x
+
+class DeepUnet(nn.Module):
+    def __init__(
+        self, 
+        kernel_size, 
+        n_blocks, 
+        en_de_layers=5, 
+        inter_layers=4, 
+        in_channels=1, 
+        en_out_channels=16
+    ):
+        super(DeepUnet, self).__init__()
+        self.encoder = Encoder(
+            in_channels, 
+            128, 
+            en_de_layers, 
+            kernel_size, 
+            n_blocks, 
+            en_out_channels
+        )
+        self.intermediate = Intermediate(
+            self.encoder.out_channel // 2, 
+            self.encoder.out_channel, 
+            inter_layers, 
+            n_blocks
+        )
+        self.decoder = Decoder(
+            self.encoder.out_channel, 
+            en_de_layers, 
+            kernel_size, 
+            n_blocks
+        )
+
+    def forward(self, x):
+        x, concat_tensors = self.encoder(x)
+
+        return self.decoder(
+            self.intermediate(x), 
+            concat_tensors
+        )
+    
+class HPADeepUnet(nn.Module):
+    def __init__(
+        self, 
+        in_channels=1, 
+        en_out_channels=16, 
+        base_channels=64, 
+        hyperace_k=2, 
+        hyperace_l=1, 
+        num_hyperedges=16, 
+        num_heads=8
+    ):
+        super().__init__()
+        self.encoder = YOLO13Encoder(
+            in_channels, 
+            base_channels
+        )
+
+        enc_ch = self.encoder.out_channels
+
+        self.hyperace = HyperACE(
+            in_channels=enc_ch,
+            out_channels=enc_ch[-1],
+            num_hyperedges=num_hyperedges,
+            num_heads=num_heads,
+            k=hyperace_k, 
+            l=hyperace_l
+        )
+
+        self.decoder = YOLO13FullPADDecoder(
+            encoder_channels=enc_ch,
+            hyperace_out_c=enc_ch[-1],
+            out_channels_final=en_out_channels
+        )
+
+    def forward(self, x):
+        features = self.encoder(x)
+
+        return nn.functional.interpolate(
+            self.decoder(
+                features, 
+                self.hyperace(features)
+            ), 
+            size=x.shape[2:], 
+            mode='bilinear', 
+            align_corners=False
+        )

infer/lib/predictors/RMVPE/e2e.py

@@ -0,0 +1,93 @@
+import os
+import sys
+import torch
+
+import torch.nn as nn
+
+sys.path.append(os.getcwd())
+
+from main.library.predictors.RMVPE.deepunet import DeepUnet, HPADeepUnet
+
+N_MELS, N_CLASS = 128, 360
+
+class BiGRU(nn.Module):
+    def __init__(
+        self, 
+        input_features, 
+        hidden_features, 
+        num_layers
+    ):
+        super(BiGRU, self).__init__()
+        self.gru = nn.GRU(
+            input_features, 
+            hidden_features, 
+            num_layers=num_layers, 
+            batch_first=True, 
+            bidirectional=True
+        )
+
+    def forward(self, x):
+        try:
+            return self.gru(x)[0]
+        except:
+            torch.backends.cudnn.enabled = False
+            return self.gru(x)[0]
+        
+class E2E(nn.Module):
+    def __init__(
+        self, 
+        n_blocks, 
+        n_gru, 
+        kernel_size, 
+        en_de_layers=5, 
+        inter_layers=4, 
+        in_channels=1, 
+        en_out_channels=16, 
+        hpa=False
+    ):
+        super(E2E, self).__init__()
+        self.unet = (
+            HPADeepUnet(
+                in_channels=in_channels, 
+                en_out_channels=en_out_channels, 
+                base_channels=64, 
+                hyperace_k=2, 
+                hyperace_l=1, 
+                num_hyperedges=16, 
+                num_heads=4
+            ) 
+        ) if hpa else (
+            DeepUnet(
+                kernel_size, 
+                n_blocks, 
+                en_de_layers, 
+                inter_layers, 
+                in_channels, 
+                en_out_channels
+            )
+        )
+
+        self.cnn = nn.Conv2d(en_out_channels, 3, (3, 3), padding=(1, 1))
+        self.fc = (
+            nn.Sequential(
+                BiGRU(3 * 128, 256, n_gru), 
+                nn.Linear(512, N_CLASS), 
+                nn.Dropout(0.25), 
+                nn.Sigmoid()
+            )
+        ) if n_gru else (
+            nn.Sequential(
+                nn.Linear(3 * N_MELS, N_CLASS), 
+                nn.Dropout(0.25), 
+                nn.Sigmoid()
+            )
+        )
+
+    def forward(self, mel):
+        return self.fc(
+            self.cnn(
+                self.unet(
+                    mel.transpose(-1, -2).unsqueeze(1)
+                )
+            ).transpose(1, 2).flatten(-2)
+        )

infer/lib/predictors/RMVPE/mel.py

@@ -0,0 +1,80 @@
+import os
+import sys
+import torch
+
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+
+from librosa.filters import mel
+
+sys.path.append(os.getcwd())
+
+class MelSpectrogram(nn.Module):
+    def __init__(
+        self, 
+        n_mel_channels, 
+        sample_rate, 
+        win_length, 
+        hop_length, 
+        n_fft=None, 
+        mel_fmin=0, 
+        mel_fmax=None, 
+        clamp=1e-5
+    ):
+        super().__init__()
+        n_fft = win_length if n_fft is None else n_fft
+        self.hann_window = {}
+        mel_basis = mel(sr=sample_rate, n_fft=n_fft, n_mels=n_mel_channels, fmin=mel_fmin, fmax=mel_fmax, htk=True)
+        mel_basis = torch.from_numpy(mel_basis).float()
+        self.register_buffer("mel_basis", mel_basis)
+        self.n_fft = win_length if n_fft is None else n_fft
+        self.hop_length = hop_length
+        self.win_length = win_length
+        self.sample_rate = sample_rate
+        self.n_mel_channels = n_mel_channels
+        self.clamp = clamp
+
+    def forward(self, audio, keyshift=0, speed=1, center=True):
+        factor = 2 ** (keyshift / 12)
+        win_length_new = int(np.round(self.win_length * factor))
+
+        keyshift_key = str(keyshift) + "_" + str(audio.device)
+        if keyshift_key not in self.hann_window: self.hann_window[keyshift_key] = torch.hann_window(win_length_new).to(audio.device)
+
+        n_fft = int(np.round(self.n_fft * factor))
+        hop_length = int(np.round(self.hop_length * speed))
+
+        if str(audio.device).startswith(("ocl", "privateuseone")):
+            if not hasattr(self, "stft"): 
+                from main.library.backends.utils import STFT
+
+                self.stft = STFT(
+                    filter_length=n_fft, 
+                    hop_length=hop_length, 
+                    win_length=win_length_new
+                ).to(audio.device)
+
+            magnitude = self.stft.transform(audio, 1e-9)
+        else:
+            fft = torch.stft(
+                audio, 
+                n_fft=n_fft, 
+                hop_length=hop_length, 
+                win_length=win_length_new, 
+                window=self.hann_window[keyshift_key], 
+                center=center, 
+                return_complex=True
+            )
+
+            magnitude = (fft.real.pow(2) + fft.imag.pow(2)).sqrt()
+
+        if keyshift != 0:
+            size = self.n_fft // 2 + 1
+            resize = magnitude.size(1)
+
+            if resize < size: magnitude = F.pad(magnitude, (0, 0, 0, size - resize))
+            magnitude = magnitude[:, :size, :] * self.win_length / win_length_new
+
+        mel_output = self.mel_basis @ magnitude
+        return mel_output.clamp(min=self.clamp).log()

infer/lib/predictors/RMVPE/yolo.py

@@ -0,0 +1,514 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+def autopad(k, p=None):
+    if p is None: p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
+    return p
+
+class Conv(nn.Module):
+    def __init__(
+        self, 
+        c1, 
+        c2, 
+        k=1, 
+        s=1, 
+        p=None, 
+        g=1, 
+        act=True
+    ):
+        super().__init__()
+        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p), groups=g, bias=False)
+        self.bn = nn.BatchNorm2d(c2) 
+        self.act = nn.SiLU() if act else nn.Identity()
+
+    def forward(self, x):
+        return self.act(
+            self.bn(
+                self.conv(x)
+            )
+        )
+
+class DSConv(nn.Module):
+    def __init__(
+        self, 
+        c1, 
+        c2, 
+        k=3, 
+        s=1, 
+        p=None, 
+        act=True
+    ):
+        super().__init__()
+        self.dwconv = nn.Conv2d(c1, c1, k, s, autopad(k, p), groups=c1, bias=False)
+        self.pwconv = nn.Conv2d(c1, c2, 1, 1, 0, bias=False)
+        self.bn = nn.BatchNorm2d(c2)
+        self.act = nn.SiLU() if act else nn.Identity()
+
+    def forward(self, x):
+        return self.act(
+            self.bn(
+                self.pwconv(
+                    self.dwconv(x)
+                )
+            )
+        )
+
+class DS_Bottleneck(nn.Module):
+    def __init__(
+        self, 
+        c1, 
+        c2, 
+        k=3, 
+        shortcut=True
+    ):
+        super().__init__()
+        self.dsconv1 = DSConv(c1, c1, k=3, s=1)
+        self.dsconv2 = DSConv(c1, c2, k=k, s=1)
+        self.shortcut = shortcut and c1 == c2
+
+    def forward(self, x):
+        return x + self.dsconv2(self.dsconv1(x)) if self.shortcut else self.dsconv2(self.dsconv1(x))
+
+class DS_C3k(nn.Module):
+    def __init__(
+        self, 
+        c1, 
+        c2, 
+        n=1, 
+        k=3, 
+        e=0.5
+    ):
+        super().__init__()
+        self.cv1 = Conv(c1, int(c2 * e), 1, 1)
+        self.cv2 = Conv(c1, int(c2 * e), 1, 1)
+        self.cv3 = Conv(2 * int(c2 * e), c2, 1, 1)
+        self.m = nn.Sequential(
+            *[
+                DS_Bottleneck(
+                    int(c2 * e), 
+                    int(c2 * e), 
+                    k=k, 
+                    shortcut=True
+                ) 
+                for _ in range(n)
+            ]
+        )
+
+    def forward(self, x):
+        return self.cv3(
+            torch.cat(
+                (self.m(self.cv1(x)), self.cv2(x)), 
+                dim=1
+            )
+        )
+
+class DS_C3k2(nn.Module):
+    def __init__(
+        self, 
+        c1, 
+        c2, 
+        n=1, 
+        k=3, 
+        e=0.5
+    ):
+        super().__init__()
+        self.cv1 = Conv(c1, int(c2 * e), 1, 1)
+        self.m = DS_C3k(int(c2 * e), int(c2 * e), n=n, k=k, e=1.0)
+        self.cv2 = Conv(int(c2 * e), c2, 1, 1)
+
+    def forward(self, x):
+        return self.cv2(
+            self.m(
+                self.cv1(x)
+            )
+        )
+
+class AdaptiveHyperedgeGeneration(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        num_hyperedges, 
+        num_heads
+    ):
+        super().__init__()
+        self.num_hyperedges = num_hyperedges
+        self.num_heads = num_heads
+        self.head_dim = max(1, in_channels // num_heads)
+        self.global_proto = nn.Parameter(torch.randn(num_hyperedges, in_channels))
+        self.context_mapper = nn.Linear(2 * in_channels, num_hyperedges * in_channels, bias=False)
+        self.query_proj = nn.Linear(in_channels, in_channels, bias=False)
+        self.scale = self.head_dim ** -0.5
+
+    def forward(self, x):
+        B, N, C = x.shape
+        P = (
+            self.global_proto.unsqueeze(0) + 
+            self.context_mapper(
+                torch.cat(
+                    (
+                        F.adaptive_avg_pool1d(x.permute(0, 2, 1), 1).squeeze(-1), 
+                        F.adaptive_max_pool1d(x.permute(0, 2, 1), 1).squeeze(-1)
+                    ), 
+                    dim=1
+                )
+            ).view(B, self.num_hyperedges, C))
+
+        return F.softmax((
+            (self.query_proj(x).view(B, N, self.num_heads, self.head_dim).permute(0, 2, 1, 3) @ P.view(B, self.num_hyperedges, self.num_heads, self.head_dim).permute(0, 2, 3, 1)) * self.scale
+        ).mean(dim=1).permute(0, 2, 1), dim=-1)
+
+class HypergraphConvolution(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels
+    ):
+        super().__init__()
+        self.W_e = nn.Linear(in_channels, in_channels, bias=False)
+        self.W_v = nn.Linear(in_channels, out_channels, bias=False)
+        self.act = nn.SiLU()
+
+    def forward(self, x, A):
+        return x + self.act(self.W_v(A.transpose(1, 2).bmm(self.act(self.W_e(A.bmm(x))))))
+
+class AdaptiveHypergraphComputation(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels, 
+        num_hyperedges, 
+        num_heads
+    ):
+        super().__init__()
+        self.adaptive_hyperedge_gen = AdaptiveHyperedgeGeneration(in_channels, num_hyperedges, num_heads)
+        self.hypergraph_conv = HypergraphConvolution(in_channels, out_channels)
+
+    def forward(self, x):
+        B, _, H, W = x.shape
+        x_flat = x.flatten(2).permute(0, 2, 1)
+
+        return self.hypergraph_conv(x_flat, self.adaptive_hyperedge_gen(x_flat)).permute(0, 2, 1).view(B, -1, H, W)
+
+class C3AH(nn.Module):
+    def __init__(
+        self, 
+        c1, 
+        c2, 
+        num_hyperedges, 
+        num_heads, 
+        e=0.5
+    ):
+        super().__init__()
+        self.cv1 = Conv(c1, int(c1 * e), 1, 1)
+        self.cv2 = Conv(c1, int(c1 * e), 1, 1)
+        self.ahc = AdaptiveHypergraphComputation(int(c1 * e), int(c1 * e), num_hyperedges, num_heads)
+        self.cv3 = Conv(2 * int(c1 * e), c2, 1, 1)
+
+    def forward(self, x):
+        return self.cv3(
+            torch.cat(
+                (self.ahc(self.cv2(x)), self.cv1(x)), 
+                dim=1
+            )
+        )
+
+class HyperACE(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        out_channels, 
+        num_hyperedges=16, 
+        num_heads=8, 
+        k=2, 
+        l=1, 
+        c_h=0.5, 
+        c_l=0.25
+    ):
+        super().__init__()
+        c2, c3, c4, c5 = in_channels 
+        c_mid = c4
+        self.fuse_conv = Conv(c2 + c3 + c4 + c5, c_mid, 1, 1) 
+        self.c_h = int(c_mid * c_h)
+        self.c_l = int(c_mid * c_l)
+        self.c_s = c_mid - self.c_h - self.c_l
+        self.high_order_branch = nn.ModuleList([
+            C3AH(
+                self.c_h, 
+                self.c_h, 
+                num_hyperedges=num_hyperedges, 
+                num_heads=num_heads, e=1.0
+            ) 
+            for _ in range(k)
+        ])
+        self.high_order_fuse = Conv(self.c_h * k, self.c_h, 1, 1)
+        self.low_order_branch = nn.Sequential(
+            *[
+                DS_C3k(
+                    self.c_l, 
+                    self.c_l, 
+                    n=1, 
+                    k=3, 
+                    e=1.0
+                ) 
+                for _ in range(l)
+            ]
+        )
+        self.final_fuse = Conv(self.c_h + self.c_l + self.c_s, out_channels, 1, 1)
+
+    def forward(self, x):
+        B2, B3, B4, B5 = x 
+        _, _, H4, W4 = B4.shape
+
+        x_h, x_l, x_s = self.fuse_conv(
+            torch.cat(
+                (
+                    F.interpolate(
+                        B2, 
+                        size=(H4, W4), 
+                        mode='bilinear', 
+                        align_corners=False
+                    ), 
+                    F.interpolate(
+                        B3, 
+                        size=(H4, W4), 
+                        mode='bilinear', 
+                        align_corners=False
+                    ), 
+                    B4, 
+                    F.interpolate(
+                        B5, 
+                        size=(H4, W4), 
+                        mode='bilinear', 
+                        align_corners=False
+                    )
+                ), 
+                dim=1
+            )
+        ).split([self.c_h, self.c_l, self.c_s], dim=1)
+
+        return self.final_fuse(
+            torch.cat(
+                (
+                    self.high_order_fuse(torch.cat([m(x_h) for m in self.high_order_branch], dim=1)), 
+                    self.low_order_branch(x_l), 
+                    x_s
+                ), 
+                dim=1
+            )
+        )
+
+class GatedFusion(nn.Module):
+    def __init__(
+        self, 
+        in_channels
+    ):
+        super().__init__()
+        self.gamma = nn.Parameter(torch.zeros(1, in_channels, 1, 1))
+
+    def forward(self, f_in, h):
+        return f_in + self.gamma * h
+
+class YOLO13Encoder(nn.Module):
+    def __init__(
+        self, 
+        in_channels, 
+        base_channels=32
+    ):
+        super().__init__()
+        self.stem = DSConv(
+            in_channels, 
+            base_channels, 
+            k=3, 
+            s=1
+        )
+        self.p2 = nn.Sequential(
+            DSConv(
+                base_channels, 
+                base_channels*2, k=3, s=(2, 2)), 
+            DS_C3k2(
+                base_channels*2, 
+                base_channels*2, 
+                n=1
+            )
+        )
+        self.p3 = nn.Sequential(
+            DSConv(
+                base_channels*2, 
+                base_channels*4, 
+                k=3, 
+                s=(2, 2)
+            ), 
+            DS_C3k2(
+                base_channels*4, 
+                base_channels*4, 
+                n=2
+            )
+        )
+        self.p4 = nn.Sequential(
+            DSConv(
+                base_channels*4, 
+                base_channels*8, 
+                k=3, 
+                s=(2, 2)
+            ), 
+            DS_C3k2(
+                base_channels*8, 
+                base_channels*8, 
+                n=2
+            )
+        )
+        self.p5 = nn.Sequential(
+            DSConv(
+                base_channels*8, 
+                base_channels*16, 
+                k=3, 
+                s=(2, 2)
+            ), 
+            DS_C3k2(
+                base_channels*16, 
+                base_channels*16, 
+                n=1
+            )
+        )
+        
+        self.out_channels = [base_channels*2, base_channels*4, base_channels*8, base_channels*16]
+
+    def forward(self, x):
+        p2 = self.p2(self.stem(x))
+        p3 = self.p3(p2)
+        p4 = self.p4(p3)
+        p5 = self.p5(p4)
+
+        return [p2, p3, p4, p5]
+
+class YOLO13FullPADDecoder(nn.Module):
+    def __init__(self, encoder_channels, hyperace_out_c, out_channels_final):
+        super().__init__()
+        c_p2, c_p3, c_p4, c_p5 = encoder_channels
+        c_d5, c_d4, c_d3, c_d2 = c_p5, c_p4, c_p3, c_p2
+        
+        self.h_to_d5 = Conv(
+            hyperace_out_c, 
+            c_d5, 
+            1, 
+            1
+        )
+        self.h_to_d4 = Conv(
+            hyperace_out_c, 
+            c_d4, 
+            1, 
+            1
+        )
+        self.h_to_d3 = Conv(
+            hyperace_out_c, 
+            c_d3, 
+            1, 
+            1
+        )
+        self.h_to_d2 = Conv(
+            hyperace_out_c, 
+            c_d2, 
+            1, 
+            1
+        )
+
+        self.fusion_d5 = GatedFusion(c_d5)
+        self.fusion_d4 = GatedFusion(c_d4)
+        self.fusion_d3 = GatedFusion(c_d3)
+        self.fusion_d2 = GatedFusion(c_d2)
+
+        self.skip_p5 = Conv(
+            c_p5, 
+            c_d5, 
+            1, 
+            1
+        )
+        self.skip_p4 = Conv(
+            c_p4, 
+            c_d4, 
+            1, 
+            1
+        )
+        self.skip_p3 = Conv(
+            c_p3, 
+            c_d3, 
+            1, 
+            1
+        )
+        self.skip_p2 = Conv(
+            c_p2, 
+            c_d2, 
+            1, 
+            1
+        )
+
+        self.up_d5 = DS_C3k2(
+            c_d5, 
+            c_d4, 
+            n=1
+        )
+        self.up_d4 = DS_C3k2(
+            c_d4, 
+            c_d3, 
+            n=1
+        )
+        self.up_d3 = DS_C3k2(
+            c_d3, 
+            c_d2, 
+            n=1
+        )
+        
+        self.final_d2 = DS_C3k2(
+            c_d2, 
+            c_d2, 
+            n=1
+        )
+        self.final_conv = Conv(
+            c_d2,
+            out_channels_final, 
+            1, 
+            1
+        )
+
+    def forward(self, enc_feats, h_ace):
+        p2, p3, p4, p5 = enc_feats
+        d5 = self.skip_p5(p5)
+
+        d4 = self.up_d5(
+            F.interpolate(
+                self.fusion_d5(d5, self.h_to_d5(F.interpolate(h_ace, size=d5.shape[2:], mode='bilinear', align_corners=False))), 
+                size=p4.shape[2:], 
+                mode='bilinear', 
+                align_corners=False
+            )
+        ) + self.skip_p4(p4)
+
+        d3 = self.up_d4(
+            F.interpolate(
+                self.fusion_d4(d4, self.h_to_d4(F.interpolate(h_ace, size=d4.shape[2:], mode='bilinear', align_corners=False))), 
+                size=p3.shape[2:], 
+                mode='bilinear', 
+                align_corners=False
+            )
+        ) + self.skip_p3(p3)
+
+        d2 = self.up_d3(
+            F.interpolate(
+                self.fusion_d3(d3, self.h_to_d3(F.interpolate(h_ace, size=d3.shape[2:], mode='bilinear', align_corners=False))), 
+                size=p2.shape[2:], 
+                mode='bilinear', 
+                align_corners=False
+            )
+        ) + self.skip_p2(p2)
+
+        return self.final_conv(
+            self.final_d2(
+                self.fusion_d2(
+                    d2, 
+                    self.h_to_d2(
+                        F.interpolate(h_ace, size=d2.shape[2:], mode='bilinear', align_corners=False)
+                    )
+                )
+            )
+        )