Add player similarity score calculation to predict_dupes function

This update introduces a new function, calculate_player_similarity_score, which computes a similarity score for each lineup based on player selections. The scores are normalized to a 0-1 scale, where higher values indicate more unique lineups. Additionally, player_columns are dynamically defined based on the portfolio structure to ensure accurate processing of player data.

global_func/predict_dupes.py

@@ -37,6 +37,67 @@ def calculate_weighted_ownership(row_ownerships):
     # Convert back to percentage form to match input format
     return weighted * 10000
 
+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).
+    Higher scores indicate more unique/different lineups.
+    
+    Args:
+        portfolio: DataFrame containing the portfolio data
+        player_columns: List of column names containing player names
+        
+    Returns:
+        Series: Similarity scores for each row
+    """
+    # Extract player data and create a matrix where each row represents a lineup
+    player_data = portfolio[player_columns].fillna('')
+    
+    # Get all unique players across all lineups
+    all_players = set()
+    for col in player_columns:
+        all_players.update(player_data[col].unique())
+    all_players = sorted(list(all_players))
+    
+    # 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)
+    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)
+        
+        # Average distance to all other lineups
+        avg_distance = np.mean(distances) if distances else 0
+        similarity_scores.append(avg_distance)
+    
+    # Normalize to 0-1 scale where 1 = most unique/different
+    similarity_scores = np.array(similarity_scores)
+    if similarity_scores.max() > similarity_scores.min():
+        similarity_scores = (similarity_scores - similarity_scores.min()) / (similarity_scores.max() - similarity_scores.min())
+    
+    return similarity_scores
+
 def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, strength_var, sport_var):
     if strength_var == 'Weak':
         dupes_multiplier = .75
@@ -54,6 +115,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank']
             own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own']
             calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            player_columns = [col for col in portfolio.columns[:5] if col not in ['salary', 'median', 'Own']]
             flex_ownerships = pd.concat([
                 portfolio.iloc[:,1].map(maps_dict['own_map']),
                 portfolio.iloc[:,2].map(maps_dict['own_map']),
@@ -95,6 +157,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
             own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
             calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
             for i in range(1, num_players + 1):
                 portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
                 portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].map(maps_dict['own_map']) / 100
@@ -118,6 +181,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank']
             own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own']
             calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            player_columns = [col for col in portfolio.columns[:6] if col not in ['salary', 'median', 'Own']]
             flex_ownerships = pd.concat([
                 portfolio.iloc[:,1].map(maps_dict['own_map']),
                 portfolio.iloc[:,2].map(maps_dict['own_map']),
@@ -162,6 +226,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 dup_count_columns = ['CPT_Own_percent_rank', 'FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank']
                 own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own']
                 calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                player_columns = [col for col in portfolio.columns[:6] if col not in ['salary', 'median', 'Own']]
                 flex_ownerships = pd.concat([
                     portfolio.iloc[:,1].map(maps_dict['own_map']),
                     portfolio.iloc[:,2].map(maps_dict['own_map']),
@@ -206,6 +271,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 dup_count_columns = [f'player_{i}_percent_rank' for i in range(1, num_players + 1)]
                 own_columns = [f'player_{i}_own' for i in range(1, num_players + 1)]
                 calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
                 for i in range(1, num_players + 1):
                     portfolio[f'player_{i}_percent_rank'] = portfolio.iloc[:,i-1].map(maps_dict['own_percent_rank'])
                     portfolio[f'player_{i}_own'] = portfolio.iloc[:,i-1].map(maps_dict['own_map']) / 100
@@ -263,6 +329,9 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
     portfolio['Lineup Edge'] = portfolio['Lineup Edge'] - portfolio['Lineup Edge'].mean()
     portfolio['Weighted Own'] = portfolio[own_columns].apply(calculate_weighted_ownership, axis=1)
     portfolio['Geomean'] = np.power((portfolio[own_columns] * 100).product(axis=1), 1 / len(own_columns))
+
+    portfolio['Similarity Score'] = calculate_player_similarity_score(portfolio, player_columns)
+
     portfolio = portfolio.drop(columns=dup_count_columns)
     portfolio = portfolio.drop(columns=own_columns)
     portfolio = portfolio.drop(columns=calc_columns)