Refactor player similarity score calculation in predict_dupes function

This update enhances the calculate_player_similarity_score function by replacing the previous Jaccard distance method with SequenceMatcher for improved accuracy in measuring lineup similarity. Each lineup is now represented as a string, allowing for a more efficient comparison process. This change simplifies the logic and ensures consistent handling of player selections.

global_func/predict_dupes.py

@@ -4,6 +4,7 @@ import pandas as pd
 import time
 from fuzzywuzzy import process
 import math
+from difflib import SequenceMatcher
 
 def calculate_weighted_ownership(row_ownerships):
     """
@@ -40,7 +41,7 @@ def calculate_weighted_ownership(row_ownerships):
 def calculate_player_similarity_score(portfolio, player_columns):
     """
     Calculate a similarity score that measures how different each row is from all other rows
-    based on actual player selection (not ownership values).
+    based on actual player selection. Converts each row to a string and uses SequenceMatcher.
     Higher scores indicate more unique/different lineups.
     
     Args:
@@ -50,52 +51,29 @@ def calculate_player_similarity_score(portfolio, player_columns):
     Returns:
         Series: Similarity scores for each row
     """
-    # Extract player data and create a matrix where each row represents a lineup
+    # Extract player data and convert each row to a string
     player_data = portfolio[player_columns].fillna('')
     
-    # Get all unique players across all lineups
-    all_players = set()
-    for col in player_columns:
-        # Only add string values (player names), skip numeric values
-        unique_vals = player_data[col].unique()
-        for val in unique_vals:
-            if isinstance(val, str) and val.strip() != '':
-                all_players.add(val)
+    # Convert each row to a string representation
+    row_strings = []
+    for _, row in player_data.iterrows():
+        # Sort the players to ensure consistent ordering
+        players = sorted([str(val) for val in row.values if str(val).strip() != ''])
+        row_string = '|'.join(players)  # Use pipe as separator
+        row_strings.append(row_string)
     
-    # Convert to sorted list
-    all_players = sorted(list(all_players))
-    
-    # If no valid players found, return zeros
-    if len(all_players) == 0:
-        return np.zeros(len(portfolio))
-    
-    # Create a binary matrix: 1 if player is in lineup, 0 if not
-    binary_matrix = np.zeros((len(portfolio), len(all_players)))
-    
-    for i, row in player_data.iterrows():
-        for j, player in enumerate(all_players):
-            if player in row.values:
-                binary_matrix[i, j] = 1
-    
-    # Calculate Jaccard distance between all pairs of lineups
-    # Jaccard distance = 1 - (intersection / union)
+    # Calculate similarity scores using SequenceMatcher
     similarity_scores = []
     
     for i in range(len(portfolio)):
         distances = []
         for j in range(len(portfolio)):
             if i != j:
-                # Calculate intersection and union
-                intersection = np.sum((binary_matrix[i] == 1) & (binary_matrix[j] == 1))
-                union = np.sum((binary_matrix[i] == 1) | (binary_matrix[j] == 1))
-                
-                # Avoid division by zero
-                if union == 0:
-                    jaccard_distance = 1.0  # Completely different if both are empty
-                else:
-                    jaccard_distance = 1 - (intersection / union)
-                
-                distances.append(jaccard_distance)
+                # Use SequenceMatcher to compare the two row strings
+                similarity_ratio = SequenceMatcher(None, row_strings[i], row_strings[j]).ratio()
+                # Convert similarity to distance (1 - similarity)
+                distance = 1 - similarity_ratio
+                distances.append(distance)
         
         # Average distance to all other lineups
         avg_distance = np.mean(distances) if distances else 0