Update app.py

app.py

@@ -136,55 +136,68 @@ class VideoSearch:
                 st.warning("Using example data embeddings")
                 self.dataset = self.load_example_data()
             
-            # Debug the embedding data
-            st.write("Sample video_embed:", self.dataset['video_embed'].iloc[0])
-            st.write("Sample description_embed:", self.dataset['description_embed'].iloc[0])
+            # Debug: Show raw data types and first row
+            st.write("Data Types:", self.dataset.dtypes)
+            st.write("\nFirst row of embeddings:")
+            st.write("video_embed type:", type(self.dataset['video_embed'].iloc[0]))
+            st.write("video_embed content:", self.dataset['video_embed'].iloc[0])
+            st.write("\ndescription_embed type:", type(self.dataset['description_embed'].iloc[0]))
+            st.write("description_embed content:", self.dataset['description_embed'].iloc[0])
 
             # Convert string representations of embeddings back to numpy arrays
-            def parse_embedding(embed_str):
+            def safe_eval_list(s):
                 try:
-                    # Remove any string formatting artifacts
-                    cleaned_str = str(embed_str).strip()
-                    if cleaned_str.startswith('[') and cleaned_str.endswith(']'):
-                        # Split by comma and convert to floats
-                        values = [float(x.strip()) for x in cleaned_str[1:-1].split(',')]
-                        return values
-                    return []
+                    # Clean the string representation
+                    if isinstance(s, str):
+                        s = s.replace('[', '').replace(']', '').strip()
+                        # Split by whitespace and/or commas
+                        numbers = [float(x.strip()) for x in s.split() if x.strip()]
+                        return numbers
+                    elif isinstance(s, list):
+                        return [float(x) for x in s]
+                    else:
+                        st.error(f"Unexpected type for embedding: {type(s)}")
+                        return None
                 except Exception as e:
-                    st.error(f"Error parsing embedding: {e}")
-                    return []
+                    st.error(f"Error parsing embedding: {str(e)}")
+                    st.write("Problematic string:", s)
+                    return None
 
-            # Process embeddings
+            # Process embeddings with detailed error reporting
             video_embeds = []
             text_embeds = []
             
             for idx in range(len(self.dataset)):
                 try:
-                    video_embed = parse_embedding(self.dataset['video_embed'].iloc[idx])
-                    desc_embed = parse_embedding(self.dataset['description_embed'].iloc[idx])
+                    video_embed = safe_eval_list(self.dataset['video_embed'].iloc[idx])
+                    desc_embed = safe_eval_list(self.dataset['description_embed'].iloc[idx])
                     
-                    if video_embed and desc_embed:
+                    if video_embed is not None and desc_embed is not None:
                         video_embeds.append(video_embed)
                         text_embeds.append(desc_embed)
+                    else:
+                        st.warning(f"Skipping row {idx} due to parsing failure")
                 except Exception as e:
-                    st.error(f"Error processing row {idx}: {e}")
+                    st.error(f"Error processing row {idx}: {str(e)}")
+                    st.write("Row data:", self.dataset.iloc[idx])
 
             if video_embeds and text_embeds:
-                self.video_embeds = np.array(video_embeds)
-                self.text_embeds = np.array(text_embeds)
-                st.success(f"Successfully processed {len(video_embeds)} embeddings")
+                try:
+                    self.video_embeds = np.array(video_embeds)
+                    self.text_embeds = np.array(text_embeds)
+                    st.success(f"Successfully processed {len(video_embeds)} embeddings")
+                    st.write("Video embeddings shape:", self.video_embeds.shape)
+                    st.write("Text embeddings shape:", self.text_embeds.shape)
+                except Exception as e:
+                    st.error(f"Error converting to numpy arrays: {str(e)}")
             else:
-                st.warning("Falling back to random embeddings")
+                st.warning("No valid embeddings found, using random embeddings")
                 num_rows = len(self.dataset)
                 self.video_embeds = np.random.randn(num_rows, 384)
                 self.text_embeds = np.random.randn(num_rows, 384)
             
-            # Debug output
-            st.write("Video embeddings shape:", self.video_embeds.shape)
-            st.write("Text embeddings shape:", self.text_embeds.shape)
-            
         except Exception as e:
-            st.error(f"Error preparing features: {e}")
+            st.error(f"Error preparing features: {str(e)}")
             import traceback
             st.write("Traceback:", traceback.format_exc())
             # Create random embeddings as fallback