Upload 7 files

5_HP-Karaoke-UVR.py

@@ -0,0 +1,132 @@
+import os
+import sys
+import torch
+import warnings
+import hashlib
+import math
+import importlib
+import numpy as np
+from tqdm import tqdm
+from scipy.io import wavfile
+import librosa
+import pdb
+from uvr5_pack.lib_v5 import spec_utils
+from uvr5_pack.utils import _get_name_params, inference
+from uvr5_pack.lib_v5.model_param_init import ModelParameters
+
+
+warnings.filterwarnings("ignore")
+
+
+class _audio_pre_():
+    def __init__(self, model_path, device, is_half):
+        self.model_path = model_path
+        self.device = device
+        self.data = {
+            # Processing Options
+            'postprocess': False,
+            'tta': False,
+            # Constants
+            'window_size': 320,
+            'agg': 10,
+            'high_end_process': 'mirroring',
+        }
+        nn_arch_sizes = [
+            31191, # default
+            33966,61968, 123821, 123812, 537238 # custom
+        ]
+        self.nn_architecture = list('{}KB'.format(s) for s in nn_arch_sizes)
+        model_size = math.ceil(os.stat(model_path).st_size / 1024)
+        nn_architecture = '{}KB'.format(min(nn_arch_sizes, key=lambda x:abs(x-model_size)))
+        nets = importlib.import_module('uvr5_pack.lib_v5.nets' + f'_{nn_architecture}'.replace('_{}KB'.format(nn_arch_sizes[0]), ''), package=None)
+        model_hash = hashlib.md5(open(model_path, 'rb').read()).hexdigest()
+        param_name, model_params_d = _get_name_params(model_path, model_hash)
+
+        mp = ModelParameters(model_params_d)
+        model = nets.CascadedASPPNet(mp.param['bins'] * 2)
+        cpk = torch.load(model_path, map_location='cpu')
+        model.load_state_dict(cpk)
+        model.eval()
+        if is_half:
+            model = model.half().to(device)
+        else:
+            model = model.to(device)
+
+        self.mp = mp
+        self.model = model
+
+    def _path_audio_(self, music_file, ins_root=None, vocal_root=None):
+        if ins_root is None and vocal_root is None:
+            return "No save root."
+        name = os.path.basename(music_file)
+        if ins_root is not None:
+            os.makedirs(ins_root, exist_ok=True)
+        if vocal_root is not None:
+            os.makedirs(vocal_root, exist_ok=True)
+        X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
+        bands_n = len(self.mp.param['band'])
+        for d in range(bands_n, 0, -1):
+            bp = self.mp.param['band'][d]
+            if d == bands_n:
+                X_wave[d], _ = librosa.core.load(
+                    music_file, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
+                if X_wave[d].ndim == 1:
+                    X_wave[d] = np.asfortranarray([X_wave[d], X_wave[d]])
+            else:
+                X_wave[d] = librosa.core.resample(X_wave[d+1], self.mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
+
+            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(X_wave[d], bp['hl'], bp['n_fft'], self.mp.param['mid_side'], self.mp.param['mid_side_b2'], self.mp.param['reverse'])
+            if d == bands_n and self.data['high_end_process'] != 'none':
+                input_high_end_h = (bp['n_fft'] // 2 - bp['crop_stop']) + (self.mp.param['pre_filter_stop'] - self.mp.param['pre_filter_start'])
+                input_high_end = X_spec_s[d][:, bp['n_fft']//2-input_high_end_h:bp['n_fft']//2, :]
+
+        X_spec_m = spec_utils.combine_spectrograms(X_spec_s, self.mp)
+        aggresive_set = float(self.data['agg']/100)
+        aggressiveness = {'value': aggresive_set, 'split_bin': self.mp.param['band'][1]['crop_stop']}
+        with torch.no_grad():
+            pred, X_mag, X_phase = inference(X_spec_m, self.device, self.model, aggressiveness, self.data)
+
+        if self.data['postprocess']:
+            pred_inv = np.clip(X_mag - pred, 0, np.inf)
+            pred = spec_utils.mask_silence(pred, pred_inv)
+
+        y_spec_m = pred * X_phase
+        v_spec_m = X_spec_m - y_spec_m
+
+        if ins_root is not None:
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], y_spec_m, input_high_end, self.mp)
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp, input_high_end_h, input_high_end_)
+            else:
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp)
+            print('%s instruments done' % name)
+            # 分离文件名和扩展名
+            file_name, ext = os.path.splitext(name)
+            wavfile.write(os.path.join(ins_root, '和声_{}{}'.format(file_name, ext)), self.mp.param['sr'], (np.array(wav_instrument)*32768).astype(np.int16))
+        if vocal_root is not None:
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], v_spec_m, input_high_end, self.mp)
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp, input_high_end_h, input_high_end_)
+            else:
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp)
+            print('%s vocals done' % name)
+            # 分离文件名和扩展名
+            file_name, ext = os.path.splitext(name)
+            wavfile.write(os.path.join(vocal_root, '{}{}'.format(file_name, ext)), self.mp.param['sr'], (np.array(wav_vocals)*32768).astype(np.int16))
+
+
+
+if __name__ == '__main__':
+    device = 'cuda'
+    is_half = True
+    model_path = 'uvr5_weights/5_HP-Karaoke-UVR.pth'
+    pre_fun = _audio_pre_(model_path=model_path, device=device, is_half=True)
+
+    # 获取混响文件夹内的所有.wav文件路径
+    audio_folder = '/mnt/workspace/input/'
+    wav_files = [os.path.join(audio_folder, file) for file in os.listdir(audio_folder) if file.endswith('.mp3')]
+
+    # 遍历每个音频文件进行处理
+    save_path = 'echo'
+    for wav_file in wav_files:
+        pre_fun._path_audio_(wav_file, save_path, save_path)

deecho.py

@@ -0,0 +1,201 @@
+import os, sys, torch, warnings, pdb
+now_dir = os.getcwd()
+sys.path.append(now_dir)
+from json import load as ll
+warnings.filterwarnings("ignore")
+import librosa
+import importlib
+import numpy as np
+import hashlib, math
+from tqdm import tqdm
+from uvr5_pack.lib_v5 import spec_utils
+from uvr5_pack.utils import _get_name_params, inference
+from uvr5_pack.lib_v5.model_param_init import ModelParameters
+import soundfile as sf
+from uvr5_pack.lib_v5.nets_new import CascadedNet
+from uvr5_pack.lib_v5 import nets_61968KB as nets
+import argparse
+
+class AudioSeparator:
+    def __init__(self, agg, model_path, device, is_half, model_params):
+        self.model_path = model_path
+        self.device = device
+        self.data = {
+            # Processing Options
+            "postprocess": False,
+            "tta": False,
+            # Constants
+            "window_size": 320,
+            "agg": agg,
+            "high_end_process": "mirroring",
+        }
+        if model_params == "4band_v3":
+            mp = ModelParameters("uvr5_pack/lib_v5/modelparams/4band_v3.json")
+            nout = 64 if "DeReverb" in model_path else 48
+            model = CascadedNet(mp.param["bins"] * 2, nout)
+        if model_params == "4band_v2":
+            mp = ModelParameters("uvr5_pack/lib_v5/modelparams/4band_v2.json")
+            model = nets.CascadedASPPNet(mp.param["bins"] * 2)
+        cpk = torch.load(model_path, map_location="cpu")
+        model.load_state_dict(cpk)
+        model.eval()
+        if is_half:
+            model = model.half().to(device)
+        else:
+            model = model.to(device)
+
+        self.mp = mp
+        self.model = model
+
+    def separate(self, music_file, vocal_root=None, ins_root=None, model_params=None, format="flac"):
+        if ins_root is None and vocal_root is None:
+            return "No save root."
+        if os.path.isfile(music_file):
+            music_files = [music_file]
+        elif os.path.isdir(music_file):
+            music_files = [os.path.join(music_file, f) for f in os.listdir(music_file) if f.endswith(".wav") or f.endswith(".mp3")]
+        else:
+            return "Invalid path."
+        for music_file in music_files:
+            name = os.path.basename(music_file)
+            if ins_root is not None:
+                os.makedirs(ins_root, exist_ok=True)
+            if vocal_root is not None:
+                os.makedirs(vocal_root, exist_ok=True)
+            X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
+            bands_n = len(self.mp.param["band"])
+            
+            for d in range(bands_n, 0, -1):
+                bp = self.mp.param["band"][d]
+                if d == bands_n:  # high-end band
+                    (
+                        X_wave[d],
+                        _,
+                    ) = librosa.core.load(
+                        music_file,
+                        bp["sr"],
+                        False,
+                        dtype=np.float32,
+                        res_type=bp["res_type"],
+                    )
+                    if X_wave[d].ndim == 1:
+                        X_wave[d] = np.asfortranarray([X_wave[d], X_wave[d]])
+                else:  # lower bands
+                    X_wave[d] = librosa.core.resample(
+                        X_wave[d + 1],
+                        self.mp.param["band"][d + 1]["sr"],
+                        bp["sr"],
+                        res_type=bp["res_type"],
+                    )
+                # Stft of wave source
+                X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(
+                    X_wave[d],
+                    bp["hl"],
+                    bp["n_fft"],
+                    self.mp.param["mid_side"],
+                    self.mp.param["mid_side_b2"],
+                    self.mp.param["reverse"],
+                )
+                if d == bands_n and self.data["high_end_process"] != "none":
+                    input_high_end_h = (bp["n_fft"] // 2 - bp["crop_stop"]) + (
+                        self.mp.param["pre_filter_stop"] - self.mp.param["pre_filter_start"]
+                    )
+                    input_high_end = X_spec_s[d][
+                        :, bp["n_fft"] // 2 - input_high_end_h : bp["n_fft"] // 2, :
+                    ]
+
+            X_spec_m = spec_utils.combine_spectrograms(X_spec_s, self.mp)
+            aggresive_set = float(self.data["agg"] / 100)
+            aggressiveness = {
+                "value": aggresive_set,
+                "split_bin": self.mp.param["band"][1]["crop_stop"],
+            }
+            with torch.no_grad():
+                pred, X_mag, X_phase = inference(
+                    X_spec_m, self.device, self.model, aggressiveness, self.data
+                )
+
+            # Postprocess
+            if self.data["postprocess"]:
+                pred_inv = np.clip(X_mag - pred, 0, np.inf)
+                pred = spec_utils.mask_silence(pred, pred_inv)
+            y_spec_m = pred * X_phase
+            v_spec_m = X_spec_m - y_spec_m
+
+            if ins_root is not None:
+                if self.data["high_end_process"].startswith("mirroring"):
+                    input_high_end_ = spec_utils.mirroring(
+                        self.data["high_end_process"], y_spec_m, input_high_end, self.mp
+                    )
+                    wav_instrument = spec_utils.cmb_spectrogram_to_wave(
+                        y_spec_m, self.mp, input_high_end_h, input_high_end_
+                    )
+                else:
+                    wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp)
+                print("%s instruments done" % name)
+                if model_params == "4band_v2":
+                    sf.write(
+                        os.path.join(
+                            ins_root, "instrument_{}_{}.{}".format(name, self.data["agg"],format)
+                        ),
+                        (np.array(wav_instrument) * 32768).astype("int16"), self.mp.param["sr"],
+                    )  #
+                if model_params == "4band_v3":
+                    sf.write(
+                        os.path.join(
+                            ins_root, "人声_{}".format(name, self.data["agg"], format)
+                        ),
+                        (np.array(wav_instrument) * 32768).astype("int16"), self.mp.param["sr"],
+                    )  #
+
+            if vocal_root is not None:
+                if self.data["high_end_process"].startswith("mirroring"):
+                    input_high_end_ = spec_utils.mirroring(
+                        self.data["high_end_process"], v_spec_m, input_high_end, self.mp
+                    )
+                    wav_vocals = spec_utils.cmb_spectrogram_to_wave(
+                        v_spec_m, self.mp, input_high_end_h, input_high_end_
+                    )
+                else:
+                    wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp)
+                print("%s vocals done" % name)
+                if model_params == "4band_v2":
+                    sf.write(
+                        os.path.join(
+                            vocal_root, "vocal_{}_{}.{}".format(name, self.data["agg"], format)
+                        ),
+                        (np.array(wav_vocals) * 32768).astype("int16"), self.mp.param["sr"],
+                    )
+                if model_params == "4band_v3":
+                    sf.write(
+                        os.path.join(
+                            vocal_root, "混响_{}".format(name, self.data["agg"], format)
+                        ),
+                        (np.array(wav_vocals) * 32768).astype("int16"), self.mp.param["sr"],
+                    )
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Process audio with specified parameters.")
+    parser.add_argument("-device", choices=["cpu", "cuda"], default="cpu", help="Device for processing")
+    parser.add_argument("-is_half", type=bool, required=True, help="Use half precision")
+    parser.add_argument("-model_path", required=True, help="Path to the model weights")
+    parser.add_argument("-agg", type=int, default=10, help="Aggregation parameter")
+    parser.add_argument("-audio_path", required=True, help="Path to the audio file or folder")
+    parser.add_argument("-save_path", required=True, help="Path to save the output")
+    parser.add_argument("-model_params", choices=["4band_v3", "4band_v2"], required=True, help="Path to save the output")
+    parser.add_argument("-format", choices=["wav", "flac"], default="wav",)
+    args = parser.parse_args()
+    separator = AudioSeparator(
+        model_path=args.model_path,
+        device=args.device,
+        is_half=args.is_half,
+        agg=args.agg,
+        model_params=args.model_params
+    )
+    separator.separate(
+        args.audio_path,
+        args.save_path,
+        args.save_path,
+        args.model_params,
+        args.format
+    )

infer.py

@@ -0,0 +1,214 @@
+import soundfile as sf
+import torch 
+import os 
+import librosa
+import numpy as np
+import onnxruntime as ort
+from pathlib import Path
+from argparse import ArgumentParser
+from tqdm import tqdm
+
+
+class ConvTDFNet:
+    def __init__(self, target_name, L, dim_f, dim_t, n_fft, hop=1024):
+        super(ConvTDFNet, self).__init__()
+        self.dim_c = 4
+        self.dim_f = dim_f
+        self.dim_t = 2**dim_t
+        self.n_fft = n_fft
+        self.hop = hop
+        self.n_bins = self.n_fft // 2 + 1
+        self.chunk_size = hop * (self.dim_t - 1)
+        self.window = torch.hann_window(window_length=self.n_fft, periodic=True)
+        self.target_name = target_name
+        
+        out_c = self.dim_c * 4 if target_name == "*" else self.dim_c
+        
+        self.freq_pad = torch.zeros([1, out_c, self.n_bins - self.dim_f, self.dim_t])
+        self.n = L // 2
+
+    def stft(self, x):
+        x = x.reshape([-1, self.chunk_size])
+        x = torch.stft(
+            x,
+            n_fft=self.n_fft,
+            hop_length=self.hop,
+            window=self.window,
+            center=True,
+            return_complex=True,
+        )
+        x = torch.view_as_real(x)
+        x = x.permute([0, 3, 1, 2])
+        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape(
+            [-1, self.dim_c, self.n_bins, self.dim_t]
+        )
+        return x[:, :, : self.dim_f]
+
+    # Inversed Short-time Fourier transform (STFT).
+    def istft(self, x, freq_pad=None):
+        freq_pad = (
+            self.freq_pad.repeat([x.shape[0], 1, 1, 1])
+            if freq_pad is None
+            else freq_pad
+        )
+        x = torch.cat([x, freq_pad], -2)
+        c = 4 * 2 if self.target_name == "*" else 2
+        x = x.reshape([-1, c, 2, self.n_bins, self.dim_t]).reshape(
+            [-1, 2, self.n_bins, self.dim_t]
+        )
+        x = x.permute([0, 2, 3, 1])
+        x = x.contiguous()
+        x = torch.view_as_complex(x)
+        x = torch.istft(
+            x, n_fft=self.n_fft, hop_length=self.hop, window=self.window, center=True
+        )
+        return x.reshape([-1, c, self.chunk_size])
+
+class Predictor:
+    def __init__(self, args):
+        self.args = args
+        self.model_ = ConvTDFNet(
+            target_name="vocals",
+            L=11,
+            dim_f=args["dim_f"], 
+            dim_t=args["dim_t"], 
+            n_fft=args["n_fft"]
+        )
+        
+        if torch.cuda.is_available():
+            self.model = ort.InferenceSession(args['model_path'], providers=['CUDAExecutionProvider'])
+        else:
+            self.model = ort.InferenceSession(args['model_path'], providers=['CPUExecutionProvider'])
+
+    def demix(self, mix):
+        samples = mix.shape[-1]
+        margin = self.args["margin"]
+        chunk_size = self.args["chunks"] * 44100
+        
+        assert not margin == 0, "margin cannot be zero!"
+        
+        if margin > chunk_size:
+            margin = chunk_size
+
+        segmented_mix = {}
+
+        if self.args["chunks"] == 0 or samples < chunk_size:
+            chunk_size = samples
+
+        counter = -1
+        for skip in range(0, samples, chunk_size):
+            counter += 1
+            s_margin = 0 if counter == 0 else margin
+            end = min(skip + chunk_size + margin, samples)
+            start = skip - s_margin
+            segmented_mix[skip] = mix[:, start:end].copy()
+            if end == samples:
+                break
+
+        sources = self.demix_base(segmented_mix, margin_size=margin)
+        return sources
+
+    def demix_base(self, mixes, margin_size):
+        chunked_sources = []
+        progress_bar = tqdm(total=len(mixes))
+        progress_bar.set_description("Processing")
+        
+        for mix in mixes:
+            cmix = mixes[mix]
+            sources = []
+            n_sample = cmix.shape[1]
+            model = self.model_
+            trim = model.n_fft // 2
+            gen_size = model.chunk_size - 2 * trim
+            pad = gen_size - n_sample % gen_size
+            mix_p = np.concatenate(
+                (np.zeros((2, trim)), cmix, np.zeros((2, pad)), np.zeros((2, trim))), 1
+            )
+            mix_waves = []
+            i = 0
+            while i < n_sample + pad:
+                waves = np.array(mix_p[:, i : i + model.chunk_size])
+                mix_waves.append(waves)
+                i += gen_size
+            
+            mix_waves = torch.tensor(np.array(mix_waves), dtype=torch.float32)
+            
+            with torch.no_grad():
+                _ort = self.model
+                spek = model.stft(mix_waves)
+                if self.args["denoise"]:
+                    spec_pred = (
+                        -_ort.run(None, {"input": -spek.cpu().numpy()})[0] * 0.5
+                        + _ort.run(None, {"input": spek.cpu().numpy()})[0] * 0.5
+                    )
+                    tar_waves = model.istft(torch.tensor(spec_pred))
+                else:
+                    tar_waves = model.istft(
+                        torch.tensor(_ort.run(None, {"input": spek.cpu().numpy() })[0])
+                    )
+                tar_signal = (
+                    tar_waves[:, :, trim:-trim]
+                    .transpose(0, 1)
+                    .reshape(2, -1)
+                    .numpy()[:, :-pad]
+                )
+
+                start = 0 if mix == 0 else margin_size
+                end = None if mix == list(mixes.keys())[::-1][0] else -margin_size
+                
+                if margin_size == 0:
+                    end = None
+                
+                sources.append(tar_signal[:, start:end])
+
+                progress_bar.update(1)
+
+            chunked_sources.append(sources)
+        _sources = np.concatenate(chunked_sources, axis=-1)
+        
+        progress_bar.close()
+        return _sources
+
+    def predict(self, file_path):
+      
+        mix, rate = librosa.load(file_path, mono=False, sr=44100)
+        
+        if mix.ndim == 1:
+            mix = np.asfortranarray([mix, mix])
+        
+        mix = mix.T
+        sources = self.demix(mix.T)
+        opt = sources[0].T
+        
+        return (mix - opt, opt, rate)
+
+def main():
+    parser = ArgumentParser()
+    
+    parser.add_argument("files", nargs="+", type=Path, default=[], help="Source audio path")
+    parser.add_argument("-o", "--output", type=Path, default=Path("separated"), help="Output folder")
+    parser.add_argument("-m", "--model_path", type=Path, help="MDX Net ONNX Model path")
+    
+    parser.add_argument("-d", "--no-denoise", dest="denoise", action="store_false", default=True, help="Disable denoising")
+    parser.add_argument("-M", "--margin", type=int, default=44100, help="Margin")
+    parser.add_argument("-c", "--chunks", type=int, default=15, help="Chunk size")
+    parser.add_argument("-F", "--n_fft", type=int, default=6144)
+    parser.add_argument("-t", "--dim_t", type=int, default=8)
+    parser.add_argument("-f", "--dim_f", type=int, default=2048)
+    
+    args = parser.parse_args()
+    dict_args = vars(args)
+    
+    os.makedirs(args.output, exist_ok=True)
+    
+    for file_path in args.files:  
+      predictor = Predictor(args=dict_args)
+      vocals, no_vocals, sampling_rate = predictor.predict(file_path)
+      filename = os.path.splitext(os.path.split(file_path)[-1])[0]
+      sf.write(os.path.join(args.output, filename+".wav"), no_vocals, sampling_rate)
+      sf.write(os.path.join(args.output, filename+"_instrum.wav"), vocals, sampling_rate)
+  
+if __name__ == "__main__":
+    main()
+  
+   

requirements.txt

@@ -0,0 +1,20 @@
+joblib>=1.1.0
+numba==0.56.4
+numpy==1.23.5
+scipy==1.9.3
+librosa>=0.9.1
+llvmlite==0.39.0
+pydub>=0.25.1
+soundfile>=0.12.1
+praat-parselmouth>=0.4.2
+Pillow==9.5.0
+resampy>=0.4.2
+scikit-learn
+starlette>=0.25.0
+tqdm>=4.63.1
+audioread==3.0.0
+soundstretch==1.2
+demucs
+pyyaml
+ml_collections
+rotary_embedding_torch

uvr.py

@@ -0,0 +1,132 @@
+import os
+import sys
+import torch
+import warnings
+import hashlib
+import math
+import importlib
+import numpy as np
+from tqdm import tqdm
+from scipy.io import wavfile
+import librosa
+import pdb
+from uvr5_pack.lib_v5 import spec_utils
+from uvr5_pack.utils import _get_name_params, inference
+from uvr5_pack.lib_v5.model_param_init import ModelParameters
+
+
+warnings.filterwarnings("ignore")
+
+
+class _audio_pre_():
+    def __init__(self, model_path, device, is_half):
+        self.model_path = model_path
+        self.device = device
+        self.data = {
+            # Processing Options
+            'postprocess': False,
+            'tta': False,
+            # Constants
+            'window_size': 320,
+            'agg': 10,
+            'high_end_process': 'mirroring',
+        }
+        nn_arch_sizes = [
+            31191, # default
+            33966,61968, 123821, 123812, 537238 # custom
+        ]
+        self.nn_architecture = list('{}KB'.format(s) for s in nn_arch_sizes)
+        model_size = math.ceil(os.stat(model_path).st_size / 1024)
+        nn_architecture = '{}KB'.format(min(nn_arch_sizes, key=lambda x:abs(x-model_size)))
+        nets = importlib.import_module('uvr5_pack.lib_v5.nets' + f'_{nn_architecture}'.replace('_{}KB'.format(nn_arch_sizes[0]), ''), package=None)
+        model_hash = hashlib.md5(open(model_path, 'rb').read()).hexdigest()
+        param_name, model_params_d = _get_name_params(model_path, model_hash)
+
+        mp = ModelParameters(model_params_d)
+        model = nets.CascadedASPPNet(mp.param['bins'] * 2)
+        cpk = torch.load(model_path, map_location='cpu')
+        model.load_state_dict(cpk)
+        model.eval()
+        if is_half:
+            model = model.half().to(device)
+        else:
+            model = model.to(device)
+
+        self.mp = mp
+        self.model = model
+
+    def _path_audio_(self, music_file, ins_root=None, vocal_root=None):
+        if ins_root is None and vocal_root is None:
+            return "No save root."
+        name = os.path.basename(music_file)
+        if ins_root is not None:
+            os.makedirs(ins_root, exist_ok=True)
+        if vocal_root is not None:
+            os.makedirs(vocal_root, exist_ok=True)
+        X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
+        bands_n = len(self.mp.param['band'])
+        for d in range(bands_n, 0, -1):
+            bp = self.mp.param['band'][d]
+            if d == bands_n:
+                X_wave[d], _ = librosa.core.load(
+                    music_file, bp['sr'], False, dtype=np.float32, res_type=bp['res_type'])
+                if X_wave[d].ndim == 1:
+                    X_wave[d] = np.asfortranarray([X_wave[d], X_wave[d]])
+            else:
+                X_wave[d] = librosa.core.resample(X_wave[d+1], self.mp.param['band'][d+1]['sr'], bp['sr'], res_type=bp['res_type'])
+
+            X_spec_s[d] = spec_utils.wave_to_spectrogram_mt(X_wave[d], bp['hl'], bp['n_fft'], self.mp.param['mid_side'], self.mp.param['mid_side_b2'], self.mp.param['reverse'])
+            if d == bands_n and self.data['high_end_process'] != 'none':
+                input_high_end_h = (bp['n_fft'] // 2 - bp['crop_stop']) + (self.mp.param['pre_filter_stop'] - self.mp.param['pre_filter_start'])
+                input_high_end = X_spec_s[d][:, bp['n_fft']//2-input_high_end_h:bp['n_fft']//2, :]
+
+        X_spec_m = spec_utils.combine_spectrograms(X_spec_s, self.mp)
+        aggresive_set = float(self.data['agg']/100)
+        aggressiveness = {'value': aggresive_set, 'split_bin': self.mp.param['band'][1]['crop_stop']}
+        with torch.no_grad():
+            pred, X_mag, X_phase = inference(X_spec_m, self.device, self.model, aggressiveness, self.data)
+
+        if self.data['postprocess']:
+            pred_inv = np.clip(X_mag - pred, 0, np.inf)
+            pred = spec_utils.mask_silence(pred, pred_inv)
+
+        y_spec_m = pred * X_phase
+        v_spec_m = X_spec_m - y_spec_m
+
+        if ins_root is not None:
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], y_spec_m, input_high_end, self.mp)
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp, input_high_end_h, input_high_end_)
+            else:
+                wav_instrument = spec_utils.cmb_spectrogram_to_wave(y_spec_m, self.mp)
+            print('%s instruments done' % name)
+            # 分离文件名和扩展名
+            file_name, ext = os.path.splitext(name)
+            wavfile.write(os.path.join(ins_root, '和声_{}{}'.format(file_name, ext)), self.mp.param['sr'], (np.array(wav_instrument)*32768).astype(np.int16))
+        if vocal_root is not None:
+            if self.data['high_end_process'].startswith('mirroring'):
+                input_high_end_ = spec_utils.mirroring(self.data['high_end_process'], v_spec_m, input_high_end, self.mp)
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp, input_high_end_h, input_high_end_)
+            else:
+                wav_vocals = spec_utils.cmb_spectrogram_to_wave(v_spec_m, self.mp)
+            print('%s vocals done' % name)
+            # 分离文件名和扩展名
+            file_name, ext = os.path.splitext(name)
+            wavfile.write(os.path.join(vocal_root, '{}{}'.format(file_name, ext)), self.mp.param['sr'], (np.array(wav_vocals)*32768).astype(np.int16))
+
+
+
+if __name__ == '__main__':
+    device = 'cuda'
+    is_half = True
+    model_path = 'uvr5_weights/5_HP-Karaoke-UVR.pth'
+    pre_fun = _audio_pre_(model_path=model_path, device=device, is_half=True)
+
+    # 获取混响文件夹内的所有.wav文件路径
+    audio_folder = 'output'
+    wav_files = [os.path.join(audio_folder, file) for file in os.listdir(audio_folder) if file.endswith('.wav')]
+
+    # 遍历每个音频文件进行处理
+    save_path = 'echo'
+    for wav_file in wav_files:
+        pre_fun._path_audio_(wav_file, save_path, save_path)

仅去和声混响.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+# Change directory
+cd /mnt/workspace/uvr5
+
+# Run 5_HP-Karaoke-UVR.py
+python 5_HP-Karaoke-UVR.py
+
+# Convert mp3 files to wav
+source_folder="/mnt/workspace/uvr5/echo"
+for mp3_file in $(ls $source_folder/*.mp3)
+do
+    wav_file="${mp3_file%.mp3}.wav"
+    mv $mp3_file $wav_file
+done
+
+# Move and convert files
+target_folder="/mnt/workspace/uvr5/伴奏"
+for file_name in $(ls $source_folder)
+do
+    if [[ $file_name == *"和声_"* && $file_name == *.wav ]]
+    then
+        file_path="$source_folder/$file_name"
+        target_path="$target_folder/$file_name"
+        mv $file_path $target_path
+        mp3_file_path="${target_path%.wav}.mp3"
+        ffmpeg -i $target_path -vn -ar 44100 -ac 2 -b:a 192k -loglevel panic $mp3_file_path
+        rm $target_path
+    fi
+done
+
+# Run deecho.py
+python deecho.py -d cuda -model_path /mnt/workspace/uvr5/uvr5_weights/VR-DeEchoAggressive.pth -audio_path /mnt/workspace/uvr5/echo/ -is_half False -save_path /mnt/workspace/uvr5/人声/ -model_params 4band_v3
+
+# Convert files to mp3 and remove wav files
+input_folder='/mnt/workspace/uvr5/人声/'
+output_folder='/mnt/workspace/uvr5/人声/'
+for file in $(ls $input_folder)
+do
+    if [[ $file == *"人声_"* && $file == *.wav ]]
+    then
+        input_path="$input_folder/$file"
+        output_file="${file%.wav}.mp3"
+        output_path="$output_folder/$output_file"
+        ffmpeg -i $input_path -vn -ar 44100 -ac 2 -b:a 192k -loglevel panic $output_path
+    fi
+done
+
+# Remove wav files
+for file in $(ls $input_folder)
+do
+    if [[ $file == *.wav ]]
+    then
+        file_path="$input_folder/$file"
+        rm $file_path
+    fi
+done
+echo -e "\033[32m> 已将所有input文件夹内的音频去除和声及混响，人声在 /mnt/workspace/uvr5/人声/ 文件夹内，非人声在 /mnt/workspace/uvr5/伴奏/ 文件夹内。 \033[0m"

全流程一键版.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+# Change directory
+cd /mnt/workspace/uvr5/MDX23v24
+
+# 设置 HF_ENDPOINT 环境变量
+export HF_ENDPOINT="https://hf-mirror.com"
+
+input_folder="/mnt/workspace/input/"
+output_folder="/mnt/workspace/input"
+
+for file_path in $(ls -1 $input_folder); do
+    filename=$(basename "$file_path" | cut -d. -f1)
+    # 调用 inference.py，并传入环境变量 HF_ENDPOINT
+    python inference.py --vocals_only --large_gpu --use_InstVoc --use_VitLarge --use_BSRoformer --input_audio "$input_folder/$file_path" --output_folder "$output_folder"
+done
+
+# Move and convert files
+source_folder="/mnt/workspace/uvr5/output"
+target_folder="/mnt/workspace/uvr5/伴奏"
+for file_name in $(ls $source_folder)
+do
+    if [[ $file_name == *"_instrum.wav" ]]
+    then
+        file_path="$source_folder/$file_name"
+        target_path="$target_folder/$file_name"
+        mv $file_path $target_path
+        mp3_file_path="${target_path%.wav}.mp3"
+        ffmpeg -i $target_path -vn -ar 44100 -ac 2 -b:a 320k -loglevel panic $mp3_file_path
+        rm $target_path
+    fi
+done
+
+# Change directory
+cd /mnt/workspace/uvr5
+
+# Run uvr.py
+python uvr.py
+
+# Move and convert files
+source_folder="/mnt/workspace/uvr5/echo"
+target_folder="/mnt/workspace/uvr5/伴奏"
+for file_name in $(ls $source_folder)
+do
+    if [[ $file_name == *"和声_"* && $file_name == *.wav ]]
+    then
+        file_path="$source_folder/$file_name"
+        target_path="$target_folder/$file_name"
+        mv $file_path $target_path
+        mp3_file_path="${target_path%.wav}.mp3"
+        ffmpeg -i $target_path -vn -ar 44100 -ac 2 -b:a 320k -loglevel panic $mp3_file_path
+        rm $target_path
+    fi
+done
+
+# Run deecho.py
+python deecho.py -d cuda -model_path /mnt/workspace/uvr5/uvr5_weights/VR-DeEchoAggressive.pth -audio_path /mnt/workspace/uvr5/echo/ -is_half False -save_path /mnt/workspace/uvr5/人声/ -model_params 4band_v3
+
+# Convert files to mp3 and remove wav files
+input_folder='/mnt/workspace/uvr5/人声/'
+output_folder='/mnt/workspace/uvr5/人声/'
+for file in $(ls $input_folder)
+do
+    if [[ $file == *"人声_"* && $file == *.wav ]]
+    then
+        input_path="$input_folder/$file"
+        output_file="${file%.wav}.mp3"
+        output_path="$output_folder/$output_file"
+        ffmpeg -i $input_path -vn -ar 44100 -ac 2 -b:a 320k -loglevel panic $output_path
+    fi
+done
+
+# Remove wav files
+for file in $(ls $input_folder)
+do
+    if [[ $file == *.wav ]]
+    then
+        file_path="$input_folder/$file"
+        rm $file_path
+    fi
+done
+echo -e "\033[32m> 已将所有input文件夹内的音频完成分离，人声在 /mnt/workspace/uvr5/人声/ 文件夹内，伴奏及和声在 /mnt/workspace/uvr5/伴奏/ 文件夹内。 \033[0m"