Add 'top_x_presence' calculation to predict_dupes.py for enhanced duplicate prediction accuracy. This new metric counts the presence of top ownership players in the portfolio, refining the dupes calculation by incorporating player ownership dynamics across various contest types.

global_func/predict_dupes.py

@@ -4,6 +4,7 @@ import pandas as pd
 import time
 import math
 from difflib import SequenceMatcher
+import heapq
 
 def calculate_weighted_ownership_vectorized(ownership_array):
     """
@@ -280,6 +281,7 @@ def predict_dupes_vectorized(portfolio, maps_dict, site_var, type_var, Contest_S
 
 # Keep the original function for backward compatibility
 def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, strength_var, sport_var):
+    player_columns = [col for col in portfolio.columns[:5] if col not in ['salary', 'median', 'Own']]
     if strength_var == 'Weak':
         dupes_multiplier = .75
         percentile_multiplier = .90
@@ -290,12 +292,13 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
         dupes_multiplier = 1.25
         percentile_multiplier = 1.10
     max_ownership = max(maps_dict['own_map'].values()) / 100
+    top_x_ownership_keys = heapq.nlargest(len(player_columns), maps_dict['own_map'], key=maps_dict['own_map'].get)
     average_ownership = np.mean(list(maps_dict['own_map'].values())) / 100
     if site_var == 'Fanduel':
         if type_var == 'Showdown':
             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', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio', 'top_x_presence']
             # Get the original player columns (first 5 columns excluding salary, median, Own)
             player_columns = [col for col in portfolio.columns[:5] if col not in ['salary', 'median', 'Own']]
             
@@ -327,10 +330,13 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
             portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
             portfolio['own_rank_percentile'] = portfolio['Own'].rank(pct=True)
+            portfolio['top_x_presence'] = portfolio[player_columns].apply(
+                lambda row: sum(1 for player in row if player in top_x_ownership_keys), axis=1
+            )
             
             # Calculate dupes formula
             portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * (portfolio['Own'] / 100) * Contest_Size + ((portfolio['salary'] - (60000 - portfolio['Own'])) / 100) - ((60000 - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000)))
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
             
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
@@ -343,7 +349,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
             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', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'own_ratio', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio', 'top_x_presence']
             # Get the original player columns (first num_players columns excluding salary, median, Own)
             player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
             
@@ -356,9 +362,12 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
             portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
             portfolio['own_rank_percentile'] = portfolio['Own'].rank(pct=True)
+            portfolio['top_x_presence'] = portfolio[player_columns].apply(
+                lambda row: sum(1 for player in row if player in top_x_ownership_keys), axis=1
+            )
             
             portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (60000 - portfolio['Own'])) / 100) - ((60000 - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000)))
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
                 np.round(portfolio['dupes_calc'], 0) <= 0,
@@ -374,7 +383,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             else:
                 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', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+            calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio', 'top_x_presence']
             # Get the original player columns (first 6 columns excluding salary, median, Own)
             player_columns = [col for col in portfolio.columns[:6] if col not in ['salary', 'median', 'Own']]
             if sport_var == 'GOLF':
@@ -431,10 +440,13 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
             portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
             portfolio['own_rank_percentile'] = portfolio['Own'].rank(pct=True)
+            portfolio['top_x_presence'] = portfolio[player_columns].apply(
+                lambda row: sum(1 for player in row if player in top_x_ownership_keys), axis=1
+            )
             
             # Calculate dupes formula
             portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((50000 - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000)))
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
 
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
@@ -446,7 +458,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             if sport_var == 'CS2':
                 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', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio', 'top_x_presence']
                 # Get the original player columns (first 6 columns excluding salary, median, Own)
                 player_columns = [col for col in portfolio.columns[:6] if col not in ['salary', 'median', 'Own']]
                 
@@ -479,10 +491,13 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
                 portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
                 portfolio['own_rank_percentile'] = portfolio['Own'].rank(pct=True)
+                portfolio['top_x_presence'] = portfolio[player_columns].apply(
+                    lambda row: sum(1 for player in row if player in top_x_ownership_keys), axis=1
+                )
                 
                 # Calculate dupes formula
                 portfolio['dupes_calc'] = ((portfolio['own_product'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 50) - ((50000 - portfolio['salary']) / 50)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000)))
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
 
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
@@ -493,7 +508,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             if sport_var == 'LOL':
                 dup_count_columns = ['CPT_Own_percent_rank', 'TOP_Own_percent_rank', 'JNG_Own_percent_rank', 'MID_Own_percent_rank', 'ADC_Own_percent_rank', 'SUP_Own_percent_rank', 'Team_Own_percent_rank']
                 own_columns = ['CPT_Own', 'TOP_Own', 'JNG_Own', 'MID_Own', 'ADC_Own', 'SUP_Own', 'Team_Own']
-                calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio', 'top_x_presence']
                 # Get the original player columns (first 6 columns excluding salary, median, Own)
                 player_columns = [col for col in portfolio.columns[:7] if col not in ['salary', 'median', 'Own']]
                 
@@ -529,10 +544,13 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
                 portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
                 portfolio['own_rank_percentile'] = portfolio['Own'].rank(pct=True)
-                
+                portfolio['top_x_presence'] = portfolio[player_columns].apply(
+                    lambda row: sum(1 for player in row if player in top_x_ownership_keys), axis=1
+                )
+
                 # Calculate dupes formula
                 portfolio['dupes_calc'] = ((portfolio['own_product'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 50) - ((50000 - portfolio['salary']) / 50)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000)))
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
 
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
@@ -544,7 +562,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
                 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', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                calc_columns = ['own_product', 'own_average', 'own_sum', 'avg_own_rank', 'own_rank_percentile', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio', 'top_x_presence']
                 # Get the original player columns (first num_players columns excluding salary, median, Own)
                 player_columns = [col for col in portfolio.columns[:num_players] if col not in ['salary', 'median', 'Own']]
                 
@@ -557,9 +575,12 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
                 portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
                 portfolio['own_rank_percentile'] = portfolio['Own'].rank(pct=True)
+                portfolio['top_x_presence'] = portfolio[player_columns].apply(
+                    lambda row: sum(1 for player in row if player in top_x_ownership_keys), axis=1
+                )
                 
                 portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((50000 - portfolio['salary']) / 100)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000)))
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
                     np.round(portfolio['dupes_calc'], 0) <= 0,