Merge 7604f36bb270d0a897df0b8d4dd9d35f860d06cb into 6375bbe3163a425bbe363d1b4c3538a6ab6422d1

GPT_SoVITS/module/core_vq.py

@@ -37,10 +37,6 @@ from einops import rearrange, repeat
 import torch
 from torch import nn
 import torch.nn.functional as F
-import torch.distributed as dist
-
-from module.distrib import broadcast_tensors, is_distributed
-from module.ddp_utils import SyncFunction
 from tqdm import tqdm
 
 
@@ -73,40 +69,27 @@ def sample_vectors(samples, num: int):
     return samples[indices]
 
 
-def kmeans(samples, num_clusters: int, num_iters: int = 10, frames_to_use: int = 10_000, batch_size: int = 64):
-    N, D = samples.shape
-    dtype, device = samples.dtype, samples.device
-
-    if frames_to_use < N:
-        indices = torch.randperm(N, device=device)[:frames_to_use]
-        samples = samples[indices]
-
+def kmeans(samples, num_clusters: int, num_iters: int = 10):
+    dim, dtype = samples.shape[-1], samples.dtype
+    max_kmeans_samples = 500
+    samples = samples[:max_kmeans_samples, :]
     means = sample_vectors(samples, num_clusters)
 
     print("kmeans start ... ")
     for _ in tqdm(range(num_iters)):
-        # Store cluster assignments
-        all_assignments = []
+        diffs = rearrange(samples, "n d -> n () d") - rearrange(means, "c d -> () c d")
+        dists = -(diffs**2).sum(dim=-1)
 
-        for i in range(0, samples.shape[0], batch_size):
-            batch = samples[i : i + batch_size]  # [B, D]
-            dists = torch.cdist(batch, means, p=2)  # [B, C]
-            assignments = dists.argmin(dim=1)  # [B]
-            all_assignments.append(assignments)
-
-        buckets = torch.cat(all_assignments, dim=0)  # [N]
+        buckets = dists.max(dim=-1).indices
         bins = torch.bincount(buckets, minlength=num_clusters)
         zero_mask = bins == 0
         bins_min_clamped = bins.masked_fill(zero_mask, 1)
 
-        # Compute new means
-        new_means = torch.zeros_like(means)
-        for i in range(num_clusters):
-            mask = buckets == i
-            if mask.any():
-                new_means[i] = samples[mask].mean(dim=0)
+        new_means = buckets.new_zeros(num_clusters, dim, dtype=dtype)
+        new_means.scatter_add_(0, repeat(buckets, "n -> n d", d=dim), samples)
+        new_means = new_means / bins_min_clamped[..., None]
 
-        means = torch.where(zero_mask[:, None], means, new_means)
+        means = torch.where(zero_mask[..., None], means, new_means)
 
     return means, bins
 
@@ -158,24 +141,13 @@ class EuclideanCodebook(nn.Module):
         if self.inited:
             return
 
-        if dist.is_available() and dist.is_initialized():
-            # [B * T * world_size, D]
-            data = SyncFunction.apply(data)
-
-        if dist.get_rank() == 0:
-            embed, cluster_size = kmeans(data, self.codebook_size, self.kmeans_iters)
-        else:
-            embed = torch.empty_like(self.embed)
-            cluster_size = torch.empty_like(self.cluster_size)
-        dist.broadcast(embed, src=0)
-        dist.broadcast(cluster_size, src=0)
-
+        embed, cluster_size = kmeans(data, self.codebook_size, self.kmeans_iters)
         self.embed.data.copy_(embed)
         self.embed_avg.data.copy_(embed.clone())
         self.cluster_size.data.copy_(cluster_size)
         self.inited.data.copy_(torch.Tensor([True]))
         # Make sure all buffers across workers are in sync after initialization
-        broadcast_tensors(self.buffers())
+        # broadcast_tensors(self.buffers())
 
     def replace_(self, samples, mask):
         modified_codebook = torch.where(mask[..., None], sample_vectors(samples, self.codebook_size), self.embed)
@@ -189,17 +161,9 @@ class EuclideanCodebook(nn.Module):
         if not torch.any(expired_codes):
             return
 
-        if is_distributed():
-            # [B * T * world_size, D]
-            batch_samples = SyncFunction.apply(batch_samples)
-
-        if dist.get_rank() == 0:
-            new_embeds = sample_vectors(batch_samples, expired_codes.sum())
-        else:
-            new_embeds = torch.zeros(expired_codes.sum(), self.embed.size(1), device=self.embed.device)
-        dist.broadcast(new_embeds, src=0)
-        self.embed.data[expired_codes] = new_embeds
-        broadcast_tensors(self.buffers())
+        batch_samples = rearrange(batch_samples, "... d -> (...) d")
+        self.replace_(batch_samples, mask=expired_codes)
+        # broadcast_tensors(self.buffers())
 
     def preprocess(self, x):
         x = rearrange(x, "... d -> (...) d")
@@ -244,26 +208,17 @@ class EuclideanCodebook(nn.Module):
         quantize = self.dequantize(embed_ind)
 
         if self.training:
-            ### Update codebook by EMA
-            embed_onehot_sum = embed_onehot.sum(0)  # [cb-size,]
-            embed_sum = x.t() @ embed_onehot  # [D, cb-size]
-            if is_distributed():
-                dist.all_reduce(embed_onehot_sum)
-                dist.all_reduce(embed_sum)
-            # Update ema cluster count N_i^t, eq. (6) in vqvae paper
-            self.cluster_size.data.mul_(self.decay).add_(embed_onehot_sum, alpha=1 - self.decay)
-            # Update ema embed: eq. (7) in vqvae paper
-            self.embed_avg.data.mul_(self.decay).add_(embed_sum.t(), alpha=1 - self.decay)
-            # apply laplace smoothing
-            n = self.cluster_size.sum()
-            cluster_size = (self.cluster_size + self.epsilon) / (n + self.codebook_size * self.epsilon) * n
-            # Update ema embed: eq. (8) in vqvae paper
-            embed_normalized = self.embed_avg / cluster_size.unsqueeze(1)
-            self.embed.data.copy_(embed_normalized)
-
             # We do the expiry of code at that point as buffers are in sync
             # and all the workers will take the same decision.
             self.expire_codes_(x)
+            ema_inplace(self.cluster_size, embed_onehot.sum(0), self.decay)
+            embed_sum = x.t() @ embed_onehot
+            ema_inplace(self.embed_avg, embed_sum.t(), self.decay)
+            cluster_size = (
+                laplace_smoothing(self.cluster_size, self.codebook_size, self.epsilon) * self.cluster_size.sum()
+            )
+            embed_normalized = self.embed_avg / cluster_size.unsqueeze(1)
+            self.embed.data.copy_(embed_normalized)
 
         return quantize, embed_ind
 

GPT_SoVITS/module/ddp_utils.py

@@ -1,181 +0,0 @@
-import torch
-from torch.nn.parallel import DistributedDataParallel
-from torch.nn.parallel.distributed import _find_tensors
-from packaging import version
-
-
-# from https://github.com/Lightning-AI/lightning-bolts/blob/5d61197cd2f491f69e238137a5edabe80ae14ad9/pl_bolts/models/self_supervised/simclr/simclr_module.py#L20
-class SyncFunction(torch.autograd.Function):
-    @staticmethod
-    # @torch.no_grad()
-    def forward(ctx, tensor):
-        world_size = torch.distributed.get_world_size()
-
-        # Collect batch sizes from all processes
-        local_bs = torch.tensor([tensor.shape[0]], device=tensor.device)
-        batch_sizes = [torch.zeros_like(local_bs) for _ in range(world_size)]
-        torch.distributed.all_gather(batch_sizes, local_bs)
-
-        # Convert to integer list and find the minimum
-        batch_sizes_int = [bs.item() for bs in batch_sizes]
-        min_bs = min(batch_sizes_int)
-
-        # Crop the tensor to the minimum batch size if needed
-        cropped_tensor = tensor[:min_bs] if tensor.shape[0] > min_bs else tensor
-
-        # Prepare for gathering
-        out_shape = (min_bs * world_size,) + tensor.shape[1:]
-        gathered_tensor = torch.zeros(out_shape, dtype=tensor.dtype, device=tensor.device)
-
-        # Build tensor list for all_gather
-        tensor_list = list(torch.chunk(gathered_tensor, world_size))
-
-        # Perform all_gather using the cropped tensors
-        torch.distributed.all_gather(tensor_list, cropped_tensor)
-
-        # Save for backward pass
-        ctx.min_bs = min_bs
-        ctx.world_size = world_size
-        ctx.orig_shape = tensor.shape
-
-        return gathered_tensor
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        assert False
-        grad_input = grad_output.clone()
-        torch.distributed.all_reduce(grad_input, op=torch.distributed.ReduceOp.SUM, async_op=False)
-
-        idx_from = torch.distributed.get_rank() * ctx.batch_size
-        idx_to = (torch.distributed.get_rank() + 1) * ctx.batch_size
-        return grad_input[idx_from:idx_to]
-
-class DDP(DistributedDataParallel):
-    """
-    Override the forward call in lightning so it goes to training and validation step respectively
-    """
-
-    def forward(self, *inputs, **kwargs):  # pragma: no cover
-        if version.parse(torch.__version__[:6]) < version.parse("1.11"):
-            self._sync_params()
-            inputs, kwargs = self.scatter(inputs, kwargs, self.device_ids)
-            assert len(self.device_ids) == 1
-            if self.module.training:
-                output = self.module.training_step(*inputs[0], **kwargs[0])
-            elif self.module.testing:
-                output = self.module.test_step(*inputs[0], **kwargs[0])
-            else:
-                output = self.module.validation_step(*inputs[0], **kwargs[0])
-            if torch.is_grad_enabled():
-                # We'll return the output object verbatim since it is a freeform
-                # object. We need to find any tensors in this object, though,
-                # because we need to figure out which parameters were used during
-                # this forward pass, to ensure we short circuit reduction for any
-                # unused parameters. Only if `find_unused_parameters` is set.
-                if self.find_unused_parameters:
-                    self.reducer.prepare_for_backward(list(_find_tensors(output)))
-                else:
-                    self.reducer.prepare_for_backward([])
-        else:
-            from torch.nn.parallel.distributed import (
-                Join,
-                _DDPSink,
-                _tree_flatten_with_rref,
-                _tree_unflatten_with_rref,
-            )
-
-            with torch.autograd.profiler.record_function("DistributedDataParallel.forward"):
-                if torch.is_grad_enabled() and self.require_backward_grad_sync:
-                    self.logger.set_runtime_stats_and_log()
-                    self.num_iterations += 1
-                    self.reducer.prepare_for_forward()
-
-                # Notify the join context that this process has not joined, if
-                # needed
-                work = Join.notify_join_context(self)
-                if work:
-                    self.reducer._set_forward_pass_work_handle(work, self._divide_by_initial_world_size)
-
-                # Calling _rebuild_buckets before forward compuation,
-                # It may allocate new buckets before deallocating old buckets
-                # inside _rebuild_buckets. To save peak memory usage,
-                # call _rebuild_buckets before the peak memory usage increases
-                # during forward computation.
-                # This should be called only once during whole training period.
-                if torch.is_grad_enabled() and self.reducer._rebuild_buckets():
-                    print("Reducer buckets have been rebuilt in this iteration.")
-                    self._has_rebuilt_buckets = True
-
-                # sync params according to location (before/after forward) user
-                # specified as part of hook, if hook was specified.
-                buffer_hook_registered = hasattr(self, "buffer_hook")
-                if self._check_sync_bufs_pre_fwd():
-                    self._sync_buffers()
-
-                if self._join_config.enable:
-                    # Notify joined ranks whether they should sync in backwards pass or not.
-                    self._check_global_requires_backward_grad_sync(is_joined_rank=False)
-
-                inputs, kwargs = self.scatter(inputs, kwargs, self.device_ids)
-                if self.module.training:
-                    output = self.module.training_step(*inputs[0], **kwargs[0])
-                elif self.module.testing:
-                    output = self.module.test_step(*inputs[0], **kwargs[0])
-                else:
-                    output = self.module.validation_step(*inputs[0], **kwargs[0])
-
-                # sync params according to location (before/after forward) user
-                # specified as part of hook, if hook was specified.
-                if self._check_sync_bufs_post_fwd():
-                    self._sync_buffers()
-
-                if torch.is_grad_enabled() and self.require_backward_grad_sync:
-                    self.require_forward_param_sync = True
-                    # We'll return the output object verbatim since it is a freeform
-                    # object. We need to find any tensors in this object, though,
-                    # because we need to figure out which parameters were used during
-                    # this forward pass, to ensure we short circuit reduction for any
-                    # unused parameters. Only if `find_unused_parameters` is set.
-                    if self.find_unused_parameters and not self.static_graph:
-                        # Do not need to populate this for static graph.
-                        self.reducer.prepare_for_backward(list(_find_tensors(output)))
-                    else:
-                        self.reducer.prepare_for_backward([])
-                else:
-                    self.require_forward_param_sync = False
-
-            # TODO: DDPSink is currently enabled for unused parameter detection and
-            # static graph training for first iteration.
-            if (self.find_unused_parameters and not self.static_graph) or (
-                self.static_graph and self.num_iterations == 1
-            ):
-                state_dict = {
-                    "static_graph": self.static_graph,
-                    "num_iterations": self.num_iterations,
-                }
-
-                output_tensor_list, treespec, output_is_rref = _tree_flatten_with_rref(output)
-                output_placeholders = [None for _ in range(len(output_tensor_list))]
-                # Do not touch tensors that have no grad_fn, which can cause issues
-                # such as https://github.com/pytorch/pytorch/issues/60733
-                for i, output in enumerate(output_tensor_list):
-                    if torch.is_tensor(output) and output.grad_fn is None:
-                        output_placeholders[i] = output
-
-                # When find_unused_parameters=True, makes tensors which require grad
-                # run through the DDPSink backward pass. When not all outputs are
-                # used in loss, this makes those corresponding tensors receive
-                # undefined gradient which the reducer then handles to ensure
-                # param.grad field is not touched and we don't error out.
-                passthrough_tensor_list = _DDPSink.apply(
-                    self.reducer,
-                    state_dict,
-                    *output_tensor_list,
-                )
-                for i in range(len(output_placeholders)):
-                    if output_placeholders[i] is None:
-                        output_placeholders[i] = passthrough_tensor_list[i]
-
-                # Reconstruct output data structure.
-                output = _tree_unflatten_with_rref(output_placeholders, treespec, output_is_rref)
-        return output

GPT_SoVITS/module/distrib.py

@@ -1,123 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""Torch distributed utilities."""
-
-import typing as tp
-
-import torch
-
-
-def rank():
-    if torch.distributed.is_initialized():
-        return torch.distributed.get_rank()
-    else:
-        return 0
-
-
-def world_size():
-    if torch.distributed.is_initialized():
-        return torch.distributed.get_world_size()
-    else:
-        return 1
-
-
-def is_distributed():
-    return world_size() > 1
-
-
-def all_reduce(tensor: torch.Tensor, op=torch.distributed.ReduceOp.SUM):
-    if is_distributed():
-        return torch.distributed.all_reduce(tensor, op)
-
-
-def _is_complex_or_float(tensor):
-    return torch.is_floating_point(tensor) or torch.is_complex(tensor)
-
-
-def _check_number_of_params(params: tp.List[torch.Tensor]):
-    # utility function to check that the number of params in all workers is the same,
-    # and thus avoid a deadlock with distributed all reduce.
-    if not is_distributed() or not params:
-        return
-    # print('params[0].device ', params[0].device)
-    tensor = torch.tensor([len(params)], device=params[0].device, dtype=torch.long)
-    all_reduce(tensor)
-    if tensor.item() != len(params) * world_size():
-        # If not all the workers have the same number, for at least one of them,
-        # this inequality will be verified.
-        raise RuntimeError(
-            f"Mismatch in number of params: ours is {len(params)}, at least one worker has a different one."
-        )
-
-
-def broadcast_tensors(tensors: tp.Iterable[torch.Tensor], src: int = 0):
-    """Broadcast the tensors from the given parameters to all workers.
-    This can be used to ensure that all workers have the same model to start with.
-    """
-    if not is_distributed():
-        return
-    tensors = [tensor for tensor in tensors if _is_complex_or_float(tensor)]
-    _check_number_of_params(tensors)
-    handles = []
-    for tensor in tensors:
-        handle = torch.distributed.broadcast(tensor.data, src=src, async_op=True)
-        handles.append(handle)
-    for handle in handles:
-        handle.wait()
-
-
-def sync_buffer(buffers, average=True):
-    """
-    Sync grad for buffers. If average is False, broadcast instead of averaging.
-    """
-    if not is_distributed():
-        return
-    handles = []
-    for buffer in buffers:
-        if torch.is_floating_point(buffer.data):
-            if average:
-                handle = torch.distributed.all_reduce(buffer.data, op=torch.distributed.ReduceOp.SUM, async_op=True)
-            else:
-                handle = torch.distributed.broadcast(buffer.data, src=0, async_op=True)
-            handles.append((buffer, handle))
-    for buffer, handle in handles:
-        handle.wait()
-        if average:
-            buffer.data /= world_size
-
-
-def sync_grad(params):
-    """
-    Simpler alternative to DistributedDataParallel, that doesn't rely
-    on any black magic. For simple models it can also be as fast.
-    Just call this on your model parameters after the call to backward!
-    """
-    if not is_distributed():
-        return
-    handles = []
-    for p in params:
-        if p.grad is not None:
-            handle = torch.distributed.all_reduce(p.grad.data, op=torch.distributed.ReduceOp.SUM, async_op=True)
-            handles.append((p, handle))
-    for p, handle in handles:
-        handle.wait()
-        p.grad.data /= world_size()
-
-
-def average_metrics(metrics: tp.Dict[str, float], count=1.0):
-    """Average a dictionary of metrics across all workers, using the optional
-    `count` as unormalized weight.
-    """
-    if not is_distributed():
-        return metrics
-    keys, values = zip(*metrics.items())
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    tensor = torch.tensor(list(values) + [1], device=device, dtype=torch.float32)
-    tensor *= count
-    all_reduce(tensor)
-    averaged = (tensor[:-1] / tensor[-1]).cpu().tolist()
-    return dict(zip(keys, averaged))

GPT_SoVITS/s2_train.py

@@ -124,7 +124,7 @@ def run(rank, n_gpus, hps):
         collate_fn=collate_fn,
         batch_sampler=train_sampler,
         persistent_workers=True,
-        prefetch_factor=3,
+        prefetch_factor=4,
     )
     # if rank == 0:
     #     eval_dataset = TextAudioSpeakerLoader(hps.data.validation_files, hps.data, val=True)

GPT_SoVITS/s2_train_v3.py

@@ -118,13 +118,13 @@ def run(rank, n_gpus, hps):
     collate_fn = TextAudioSpeakerCollate()
     train_loader = DataLoader(
         train_dataset,
-        num_workers=5,
+        num_workers=6,
         shuffle=False,
         pin_memory=True,
         collate_fn=collate_fn,
         batch_sampler=train_sampler,
         persistent_workers=True,
-        prefetch_factor=3,
+        prefetch_factor=4,
     )
     # if rank == 0:
     #     eval_dataset = TextAudioSpeakerLoader(hps.data.validation_files, hps.data, val=True)

GPT_SoVITS/s2_train_v3_lora.py

@@ -120,13 +120,13 @@ def run(rank, n_gpus, hps):
     collate_fn = TextAudioSpeakerCollate()
     train_loader = DataLoader(
         train_dataset,
-        num_workers=5,
+        num_workers=6,
         shuffle=False,
         pin_memory=True,
         collate_fn=collate_fn,
         batch_sampler=train_sampler,
         persistent_workers=True,
-        prefetch_factor=3,
+        prefetch_factor=4,
     )
     save_root = "%s/logs_s2_%s_lora_%s" % (hps.data.exp_dir, hps.model.version, hps.train.lora_rank)
     os.makedirs(save_root, exist_ok=True)

api_v2.py

@@ -41,9 +41,11 @@ POST:
     "repetition_penalty": 1.35,   # float. repetition penalty for T2S model.
     "sample_steps": 32,           # int. number of sampling steps for VITS model V3.
     "super_sampling": False,      # bool. whether to use super-sampling for audio when using VITS model V3.
-    "streaming_mode": False,      # bool or int. return audio chunk by chunk.T he available options are: 0,1,2,3 or True/False (0/False: Disabled | 1/True: Best Quality, Slowest response speed (old version streaming_mode) | 2: Medium Quality, Slow response speed | 3: Lower Quality, Faster response speed )
+    "return_fragment": False,     # bool. step by step return the audio fragment. (Best Quality, Slowest response speed. old version of streaming mode)
+    "streaming_mode": False,      # bool. return audio chunk by chunk. (Medium quality, Slow response speed)
     "overlap_length": 2,          # int. overlap length of semantic tokens for streaming mode.
-    "min_chunk_length": 16,       # int. The minimum chunk length of semantic tokens for streaming mode. (affects audio chunk size)
+    "min_chunk_length": 16,        # int. The minimum chunk length of semantic tokens for streaming mode. (affects audio chunk size)
+    "fixed_length_chunk": False,  # bool. When turned on, it can achieve faster streaming response, but with lower quality. (lower quality, faster response speed)
 }
 ```
 
@@ -104,7 +106,7 @@ RESP:
 import os
 import sys
 import traceback
-from typing import Generator, Union
+from typing import Generator
 
 now_dir = os.getcwd()
 sys.path.append(now_dir)
@@ -169,13 +171,15 @@ class TTS_Request(BaseModel):
     fragment_interval: float = 0.3
     seed: int = -1
     media_type: str = "wav"
-    streaming_mode: Union[bool, int] = False
+    streaming_mode: bool = False
     parallel_infer: bool = True
     repetition_penalty: float = 1.35
     sample_steps: int = 32
     super_sampling: bool = False
     overlap_length: int = 2
     min_chunk_length: int = 16
+    return_fragment: bool = False
+    fixed_length_chunk: bool = False
 
 
 def pack_ogg(io_buffer: BytesIO, data: np.ndarray, rate: int):
@@ -369,9 +373,11 @@ async def tts_handle(req: dict):
                 "repetition_penalty": 1.35,   # float. repetition penalty for T2S model.
                 "sample_steps": 32,           # int. number of sampling steps for VITS model V3.
                 "super_sampling": False,      # bool. whether to use super-sampling for audio when using VITS model V3.
-                "streaming_mode": False,      # bool or int. return audio chunk by chunk.T he available options are: 0,1,2,3 or True/False (0/False: Disabled | 1/True: Best Quality, Slowest response speed (old version streaming_mode) | 2: Medium Quality, Slow response speed | 3: Lower Quality, Faster response speed )
+                "return_fragment": False,     # bool. step by step return the audio fragment. (Best Quality, Slowest response speed. old version of streaming mode)
+                "streaming_mode": False,      # bool. return audio chunk by chunk. (Medium quality, Slow response speed)
                 "overlap_length": 2,          # int. overlap length of semantic tokens for streaming mode.
-                "min_chunk_length": 16,       # int. The minimum chunk length of semantic tokens for streaming mode. (affects audio chunk size)
+                "min_chunk_length": 16,        # int. The minimum chunk length of semantic tokens for streaming mode. (affects audio chunk size)
+                "fixed_length_chunk": False,  # bool. When turned on, it can achieve faster streaming response, but with lower quality. (lower quality, faster response speed)
             }
     returns:
         StreamingResponse: audio stream response.
@@ -384,33 +390,9 @@ async def tts_handle(req: dict):
     check_res = check_params(req)
     if check_res is not None:
         return check_res
-    
-    if streaming_mode == 0:
-        streaming_mode = False
-        return_fragment = False
-        fixed_length_chunk = False
-    elif streaming_mode == 1:
-        streaming_mode = False
-        return_fragment = True
-        fixed_length_chunk = False
-    elif streaming_mode == 2:
-        streaming_mode = True
-        return_fragment = False
-        fixed_length_chunk = False
-    elif streaming_mode == 3:
-        streaming_mode = True
-        return_fragment = False
-        fixed_length_chunk = True
-
-    else:
-        return JSONResponse(status_code=400, content={"message": f"the value of streaming_mode must be 0, 1, 2, 3(int) or true/false(bool)"})
 
     req["streaming_mode"] = streaming_mode
     req["return_fragment"] = return_fragment
-    req["fixed_length_chunk"] = fixed_length_chunk
-
-    print(f"{streaming_mode} {return_fragment} {fixed_length_chunk}")
-
     streaming_mode = streaming_mode or return_fragment
 
 
@@ -475,9 +457,11 @@ async def tts_get_endpoint(
     repetition_penalty: float = 1.35,
     sample_steps: int = 32,
     super_sampling: bool = False,
-    streaming_mode: Union[bool, int] = False,
+    return_fragment: bool = False,
+    streaming_mode: bool = False,
     overlap_length: int = 2,
     min_chunk_length: int = 16,
+    fixed_length_chunk: bool = False,
 ):
     req = {
         "text": text,
@@ -504,6 +488,8 @@ async def tts_get_endpoint(
         "super_sampling": super_sampling,
         "overlap_length": int(overlap_length),
         "min_chunk_length": int(min_chunk_length),
+        "return_fragment": return_fragment,
+        "fixed_length_chunk": fixed_length_chunk
     }
     return await tts_handle(req)
 

requirements.txt

@@ -16,7 +16,7 @@ pypinyin
 pyopenjtalk>=0.4.1
 g2p_en
 torchaudio
-modelscope
+modelscope==1.10.0
 sentencepiece
 transformers>=4.43,<=4.50
 peft
@@ -39,5 +39,7 @@ x_transformers
 torchmetrics<=1.5
 pydantic<=2.10.6
 ctranslate2>=4.0,<5
+huggingface_hub>=0.13
+tokenizers>=0.13,<1
 av>=11
 tqdm

tools/asr/config.py

@@ -1,13 +1,34 @@
+import os
+
+
+def check_fw_local_models():
+    """
+    启动时检查本地是否有 Faster Whisper 模型.
+    """
+    model_size_list = [
+        "medium",
+        "medium.en",
+        "distil-large-v2",
+        "distil-large-v3",
+        "large-v1",
+        "large-v2",
+        "large-v3",
+    ]
+    for i, size in enumerate(model_size_list):
+        if os.path.exists(f"tools/asr/models/faster-whisper-{size}"):
+            model_size_list[i] = size + "-local"
+    return model_size_list
+
+
 def get_models():
     model_size_list = [
         "medium",
         "medium.en",
+        "distil-large-v2",
+        "distil-large-v3",
+        "large-v1",
         "large-v2",
         "large-v3",
-        "large-v3-turbo",
-        #"distil-large-v2",
-        #"distil-large-v3",
-        #"distil-large-v3.5",
     ]
     return model_size_list
 
@@ -15,7 +36,7 @@ def get_models():
 asr_dict = {
     "达摩 ASR (中文)": {"lang": ["zh", "yue"], "size": ["large"], "path": "funasr_asr.py", "precision": ["float32"]},
     "Faster Whisper (多语种)": {
-        "lang": ["auto", "en", "ja", "ko"],
+        "lang": ["auto", "zh", "en", "ja", "ko", "yue"],
         "size": get_models(),
         "path": "fasterwhisper_asr.py",
         "precision": ["float32", "float16", "int8"],

tools/asr/fasterwhisper_asr.py

@@ -1,12 +1,12 @@
 import argparse
 import os
+import time
 import traceback
 
-import requests
 import torch
 from faster_whisper import WhisperModel
-from huggingface_hub import snapshot_download as snapshot_download_hf
-from modelscope import snapshot_download as snapshot_download_ms
+from huggingface_hub import snapshot_download
+from huggingface_hub.errors import LocalEntryNotFoundError
 from tqdm import tqdm
 
 from tools.asr.config import get_models
@@ -40,32 +40,11 @@ language_code_list = [
 
 
 def download_model(model_size: str):
-    url = "https://huggingface.co/api/models/gpt2"
-    try:
-        requests.get(url, timeout=3)
-        source = "HF"
-    except Exception:
-        source = "ModelScope"
-
-    model_path = ""
-    if source == "HF":
-        if "distil" in model_size:
-            if "3.5" in model_size:
-                repo_id = "distil-whisper/distil-large-v3.5-ct2"
-                model_path = "tools/asr/models/faster-distil-whisper-large-v3.5"
-            else:
-                repo_id = "Systran/faster-{}-whisper-{}".format(*model_size.split("-", maxsplit=1))
-        elif model_size == "large-v3-turbo":
-            repo_id = "mobiuslabsgmbh/faster-whisper-large-v3-turbo"
-            model_path = "tools/asr/models/faster-whisper-large-v3-turbo"
-        else:
-            repo_id = f"Systran/faster-whisper-{model_size}"
-        model_path = (
-            model_path or f"tools/asr/models/{repo_id.replace('Systran/', '').replace('distil-whisper/', '', 1)}"
-        )
+    if "distil" in model_size:
+        repo_id = "Systran/faster-{}-whisper-{}".format(*model_size.split("-", maxsplit=1))
     else:
-        repo_id = "XXXXRT/faster-whisper"
-        model_path = "tools/asr/models"
+        repo_id = f"Systran/faster-whisper-{model_size}"
+    model_path = f"tools/asr/models/{repo_id.strip('Systran/')}"
 
     files: list[str] = [
         "config.json",
@@ -73,31 +52,32 @@ def download_model(model_size: str):
         "tokenizer.json",
         "vocabulary.txt",
     ]
-    if "large-v3" in model_size or "distil" in model_size:
+    if model_size == "large-v3" or "distil" in model_size:
         files.append("preprocessor_config.json")
         files.append("vocabulary.json")
 
         files.remove("vocabulary.txt")
 
-    if source == "ModelScope":
-        files = [f"faster-whisper-{model_size}/{file}".replace("whisper-distil", "distil-whisper") for file in files]
+    for attempt in range(2):
+        try:
+            snapshot_download(
+                repo_id=repo_id,
+                allow_patterns=files,
+                local_dir=model_path,
+            )
+            break
+        except LocalEntryNotFoundError:
+            if attempt < 1:
+                time.sleep(2)
+            else:
+                print("[ERROR] LocalEntryNotFoundError and no fallback.")
+                traceback.print_exc()
+                exit(1)
+        except Exception as e:
+            print(f"[ERROR] Unexpected error on attempt {attempt + 1}: {e}")
+            traceback.print_exc()
+            exit(1)
 
-    if source == "HF":
-        print(f"Downloading model from HuggingFace: {repo_id} to {model_path}")
-        snapshot_download_hf(
-            repo_id,
-            local_dir=model_path,
-            local_dir_use_symlinks=False,
-            allow_patterns=files,
-        )
-    else:
-        print(f"Downloading model from ModelScope: {repo_id} to {model_path}")
-        snapshot_download_ms(
-            repo_id,
-            local_dir=model_path,
-            allow_patterns=files,
-        )
-        return model_path + f"/faster-whisper-{model_size}".replace("whisper-distil", "distil-whisper")
     return model_path
 
 
@@ -126,7 +106,7 @@ def execute_asr(input_folder, output_folder, model_path, language, precision):
             )
             text = ""
 
-            if info.language in ["zh", "yue"]:
+            if info.language == "zh":
                 print("检测为中文文本, 转 FunASR 处理")
                 text = only_asr(file_path, language=info.language.lower())
 

tools/asr/funasr_asr.py

@@ -4,8 +4,9 @@ import argparse
 import os
 import traceback
 
+# from funasr.utils import version_checker
+# version_checker.check_for_update = lambda: None
 from funasr import AutoModel
-from modelscope import snapshot_download
 from tqdm import tqdm
 
 funasr_models = {}  # 存储模型避免重复加载
@@ -15,43 +16,40 @@ def only_asr(input_file, language):
     try:
         model = create_model(language)
         text = model.generate(input=input_file)[0]["text"]
-    except Exception:
+    except:
         text = ""
         print(traceback.format_exc())
     return text
 
 
 def create_model(language="zh"):
+    path_vad = "tools/asr/models/speech_fsmn_vad_zh-cn-16k-common-pytorch"
+    path_punc = "tools/asr/models/punc_ct-transformer_zh-cn-common-vocab272727-pytorch"
+    path_vad = path_vad if os.path.exists(path_vad) else "iic/speech_fsmn_vad_zh-cn-16k-common-pytorch"
+    path_punc = path_punc if os.path.exists(path_punc) else "iic/punc_ct-transformer_zh-cn-common-vocab272727-pytorch"
+    vad_model_revision = punc_model_revision = "v2.0.4"
+
     if language == "zh":
-        path_vad = "tools/asr/models/speech_fsmn_vad_zh-cn-16k-common-pytorch"
-        path_punc = "tools/asr/models/punc_ct-transformer_zh-cn-common-vocab272727-pytorch"
         path_asr = "tools/asr/models/speech_paraformer-large_asr_nat-zh-cn-16k-common-vocab8404-pytorch"
-        snapshot_download(
-            "iic/speech_fsmn_vad_zh-cn-16k-common-pytorch",
-            local_dir="tools/asr/models/speech_fsmn_vad_zh-cn-16k-common-pytorch",
-        )
-        snapshot_download(
-            "iic/punc_ct-transformer_zh-cn-common-vocab272727-pytorch",
-            local_dir="tools/asr/models/punc_ct-transformer_zh-cn-common-vocab272727-pytorch",
-        )
-        snapshot_download(
-            "iic/speech_paraformer-large_asr_nat-zh-cn-16k-common-vocab8404-pytorch",
-            local_dir="tools/asr/models/speech_paraformer-large_asr_nat-zh-cn-16k-common-vocab8404-pytorch",
+        path_asr = (
+            path_asr
+            if os.path.exists(path_asr)
+            else "iic/speech_paraformer-large_asr_nat-zh-cn-16k-common-vocab8404-pytorch"
         )
         model_revision = "v2.0.4"
     elif language == "yue":
         path_asr = "tools/asr/models/speech_UniASR_asr_2pass-cantonese-CHS-16k-common-vocab1468-tensorflow1-online"
-        snapshot_download(
-            "iic/speech_UniASR_asr_2pass-cantonese-CHS-16k-common-vocab1468-tensorflow1-online",
-            local_dir="tools/asr/models/speech_UniASR_asr_2pass-cantonese-CHS-16k-common-vocab1468-tensorflow1-online",
+        path_asr = (
+            path_asr
+            if os.path.exists(path_asr)
+            else "iic/speech_UniASR_asr_2pass-cantonese-CHS-16k-common-vocab1468-tensorflow1-online"
         )
-        path_vad = path_punc = None
-        vad_model_revision = punc_model_revision = ""
         model_revision = "master"
+        path_vad = path_punc = None
+        vad_model_revision = punc_model_revision = None
+        ###友情提示：粤语带VAD识别可能会有少量shape不对报错的，但是不带VAD可以.不带vad只能分阶段单独加标点。不过标点模型对粤语效果真的不行…
     else:
-        raise ValueError(f"{language} is not supported")
-
-    vad_model_revision = punc_model_revision = "v2.0.4"
+        raise ValueError("FunASR 不支持该语言" + ": " + language)
 
     if language in funasr_models:
         return funasr_models[language]
@@ -85,7 +83,7 @@ def execute_asr(input_folder, output_folder, model_size, language):
             file_path = os.path.join(input_folder, file_name)
             text = model.generate(input=file_path)[0]["text"]
             output.append(f"{file_path}|{output_file_name}|{language.upper()}|{text}")
-        except Exception:
+        except:
             print(traceback.format_exc())
 
     output_folder = output_folder or "output/asr_opt"

tools/i18n/locale/en_US.json

@@ -38,7 +38,7 @@
     "hop_size:怎么算音量曲线，越小精度越大计算量越高（不是精度越大效果越好）": "hop_size: FO hop size, the smaller the value, the higher the accuracy）",
     "max:归一化后最大值多少": "Loudness multiplier after normalized",
     "max_sil_kept:切完后静音最多留多长": "Maximum length for silence to be kept",
-    "min_interval:最短切割间隔": "Minimum interval for audio cutting",
+    "min_interval:最短切割间隔": "Minumum interval for audio cutting",
     "min_length:每段最小多长，如果第一段太短一直和后面段连起来直到超过这个值": "min_length: the minimum length of each segment. If the first segment is too short, it will be concatenated with the next segment until it exceeds this value",
     "temperature": "temperature",
     "threshold:音量小于这个值视作静音的备选切割点": "Noise gate threshold (loudness below this value will be treated as noise",
@@ -176,7 +176,7 @@
     "语音降噪": "Speech Denoising",
     "请上传3~10秒内参考音频，超过会报错！": "Please upload a reference audio within the 3-10 second range; if it exceeds this duration, it will raise errors.",
     "请上传参考音频": "Please Upload the Reference Audio",
-    "请填入推理文本": "Please Fill in the Target Text",
+    "请填入推理文本": "Please Fill in the Terget Text",
     "请填入正确的List路径": "Please Fill in the Correct List Path",
     "请填入正确的音频文件夹路径": "Please Fill in the Correct Audio Folder Path",
     "请输入有效文本": "Please enter valid text.",

webui.py

@@ -89,6 +89,7 @@ from config import (
 from tools import my_utils
 from tools.my_utils import check_details, check_for_existance
 
+os.environ["HF_ENDPOINT"] = "https://hf-mirror.com"
 os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
 
 # os.environ['PYTORCH_ENABLE_MPS_FALLBACK'] = '1' # 当遇到mps不支持的步骤时使用cpu
@@ -119,8 +120,8 @@ def set_default():
     gpu_info = "\n".join(gpu_infos)
     if is_gpu_ok:
         minmem = min(mem)
-        default_batch_size = int(minmem // 2 if version not in v3v4set else minmem // 8)
-        default_batch_size_s1 = int(minmem // 2)
+        default_batch_size = minmem // 2 if version not in v3v4set else minmem // 8
+        default_batch_size_s1 = minmem // 2
     else:
         default_batch_size = default_batch_size_s1 = int(psutil.virtual_memory().total / 1024 / 1024 / 1024 / 4)
     if version not in v3v4set:
@@ -1982,3 +1983,4 @@ with gr.Blocks(title="GPT-SoVITS WebUI", analytics_enabled=False, js=js, css=css
         server_port=webui_port_main,
         # quiet=True,
     )
+