wave running

app.py

@@ -54,10 +54,15 @@ def load_llm_model():
     
     tokenizer = AutoTokenizer.from_pretrained(model_id)
     
-    # Ensure pad token is set to something different than EOS token
-    if tokenizer.pad_token is None:
+    # Check if pad_token is None or if pad_token is the same as eos_token
+    needs_pad_token = (tokenizer.pad_token is None or 
+                      (tokenizer.pad_token == tokenizer.eos_token))
+    
+    if needs_pad_token:
         # Use a different special token as padding token
         tokenizer.add_special_tokens({'pad_token': '[PAD]'})
+        print(f"Changed pad token from {tokenizer.pad_token} to [PAD], different from EOS token: {tokenizer.eos_token}")
+        
         # Resize the token embeddings since we added a new token
         model = AutoModelForCausalLM.from_pretrained(
             model_id,
@@ -66,6 +71,7 @@ def load_llm_model():
         )
         model.resize_token_embeddings(len(tokenizer))
     else:
+        print(f"Pad token ({tokenizer.pad_token}) is already different from EOS token ({tokenizer.eos_token})")
         model = AutoModelForCausalLM.from_pretrained(
             model_id,
             torch_dtype=torch_dtype,
@@ -78,40 +84,73 @@ def load_llm_model():
 
 # Step 3: Text-to-Speech with gTTS (Google Text-to-Speech)
 def gtts_text_to_speech(text):
-    # Create a temporary file
-    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as f:
-        tmp_filename = f.name
-    
-    # Use gTTS to convert text to speech
-    tts = gTTS(text=text, lang='en', slow=False)
+    """Convert text to speech using gTTS and ensure proper WAV format."""
+    # Create temporary files
+    mp3_fd, mp3_filename = tempfile.mkstemp(suffix='.mp3')
+    os.close(mp3_fd)
     
-    # Save as MP3 first (gTTS only outputs MP3)
-    mp3_filename = tmp_filename.replace('.wav', '.mp3')
-    tts.save(mp3_filename)
+    wav_fd, wav_filename = tempfile.mkstemp(suffix='.wav')
+    os.close(wav_fd)
     
-    # Convert MP3 to WAV using FFmpeg if available, otherwise use a fallback
     try:
-        import subprocess
-        subprocess.run(['ffmpeg', '-i', mp3_filename, '-acodec', 'pcm_s16le', '-ar', '24000', '-ac', '1', tmp_filename], 
-                       stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    except (ImportError, FileNotFoundError):
-        # Fallback if FFmpeg is not available
-        from pydub import AudioSegment
-        sound = AudioSegment.from_mp3(mp3_filename)
-        sound = sound.set_frame_rate(24000).set_channels(1)
-        sound.export(tmp_filename, format="wav")
-    
-    # Read the WAV file
-    sample_rate, audio_data = wavfile.read(tmp_filename)
-    
-    # Clean up temporary files
-    os.remove(mp3_filename)
-    os.remove(tmp_filename)
-    
-    # Convert to expected format
-    audio_data = audio_data.reshape(1, -1).astype(np.int16)
-    
-    return (sample_rate, audio_data)
+        # Use gTTS to convert text to speech
+        tts = gTTS(text=text, lang='en', slow=False)
+        tts.save(mp3_filename)
+        
+        # Convert MP3 to WAV - preferred method with ffmpeg
+        try:
+            import subprocess
+            result = subprocess.run(
+                ['ffmpeg', '-y', '-i', mp3_filename, '-acodec', 'pcm_s16le', '-ar', '24000', '-ac', '1', wav_filename], 
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                check=True
+            )
+            
+        except (ImportError, FileNotFoundError, subprocess.CalledProcessError):
+            # Fallback if FFmpeg is not available or fails
+            from pydub import AudioSegment
+            sound = AudioSegment.from_mp3(mp3_filename)
+            sound = sound.set_frame_rate(24000).set_channels(1)
+            sound.export(wav_filename, format="wav")
+        
+        # Verify the WAV file exists and has size
+        if os.path.exists(wav_filename) and os.path.getsize(wav_filename) > 0:
+            # Read the WAV file with scipy
+            try:
+                sample_rate, audio_data = wavfile.read(wav_filename)
+                # Convert to expected format
+                audio_data = audio_data.reshape(1, -1).astype(np.int16)
+                return (sample_rate, audio_data)
+            except Exception as e:
+                print(f"Error reading WAV file with scipy: {e}")
+                # Try alternative approach with pydub
+                try:
+                    from pydub import AudioSegment
+                    sound = AudioSegment.from_file(wav_filename, format="wav")
+                    audio_data = np.array(sound.get_array_of_samples(), dtype=np.int16)
+                    audio_data = audio_data.reshape(1, -1)
+                    return (sound.frame_rate, audio_data)
+                except Exception as e2:
+                    print(f"Error with pydub fallback: {e2}")
+        
+        # If all else fails, generate a simple tone
+        print("Falling back to synthetic audio tone")
+        sample_rate = 24000
+        duration_sec = len(text) * 0.1  # Rough estimate of speech duration
+        tone_length = int(sample_rate * duration_sec)
+        audio_data = np.sin(2 * np.pi * np.arange(tone_length) * 440 / sample_rate)
+        audio_data = (audio_data * 32767).astype(np.int16)
+        audio_data = audio_data.reshape(1, -1)
+        return (sample_rate, audio_data)
+        
+    finally:
+        # Clean up temporary files
+        for filename in [mp3_filename, wav_filename]:
+            try:
+                if os.path.exists(filename):
+                    os.remove(filename)
+            except:
+                pass
 
 # Initialize models
 print("Loading ASR model...")
@@ -144,12 +183,11 @@ def generate_response(prompt):
     full_prompt += "Assistant: "
     
     # Generate response with proper attention mask
-    # Let the tokenizer create the attention mask automatically
     tokenized_inputs = llm_tokenizer(
         full_prompt, 
         return_tensors="pt", 
         padding=True,
-        return_attention_mask=True  # This generates the proper attention mask
+        return_attention_mask=True
     )
     
     # Move to device
@@ -160,7 +198,7 @@ def generate_response(prompt):
     with torch.no_grad():
         output = llm_model.generate(
             input_ids=input_ids,
-            attention_mask=attention_mask,  # Use the tokenizer's attention mask
+            attention_mask=attention_mask,
             max_new_tokens=128,
             do_sample=True,
             temperature=0.7,