AttributeError: 'int' object has no attribute 'device'

[cod3r0k]

I have an issue with inference_stream function of model (ref https://docs.coqui.ai/en/stable/models/xtts.html#streaming-manually).

Inference...
/home/tts/TTS/tts/layers/xtts/stream_generator.py:138: UserWarning: You have modified the pretrained model configuration to control generation. This is a deprecated strategy to control generation and will be removed soon, in a future version. Please use a generation configuration file (see https://huggingface.co/docs/transformers/main_classes/text_generation)
  warnings.warn(
/home/tts/.venv/lib/python3.10/site-packages/transformers/generation/configuration_utils.py:774: UserWarning: `return_dict_in_generate` is NOT set to `True`, but `output_hidden_states` is. When `return_dict_in_generate` is not `True`, `output_hidden_states` is ignored.
  warnings.warn(
Traceback (most recent call last):
  File "/home/tts/test_stream.py", line 62, in <module>
    for i, chunk in enumerate(chunks):
  File "/home/tts/.venv/lib/python3.10/site-packages/torch/utils/_contextlib.py", line 36, in generator_context
    response = gen.send(None)
  File "/home/tts/TTS/tts/models/xtts.py", line 655, in inference_stream
    gpt_generator = self.gpt.get_generator(
  File "/home/tts/TTS/tts/layers/xtts/gpt.py", line 660, in get_generator
    return self.gpt_inference.generate_stream(
  File "/home/tts/.venv/lib/python3.10/site-packages/torch/utils/_contextlib.py", line 116, in decorate_context
    return func(*args, **kwargs)
  File "/home/tts/TTS/tts/layers/xtts/stream_generator.py", line 186, in generate
    model_kwargs["attention_mask"] = self._prepare_attention_mask_for_generation(
  File "/home/tts/.venv/lib/python3.10/site-packages/transformers/generation/utils.py", line 588, in _prepare_attention_mask_for_generation
    isin_mps_friendly(elements=eos_token_id, test_elements=pad_token_id).any()
  File "/home/tts/.venv/lib/python3.10/site-packages/transformers/pytorch_utils.py", line 324, in isin_mps_friendly
    if elements.device.type == "mps" and not is_torch_greater_or_equal_than_2_4:
AttributeError: 'int' object has no attribute 'device'

[anhnh2002]

It seems the issue comes from the Coqui XTTS package. Try uninstalling the TTS package using pip uninstall TTS and importing from my source as shown in the README.

[cod3r0k]

Hi @anhnh2002 , I reinstall TTS as you suggested, but I'm still encountering the same error. I have added more logs for better understanding.

Here are the steps I followed:
1- Trained the model following the README instructions.
2- Created a test_stream.py file with the content shown below, similar to the reference I shared earlier.

chunks = model.inference_stream(
    "It took me quite a long time to develop a voice and now that I have it I am not going to be silent.",
    "en",
    gpt_cond_latent,
    speaker_embedding
)

But it has an error again

My env has below configs:

TTS==0.22.0
transformers==4.46.3
torch==2.5.1+cu121
torchaudio==2.5.1+cu121
torchvision==0.20.1+cu121

[anhnh2002]

Could you provide your test_stream.py

[cod3r0k]

Yes, of course. I use coqui xtts's stream code as below:

import os
import time
import torch
import torchaudio
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts

from underthesea import sent_tokenize
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts


# Model paths
xtts_checkpoint = "checkpoints/GPT_XTTS_FT-January-19-2025_11+29PM-8e59ec3/best_model.pth"
xtts_config = "checkpoints/XTTS_v2.0_original_model_files/config.json"
xtts_vocab = "checkpoints/XTTS_v2.0_original_model_files/vocab.json"

print("Loading model...")
# config = XttsConfig()
# config.load_json("checkpoints/XTTS_v2.0_original_model_files/config.json")
# model = Xtts.init_from_config(config)
# model.load_checkpoint(config, checkpoint_path="checkpoints/GPT_XTTS_FT-January-19-2025_11+29PM-8e59ec3/best_model.pth", use_deepspeed=True)
# model.cuda()

# Device configuration
device = "cuda:0" if torch.cuda.is_available() else "cpu"

# Load model
config = XttsConfig()
config.load_json(xtts_config)
model = Xtts.init_from_config(config)
model.load_checkpoint(config, checkpoint_path=xtts_checkpoint, vocab_path=xtts_vocab, use_deepspeed=False)
model.to(device)

print("Model loaded successfully!")

print("Computing speaker latents...")
tts_text = "Hi how about my test"
speaker_audio_file = "wa-47.wav"
lang = "fa"

gpt_cond_latent, speaker_embedding = model.get_conditioning_latents(
    audio_path=speaker_audio_file,
    gpt_cond_len=model.config.gpt_cond_len,
    max_ref_length=model.config.max_ref_len,
    sound_norm_refs=model.config.sound_norm_refs,
)

tts_texts = sent_tokenize(tts_text)

print("Inference...")
t0 = time.time()
chunks = model.inference_stream(
    "It took me quite a long time to develop a voice and now that I have it I am not going to be silent.",
    "en",
    gpt_cond_latent,
    speaker_embedding
)

wav_chuncks = []
for i, chunk in enumerate(chunks):
    if i == 0:
        print(f"Time to first chunck: {time.time() - t0}")
    print(f"Received chunk {i} of audio length {chunk.shape[-1]}")
    wav_chuncks.append(chunk)
wav = torch.cat(wav_chuncks, dim=0)
torchaudio.save("xtts_streaming.wav", wav.squeeze().unsqueeze(0).cpu(), 24000)

[cod3r0k]

Hi , could you guide me @anhnh2002

[KyleGuyMandude]

Hi , could you guide me @anhnh2002

Did you find a solution, I have the same issue.

[kin0303]

I changed the Transformers version to 4.50.1, but it caused a new error: AttributeError: 'int' object has no attribute '_pad_token_tensor'

[KyleGuyMandude]

I changed the Transformers version to 4.50.1, but it caused a new error: AttributeError: 'int' object has no attribute '_pad_token_tensor'

not sure if this will help but I patched the code to fix this.

import torch
import torchaudio
from tqdm import tqdm
from nltk.tokenize import sent_tokenize

# Monkey patch 1: Fix isin_mps_friendly function to handle integer inputs

def patched_isin_mps_friendly(elements, test_elements):
    """
    Patched version that handles integer inputs for both elements and test_elements
    """
    if isinstance(elements, int):
        elements = torch.tensor([elements])
    elif not isinstance(elements, torch.Tensor):
        elements = torch.tensor(elements)
    
    if isinstance(test_elements, int):
        test_elements = torch.tensor([test_elements], device=elements.device, dtype=elements.dtype)
    elif not isinstance(test_elements, torch.Tensor):
        test_elements = torch.tensor(test_elements, device=elements.device, dtype=elements.dtype)
    
    if test_elements.device != elements.device:
        test_elements = test_elements.to(elements.device)
    
    from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_4
    if elements.device.type == "mps" and not is_torch_greater_or_equal_than_2_4:
        return elements.tile(test_elements.shape[0], 1).eq(test_elements.unsqueeze(1)).sum(dim=0).bool().squeeze()
    else:
        return torch.isin(elements, test_elements)

# Monkey patch 2: Fix StreamGenerationConfig to have required attributes
def patch_stream_generation_config():
    """
    Patch the StreamGenerationConfig class to include missing attributes
    """
    try:
        from TTS.tts.layers.xtts.stream_generator import StreamGenerationConfig
        
        # Store original __init__ method
        original_init = StreamGenerationConfig.__init__
        
        def patched_init(self, *args, **kwargs):
            # Call original init
            original_init(self, *args, **kwargs)
            
            # Add missing attributes - use lazy property approach to avoid serialization issues
            self._eos_token_tensor_cache = None
            self._pad_token_tensor_cache = None
        
        def eos_token_tensor_property(self):
            if self._eos_token_tensor_cache is None:
                if hasattr(self, 'eos_token_id') and self.eos_token_id is not None:
                    self._eos_token_tensor_cache = torch.tensor([self.eos_token_id])
                else:
                    self._eos_token_tensor_cache = None
            return self._eos_token_tensor_cache
        
        def pad_token_tensor_property(self):
            if self._pad_token_tensor_cache is None:
                if hasattr(self, 'pad_token_id') and self.pad_token_id is not None:
                    self._pad_token_tensor_cache = torch.tensor([self.pad_token_id])
                else:
                    self._pad_token_tensor_cache = None
            return self._pad_token_tensor_cache
        
        # Apply the patches
        StreamGenerationConfig.__init__ = patched_init
        StreamGenerationConfig._eos_token_tensor = property(eos_token_tensor_property)
        StreamGenerationConfig._pad_token_tensor = property(pad_token_tensor_property)
        
    except ImportError:
        print("Could not import StreamGenerationConfig - using alternative approach")

# Monkey patch 3: Alternative approach - patch the logits processor getter
def patched_get_logits_processor(original_method):
    """
    Wrapper for _get_logits_processor to handle missing _eos_token_tensor
    """
    def wrapper(self, generation_config, *args, **kwargs):
        # Ensure generation_config has required attributes
        if not hasattr(generation_config, '_eos_token_tensor'):
            # Use property-like access to avoid serialization issues
            def get_eos_tensor():
                if hasattr(generation_config, 'eos_token_id') and generation_config.eos_token_id is not None:
                    return torch.tensor([generation_config.eos_token_id])
                return None
            generation_config._eos_token_tensor = get_eos_tensor()
        
        if not hasattr(generation_config, '_pad_token_tensor'):
            def get_pad_tensor():
                if hasattr(generation_config, 'pad_token_id') and generation_config.pad_token_id is not None:
                    return torch.tensor([generation_config.pad_token_id])
                return None
            generation_config._pad_token_tensor = get_pad_tensor()
        
        return original_method(self, generation_config, *args, **kwargs)
    
    return wrapper

# Monkey patch 4: Handle JSON serialization issues in generation
def patch_json_serialization():
    """
    Patch any JSON serialization that might be happening with tensors
    """
    import json
    original_default = json.JSONEncoder.default
    
    def patched_default(self, obj):
        if isinstance(obj, torch.Tensor):
            return obj.tolist()  # Convert tensor to list for JSON serialization
        return original_default(self, obj)
    
    json.JSONEncoder.default = patched_default

# Monkey patch 5: Add missing _get_logits_warper method to GPT2InferenceModel
def patch_gpt2_inference_model():
    """
    Add missing methods to GPT2InferenceModel that are expected by the generation pipeline
    """
    try:
        from TTS.tts.layers.xtts.gpt import GPT2InferenceModel
        from transformers import LogitsProcessorList, TopKLogitsWarper, TopPLogitsWarper, TemperatureLogitsWarper
        
        def _get_logits_warper(self, generation_config):
            """
            Add logits warpers based on generation config
            """
            warpers = LogitsProcessorList()
            
            # Add temperature warper
            if generation_config.temperature is not None and generation_config.temperature != 1.0:
                warpers.append(TemperatureLogitsWarper(generation_config.temperature))
            
            # Add top-k warper
            if generation_config.top_k is not None and generation_config.top_k != 0:
                warpers.append(TopKLogitsWarper(top_k=generation_config.top_k))
            
            # Add top-p warper
            if generation_config.top_p is not None and generation_config.top_p < 1.0:
                warpers.append(TopPLogitsWarper(top_p=generation_config.top_p))
            
            return warpers
        
        def _get_logits_processor(self, *args, **kwargs):
            """
            Return empty logits processor list - we handle processing in warpers
            """
            return LogitsProcessorList()
        
        # Add the missing methods
        GPT2InferenceModel._get_logits_warper = _get_logits_warper
        GPT2InferenceModel._get_logits_processor = _get_logits_processor
        
        print("Added missing methods to GPT2InferenceModel")
        
    except ImportError as e:
        print(f"Could not patch GPT2InferenceModel: {e}")

# Monkey patch 6: More comprehensive generation method patching
def patch_generation_methods():
    """
    Add any other missing methods that might be expected
    """
    try:
        from TTS.tts.layers.xtts.gpt import GPT2InferenceModel
        
        # Add _get_stopping_criteria if missing
        if not hasattr(GPT2InferenceModel, '_get_stopping_criteria'):
            def _get_stopping_criteria(self, generation_config, stopping_criteria):
                from transformers import StoppingCriteriaList, MaxLengthCriteria
                stopping_criteria = stopping_criteria or StoppingCriteriaList()
                if generation_config.max_length is not None:
                    stopping_criteria.append(MaxLengthCriteria(max_length=generation_config.max_length))
                return stopping_criteria
            
            GPT2InferenceModel._get_stopping_criteria = _get_stopping_criteria
        
        # Add _prepare_model_inputs if missing
        if not hasattr(GPT2InferenceModel, '_prepare_model_inputs'):
            def _prepare_model_inputs(self, inputs, bos_token_id, model_kwargs):
                return inputs, model_kwargs
            
            GPT2InferenceModel._prepare_model_inputs = _prepare_model_inputs
            
        print("Added additional missing methods to GPT2InferenceModel")
        
    except ImportError as e:
        print(f"Could not add additional methods: {e}")
        
# Monkey patch 7: Handle cache_position in _update_model_kwargs_for_generation
def patch_update_model_kwargs():
    """
    Patch _update_model_kwargs_for_generation to handle missing cache_position
    """
    from transformers.generation.utils import GenerationMixin
    original_update_model_kwargs = GenerationMixin._update_model_kwargs_for_generation

    def patched_update_model_kwargs(self, outputs, model_kwargs, is_encoder_decoder=False, num_new_tokens=1):
        # Initialize cache_position if not present
        if "cache_position" not in model_kwargs and model_kwargs.get("use_cache", True):
            # Assume we're starting from position 0 if not provided
            model_kwargs["cache_position"] = torch.tensor([0], dtype=torch.long, device=self.device)

        # Call the original method
        model_kwargs = original_update_model_kwargs(self, outputs, model_kwargs, is_encoder_decoder, num_new_tokens)

        # Update cache_position for the next step
        if model_kwargs.get("use_cache", True):
            current_pos = model_kwargs["cache_position"]
            model_kwargs["cache_position"] = current_pos[-1:] + num_new_tokens

        return model_kwargs

    # Apply the patch
    GenerationMixin._update_model_kwargs_for_generation = patched_update_model_kwargs
    print("Patched _update_model_kwargs_for_generation to handle cache_position")

# Apply the new monkey patch
print("Applying monkey patches...")

# Patch 1: isin_mps_friendly
import transformers.pytorch_utils
transformers.pytorch_utils.isin_mps_friendly = patched_isin_mps_friendly

# Patch 2: StreamGenerationConfig
patch_stream_generation_config()

# Patch 3: _get_logits_processor
from transformers.generation.utils import GenerationMixin
GenerationMixin._get_logits_processor = patched_get_logits_processor(GenerationMixin._get_logits_processor)

# Patch 4: JSON serialization
patch_json_serialization()

# Patch 5: GPT2InferenceModel missing methods
patch_gpt2_inference_model()

# Patch 6: Additional generation methods
patch_generation_methods()

# Patch 7: update model kwargs
patch_update_model_kwargs()

print("Monkey patches applied successfully!")

import torchaudio
from tqdm import tqdm
from underthesea import sent_tokenize

from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts

[kin0303]

I changed the Transformers version to 4.50.1, but it caused a new error: AttributeError: 'int' object has no attribute '_pad_token_tensor'

not sure if this will help but I patched the code to fix this.

import torch
import torchaudio
from tqdm import tqdm
from nltk.tokenize import sent_tokenize

# Monkey patch 1: Fix isin_mps_friendly function to handle integer inputs

def patched_isin_mps_friendly(elements, test_elements):
    """
    Patched version that handles integer inputs for both elements and test_elements
    """
    if isinstance(elements, int):
        elements = torch.tensor([elements])
    elif not isinstance(elements, torch.Tensor):
        elements = torch.tensor(elements)
    
    if isinstance(test_elements, int):
        test_elements = torch.tensor([test_elements], device=elements.device, dtype=elements.dtype)
    elif not isinstance(test_elements, torch.Tensor):
        test_elements = torch.tensor(test_elements, device=elements.device, dtype=elements.dtype)
    
    if test_elements.device != elements.device:
        test_elements = test_elements.to(elements.device)
    
    from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_4
    if elements.device.type == "mps" and not is_torch_greater_or_equal_than_2_4:
        return elements.tile(test_elements.shape[0], 1).eq(test_elements.unsqueeze(1)).sum(dim=0).bool().squeeze()
    else:
        return torch.isin(elements, test_elements)

# Monkey patch 2: Fix StreamGenerationConfig to have required attributes
def patch_stream_generation_config():
    """
    Patch the StreamGenerationConfig class to include missing attributes
    """
    try:
        from TTS.tts.layers.xtts.stream_generator import StreamGenerationConfig
        
        # Store original __init__ method
        original_init = StreamGenerationConfig.__init__
        
        def patched_init(self, *args, **kwargs):
            # Call original init
            original_init(self, *args, **kwargs)
            
            # Add missing attributes - use lazy property approach to avoid serialization issues
            self._eos_token_tensor_cache = None
            self._pad_token_tensor_cache = None
        
        def eos_token_tensor_property(self):
            if self._eos_token_tensor_cache is None:
                if hasattr(self, 'eos_token_id') and self.eos_token_id is not None:
                    self._eos_token_tensor_cache = torch.tensor([self.eos_token_id])
                else:
                    self._eos_token_tensor_cache = None
            return self._eos_token_tensor_cache
        
        def pad_token_tensor_property(self):
            if self._pad_token_tensor_cache is None:
                if hasattr(self, 'pad_token_id') and self.pad_token_id is not None:
                    self._pad_token_tensor_cache = torch.tensor([self.pad_token_id])
                else:
                    self._pad_token_tensor_cache = None
            return self._pad_token_tensor_cache
        
        # Apply the patches
        StreamGenerationConfig.__init__ = patched_init
        StreamGenerationConfig._eos_token_tensor = property(eos_token_tensor_property)
        StreamGenerationConfig._pad_token_tensor = property(pad_token_tensor_property)
        
    except ImportError:
        print("Could not import StreamGenerationConfig - using alternative approach")

# Monkey patch 3: Alternative approach - patch the logits processor getter
def patched_get_logits_processor(original_method):
    """
    Wrapper for _get_logits_processor to handle missing _eos_token_tensor
    """
    def wrapper(self, generation_config, *args, **kwargs):
        # Ensure generation_config has required attributes
        if not hasattr(generation_config, '_eos_token_tensor'):
            # Use property-like access to avoid serialization issues
            def get_eos_tensor():
                if hasattr(generation_config, 'eos_token_id') and generation_config.eos_token_id is not None:
                    return torch.tensor([generation_config.eos_token_id])
                return None
            generation_config._eos_token_tensor = get_eos_tensor()
        
        if not hasattr(generation_config, '_pad_token_tensor'):
            def get_pad_tensor():
                if hasattr(generation_config, 'pad_token_id') and generation_config.pad_token_id is not None:
                    return torch.tensor([generation_config.pad_token_id])
                return None
            generation_config._pad_token_tensor = get_pad_tensor()
        
        return original_method(self, generation_config, *args, **kwargs)
    
    return wrapper

# Monkey patch 4: Handle JSON serialization issues in generation
def patch_json_serialization():
    """
    Patch any JSON serialization that might be happening with tensors
    """
    import json
    original_default = json.JSONEncoder.default
    
    def patched_default(self, obj):
        if isinstance(obj, torch.Tensor):
            return obj.tolist()  # Convert tensor to list for JSON serialization
        return original_default(self, obj)
    
    json.JSONEncoder.default = patched_default

# Monkey patch 5: Add missing _get_logits_warper method to GPT2InferenceModel
def patch_gpt2_inference_model():
    """
    Add missing methods to GPT2InferenceModel that are expected by the generation pipeline
    """
    try:
        from TTS.tts.layers.xtts.gpt import GPT2InferenceModel
        from transformers import LogitsProcessorList, TopKLogitsWarper, TopPLogitsWarper, TemperatureLogitsWarper
        
        def _get_logits_warper(self, generation_config):
            """
            Add logits warpers based on generation config
            """
            warpers = LogitsProcessorList()
            
            # Add temperature warper
            if generation_config.temperature is not None and generation_config.temperature != 1.0:
                warpers.append(TemperatureLogitsWarper(generation_config.temperature))
            
            # Add top-k warper
            if generation_config.top_k is not None and generation_config.top_k != 0:
                warpers.append(TopKLogitsWarper(top_k=generation_config.top_k))
            
            # Add top-p warper
            if generation_config.top_p is not None and generation_config.top_p < 1.0:
                warpers.append(TopPLogitsWarper(top_p=generation_config.top_p))
            
            return warpers
        
        def _get_logits_processor(self, *args, **kwargs):
            """
            Return empty logits processor list - we handle processing in warpers
            """
            return LogitsProcessorList()
        
        # Add the missing methods
        GPT2InferenceModel._get_logits_warper = _get_logits_warper
        GPT2InferenceModel._get_logits_processor = _get_logits_processor
        
        print("Added missing methods to GPT2InferenceModel")
        
    except ImportError as e:
        print(f"Could not patch GPT2InferenceModel: {e}")

# Monkey patch 6: More comprehensive generation method patching
def patch_generation_methods():
    """
    Add any other missing methods that might be expected
    """
    try:
        from TTS.tts.layers.xtts.gpt import GPT2InferenceModel
        
        # Add _get_stopping_criteria if missing
        if not hasattr(GPT2InferenceModel, '_get_stopping_criteria'):
            def _get_stopping_criteria(self, generation_config, stopping_criteria):
                from transformers import StoppingCriteriaList, MaxLengthCriteria
                stopping_criteria = stopping_criteria or StoppingCriteriaList()
                if generation_config.max_length is not None:
                    stopping_criteria.append(MaxLengthCriteria(max_length=generation_config.max_length))
                return stopping_criteria
            
            GPT2InferenceModel._get_stopping_criteria = _get_stopping_criteria
        
        # Add _prepare_model_inputs if missing
        if not hasattr(GPT2InferenceModel, '_prepare_model_inputs'):
            def _prepare_model_inputs(self, inputs, bos_token_id, model_kwargs):
                return inputs, model_kwargs
            
            GPT2InferenceModel._prepare_model_inputs = _prepare_model_inputs
            
        print("Added additional missing methods to GPT2InferenceModel")
        
    except ImportError as e:
        print(f"Could not add additional methods: {e}")
        
# Monkey patch 7: Handle cache_position in _update_model_kwargs_for_generation
def patch_update_model_kwargs():
    """
    Patch _update_model_kwargs_for_generation to handle missing cache_position
    """
    from transformers.generation.utils import GenerationMixin
    original_update_model_kwargs = GenerationMixin._update_model_kwargs_for_generation

    def patched_update_model_kwargs(self, outputs, model_kwargs, is_encoder_decoder=False, num_new_tokens=1):
        # Initialize cache_position if not present
        if "cache_position" not in model_kwargs and model_kwargs.get("use_cache", True):
            # Assume we're starting from position 0 if not provided
            model_kwargs["cache_position"] = torch.tensor([0], dtype=torch.long, device=self.device)

        # Call the original method
        model_kwargs = original_update_model_kwargs(self, outputs, model_kwargs, is_encoder_decoder, num_new_tokens)

        # Update cache_position for the next step
        if model_kwargs.get("use_cache", True):
            current_pos = model_kwargs["cache_position"]
            model_kwargs["cache_position"] = current_pos[-1:] + num_new_tokens

        return model_kwargs

    # Apply the patch
    GenerationMixin._update_model_kwargs_for_generation = patched_update_model_kwargs
    print("Patched _update_model_kwargs_for_generation to handle cache_position")

# Apply the new monkey patch
print("Applying monkey patches...")

# Patch 1: isin_mps_friendly
import transformers.pytorch_utils
transformers.pytorch_utils.isin_mps_friendly = patched_isin_mps_friendly

# Patch 2: StreamGenerationConfig
patch_stream_generation_config()

# Patch 3: _get_logits_processor
from transformers.generation.utils import GenerationMixin
GenerationMixin._get_logits_processor = patched_get_logits_processor(GenerationMixin._get_logits_processor)

# Patch 4: JSON serialization
patch_json_serialization()

# Patch 5: GPT2InferenceModel missing methods
patch_gpt2_inference_model()

# Patch 6: Additional generation methods
patch_generation_methods()

# Patch 7: update model kwargs
patch_update_model_kwargs()

print("Monkey patches applied successfully!")

import torchaudio
from tqdm import tqdm
from underthesea import sent_tokenize

from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts

Still getting the same error.