Update app.py

app.py

@@ -1,44 +1,51 @@
 import gradio as gr
-import speech_recognition as sr
 from pydub import AudioSegment
 import tempfile
 from langdetect import detect
 import os
 import asyncio
+import torch
+from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor
 from telegram import Update
 from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
 
 # Telegram bot token (to be set via Hugging Face Space secrets)
 TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
 
+# Load the Hugging Face model and processor for transcription
+processor = Wav2Vec2Processor.from_pretrained("facebook/wav2vec2-base-960h")
+model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
+
 # Process audio and transcribe
 def process_audio(audio_input):
-    recognizer = sr.Recognizer()
-
-    # Convert all audio inputs to WAV format
+    # Convert all audio inputs to WAV format with 16kHz sample rate (required by wav2vec2)
     with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
         if isinstance(audio_input, tuple):  # Recorded audio (sample_rate, numpy_array)
             sample_rate, audio_data = audio_input
-            AudioSegment(audio_data, sample_rate=sample_rate, frame_rate=sample_rate, channels=1).export(temp_file.name, format="wav")
+            audio_segment = AudioSegment(audio_data, sample_rate=sample_rate, frame_rate=sample_rate, channels=1)
         else:  # Uploaded audio file (file path or Telegram file)
-            audio = AudioSegment.from_file(audio_input)
-            audio = audio.set_channels(1)  # Convert to mono for consistency
-            audio.export(temp_file.name, format="wav")
+            audio_segment = AudioSegment.from_file(audio_input).set_channels(1)
+        
+        # Resample to 16kHz (required by wav2vec2)
+        audio_segment = audio_segment.set_frame_rate(16000)
+        audio_segment.export(temp_file.name, format="wav")
         audio_file_path = temp_file.name
 
-    # Debug: Check if the WAV file is valid
-    if os.path.getsize(audio_file_path) == 0:
-        raise ValueError("The converted WAV file is empty. The input audio may be corrupted.")
-
-    # Transcribe the WAV file using pocketsphinx (offline)
-    with sr.AudioFile(audio_file_path) as source:
-        audio = recognizer.record(source)
-        try:
-            transcription = recognizer.recognize_sphinx(audio)  # Use pocketsphinx for offline transcription
-        except sr.UnknownValueError:
-            transcription = "Could not understand the audio."
-        except sr.RequestError as e:
-            transcription = f"Transcription failed: {str(e)}"
+    # Load the WAV file for transcription
+    import soundfile as sf
+    audio_data, sample_rate = sf.read(audio_file_path)
+    assert sample_rate == 16000, "Sample rate must be 16kHz"
+
+    # Preprocess audio for the model
+    inputs = processor(audio_data, sampling_rate=sample_rate, return_tensors="pt", padding=True)
+
+    # Perform transcription
+    with torch.no_grad():
+        logits = model(inputs.input_values).logits
+
+    # Decode the logits to text
+    predicted_ids = torch.argmax(logits, dim=-1)
+    transcription = processor.batch_decode(predicted_ids)[0]
 
     # Detect language
     try: