"""https://github.com/facebookresearch/audiocraft/blob/main/audiocraft/models/multibanddiffusion.py""" import logging from typing import List, Optional, Tuple from math import ceil import torch import julius from tqdm import tqdm from audiocraft.modules.diffusion_schedule import NoiseSchedule from audiocraft.models.unet import DiffusionUnet from audiocraft.models.encodec import CompressionModel from audiocraft.models.loaders import load_diffusion_models from audiocraft.solvers.compression import CompressionSolver from df.enhance import enhance, init_df, load_audio, save_audio # deepfilternet class DFEnhancer: """Speech enhancer.""" def __init__(self): self.model, self.df_state, _ = init_df() self.sample_rate = self.df_state.sr() def enhance_audio(self, audio: torch.Tensor, sample_rate: int) -> torch.Tensor: if sample_rate != self.sample_rate: audio = julius.resample_frac(audio, sample_rate, self.sample_rate) enhanced_audio = [] for single_audio in audio: enhanced_audio.append(enhance(self.model, self.df_state, single_audio)) return torch.stack(enhanced_audio) class DiffusionProcess: """Sampling for a diffusion Model. Args: model (DiffusionUnet): Diffusion U-Net model. noise_schedule (NoiseSchedule): Noise schedule for diffusion process. """ def __init__(self, model: DiffusionUnet, noise_schedule: NoiseSchedule) -> None: self.model = model self.schedule = noise_schedule def generate(self, condition: torch.Tensor, initial_noise: torch.Tensor, step_size: int = 5) -> torch.Tensor: """Perform one diffusion process to generate one of the bands. Args: condition (torch.Tensor): The embeddings from the compression model. initial_noise (torch.Tensor): The initial noise to start the process. step_size (int): The number of the linearly spaced Markov chain steps. """ step_list = list(range(1000))[::-int(1000/step_size)] + [0] return self.schedule.generate_subsampled( model=self.model, initial=initial_noise, step_list=step_list, condition=condition ) class BaseMultiBandDiffusion: def __init__(self, diffusion_processes: List[DiffusionProcess], codec_model: CompressionModel, sample_per_token: int = 320, num_codebooks_decoder: int = 3, num_codebooks_encoder: Optional[int] = None) -> None: """Base class for multi-band diffusion. Args: diffusion_processes (list of DiffusionProcess): Diffusion processes. codec_model (CompressionModel): Underlying compression model used to obtain discrete tokens. sample_per_token (int): Number of sample per token (320 for 24kHz encodec). num_codebooks_decoder (int): Number of codebook to use for decoder. num_codebooks_encoder (int): Number of codebook to use for encoder (default full code). """ self.diffusion_processes = diffusion_processes self.codec_model = codec_model self.device = next(self.codec_model.parameters()).device self.sample_per_token = sample_per_token self.num_codebooks_decoder = num_codebooks_decoder self.num_codebooks_encoder = num_codebooks_encoder self.enhancer = DFEnhancer() @property def sample_rate(self) -> int: return self.codec_model.sample_rate def generate(self, emb: torch.Tensor, size: torch.Size, step_size: int = 5) -> torch.Tensor: """Generate waveform audio from the latent embeddings of the compression model. Args: emb (torch.Tensor): Conditioning embeddings size (None, torch.Size): Size of the output. step_size (int): The number of the linearly spaced Markov chain steps. """ assert size[0] == emb.size(0) out = torch.zeros(size).to(self.device) for diffusion_process in self.diffusion_processes: out += diffusion_process.generate(condition=emb, step_size=step_size, initial_noise=torch.randn_like(out)) return out def re_eq(self, wav: torch.Tensor, ref: torch.Tensor, n_bands: int = 32, strictness: float = 1) -> torch.Tensor: """Match the eq to the encodec output by matching the standard deviation of some frequency bands. Args: wav (torch.Tensor): Audio to equalize. ref (torch.Tensor): Reference audio from which we match the spectrogram. n_bands (int): Number of bands of the eq. strictness (float): How strict the matching. 0 is no matching, 1 is exact matching. """ split = julius.SplitBands(n_bands=n_bands, sample_rate=self.codec_model.sample_rate).to(wav.device) bands = split(wav) bands_ref = split(ref) out = torch.zeros_like(ref) for i in range(n_bands): out += bands[i] * (bands_ref[i].std() / bands[i].std()) ** strictness return out @torch.no_grad() def wav_to_tokens(self, wav: torch.Tensor, sample_rate: int, cpu_offload: bool = True, chunk_length: Optional[int] = None, stride: Optional[int] = None, concat_strategy: str = "first") -> torch.Tensor: """Get audio tokens from waveform in batch. Note that Encodec generates 75 tokens per second of audio at 24 kHz meaning 320 samples (13.333 msec) per tokens. Args: wav (torch.Tensor): The audio that we want to extract the conditioning from (batch, channel, wav). sample_rate (int): Sample rate of the audio. cpu_offload (bool): Move the output tokens to cpu on the fly to save cuda memory. chunk_length (int): Chunk length to split a long audio (sample size, must be divisible by sample_per_token). stride (int): Stride over chunked audio (sample size, must be divisible by sample_per_token). concat_strategy (str): "first" or "last" to indicate which chunk to use when consolidating the overlap. """ # sanity check if wav.ndim != 3: raise ValueError(f"wav should be (batch, channel, time): {wav.ndim} dims") original_device = wav.device # sampling audio if sample_rate != self.sample_rate: wav = julius.resample_frac(wav, sample_rate, self.sample_rate) batch_size, channels, input_length = wav.shape if channels > 1: logging.warning("Audio has more than one channel but encoder takes the first channel only.") # validate chunk length and stride (if None, do one-shot process) if chunk_length: if chunk_length % self.sample_per_token != 0: raise ValueError(f"chunk_length must be divisible by {self.sample_per_token}: {chunk_length}") else: chunk_length = input_length chunk_length_latent = ceil(chunk_length / self.sample_per_token) if stride: if stride % self.sample_per_token != 0: raise ValueError(f"stride must be divisible by {self.sample_per_token}: {stride}") else: stride = chunk_length stride_latent = ceil(stride / self.sample_per_token) # initialize the token tensor num_tokens = ceil(input_length / self.sample_per_token) num_filters = self.codec_model.model.config.num_filters if self.num_codebooks_encoder is not None: if self.num_codebooks_encoder > num_filters: raise ValueError(f"num_codebooks_encoder must be smaller than {num_filters}") num_filters = self.num_codebooks_encoder tokens = torch.zeros( (batch_size, num_filters, num_tokens), device="cpu" if cpu_offload else original_device, dtype=torch.int64 ) # tokenize by chunk in a sequential manner for offset in tqdm(list(range(0, input_length - chunk_length + stride, stride))): frame = wav[:, :1, offset: offset + chunk_length] tmp_tokens, _ = self.codec_model.encode(frame.to(self.device)) offset_latent = int(offset / self.sample_per_token) tmp_tokens = tmp_tokens.to("cpu") if cpu_offload else tmp_tokens.to(original_device) if concat_strategy == "last" or offset == 0: tokens[:, :, offset_latent: offset_latent + chunk_length_latent] = tmp_tokens[:, :num_filters, :] else: overlap_token = chunk_length_latent - stride_latent tokens[:, :, offset_latent + overlap_token: offset_latent + chunk_length_latent] \ = tmp_tokens[:, :num_filters, overlap_token:] return tokens @torch.no_grad() def tokens_to_wav(self, tokens: torch.Tensor, n_bands: int = 32, step_size: int = 5, cpu_offload: bool = True, chunk_length: Optional[int] = None, stride: Optional[int] = None, concat_strategy: str = "crossfade", skip_enhancer: bool = False) -> Tuple[torch.Tensor, float]: """Generate waveform audio with diffusion from the discrete codes in batch. Args: tokens (torch.Tensor): Discrete codes (batch, num_code, length). n_bands (int): Bands for the eq matching. step_size (int): Number of the linearly spaced Markov chain steps. chunk_length (int): Chunk length to split a long audio. stride (int): Stride over chunked audio. cpu_offload (bool): Move the output tokens to cpu on the fly to save cuda memory. concat_strategy (str): "first" or "last" to indicate which chunk to use when consolidating the overlap. skip_enhancer (bool): Skip applying the enhancer. """ batch_size, num_filters, input_length = tokens.shape if num_filters < self.num_codebooks_decoder: raise ValueError(f"num_codebooks_decoder must be smaller than num_filters: {num_filters}") original_device = tokens.device # validate chunk length and stride (if None, do one-shot process) chunk_length = chunk_length if chunk_length else input_length chunk_length_wav = self.sample_per_token * chunk_length stride = stride if stride else chunk_length stride_wav = stride * self.sample_per_token # initialize wav tensor wav = torch.zeros( (batch_size, 1, input_length * self.sample_per_token), device="cpu" if cpu_offload else original_device, dtype=torch.float32 ) # detokenize by chunk in a sequential manner for offset in tqdm(list(range(0, input_length - chunk_length + stride, stride))): tmp_tokens = tokens[:, :num_filters, offset: offset + chunk_length].to(self.device) wav_encodec = self.codec_model.decode(tmp_tokens) condition = self.codec_model.decode_latent(tmp_tokens) wav_diffusion = self.generate(emb=condition, size=wav_encodec.size(), step_size=step_size) tmp_wav = self.re_eq(wav=wav_diffusion, ref=wav_encodec, n_bands=n_bands) tmp_wav = tmp_wav.to("cpu") if cpu_offload else wav.to(original_device) offset_wav = offset * self.sample_per_token overlap_wav = chunk_length_wav - stride_wav if concat_strategy == "last" or offset == 0: wav[:, :, offset_wav: offset_wav + chunk_length_wav] = tmp_wav elif concat_strategy == "crossfade": fade_out = torch.linspace(1, 0, overlap_wav).unsqueeze(0).to(wav.device) fade_in = torch.linspace(0, 1, overlap_wav).unsqueeze(0).to(wav.device) tmp_wav[:, :, :overlap_wav] = (tmp_wav[:, :, :overlap_wav] * fade_in + wav[:, :, offset_wav: offset_wav + overlap_wav] * fade_out) wav[:, :, offset_wav: offset_wav + chunk_length_wav] = tmp_wav else: wav[:, :, offset_wav + overlap_wav: offset_wav + chunk_length_wav] = tmp_wav[:, :, overlap_wav:] if skip_enhancer: return wav, self.sample_rate return self.enhancer.enhance_audio(wav, self.sample_rate), self.enhancer.sample_rate class MultiBandDiffusion: @staticmethod def from_pretrained(num_codebooks_decoder: int = 3, num_codebooks_encoder: Optional[int] = None, mbd_model_alias: str = "mbd_comp_8.pt", mbd_model_repo: str = "facebook/multiband-diffusion") -> BaseMultiBandDiffusion: """Get the pretrained Models for MultiBandDiffusion. Args: num_codebooks_decoder (int): Number of codebook to use for decoder. num_codebooks_encoder (int): Number of codebook to use for encoder (default full code). mbd_model_alias (str): Name of the MBD model weight. see here https://huggingface.co/facebook/multiband-diffusion/tree/main mbd_model_repo (str): Name of the MBD model repository. """ device = 'cuda' if torch.cuda.is_available() else 'cpu' codec_model = CompressionSolver.model_from_checkpoint( '//pretrained/facebook/encodec_24khz', device=device ) codec_model = codec_model.to(device) models, processors, cfgs = load_diffusion_models(mbd_model_repo, filename=mbd_model_alias, device=device) diffusion_processes = [] for i in range(len(models)): schedule = NoiseSchedule(**cfgs[i].schedule, sample_processor=processors[i], device=device) diffusion_processes.append(DiffusionProcess(model=models[i], noise_schedule=schedule)) return BaseMultiBandDiffusion( diffusion_processes=diffusion_processes, codec_model=codec_model, num_codebooks_decoder=num_codebooks_decoder, num_codebooks_encoder=num_codebooks_encoder )