Upload 2 files

config.json

@@ -23,7 +23,7 @@
     "sample_rate": 22050,
     "win_length": 1024
   },
-  "batch_size": 1,
+  "batch_size": 32,
   "char_limits": {
     "ar": 166,
     "cs": 186,
@@ -43,13 +43,19 @@
     "zh": 82
   },
   "checkpointing": false,
+  "clvp_checkpoint": null,
   "code_stride_len": 1024,
   "cond_chunk_len": 4,
+  "cond_d_vector_in_each_upsampling_layer": true,
   "cond_len": 30,
+  "d_vector_dim": 512,
+  "decoder_checkpoint": null,
+  "decoder_input_dim": 1024,
   "duration_const": 102400,
   "embd_pdrop": 0.1,
   "enable_redaction": false,
   "hidden_size": 1024,
+  "input_sample_rate": 22050,
   "kv_cache": true,
   "label_smoothing": 0.0,
   "languages": [
@@ -80,10 +86,11 @@
   "model_type": "xtts_gpt",
   "n_inner": null,
   "num_attention_heads": 16,
-  "num_audio_tokens": 1026,
   "num_chars": 255,
   "num_hidden_layers": 30,
   "number_text_tokens": 6681,
+  "output_hop_length": 256,
+  "output_sample_rate": 24000,
   "perceiver_cond_length_compression": 256,
   "reorder_and_upcast_attn": false,
   "resid_pdrop": 0.1,
@@ -93,9 +100,10 @@
   "start_text_token": null,
   "stop_audio_token": 1025,
   "stop_text_token": null,
+  "tokenizer_file": "",
   "train_solo_embeddings": false,
   "transformers_version": "4.46.0",
   "use_masking_gt_prompt_approach": true,
   "use_perceiver_resampler": true,
-  "vocab_size": 256
+  "vocab_size": 1026
 }

gpt_config.py

@@ -1,11 +1,10 @@
-from dataclasses import asdict, dataclass, field
+from dataclasses import asdict, dataclass
 from typing import Dict, Optional, List
 from transformers.configuration_utils import PretrainedConfig
 from transformers.utils import logging
 
 logger = logging.get_logger(__name__)
 
-
 @dataclass
 class XTTSAudioConfig:
     """Configuration for audio processing parameters"""
@@ -20,15 +19,14 @@ class XTTSAudioConfig:
     power: float = 1.0
     mel_norms_file: Optional[str] = None
 
-
 class XTTSGPTConfig(PretrainedConfig):
-    """Configuration class for the GPT component of XTTS"""
+    """Configuration class for the GPT component of XTTS with automatic legacy conversion"""
     model_type = "xtts_gpt"
 
     def __init__(
             self,
             # Model architecture
-            vocab_size: int = 256,
+            vocab_size: int = 1026, # num_audio_tokens
             hidden_size: int = 1024,  # Changed from gpt_n_model_channels
             num_hidden_layers: int = 30,  # Changed from gpt_layers
             num_attention_heads: int = 16,  # Changed from gpt_n_heads
@@ -49,7 +47,6 @@ class XTTSGPTConfig(PretrainedConfig):
             number_text_tokens: int = 6681,  # Changed from gpt_number_text_tokens
             start_text_token: Optional[int] = None,  # Changed from gpt_start_text_token
             stop_text_token: Optional[int] = None,  # Changed from gpt_stop_text_token
-            num_audio_tokens: int = 1026,  # Changed from gpt_num_audio_tokens
             start_audio_token: int = 1024,  # Changed from gpt_start_audio_token
             stop_audio_token: int = 1025,  # Changed from gpt_stop_audio_token
             code_stride_len: int = 1024,  # Changed from gpt_code_stride_len
@@ -65,11 +62,6 @@ class XTTSGPTConfig(PretrainedConfig):
             label_smoothing: float = 0.0,
 
             # Generation parameters
-            #temperature: float = 0.75,
-            #length_penalty: float = 1.0,
-            #repetition_penalty: float = 5.0,
-            #top_k: int = 50,
-            #top_p: float = 0.85,
             cond_len: int = 30,  # Changed from gpt_cond_len
             cond_chunk_len: int = 4,  # Changed from gpt_cond_chunk_len
             max_ref_len: int = 30,
@@ -82,17 +74,29 @@ class XTTSGPTConfig(PretrainedConfig):
             duration_const: int = 102400,
             char_limits: Optional[Dict[str, int]] = None,
             languages: Optional[List[str]] = None,
-            pad_token_id: Optional[int] = None,
-            bos_token_id: Optional[int] = None,
-            eos_token_id: Optional[int] = None,
+
 
             # GPT-2 compatibility flags
             scale_attn_by_inverse_layer_idx: bool = False,
             reorder_and_upcast_attn: bool = False,
             add_cross_attention: bool = False,
             tie_word_embeddings: bool = True,
-            **kwargs,
+            **kwargs
     ):
+        # Handle legacy config conversion
+        if any(k.startswith('gpt_') for k in kwargs):
+            kwargs = self._convert_legacy_config(kwargs)
+
+        if 'model_args' in kwargs:
+            kwargs = self._convert_legacy_config(kwargs['model_args'])
+
+        # Initialize audio config
+        if audio_config is None:
+            audio_config = XTTSAudioConfig()
+        elif isinstance(audio_config, dict):
+            audio_config = XTTSAudioConfig(**audio_config)
+
+        # Set default char limits
         if char_limits is None:
             char_limits = {
                 "en": 250, "de": 253, "fr": 273, "es": 239,
@@ -101,22 +105,21 @@ class XTTSGPTConfig(PretrainedConfig):
                 "tr": 226, "ja": 71, "hu": 224, "ko": 95,
             }
 
+        # Set default languages
         if languages is None:
             languages = [
                 "en", "es", "fr", "de", "it", "pt", "pl", "tr", "ru", "nl",
                 "cs", "ar", "zh-cn", "hu", "ko", "ja", "hi"
             ]
 
-        if audio_config is None:
-            audio_config = XTTSAudioConfig()
-
         super().__init__(
-            pad_token_id=pad_token_id,
-            bos_token_id=bos_token_id,
-            eos_token_id=eos_token_id,
+            pad_token_id=kwargs.pop('pad_token_id', None),
+            bos_token_id=kwargs.pop('bos_token_id', None),
+            eos_token_id=kwargs.pop('eos_token_id', None),
             **kwargs
         )
 
+        # Set all attributes
         self.vocab_size = vocab_size
         self.hidden_size = hidden_size
         self.num_hidden_layers = num_hidden_layers
@@ -129,7 +132,7 @@ class XTTSGPTConfig(PretrainedConfig):
         self.embd_pdrop = embd_pdrop
         self.attn_pdrop = attn_pdrop
 
-        # XTTS specific parameters
+        # XTTS specific
         self.num_chars = num_chars
         self.batch_size = batch_size
         self.max_audio_tokens = max_audio_tokens
@@ -138,7 +141,6 @@ class XTTSGPTConfig(PretrainedConfig):
         self.number_text_tokens = number_text_tokens
         self.start_text_token = start_text_token
         self.stop_text_token = stop_text_token
-        self.num_audio_tokens = num_audio_tokens
         self.start_audio_token = start_audio_token
         self.stop_audio_token = stop_audio_token
         self.code_stride_len = code_stride_len
@@ -147,48 +149,92 @@ class XTTSGPTConfig(PretrainedConfig):
         self.checkpointing = checkpointing
         self.train_solo_embeddings = train_solo_embeddings
 
-        # Training parameters
+        # Training
         self.enable_redaction = enable_redaction
         self.kv_cache = kv_cache
         self.perceiver_cond_length_compression = perceiver_cond_length_compression
         self.label_smoothing = label_smoothing
 
-        # Generation parameters
-        #self.temperature = temperature
-        #self.length_penalty = length_penalty
-        #self.repetition_penalty = repetition_penalty
-        #self.top_k = top_k
-        #self.top_p = top_p
+        # Generation
         self.cond_len = cond_len
         self.cond_chunk_len = cond_chunk_len
         self.max_ref_len = max_ref_len
         self.sound_norm_refs = sound_norm_refs
 
-        # Audio processing
+        # Audio and other
         self.audio_config = audio_config
-
-        # Constants and limits
         self.duration_const = duration_const
         self.char_limits = char_limits
         self.languages = languages
 
-        # GPT-2 compatibility flags
+        # GPT-2 flags
         self.scale_attn_by_inverse_layer_idx = scale_attn_by_inverse_layer_idx
         self.reorder_and_upcast_attn = reorder_and_upcast_attn
         self.add_cross_attention = add_cross_attention
         self.tie_word_embeddings = tie_word_embeddings
 
-    def to_dict(self):
+    @staticmethod
+    def _convert_legacy_config(config_dict: Dict) -> Dict:
+        """Converts legacy config format to new format."""
+        mapping = {
+            'gpt_batch_size': 'batch_size',
+            'gpt_max_audio_tokens': 'max_audio_tokens',
+            'gpt_max_text_tokens': 'max_text_tokens',
+            'gpt_max_prompt_tokens': 'max_prompt_tokens',
+            'gpt_layers': 'num_hidden_layers',
+            'gpt_n_model_channels': 'hidden_size',
+            'gpt_n_heads': 'num_attention_heads',
+            'gpt_number_text_tokens': 'number_text_tokens',
+            'gpt_start_text_token': 'start_text_token',
+            'gpt_stop_text_token': 'stop_text_token',
+            'gpt_num_audio_tokens': 'vocab_size',
+            'gpt_start_audio_token': 'start_audio_token',
+            'gpt_stop_audio_token': 'stop_audio_token',
+            'gpt_code_stride_len': 'code_stride_len',
+            'gpt_use_masking_gt_prompt_approach': 'use_masking_gt_prompt_approach',
+            'gpt_use_perceiver_resampler': 'use_perceiver_resampler',
+            'gpt_checkpointing': 'checkpointing',
+            'gpt_train_solo_embeddings': 'train_solo_embeddings',
+            'gpt_cond_len': 'cond_len',
+            'gpt_cond_chunk_len': 'cond_chunk_len'
+        }
+
+        new_config = {}
+
+        # Convert keys
+        for old_key, new_key in mapping.items():
+            if old_key in config_dict:
+                new_config[new_key] = config_dict[old_key]
+
+        # Copy non-mapped keys
+        for k, v in config_dict.items():
+            if not k.startswith('gpt_') and k not in new_config:
+                new_config[k] = v
+
+        # Handle audio config
+        if 'input_sample_rate' in config_dict or 'output_sample_rate' in config_dict:
+            audio_config = {
+                'sample_rate': config_dict.get('input_sample_rate', 22050),
+                'output_sample_rate': config_dict.get('output_sample_rate', 24000),
+                'hop_length': config_dict.get('output_hop_length', 256)
+            }
+            new_config['audio_config'] = audio_config
+
+        return new_config
+
+    def to_dict(self) -> Dict:
         """Convert config to dictionary"""
         config_dict = super().to_dict()
         config_dict["audio_config"] = asdict(self.audio_config)
         return config_dict
 
     @classmethod
-    def from_dict(cls, config_dict, *args, **kwargs):
+    def from_dict(cls, config_dict: Dict, **kwargs) -> 'XTTSGPTConfig':
         """Create config from dictionary"""
-        audio_config = XTTSAudioConfig(**config_dict.pop("audio_config", {}))
-        return cls(audio_config=audio_config, **config_dict, **kwargs)
+        if isinstance(config_dict.get("audio_config"), dict):
+            audio_config = XTTSAudioConfig(**config_dict["audio_config"])
+            config_dict["audio_config"] = audio_config
+        return cls(**config_dict, **kwargs)
 
     def update_with_tokenizer(self, tokenizer=None):
         """Update configuration values based on tokenizer"""