Update app.py

app.py

@@ -1,3 +1,4 @@
+
 import streamlit as st
 import numpy as np
 import librosa
@@ -51,9 +52,8 @@ class TwiTranscriptionModel:
         return transcriptions
 
 @st.cache_resource
-def load_model():
+def get_model():
     try:
-        # Modify this path if your model is stored differently in Hugging Face
         with open('twi_transcription_model.pkl', 'rb') as f:
             model_data = pickle.load(f)
             return TwiTranscriptionModel(
@@ -88,6 +88,49 @@ def calculate_error_rates(reference, hypothesis):
     except Exception as e:
         return None, None
 
+def process_audio_file(audio_file, model, reference_text=None):
+    """Process uploaded audio file and return transcription"""
+    try:
+        # Read audio file
+        audio_data, sr = librosa.load(audio_file, sr=None)
+        if len(audio_data.shape) > 1:
+            audio_data = np.mean(audio_data, axis=1)
+        
+        # Extract features
+        mfcc_features = extract_mfcc(audio_data, sr)
+        mfcc_features = np.expand_dims(mfcc_features, axis=0)
+        
+        # Get transcription
+        transcription = model.predict(mfcc_features)[0]
+        
+        # Prepare response
+        response = {
+            'status': 'success',
+            'transcription': transcription,
+            'audio_details': {
+                'sample_rate': int(sr),
+                'duration': float(len(audio_data) / sr)
+            },
+            'audio_data': audio_data,
+            'sample_rate': sr
+        }
+        
+        # Add error metrics if reference provided
+        if reference_text:
+            error_wer, error_cer = calculate_error_rates(reference_text, transcription)
+            if error_wer is not None and error_cer is not None:
+                response['error_metrics'] = {
+                    'word_error_rate': round(float(error_wer), 4),
+                    'character_error_rate': round(float(error_cer), 4)
+                }
+        
+        return response
+    except Exception as e:
+        return {
+            'status': 'error',
+            'error': str(e)
+        }
+
 def main():
     st.set_page_config(
         page_title="Twi Speech Recognition",
@@ -95,77 +138,55 @@ def main():
         layout="wide"
     )
     
-    # Load the model
-    model = load_model()
+    # Initialize model
+    model = get_model()
     if model is None:
-        st.error("Failed to load model. Please check model file.")
+        st.error("Failed to load model. Please try again later.")
         return
 
-    st.title("Twi Speech Transcription")
-    st.write("Upload an audio file to transcribe Twi speech")
+    st.title("Twi Speech Recognition")
+    st.write("Upload an audio file for transcription")
     
     # File uploader
     audio_file = st.file_uploader("Choose an audio file", type=['wav', 'mp3', 'ogg'])
     
     # Optional reference text
-    reference_text = st.text_area("Reference text (optional)", 
-                                  help="Enter the correct transcription to calculate error rates")
+    reference_text = st.text_area("Reference text (optional)", "", help="Enter the correct transcription to calculate error rates")
     
     if audio_file is not None:
         if st.button("Transcribe"):
-            with st.spinner("Processing audio... This may take a moment."):
-                try:
-                    # Read audio file
-                    audio_data, sr = librosa.load(audio_file, sr=None)
-                    if len(audio_data.shape) > 1:
-                        audio_data = np.mean(audio_data, axis=1)
-                    
-                    # Extract features
-                    mfcc_features = extract_mfcc(audio_data, sr)
-                    mfcc_features = np.expand_dims(mfcc_features, axis=0)
-                    
-                    # Get transcription
-                    transcription = model.predict(mfcc_features)[0]
-                    
-                    # Display results
-                    st.success("Transcription completed!")
-                    
-                    # Audio Playback
-                    st.audio(audio_file, format='audio/wav')
-                    
-                    # Transcription Display
-                    st.write("### Transcription:")
-                    st.write(transcription)
-                    
-                    # Audio Details
-                    st.write("### Audio Details:")
-                    st.json({
-                        'sample_rate': int(sr),
-                        'duration': float(len(audio_data) / sr)
-                    })
-                    
-                    # Error Metrics (if reference text provided)
-                    if reference_text:
-                        error_wer, error_cer = calculate_error_rates(reference_text, transcription)
-                        if error_wer is not None and error_cer is not None:
-                            st.write("### Error Metrics:")
-                            st.json({
-                                'word_error_rate': round(float(error_wer), 4),
-                                'character_error_rate': round(float(error_cer), 4)
-                            })
+            with st.spinner("Processing audio... This may take a few minutes."):
+                result = process_audio_file(
+                    audio_file,
+                    model,
+                    reference_text if reference_text else None
+                )
+            
+            if result['status'] == 'success':
+                st.success("Transcription completed!")
+                
+                # Convert audio data to bytes for Streamlit audio player
+                audio_bytes = BytesIO()
+                sf.write(audio_bytes, result['audio_data'], result['sample_rate'], format='WAV')
+                audio_bytes.seek(0)
+                
+                # Audio Playback
+                st.audio(audio_bytes, format='audio/wav')
+                
+                # Transcription Display
+                st.write("### Transcription:")
+                st.write(result['transcription'])
+                
+                # Audio Details
+                st.write("### Audio Details:")
+                st.json(result['audio_details'])
                 
-                except Exception as e:
-                    st.error(f"Error processing audio: {str(e)}")
+                # Error Metrics
+                if 'error_metrics' in result:
+                    st.write("### Error Metrics:")
+                    st.json(result['error_metrics'])
+            else:
+                st.error(f"Error: {result.get('error', 'Unknown error')}")
 
 if __name__ == "__main__":
-    main()
-
-# Requirements for Hugging Face (create a requirements.txt)
-"""
-streamlit
-numpy
-librosa
-tensorflow
-jiwer
-soundfile
-"""
+    main()