fixes for speed

app.py

@@ -369,6 +369,26 @@ def get_words(text):
     SOURCE_WORDS_CACHE[text] = words
     return words
 
+def exact_string_search(action1, action2):
+    """Search for exact string matches first"""
+    exact_results = []
+    
+    action1_lower = action1.lower().strip()
+    action2_lower = action2.lower().strip()
+    
+    for k, v in motion_dict.items():
+        source_lower = v["source_annot"].lower()
+        target_lower = v["target_annot"].lower()
+        
+        # Check for exact matches in either annotation
+        cond1 = action1_lower in source_lower or action1_lower in target_lower
+        cond2 = action2_lower in source_lower or action2_lower in target_lower
+        
+        if cond1 and cond2:
+            exact_results.append(v)
+    
+    return exact_results
+
 def search_motions_two_actions(action1, action2):
     """Enhanced substring search with synonym expansion"""
     # Create a cache key for this query
@@ -498,7 +518,7 @@ def search_gpt_semantic(action, top_k=1):
     return result
 
 def search_motions_combined(action1, action2, n_motions):
-    """Optimized combined search approach with synonym expansion"""
+    """Improved combined search approach that prioritizes exact matches"""
     # Create a cache key for this query
     cache_key = f"{action1.lower().strip()}_{action2.lower().strip()}_{n_motions}"
     
@@ -506,49 +526,67 @@ def search_motions_combined(action1, action2, n_motions):
     if cache_key in SEARCH_RESULTS_CACHE:
         return SEARCH_RESULTS_CACHE[cache_key]
     
-    # Perform the search
+    # 1. First try exact string matches
+    exact_results = exact_string_search(action1, action2)
+    
+    if len(exact_results) >= n_motions:
+        # If we have enough exact matches, return them
+        result = (random.sample(exact_results, n_motions), ['EXACT']*n_motions)
+        SEARCH_RESULTS_CACHE[cache_key] = result
+        return result
+    
+    # 2. If not enough exact matches, try the enhanced substring search with synonyms
     string_results = search_motions_two_actions(action1, action2)
     
-    if len(string_results) == 0:
-        # Fallback to purely semantic
-        semantic_res, sem_scores = search_motions_semantic(action1, action2, top_k=2*n_motions)
-        if not semantic_res:
-            result = (get_random_motions(n_motions), ['NA']*n_motions)
-        else:
-            result = (semantic_res[:n_motions], sem_scores[:n_motions])
+    # Filter out any results that are already in exact_results
+    string_results = [r for r in string_results if r not in exact_results]
+    
+    # Combine exact_results with string_results
+    combined_results = list(exact_results)
+    combined_scores = ['EXACT'] * len(exact_results)
+    
+    if len(combined_results) + len(string_results) >= n_motions:
+        # If we have enough combined results, use them
+        needed = n_motions - len(combined_results)
+        if needed > 0:
+            combined_results.extend(random.sample(string_results, needed))
+            combined_scores.extend(['SUBSTR'] * needed)
+        
+        result = (combined_results[:n_motions], combined_scores[:n_motions])
     else:
-        if len(string_results) >= n_motions:
-            result = (random.sample(string_results, n_motions), ['NA']*n_motions)
-        else:
-            needed = n_motions - len(string_results)
-            final_list = list(string_results)
-            scores_ret = ['NA']*len(final_list)
+        # 3. If still not enough, add all substring matches and then use semantic search
+        combined_results.extend(string_results)
+        combined_scores.extend(['SUBSTR'] * len(string_results))
+        
+        # Use semantic search for the remaining needed motions
+        needed = n_motions - len(combined_results)
+        if needed > 0:
+            sem_list, sem_score_list = search_motions_semantic(action1, action2, top_k=2*needed)
             
-            # Fill from semantic
-            sem_list, sem_score_list = search_motions_semantic(action1, action2, top_k=2*n_motions)
-            used_combo = {m["motion_combo"] for m in final_list}
+            # Filter out duplicates
+            used_combo = {m["motion_combo"] for m in combined_results}
             
             for item, score in zip(sem_list, sem_score_list):
                 if item["motion_combo"] not in used_combo:
-                    final_list.append(item)
-                    scores_ret.append(score)
+                    combined_results.append(item)
+                    combined_scores.append(score)
                     used_combo.add(item["motion_combo"])
-                if len(final_list) == n_motions:
+                if len(combined_results) == n_motions:
                     break
             
             # Still short? Fill with random
-            if len(final_list) < n_motions:
-                needed2 = n_motions - len(final_list)
+            if len(combined_results) < n_motions:
+                needed2 = n_motions - len(combined_results)
                 rnd = get_random_motions(needed2)
                 for r in rnd:
                     if r["motion_combo"] not in used_combo:
-                        final_list.append(r)
-                        scores_ret.append('NA')
+                        combined_results.append(r)
+                        combined_scores.append('RANDOM')
                         used_combo.add(r["motion_combo"])
-                    if len(final_list) == n_motions:
+                    if len(combined_results) == n_motions:
                         break
-            
-            result = (final_list[:n_motions], scores_ret[:n_motions])
+        
+        result = (combined_results[:n_motions], combined_scores[:n_motions])
     
     # Cache the results
     SEARCH_RESULTS_CACHE[cache_key] = result
@@ -556,9 +594,21 @@ def search_motions_combined(action1, action2, n_motions):
     return result
 
 def safe_video_update(motion_data, semantic_score, visible=True):
-    """Optimized video update without unnecessary network checks"""
-    ssim = str(round(semantic_score, 2)) if semantic_score != 'NA' else ''
-    actual_annot = f"{motion_data['annotation']} | text sim. : {ssim}"
+    """Optimized video update with match type display"""
+    
+    # Prepare the annotation text based on the match type
+    if semantic_score == 'EXACT':
+        match_info = "Exact Match"
+    elif semantic_score == 'SUBSTR':
+        match_info = "Substring Match"
+    elif semantic_score == 'RANDOM':
+        match_info = "Random Result"
+    else:
+        # For semantic matches, round to 2 decimal places
+        ssim = str(round(semantic_score, 2)) if semantic_score != 'NA' else ''
+        match_info = f"Semantic Match (sim: {ssim})"
+    
+    actual_annot = f"{motion_data['annotation']} | {match_info}"
     
     return [
         gr.update(value=url, visible=visible)
@@ -610,8 +660,20 @@ def update_videos(motions, n_visible, semantic_scores):
                 if i < len(motions[:n_visible]):
                     motion = motions[i]
                     score = semantic_scores[i]
-                    ssim = str(round(score, 2)) if score != 'NA' else ''
-                    actual_annot = f"{motion['annotation']} | text sim. : {ssim}"
+                    
+                    # Handle different score types
+                    if score == 'EXACT':
+                        match_info = "Exact Match"
+                    elif score == 'SUBSTR':
+                        match_info = "Substring Match"
+                    elif score == 'RANDOM':
+                        match_info = "Random Result"
+                    else:
+                        # For semantic matches, round to 2 decimal places
+                        ssim = str(round(score, 2)) if score != 'NA' else ''
+                        match_info = f"Semantic Match (sim: {ssim})"
+                    
+                    actual_annot = f"{motion['annotation']} | {match_info}"
                     updates.extend([
                         gr.update(value=motion["motion_combo"], visible=True),
                         gr.update(value=motion["motion_a"], visible=True),
@@ -909,7 +971,7 @@ def prefetch_videos():
 threading.Thread(target=prefetch_videos).start()
 
 # Print ready message
-print("Demo ready! Optimized code running with synonym-enhanced TF-IDF similarity.")
+print("Demo ready! Optimized code running with exact matching prioritized over synonym-enhanced TF-IDF similarity.")
 
 # Launch the demo
 demo.launch(server_name="0.0.0.0", server_port=7860, share=False)