Upload 2 files

config.json

@@ -1,109 +1,40 @@
 {
-   "_name_or_path": "AstraMindAI/xtts2-gpt",
   "architectures": [
     "XttsGPT"
   ],
-  "torch_dtype": "float32",
-  "auto_map": {
-    "AutoConfig": "AstraMindAI/xtts2-gpt--gpt_config.XTTSGPTConfig",
-    "AutoModelForCausalLM": "AstraMindAI/xtts2-gpt--xtts2_gpt_modeling.XttsGPT",
-    "AutoTokenizer": "AstraMindAI/xtts2-gpt--tokenizer.XTTSTokenizerFast"
-  },
-  "activation_function": "gelu",
-  "attn_pdrop": 0.1,
   "audio_config": {
-    "fmax": 8000,
-    "fmin": 0,
-    "hop_length": 256,
     "mel_channels": 80,
-    "mel_norms_file": null,
-    "n_fft": 1024,
     "output_sample_rate": 24000,
-    "power": 1.0,
-    "sample_rate": 22050,
-    "win_length": 1024
+    "sample_rate": 22050
   },
-  "batch_size": 32,
-  "char_limits": {
-    "ar": 166,
-    "cs": 186,
-    "de": 253,
-    "en": 250,
-    "es": 239,
-    "fr": 273,
-    "hu": 224,
-    "it": 213,
-    "ja": 71,
-    "ko": 95,
-    "nl": 251,
-    "pl": 224,
-    "pt": 203,
-    "ru": 182,
-    "tr": 226,
-    "zh": 82
+  "auto_map": {
+    "AutoConfig": "AstraMindAI/xtts2-gpt--gpt_config.XTTSGPTConfig",
+    "AutoModelForCausalLM": "AstraMindAI/xtts2-gpt--xtts2_gpt_modeling.XttsGPT"
   },
-  "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,
+  "gpt_batch_size": 1,
+  "gpt_max_audio_tokens": 605,
   "hidden_size": 1024,
-  "input_sample_rate": 22050,
+  "initializer_range": 0.02,
   "kv_cache": true,
-  "label_smoothing": 0.0,
-  "languages": [
-    "en",
-    "es",
-    "fr",
-    "de",
-    "it",
-    "pt",
-    "pl",
-    "tr",
-    "ru",
-    "nl",
-    "cs",
-    "ar",
-    "zh-cn",
-    "hu",
-    "ko",
-    "ja",
-    "hi"
-  ],
   "layer_norm_epsilon": 1e-05,
   "max_audio_tokens": 605,
-  "max_position_embeddings": 2048,
   "max_prompt_tokens": 70,
-  "max_ref_len": 30,
   "max_text_tokens": 402,
   "model_type": "xtts_gpt",
-  "n_inner": null,
   "num_attention_heads": 16,
-  "num_chars": 255,
+  "num_audio_tokens": 1026,
   "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,
   "scale_attn_by_inverse_layer_idx": false,
-  "sound_norm_refs": false,
   "start_audio_token": 1024,
   "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": 1026
+  "vocab_size": 6681
 }

gpt_config.py

@@ -5,6 +5,14 @@ from transformers.utils import logging
 
 logger = logging.get_logger(__name__)
 
+
+@dataclass
+class GPTAudioConfig:
+    """Configuration for GPT audio processing parameters"""
+    mel_channels: int = 80
+    sample_rate: int = 22050
+    output_sample_rate: int = 24000
+
 @dataclass
 class XTTSAudioConfig:
     """Configuration for audio processing parameters"""
@@ -19,226 +27,112 @@ class XTTSAudioConfig:
     power: float = 1.0
     mel_norms_file: Optional[str] = None
 
+
 class XTTSGPTConfig(PretrainedConfig):
-    """Configuration class for the GPT component of XTTS with automatic legacy conversion"""
+    """Configuration class for the GPT component of XTTS."""
     model_type = "xtts_gpt"
 
     def __init__(
             self,
             # Model architecture
-            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
-            n_inner: Optional[int] = None,  # Added for GPT-2 compatibility
-            max_position_embeddings: int = 2048,  # Added for positional embeddings
-            layer_norm_epsilon: float = 1e-5,  # Added for layer norm
-            activation_function: str = "gelu",  # Added activation function
-            resid_pdrop: float = 0.1,  # Added dropout rates
-            embd_pdrop: float = 0.1,
-            attn_pdrop: float = 0.1,
-
-            # Specific XTTS parameters
-            num_chars: int = 255,
-            batch_size: int = 1,  # Changed from gpt_batch_size
-            max_audio_tokens: int = 605,  # Changed from gpt_max_audio_tokens
-            max_text_tokens: int = 402,  # Changed from gpt_max_text_tokens
-            max_prompt_tokens: int = 70,  # Changed from gpt_max_prompt_tokens
-            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
-            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
-            use_masking_gt_prompt_approach: bool = True,  # Changed from gpt_use_masking_gt_prompt_approach
-            use_perceiver_resampler: bool = True,  # Changed from gpt_use_perceiver_resampler
-            checkpointing: bool = False,  # Changed from gpt_checkpointing
-            train_solo_embeddings: bool = False,  # Changed from gpt_train_solo_embeddings
-
-            # Training parameters
-            enable_redaction: bool = False,
+            hidden_size: int = 1024,  # gpt_n_model_channels in original
+            num_hidden_layers: int = 30,  # gpt_layers in original
+            num_attention_heads: int = 16,  # gpt_n_heads in original
+
+            # Tokenizer settings
+            vocab_size: int = 6681,  # gpt_number_text_tokens in original
+            number_text_tokens: int = 6681,  # Explicit text token vocabulary size
+            start_text_token: Optional[int] = None,
+            stop_text_token: Optional[int] = None,
+
+            # Audio token settings
+            num_audio_tokens: int = 1026,  # gpt_num_audio_tokens in original
+            start_audio_token: int = 1024,  # gpt_start_audio_token in original
+            stop_audio_token: int = 1025,  # gpt_stop_audio_token in original
+
+            # Sequence length settings
+            max_audio_tokens: int = 605,  # gpt_max_audio_tokens in original
+            max_text_tokens: int = 402,  # gpt_max_text_tokens in original
+            max_prompt_tokens: int = 70,  # gpt_max_prompt_tokens in original
+            gpt_max_audio_tokens: int = 605,  # Used for generation
+
+            # Model behavior settings
+            use_masking_gt_prompt_approach: bool = True,  # gpt_use_masking_gt_prompt_approach in original
+            use_perceiver_resampler: bool = True,  # gpt_use_perceiver_resampler in original
             kv_cache: bool = True,
-            perceiver_cond_length_compression: int = 256,
-            label_smoothing: float = 0.0,
+            enable_redaction: bool = False,
 
-            # Generation parameters
-            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,
-            sound_norm_refs: bool = False,
+            # GPT batch settings
+            gpt_batch_size: int = 1,
 
             # Audio processing
-            audio_config: Optional[XTTSAudioConfig] = None,
-
-            # Constants and limits
-            duration_const: int = 102400,
-            char_limits: Optional[Dict[str, int]] = None,
-            languages: Optional[List[str]] = None,
+            audio_config: Optional[Dict] = None,
 
-
-            # GPT-2 compatibility flags
+            # Architecture specifics
+            layer_norm_epsilon: float = 1e-5,
+            initializer_range: float = 0.02,
+            add_cross_attention: bool = False,
             scale_attn_by_inverse_layer_idx: bool = False,
             reorder_and_upcast_attn: bool = False,
-            add_cross_attention: bool = False,
-            tie_word_embeddings: bool = True,
+
+            # Size settings for the decoder
+            decoder_input_dim: int = 1024,
+            architectures=["XttsGPT"],
+            auto_map={
+                "AutoConfig": "AstraMindAI/xtts2-gpt--gpt_config.XTTSGPTConfig",
+                "AutoModelForCausalLM": "AstraMindAI/xtts2-gpt--xtts2_gpt_modeling.XttsGPT",
+            },
             **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,
-                "it": 213, "pt": 203, "pl": 224, "zh": 82,
-                "ar": 166, "cs": 186, "ru": 182, "nl": 251,
-                "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"
-            ]
-
-        super().__init__(
-            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
+        super().__init__(**kwargs)
+        self.architectures = architectures
+        self.auto_map = auto_map
+        self.audio_config = GPTAudioConfig(
+            **audio_config if audio_config is not None else {}
         )
 
-        # Set all attributes
-        self.vocab_size = vocab_size
         self.hidden_size = hidden_size
         self.num_hidden_layers = num_hidden_layers
         self.num_attention_heads = num_attention_heads
-        self.n_inner = n_inner
-        self.max_position_embeddings = max_position_embeddings
-        self.layer_norm_epsilon = layer_norm_epsilon
-        self.activation_function = activation_function
-        self.resid_pdrop = resid_pdrop
-        self.embd_pdrop = embd_pdrop
-        self.attn_pdrop = attn_pdrop
-
-        # XTTS specific
-        self.num_chars = num_chars
-        self.batch_size = batch_size
-        self.max_audio_tokens = max_audio_tokens
-        self.max_text_tokens = max_text_tokens
-        self.max_prompt_tokens = max_prompt_tokens
+
+        self.vocab_size = vocab_size
         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
+
+        self.max_audio_tokens = max_audio_tokens
+        self.max_text_tokens = max_text_tokens
+        self.max_prompt_tokens = max_prompt_tokens
+        self.gpt_max_audio_tokens = gpt_max_audio_tokens
+
         self.use_masking_gt_prompt_approach = use_masking_gt_prompt_approach
         self.use_perceiver_resampler = use_perceiver_resampler
-        self.checkpointing = checkpointing
-        self.train_solo_embeddings = train_solo_embeddings
-
-        # 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
-        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 and other
-        self.audio_config = audio_config
-        self.duration_const = duration_const
-        self.char_limits = char_limits
-        self.languages = languages
-
-        # GPT-2 flags
+        self.enable_redaction = enable_redaction
+
+        self.gpt_batch_size = gpt_batch_size
+
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.initializer_range = initializer_range
+        self.add_cross_attention = add_cross_attention
         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
-
-    @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
+
+        self.decoder_input_dim = decoder_input_dim
 
     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
+        """Convert the config to a dictionary."""
+        output = super().to_dict()
+        output["audio_config"] = asdict(self.audio_config)
+        return output
 
     @classmethod
-    def from_dict(cls, config_dict: Dict, **kwargs) -> 'XTTSGPTConfig':
-        """Create config from dictionary"""
-        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"""
-        if tokenizer is not None:
-            self.number_text_tokens = tokenizer.get_vocab_size()
-            self.start_text_token = tokenizer.bos_token_id
-            self.stop_text_token = tokenizer.eos_token_id
+    def from_dict(cls, config_dict: Dict, *args, **kwargs) -> "XTTSGPTConfig":
+        """Create a config from a dictionary."""
+        return cls(**config_dict)
+
+