Delete yarngpt/generate.py

yarngpt/generate.py

@@ -1,151 +0,0 @@
-import os
-import sys
-import logging
-import torch
-import torchaudio
-import numpy as np
-from transformers import AutoTokenizer, AutoProcessor, AutoModelForSpeechSeq2Seq, Speech2Text2Config
-from huggingface_hub import hf_hub_download
-import warnings
-import scipy.io.wavfile as wav
-from datetime import datetime
-import json
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, 
-                   format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Constants
-INIT_TIMESTAMP = "2025-05-21 02:21:23"
-CURRENT_USER = "Abdulhameed556"
-
-class TextToSpeech:
-    def __init__(self, model_name_or_path, processor_name_or_path=None):
-        """Initialize the TextToSpeech class."""
-        self.model_name_or_path = model_name_or_path
-        self.processor_name_or_path = processor_name_or_path or model_name_or_path
-        self.init_time = INIT_TIMESTAMP
-        self.user = CURRENT_USER
-        self.cache_dir = "/code/cache"
-        
-        logger.info(f"Initializing TextToSpeech with model: {model_name_or_path}")
-        
-        try:
-            # Create cache directory if it doesn't exist
-            os.makedirs(self.cache_dir, exist_ok=True)
-            
-            # Create tokenizer files locally if they don't exist
-            self._create_tokenizer_files()
-            
-            # Initialize configuration
-            config = Speech2Text2Config.from_pretrained(
-                pretrained_model_name_or_path=self.model_name_or_path,
-                cache_dir=self.cache_dir,
-                token=os.getenv('HF_TOKEN')
-            )
-            
-            # Initialize tokenizer
-            logger.info("Loading tokenizer...")
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.cache_dir,  # Use local cache directory
-                config=config,
-                token=os.getenv('HF_TOKEN')
-            )
-            
-            # Initialize model
-            logger.info("Loading model...")
-            self.device = "cuda" if torch.cuda.is_available() else "cpu"
-            logger.info(f"Using device: {self.device}")
-            
-            self.model = AutoModelForSpeechSeq2Seq.from_pretrained(
-                self.model_name_or_path,
-                config=config,
-                cache_dir=self.cache_dir,
-                token=os.getenv('HF_TOKEN')
-            ).to(self.device)
-            
-            logger.info("Model initialization complete")
-            
-        except Exception as e:
-            logger.error(f"Error initializing TextToSpeech: {e}")
-            raise
-
-    def _create_tokenizer_files(self):
-        """Create necessary tokenizer files in cache directory."""
-        tokenizer_files = {
-            "tokenizer_config.json": {
-                "name_or_path": self.model_name_or_path,
-                "padding_side": "right",
-                "truncation_side": "right",
-                "model_max_length": 1024,
-                "bos_token": "<s>",
-                "eos_token": "</s>",
-                "unk_token": "<unk>",
-                "pad_token": "<pad>",
-                "mask_token": "<mask>",
-                "special_tokens_map_file": "special_tokens_map.json",
-                "tokenizer_class": "Speech2Text2Tokenizer"
-            },
-            "special_tokens_map.json": {
-                "bos_token": "<s>",
-                "eos_token": "</s>",
-                "pad_token": "<pad>",
-                "unk_token": "<unk>",
-                "mask_token": "<mask>"
-            },
-            "vocab.json": {
-                "<s>": 0,
-                "<pad>": 1,
-                "</s>": 2,
-                "<unk>": 3,
-                "<mask>": 4
-            }
-        }
-        
-        logger.info("Creating tokenizer files in cache directory...")
-        for filename, content in tokenizer_files.items():
-            filepath = os.path.join(self.cache_dir, filename)
-            with open(filepath, 'w', encoding='utf-8') as f:
-                json.dump(content, f, indent=2)
-            logger.info(f"Created {filename}")
-
-    def tts(self, text, speed=1.0):
-        """Generate speech from text."""
-        try:
-            logger.info(f"Processing text: {text[:50]}...")
-            
-            # Tokenize text
-            inputs = self.tokenizer(
-                text,
-                return_tensors="pt",
-                padding=True,
-                truncation=True,
-                max_length=self.tokenizer.model_max_length
-            ).to(self.device)
-            
-            # Generate speech
-            with torch.no_grad():
-                output = self.model.generate(
-                    **inputs,
-                    max_length=500,
-                    num_beams=5,
-                    early_stopping=True
-                )
-            
-            # Convert to audio
-            audio = output[0].cpu().numpy()
-            
-            # Apply speed adjustment if needed
-            if speed != 1.0:
-                audio = np.interp(
-                    np.arange(0, len(audio), speed),
-                    np.arange(0, len(audio)),
-                    audio
-                )
-            
-            return audio.astype(np.float32)
-            
-        except Exception as e:
-            logger.error(f"Error generating speech: {e}")
-            raise