Update app.py

app.py

@@ -9,22 +9,65 @@ import os
 from pathlib import Path
 
 class VideoRetrieval:
-    def __init__(self):
+    def __init__(self, use_dummy_data=True):
         self.text_model = SentenceTransformer('all-MiniLM-L6-v2')
-        self.load_data()
+        if use_dummy_data:
+            self.create_dummy_data()
+        else:
+            self.load_data()
+        
+    def create_dummy_data(self):
+        """Create dummy features and metadata for demonstration"""
+        # Create dummy features
+        n_clips = 20
+        feature_dim = 384  # matching the dimension of all-MiniLM-L6-v2
         
-    def load_data(self):
-        # Load pre-computed features
-        # In practice, these would be loaded from your actual feature files
         self.features = {
-            'visual_features': np.load('path_to_visual_features.npy'),
-            'scene_features': np.load('path_to_scene_features.npy'),
-            'object_features': np.load('path_to_object_features.npy')
+            'visual_features': np.random.randn(n_clips, feature_dim),
+            'scene_features': np.random.randn(n_clips, feature_dim),
+            'object_features': np.random.randn(n_clips, feature_dim)
         }
         
-        # Load clip metadata
-        self.clips_df = pd.read_csv('clips_metadata.csv')
+        # Create dummy metadata
+        movie_titles = [
+            "The Matrix", "Inception", "The Dark Knight", "Pulp Fiction",
+            "The Shawshank Redemption", "Forrest Gump", "The Godfather",
+            "Fight Club", "Interstellar", "The Silence of the Lambs"
+        ]
+        
+        descriptions = [
+            "A dramatic confrontation in a dark room where the truth is revealed",
+            "A high-stakes chase through a crowded city street",
+            "An emotional reunion between long-lost friends",
+            "A tense negotiation that determines the fate of many",
+            "A quiet moment of reflection before a life-changing decision"
+        ]
+        
+        data = []
+        for i in range(n_clips):
+            data.append({
+                'clip_id': f'clip_{i}',
+                'movie_title': movie_titles[i % len(movie_titles)],
+                'description': descriptions[i % len(descriptions)],
+                'timestamp': f'{(i*5):02d}:00 - {(i*5+3):02d}:00',
+                'duration': '3:00'
+            })
+        
+        self.clips_df = pd.DataFrame(data)
         
+    def load_data(self):
+        """Load actual pre-computed features and metadata"""
+        try:
+            self.features = {
+                'visual_features': np.load('path_to_visual_features.npy'),
+                'scene_features': np.load('path_to_scene_features.npy'),
+                'object_features': np.load('path_to_object_features.npy')
+            }
+            self.clips_df = pd.read_csv('clips_metadata.csv')
+        except FileNotFoundError as e:
+            st.error(f"Error loading data: {e}. Falling back to dummy data.")
+            self.create_dummy_data()
+    
     def encode_query(self, query_text):
         """Encode the text query into embeddings"""
         return self.text_model.encode(query_text)
@@ -67,88 +110,90 @@ class VideoRetrieval:
                 'movie_title': self.clips_df.iloc[idx]['movie_title'],
                 'description': self.clips_df.iloc[idx]['description'],
                 'timestamp': self.clips_df.iloc[idx]['timestamp'],
-                'similarity_score': combined_similarities[idx]
+                'similarity_score': float(combined_similarities[idx])  # Convert to float for JSON serialization
             })
         
         return results
 
-# Streamlit UI
 def main():
-    st.title("Movie Scene Retrieval System")
+    st.set_page_config(
+        page_title="Movie Scene Retrieval System",
+        page_icon="🎬",
+        layout="wide"
+    )
+    
+    st.title("🎬 Movie Scene Retrieval System")
     st.write("""
     Search for movie scenes using natural language descriptions.
     The system will retrieve the most relevant 2-3 minute clips based on your query.
+    
+    *Note: This is a demo version using simulated data.*
     """)
     
     # Initialize retrieval system
     try:
         retrieval_system = st.session_state.retrieval_system
     except AttributeError:
-        retrieval_system = VideoRetrieval()
+        retrieval_system = VideoRetrieval(use_dummy_data=True)
         st.session_state.retrieval_system = retrieval_system
     
     # Search interface
-    query = st.text_input("Enter your scene description:", 
-                         "A dramatic confrontation between two characters in a dark room")
+    col1, col2 = st.columns([3, 1])
     
-    num_results = st.slider("Number of results to show:", min_value=1, max_value=5, value=3)
+    with col1:
+        query = st.text_input(
+            "Enter your scene description:",
+            placeholder="e.g., A dramatic confrontation between two characters in a dark room"
+        )
     
-    if st.button("Search"):
-        with st.spinner("Searching for relevant clips..."):
-            results = retrieval_system.retrieve_clips(query, top_k=num_results)
-            
-            for i, result in enumerate(results, 1):
-                st.subheader(f"Result {i}: {result['movie_title']}")
-                col1, col2 = st.columns([2, 1])
-                
-                with col1:
-                    st.write("**Scene Description:**")
-                    st.write(result['description'])
-                    st.write(f"**Timestamp:** {result['timestamp']}")
-                
-                with col2:
-                    st.write("**Similarity Score:**")
-                    st.progress(float(result['similarity_score']))
+    with col2:
+        num_results = st.slider("Number of results:", min_value=1, max_value=5, value=3)
+    
+    if st.button("🔍 Search", type="primary"):
+        if not query:
+            st.warning("Please enter a scene description.")
+        else:
+            with st.spinner("Searching for relevant clips..."):
+                results = retrieval_system.retrieve_clips(query, top_k=num_results)
                 
-                # In practice, you would have a way to play the video clip here
-                st.write("---")
+                for i, result in enumerate(results, 1):
+                    with st.container():
+                        st.subheader(f"{result['movie_title']}")
+                        cols = st.columns([2, 1])
+                        
+                        with cols[0]:
+                            st.markdown(f"**Scene Description:**")
+                            st.write(result['description'])
+                            st.text(f"⏱️ Timestamp: {result['timestamp']}")
+                        
+                        with cols[1]:
+                            st.markdown("**Relevance Score:**")
+                            score = min(1.0, max(0.0, result['similarity_score']))
+                            st.progress(score)
+                            st.text(f"{score:.2%} match")
+                        
+                        st.divider()
     
-    # Additional features
+    # Sidebar with additional information
     with st.sidebar:
-        st.header("About")
+        st.header("ℹ️ About")
         st.write("""
-        This system uses pre-computed visual features from several expert models to retrieve
-        relevant movie clips based on natural language descriptions. Features include:
+        This demo system simulates a video retrieval engine that uses:
         
-        - Visual scene understanding
-        - Character interaction analysis
-        - Object detection
-        - Action recognition
+        - 🎥 Visual scene understanding
+        - 👥 Character interaction analysis
+        - 🎯 Object detection
+        - 🎭 Action recognition
+        
+        In a production system, these features would be pre-computed
+        from actual movie clips using state-of-the-art AI models.
         """)
         
-        st.header("Feature Weights")
+        st.header("⚙️ Feature Weights")
         st.write("Current weights used for similarity computation:")
-        st.write("- Visual Features: 40%")
-        st.write("- Scene Features: 30%")
-        st.write("- Object Features: 30%")
+        st.write("- 🎬 Visual Features: 40%")
+        st.write("- 🏞️ Scene Features: 30%")
+        st.write("- 📦 Object Features: 30%")
 
 if __name__ == "__main__":
-    main()
-
-# Requirements.txt
-'''
-streamlit==1.22.0
-pandas==1.5.3
-numpy==1.23.5
-sentence-transformers==2.2.2
-scikit-learn==1.2.2
-torch==2.0.0
-
-streamlit
-pandas
-numpy
-sentence-transformers
-scikit-learn
-torch
-
-'''
+    main()