Update app.py

app.py

@@ -602,46 +602,31 @@ def evaluate_pronunciation():
         temp_dir = os.path.join(OUTPUT_DIR, f"temp_{request_id}")
         os.makedirs(temp_dir, exist_ok=True)
         
-        # Save the uploaded file temporarily
+        # Process user audio
         user_audio_path = os.path.join(temp_dir, "user_audio_input.wav")
         with open(user_audio_path, 'wb') as f:
             f.write(audio_file.read())
-        logger.debug(f"[{request_id}] 📁 User audio saved to {user_audio_path}")
-
-        # Convert to WAV if necessary and ensure correct format
+        
         try:
             logger.info(f"[{request_id}] 🔄 Processing user audio file")
-            # First try using pydub for consistent processing
             audio = AudioSegment.from_file(user_audio_path)
             audio = audio.set_frame_rate(SAMPLE_RATE).set_channels(1)
-
-            # Save processed audio
+            
             processed_path = os.path.join(temp_dir, "processed_user_audio.wav")
             audio.export(processed_path, format="wav")
-            logger.debug(f"[{request_id}] 📁 Processed user audio saved to {processed_path}")
-
-            # Load the processed audio for ASR
+            
             user_waveform, sr = torchaudio.load(processed_path)
             user_waveform = user_waveform.squeeze().numpy()
-            logger.info(f"[{request_id}] ✅ User audio processed successfully: {sr}Hz, length: {len(user_waveform)} samples")
-
-            # Update user_audio_path to processed file
+            logger.info(f"[{request_id}] ✅ User audio processed: {sr}Hz, length: {len(user_waveform)} samples")
+            
             user_audio_path = processed_path
         except Exception as e:
             logger.error(f"[{request_id}] ❌ Audio processing failed: {str(e)}")
-            logger.debug(f"[{request_id}] Stack trace: {traceback.format_exc()}")
-            # Clean up temp directory
-            try:
-                import shutil
-                shutil.rmtree(temp_dir)
-            except:
-                pass
             return jsonify({"error": f"Audio processing failed: {str(e)}"}), 500
 
         # Transcribe user audio
         try:
             logger.info(f"[{request_id}] 🔄 Transcribing user audio")
-            # Process audio for ASR
             inputs = asr_processor(
                 user_waveform,
                 sampling_rate=SAMPLE_RATE,
@@ -650,7 +635,6 @@ def evaluate_pronunciation():
             )
             inputs = {k: v.to(device) for k, v in inputs.items()}
 
-            # Perform ASR
             with torch.no_grad():
                 logits = asr_model(**inputs).logits
             ids = torch.argmax(logits, dim=-1)[0]
@@ -659,37 +643,32 @@ def evaluate_pronunciation():
             logger.info(f"[{request_id}] ✅ User transcription: '{user_transcription}'")
         except Exception as e:
             logger.error(f"[{request_id}] ❌ ASR inference failed: {str(e)}")
-            # Clean up temp directory
-            try:
-                import shutil
-                shutil.rmtree(temp_dir)
-            except:
-                pass
             return jsonify({"error": f"ASR inference failed: {str(e)}"}), 500
 
-        # Compare with reference audios
+        # Process reference files in batches
+        batch_size = 2  # Process 2 files at a time - adjust based on your hardware
         results = []
         best_score = 0
         best_reference = None
         best_transcription = None
-
-        logger.info(f"[{request_id}] 🔄 Beginning comparison with {len(reference_files)} reference files")
-
-        for ref_idx, ref_file in enumerate(reference_files):
+        
+        # Use this if you want to limit the number of files to process
+        max_files_to_check = min(5, len(reference_files))  # Check at most 5 files
+        reference_files = reference_files[:max_files_to_check]
+        
+        logger.info(f"[{request_id}] 🔄 Processing {len(reference_files)} reference files in batches of {batch_size}")
+        
+        # Function to process a single reference file
+        def process_reference_file(ref_file):
+            ref_filename = os.path.basename(ref_file)
             try:
-                ref_filename = os.path.basename(ref_file)
-                logger.info(f"[{request_id}] 🔄 [{ref_idx+1}/{len(reference_files)}] Processing reference file: {ref_filename}")
-
-                # Load reference audio using torchaudio instead of librosa
+                # Load and resample reference audio
                 ref_waveform, ref_sr = torchaudio.load(ref_file)
                 if ref_sr != SAMPLE_RATE:
-                    logger.debug(f"[{request_id}] 🔄 Resampling reference audio from {ref_sr}Hz to {SAMPLE_RATE}Hz")
                     ref_waveform = torchaudio.transforms.Resample(ref_sr, SAMPLE_RATE)(ref_waveform)
                 ref_waveform = ref_waveform.squeeze().numpy()
-                logger.debug(f"[{request_id}] ✅ Reference audio loaded: {len(ref_waveform)} samples")
-
+                
                 # Transcribe reference audio
-                logger.debug(f"[{request_id}] 🔄 Transcribing reference audio: {ref_filename}")
                 inputs = asr_processor(
                     ref_waveform,
                     sampling_rate=SAMPLE_RATE,
@@ -697,50 +676,61 @@ def evaluate_pronunciation():
                     language=lang_code
                 )
                 inputs = {k: v.to(device) for k, v in inputs.items()}
-
+                
                 with torch.no_grad():
                     logits = asr_model(**inputs).logits
                 ids = torch.argmax(logits, dim=-1)[0]
                 ref_transcription = asr_processor.decode(ids)
-                logger.info(f"[{request_id}] ✅ Reference transcription for {ref_filename}: '{ref_transcription}'")
-
+                
                 # Calculate similarity
                 similarity = calculate_similarity(user_transcription, ref_transcription)
-                logger.info(f"[{request_id}] 📊 Similarity with {ref_filename}: {similarity:.2f}%")
-
-                results.append({
+                
+                logger.info(f"[{request_id}] 📊 Similarity with {ref_filename}: {similarity:.2f}%, transcription: '{ref_transcription}'")
+                
+                return {
                     "reference_file": ref_filename,
                     "reference_text": ref_transcription,
                     "similarity_score": similarity
-                })
-
-                if similarity > best_score:
-                    best_score = similarity
-                    best_reference = ref_filename
-                    best_transcription = ref_transcription
-                    logger.info(f"[{request_id}] 📊 New best match: {best_reference} with score {best_score:.2f}%")
-
-                    # Add this early exit condition here
-                    if similarity > 80.0:  # If we find a really good match
-                        logger.info(f"[{request_id}] 🏁 Found excellent match (>80%). Stopping evaluation early.")
-                        break  # Exit the loop early
-                    
+                }
             except Exception as e:
-                logger.error(f"[{request_id}] ❌ Error processing reference audio {ref_file}: {str(e)}")
-                logger.debug(f"[{request_id}] Stack trace: {traceback.format_exc()}")
+                logger.error(f"[{request_id}] ❌ Error processing {ref_filename}: {str(e)}")
+                return {
+                    "reference_file": ref_filename,
+                    "reference_text": "Error",
+                    "similarity_score": 0,
+                    "error": str(e)
+                }
+        
+        # Process files in batches using ThreadPoolExecutor
+        from concurrent.futures import ThreadPoolExecutor
+        
+        with ThreadPoolExecutor(max_workers=batch_size) as executor:
+            batch_results = list(executor.map(process_reference_file, reference_files))
+            results.extend(batch_results)
+            
+            # Find the best result
+            for result in batch_results:
+                if result["similarity_score"] > best_score:
+                    best_score = result["similarity_score"]
+                    best_reference = result["reference_file"]
+                    best_transcription = result["reference_text"]
+                    
+                    # Exit early if we found a very good match (optional)
+                    if best_score > 80.0:
+                        logger.info(f"[{request_id}] 🏁 Found excellent match: {best_score:.2f}%")
+                        break
 
         # Clean up temp files
         try:
             import shutil
             shutil.rmtree(temp_dir)
-            logger.debug(f"[{request_id}] 🧹 Cleaned up temporary directory: {temp_dir}")
+            logger.debug(f"[{request_id}] 🧹 Cleaned up temporary directory")
         except Exception as e:
             logger.warning(f"[{request_id}] ⚠️ Failed to clean up temp files: {str(e)}")
 
-        # Enhanced feedback based on score range
+        # Determine feedback based on score
         is_correct = best_score >= 70.0
-        feedback = ""
-
+        
         if best_score >= 90.0:
             feedback = "Perfect pronunciation! Excellent job!"
         elif best_score >= 80.0:
@@ -772,8 +762,17 @@ def evaluate_pronunciation():
     except Exception as e:
         logger.error(f"[{request_id}] ❌ Unhandled exception in evaluation endpoint: {str(e)}")
         logger.debug(f"[{request_id}] Stack trace: {traceback.format_exc()}")
+        
+        # Clean up on error
+        try:
+            import shutil
+            shutil.rmtree(temp_dir)
+        except:
+            pass
+            
         return jsonify({"error": f"Internal server error: {str(e)}"}), 500
 
+
 @app.route("/upload_reference", methods=["POST"])
 def upload_reference_audio():
     try: