removed comments from app.py

app.py

@@ -11,8 +11,6 @@ from transformers import AutoTokenizer, AutoModelForSequenceClassification
 from transformers import BlipProcessor, BlipForConditionalGeneration
 import cv2
 
-# Define the necessary functions
-
 def download_youtube_video(video_url, output_path):
     ydl_opts = {
         'format': 'bestvideo+bestaudio',
@@ -83,7 +81,6 @@ def predict_emotions(caption):
     
     return predicted_emotions
 
-# Load models and processors once at the start
 caption_model_name = "Salesforce/blip-image-captioning-base"
 caption_processor = BlipProcessor.from_pretrained(caption_model_name)
 caption_model = BlipForConditionalGeneration.from_pretrained(caption_model_name)
@@ -92,83 +89,54 @@ emotion_model_name = "j-hartmann/emotion-english-distilroberta-base"
 emotion_tokenizer = AutoTokenizer.from_pretrained(emotion_model_name)
 emotion_model = AutoModelForSequenceClassification.from_pretrained(emotion_model_name)
 
-# Gradio Interface Function
 def analyze_video(video_url):
-    # Set output path for downloads
     global output_path
     output_path = './'
-
-    # Download the video
     video_path = download_youtube_video(video_url, output_path)
-
-    # Convert to mp4 format
     mp4_path = convert_to_mp4(video_path, output_path)
-
-    # Extract audio from the video
     audio_path = extract_audio_from_video(mp4_path)
-
-    # Convert audio to wav format for processing
     audio_wav_path = convert_mp3_to_wav(audio_path)
-
-    # Process the audio using Whisper for transcription
     model_whisper = whisper.load_model("base")
     
     result_whisper = model_whisper.transcribe(audio_wav_path)
     
     transcript = result_whisper['text']
-    
-    # Process text to get emotions
     emotion_dict_text, predicted_emotion_text = process_text(transcript)
-
     
-   # Process the video using image captioning and emotion recognition
-   n_frame_interval = 60  # Process every 60th frame
-   emotion_vectors_video = []
+    n_frame_interval = 60
+    emotion_vectors_video = []
+    video_capture = cv2.VideoCapture(mp4_path)
+    total_frames_video = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    frame_count_video = 0
 
-   # Process the video frames for emotions using BLIP model 
-   video_capture = cv2.VideoCapture(mp4_path)
-   total_frames_video = int(video_capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    while video_capture.isOpened():
+        ret_video, frame_video = video_capture.read()
 
-   frame_count_video = 0
+        if not ret_video or frame_count_video > total_frames_video:
+            break
 
-   while video_capture.isOpened():
-       ret_video, frame_video = video_capture.read()
+        if frame_count_video % n_frame_interval == 0:
+            pixel_values_video = preprocess_frame(frame_video)
+            caption_video = generate_caption(pixel_values_video)
+            predicted_emotions_video, _ = predict_emotions(caption_video)
+            emotion_vectors_video.append(np.array(list(predicted_emotions_video.values())))
 
-       if not ret_video or frame_count_video > total_frames_video:
-           break
+        frame_count_video += 1
 
-       if frame_count_video % n_frame_interval == 0:
-           pixel_values_video = preprocess_frame(frame_video)
-           caption_video = generate_caption(pixel_values_video)
-           predicted_emotions_video, _ = predict_emotions(caption_video)
+    video_capture.release()
 
-           # Collect emotion vectors from frames 
-           emotion_vectors_video.append(np.array(list(predicted_emotions_video.values())))
+    average_emotion_vector_video = np.mean(emotion_vectors_video, axis=0)
+    combined_emotion_vector_final = np.concatenate((np.array(list(emotion_dict_text.values())), average_emotion_vector_video))
+    final_most_predicted_index = np.argmax(combined_emotion_vector_final)
+    final_most_predicted_emotion = list(emotion_dict_text.keys())[final_most_predicted_index]
 
-       frame_count_video += 1
+    return transcript, predicted_emotion_text, final_most_predicted_emotion
 
-   video_capture.release()
-
-   # Aggregate results from video frames 
-   average_emotion_vector_video = np.mean(emotion_vectors_video, axis=0)
-
-   # Combine text and video emotion results 
-   combined_emotion_vector_final= np.concatenate((np.array(list(emotion_dict_text.values())), average_emotion_vector_video))
-
-   final_most_predicted_index= np.argmax(combined_emotion_vector_final)
-   
-   final_most_predicted_emotion= list(emotion_dict_text.keys())[final_most_predicted_index]
-
-   return transcript, predicted_emotion_text, final_most_predicted_emotion
-
-
-# Create Gradio interface 
-iface= gr.Interface(fn=analyze_video,
+iface = gr.Interface(fn=analyze_video,
                      inputs=gr.Textbox(label="YouTube Video URL"),
                      outputs=["text", "text", "text"],
                      title="Multimodal Emotion Recognition",
                      description="Enter a YouTube Video URL to analyze emotions from both audio and visual content.")
-                     
-# Launch the app 
+
 if __name__ == "__main__":
-     iface.launch()
+    iface.launch()