Update RVC/modules/rmvpe.py

RVC/modules/rmvpe.py

@@ -10,14 +10,258 @@ from librosa.filters import mel
 
 sys.path.append(os.getcwd())
 
-from modules import opencl
-
 N_MELS, N_CLASS = 128, 360
 
+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):
+        x = self.stem(x)
+        p2 = self.p2(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)))))
+
 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())
+        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
@@ -91,7 +335,23 @@ 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.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))
 
@@ -131,19 +391,89 @@ class DeepUnet(nn.Module):
     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)
+
+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):
+    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 = DeepUnet(kernel_size, n_blocks, en_de_layers, inter_layers, in_channels, en_out_channels)
+        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())
+        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))
 
-class MelSpectrogram(torch.nn.Module):
-    def __init__(self, is_half, n_mel_channels, sample_rate, win_length, hop_length, n_fft=None, mel_fmin=0, mel_fmax=None, clamp=1e-5):
+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 = {}
@@ -156,7 +486,6 @@ class MelSpectrogram(torch.nn.Module):
         self.sample_rate = sample_rate
         self.n_mel_channels = n_mel_channels
         self.clamp = clamp
-        self.is_half = is_half 
 
     def forward(self, audio, keyshift=0, speed=1, center=True):
         factor = 2 ** (keyshift / 12)
@@ -167,12 +496,8 @@ class MelSpectrogram(torch.nn.Module):
         n_fft = int(np.round(self.n_fft * factor))
         hop_length = int(np.round(self.hop_length * speed))
 
-        if str(audio.device).startswith("ocl"):
-            stft = opencl.STFT(filter_length=n_fft, hop_length=hop_length, win_length=win_length_new).to(audio.device)
-            magnitude = 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 = torch.sqrt(fft.real.pow(2) + fft.imag.pow(2))
+        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
@@ -180,34 +505,55 @@ class MelSpectrogram(torch.nn.Module):
             if resize < size: magnitude = F.pad(magnitude, (0, 0, 0, size - resize))
             magnitude = magnitude[:, :size, :] * self.win_length / win_length_new
 
-        mel_output = torch.matmul(self.mel_basis, magnitude)
-        if self.is_half: mel_output = mel_output.half()
-
-        return torch.log(torch.clamp(mel_output, min=self.clamp))
+        mel_output = self.mel_basis @ magnitude
+        return mel_output.clamp(min=self.clamp).log()
 
 class RMVPE:
-    def __init__(self, model_path, is_half, device=None):
-        self.resample_kernel = {}
-        self.resample_kernel = {}
-        model = E2E(4, 1, (2, 2))
-        ckpt = torch.load(model_path, map_location="cpu")
-        model.load_state_dict(ckpt)
-        model.eval()
-        if is_half: model = model.half()
-        self.model = model.to(device)
-        self.is_half = is_half
+    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:
+            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.mel_extractor = MelSpectrogram(is_half, N_MELS, 16000, 1024, 160, None, 30, 8000).to(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):
+    def mel2hidden(self, mel, chunk_size = 32000):
         with torch.no_grad():
             n_frames = mel.shape[-1]
-            n_pad = 32 * ((n_frames - 1) // 32 + 1) - n_frames
-            if n_pad > 0: mel = F.pad(mel, (0, n_pad), mode="constant")
+            mel = F.pad(mel, (0, 32 * ((n_frames - 1) // 32 + 1) - n_frames), mode="reflect")
 
-            hidden = self.model(mel.half() if self.is_half else mel.float())
+            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):
@@ -219,12 +565,10 @@ class RMVPE:
     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) if self.is_half else hidden.squeeze(0).cpu().numpy()), thred=thred)
+        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):
-        hidden = self.mel2hidden(self.mel_extractor(torch.from_numpy(audio).float().to(self.device).unsqueeze(0), center=True))
-
-        f0 = self.decode((hidden.squeeze(0).cpu().numpy().astype(np.float32) if self.is_half else hidden.squeeze(0).cpu().numpy()), thred=thred)
+        f0 = self.infer_from_audio(audio, thred)
         f0[(f0 < f0_min) | (f0 > f0_max)] = 0  
 
         return f0
@@ -245,16 +589,4 @@ class RMVPE:
         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
-
-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]
+        return devided