Enhance predict_dupes function by adding max_salary parameter for improved salary handling and adjusting sample range slider step in app.py for better user experience.

app.py

@@ -1093,7 +1093,7 @@ with tab2:
             st.session_state['working_frame']['median'] = st.session_state['working_frame']['median'].astype('float32')
             st.session_state['working_frame']['salary'] = st.session_state['working_frame']['salary'].astype('uint16')
             
-            st.session_state['base_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
+            st.session_state['base_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
             st.session_state['working_frame'] = st.session_state['base_frame'].copy()
             # st.session_state['highest_owned_teams'] = st.session_state['projections_df'][~st.session_state['projections_df']['position'].isin(['P', 'SP'])].groupby('team')['ownership'].sum().sort_values(ascending=False).head(3).index.tolist()
             # st.session_state['highest_owned_pitchers'] = st.session_state['projections_df'][st.session_state['projections_df']['position'].isin(['P', 'SP'])]['player_names'].sort_values(by='ownership', ascending=False).head(3).tolist()
@@ -1441,7 +1441,7 @@ with tab2:
                 with st.form(key='Stratification'):
                     sorting_choice = st.selectbox("Stat Choice", options=['median', 'Own', 'Weighted Own', 'Geomean', 'Lineup Edge', 'Finish_percentile', 'Diversity'], index=0)
                     lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1)
-                    strat_sample = st.slider("Sample range", value=[0.0, 100.0], min_value=0.0, max_value=100.0, step=0.05)
+                    strat_sample = st.slider("Sample range", value=[0.0, 100.0], min_value=0.0, max_value=100.0, step=1.0)
                     submitted_col, export_col = st.columns(2)
                     st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                     with submitted_col:

global_func/predict_dupes.py

@@ -4,7 +4,6 @@ import pandas as pd
 import time
 import math
 from difflib import SequenceMatcher
-import heapq
 
 def calculate_weighted_ownership_vectorized(ownership_array):
     """
@@ -106,182 +105,8 @@ def calculate_player_similarity_score_vectorized(portfolio, player_columns):
     
     return similarity_scores
 
-def predict_dupes_vectorized(portfolio, maps_dict, site_var, type_var, Contest_Size, strength_var, sport_var):
-    """
-    Vectorized version of predict_dupes using NumPy arrays for better performance.
-    """
-    # Set multipliers based on strength
-    if strength_var == 'Weak':
-        dupes_multiplier = 0.75
-        percentile_multiplier = 0.90
-    elif strength_var == 'Average':
-        dupes_multiplier = 1.00
-        percentile_multiplier = 1.00
-    elif strength_var == 'Sharp':
-        dupes_multiplier = 1.25
-        percentile_multiplier = 1.10
-    
-    max_ownership = max(maps_dict['own_map'].values()) / 100
-    average_ownership = np.mean(list(maps_dict['own_map'].values())) / 100
-    
-    # Convert portfolio to NumPy arrays for faster operations
-    portfolio_values = portfolio.values
-    n_rows = len(portfolio)
-    
-    # Pre-allocate arrays for ownership data
-    if site_var == 'Fanduel':
-        if type_var == 'Showdown':
-            num_players = 5
-            salary_cap = 60000
-            player_cols = list(range(5))  # First 5 columns are players
-        elif type_var == 'Classic':
-            if sport_var == 'WNBA':
-                num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
-                salary_cap = 40000
-                player_cols = list(range(num_players))
-            else:
-                num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
-                salary_cap = 60000
-                player_cols = list(range(num_players))
-    elif site_var == 'Draftkings':
-        if type_var == 'Showdown':
-            num_players = 6
-            salary_cap = 50000
-            player_cols = list(range(6))
-        elif type_var == 'Classic':
-            if sport_var == 'CS2':
-                num_players = 6
-                salary_cap = 50000
-                player_cols = list(range(6))
-            elif sport_var == 'LOL':
-                num_players = 7
-                salary_cap = 50000
-                player_cols = list(range(7))
-            else:
-                num_players = len([col for col in portfolio.columns if col not in ['salary', 'median', 'Own']])
-                salary_cap = 50000
-                player_cols = list(range(num_players))
-    
-    # Pre-allocate ownership arrays
-    ownership_array = np.zeros((n_rows, num_players), dtype=np.float32)
-    ownership_rank_array = np.zeros((n_rows, num_players), dtype=np.float32)
-    
-    # Vectorized ownership mapping
-    for i, col_idx in enumerate(player_cols):
-        if i == 0 and type_var == 'Showdown':  # Captain
-            ownership_array[:, i] = np.vectorize(lambda x: maps_dict['cpt_own_map'].get(x, 0))(portfolio_values[:, col_idx]) / 100
-            ownership_rank_array[:, i] = np.vectorize(lambda x: maps_dict['cpt_own_map'].get(x, 0))(portfolio_values[:, col_idx])
-        else:  # Flex players
-            ownership_array[:, i] = np.vectorize(lambda x: maps_dict['own_map'].get(x, 0))(portfolio_values[:, col_idx]) / 100
-            ownership_rank_array[:, i] = np.vectorize(lambda x: maps_dict['own_map'].get(x, 0))(portfolio_values[:, col_idx])
-    
-    # Calculate ranks for flex players (excluding captain)
-    if type_var == 'Showdown':
-        flex_ownerships = ownership_rank_array[:, 1:].flatten()
-        flex_rank = pd.Series(flex_ownerships).rank(pct=True).values.reshape(n_rows, -1)
-        ownership_rank_array[:, 1:] = flex_rank
-    
-    # Convert to percentile ranks
-    ownership_rank_array = ownership_rank_array / 100
-    
-    # Vectorized calculations
-    own_product = np.prod(ownership_array, axis=1)
-    own_average = (portfolio_values[:, portfolio.columns.get_loc('Own')].max() * 0.33) / 100
-    own_sum = np.sum(ownership_array, axis=1)
-    avg_own_rank = np.mean(ownership_rank_array, axis=1)
-    
-    # Calculate dupes formula vectorized
-    salary_col = portfolio.columns.get_loc('salary')
-    own_col = portfolio.columns.get_loc('Own')
-    
-    dupes_calc = (own_product * avg_own_rank) * Contest_Size + \
-                 ((portfolio_values[:, salary_col] - (salary_cap - portfolio_values[:, own_col])) / 100) - \
-                 ((salary_cap - portfolio_values[:, salary_col]) / 100)
-    
-    dupes_calc *= dupes_multiplier
-    
-    # Round and handle negative values
-    dupes = np.where(np.round(dupes_calc, 0) <= 0, 0, np.round(dupes_calc, 0) - 1)
-    
-    # Calculate own_ratio vectorized
-    max_own_mask = np.any(ownership_array == max_ownership, axis=1)
-    own_ratio = np.where(max_own_mask, 
-                         own_sum / own_average,
-                         (own_sum - max_ownership) / own_average)
-    
-    # Calculate Finish_percentile vectorized
-    percentile_cut_scalar = portfolio_values[:, portfolio.columns.get_loc('median')].max()
-    
-    if type_var == 'Classic':
-        own_ratio_nerf = 2 if sport_var == 'CS2' or sport_var == 'LOL' else 1.5
-    elif type_var == 'Showdown':
-        own_ratio_nerf = 1.5
-    
-    median_col = portfolio.columns.get_loc('median')
-    finish_percentile = (own_ratio - own_ratio_nerf) / ((5 * (portfolio_values[:, median_col] / percentile_cut_scalar)) / 3)
-    finish_percentile = np.where(finish_percentile < 0.0005, 0.0005, finish_percentile / 2)
-    
-    # Calculate other metrics vectorized
-    ref_proj = portfolio_values[:, median_col].max()
-    max_proj = ref_proj + 10
-    min_proj = ref_proj - 10
-    avg_ref = (max_proj + min_proj) / 2
-    
-    win_percent = (((portfolio_values[:, median_col] / avg_ref) - (0.1 + ((ref_proj - portfolio_values[:, median_col])/100))) / (Contest_Size / 1000)) / 10
-    max_allowed_win = (1 / Contest_Size) * 5
-    win_percent = win_percent / win_percent.max() * max_allowed_win
-    
-    finish_percentile = finish_percentile + 0.005 + (0.005 * (Contest_Size / 10000))
-    finish_percentile *= percentile_multiplier
-    win_percent *= (1 - finish_percentile)
-    
-    # Calculate low ownership count vectorized
-    low_own_count = np.sum(ownership_array < 0.10, axis=1)
-    finish_percentile = np.where(low_own_count <= 0, 
-                                finish_percentile, 
-                                finish_percentile / low_own_count)
-    
-    # Calculate Lineup Edge vectorized
-    lineup_edge = win_percent * ((0.5 - finish_percentile) * (Contest_Size / 2.5))
-    lineup_edge = np.where(dupes > 0, lineup_edge / (dupes + 1), lineup_edge)
-    lineup_edge = lineup_edge - lineup_edge.mean()
-    
-    # Calculate Weighted Own vectorized
-    weighted_own = calculate_weighted_ownership_vectorized(ownership_array)
-    
-    # Calculate Geomean vectorized
-    geomean = np.power(np.prod(ownership_array * 100, axis=1), 1 / num_players)
-    
-    # Calculate Diversity vectorized
-    diversity = calculate_player_similarity_score_vectorized(portfolio, player_cols)
-    
-    # Create result DataFrame with optimized data types
-    result_data = {
-        'Dupes': dupes.astype('uint16'),
-        'median': portfolio_values[:, portfolio.columns.get_loc('median')].astype('float32'),
-        'Own': portfolio_values[:, portfolio.columns.get_loc('Own')].astype('float32'),
-        'salary': portfolio_values[:, portfolio.columns.get_loc('salary')].astype('uint16'),
-        'Finish_percentile': finish_percentile.astype('float32'),
-        'Win%': win_percent.astype('float32'),
-        'Lineup Edge': lineup_edge.astype('float32'),
-        'Weighted Own': weighted_own.astype('float32'),
-        'Geomean': geomean.astype('float32'),
-        'Diversity': diversity.astype('float32')
-    }
-    
-    # Add Size column if it exists
-    if 'Size' in portfolio.columns:
-        result_data['Size'] = portfolio_values[:, portfolio.columns.get_loc('Size')].astype('uint16')
-    
-    # Add player columns back
-    for i, col_name in enumerate(portfolio.columns[:num_players]):
-        result_data[col_name] = portfolio_values[:, i]
-    
-    return pd.DataFrame(result_data)
-
 # 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']]
+def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, strength_var, sport_var, max_salary):
     if strength_var == 'Weak':
         dupes_multiplier = .75
         percentile_multiplier = .90
@@ -292,22 +117,22 @@ 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', 'top_x_presence']
+            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']
             # 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']]
             
             flex_ownerships = pd.concat([
-                portfolio.iloc[:,1].map(maps_dict['own_map']),
-                portfolio.iloc[:,2].map(maps_dict['own_map']),
-                portfolio.iloc[:,3].map(maps_dict['own_map']),
-                portfolio.iloc[:,4].map(maps_dict['own_map'])
-            ])
+                    portfolio.iloc[:,1].map(maps_dict['own_map']),
+                    portfolio.iloc[:,2].map(maps_dict['own_map']),
+                    portfolio.iloc[:,3].map(maps_dict['own_map']),
+                    portfolio.iloc[:,4].map(maps_dict['own_map']),
+                    portfolio.iloc[:,5].map(maps_dict['own_map'])
+                ])
             flex_rank = flex_ownerships.rank(pct=True)
             
             # Assign ranks back to individual columns using the same rank scale
@@ -325,31 +150,31 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
             portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
             
-            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
             portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
             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['avg_own_rank'] / 1000) * (Contest_Size / 100) + ((portfolio['salary'] - (60000 - portfolio['Own'])) / 100) - ((59700 - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * (portfolio['Own'] / 100) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
             
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
-                np.round(portfolio['dupes_calc'], 0) <= 0,
+                portfolio['salary'] == max_salary,
+                portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                portfolio['dupes_calc']
+            )
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['Dupes'], 0) <= 0,
                 0, 
-                np.round((portfolio['dupes_calc'] * (1 + portfolio['own_rank_percentile'])), 0) - 1
+                np.round(portfolio['Dupes'], 0) - 1
             )
-            
         elif type_var == 'Classic':
             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', 'top_x_presence']
+            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']
             # 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']]
             
@@ -357,22 +182,23 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 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']).astype('float32') / 100
             
-            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
             portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
             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['avg_own_rank'] / 1000) * (Contest_Size / 100) + ((portfolio['salary'] - (60000 - portfolio['Own'])) / 100) - ((59700 - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
-                np.round(portfolio['dupes_calc'], 0) <= 0,
+                portfolio['salary'] == max_salary,
+                portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                portfolio['dupes_calc']
+            )
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['Dupes'], 0) <= 0,
                 0, 
-                np.round((portfolio['dupes_calc'] * (1 + portfolio['own_rank_percentile'])), 0) - 1
+                np.round(portfolio['Dupes'], 0) - 1
             )
 
     elif site_var == 'Draftkings':
@@ -383,7 +209,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', 'top_x_presence']
+            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']
             # 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':
@@ -435,30 +261,31 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
                 portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
 
-            portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+            portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
             portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
             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['avg_own_rank'] / 1000) * (Contest_Size / 100) + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((49700 - portfolio['salary']) / 100)
-            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
+            portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+            portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
 
             # Round and handle negative values
             portfolio['Dupes'] = np.where(
-                np.round(portfolio['dupes_calc'], 0) <= 0,
+                portfolio['salary'] == max_salary,
+                portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                portfolio['dupes_calc']
+            )
+            portfolio['Dupes'] = np.where(
+                np.round(portfolio['Dupes'], 0) <= 0,
                 0, 
-                np.round((portfolio['dupes_calc'] * (1 + portfolio['own_rank_percentile'])), 0) - 1
+                np.round(portfolio['Dupes'], 0) - 1
             )
         elif type_var == 'Classic':
             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', 'top_x_presence']
+                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']
                 # 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']]
                 
@@ -486,29 +313,30 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
                 portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
 
-                portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+                portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
                 portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
                 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['avg_own_rank'] / 1000) * (Contest_Size / 100) + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((49700 - portfolio['salary']) / 100)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
+                portfolio['dupes_calc'] = ((portfolio['own_product'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 50) - ((max_salary - portfolio['salary']) / 50)
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
 
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
-                    np.round(portfolio['dupes_calc'], 0) <= 0,
+                    portfolio['salary'] == max_salary,
+                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                    portfolio['dupes_calc']
+                )
+                portfolio['Dupes'] = np.where(
+                    np.round(portfolio['Dupes'], 0) <= 0,
                     0, 
-                    np.round((portfolio['dupes_calc'] * (1 + portfolio['own_rank_percentile'])), 0) - 1
+                    np.round(portfolio['Dupes'], 0) - 1
                 )
             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', 'top_x_presence']
+                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']
                 # 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']]
                 
@@ -539,30 +367,31 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['SUP_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
                 portfolio['Team_Own'] = portfolio.iloc[:,6].map(maps_dict['own_map']).astype('float32') / 100
 
-                portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+                portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
                 portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
                 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['avg_own_rank'] / 1000) * (Contest_Size / 100) + ((portfolio['salary'] - (50000 - portfolio['Own'])) / 100) - ((49700 - portfolio['salary']) / 100)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
+                portfolio['dupes_calc'] = ((portfolio['own_product'] * 10) * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 50) - ((max_salary - portfolio['salary']) / 50)
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
 
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
-                    np.round(portfolio['dupes_calc'], 0) <= 0,
+                    portfolio['salary'] == max_salary,
+                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                    portfolio['dupes_calc']
+                )
+                portfolio['Dupes'] = np.where(
+                    np.round(portfolio['Dupes'], 0) <= 0,
                     0, 
-                    np.round((portfolio['dupes_calc'] * (1 + portfolio['own_rank_percentile'])), 0) - 1
+                    np.round(portfolio['Dupes'], 0) - 1
                 )
-            elif sport_var != 'CS2' and sport_var != 'LOL':
+            elif sport_var == 'GOLF':
                 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', 'top_x_presence']
+                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']
                 # 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']]
                 
@@ -570,23 +399,55 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                     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']).astype('float32') / 100
                 
-                portfolio['own_product'] = (portfolio[own_columns].product(axis=1))
+                portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
                 portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
                 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'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
+                # Round and handle negative values
+                portfolio['Dupes'] = np.where(
+                    portfolio['salary'] == max_salary,
+                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                    portfolio['dupes_calc']
                 )
+                portfolio['Dupes'] = np.where(
+                    np.round(portfolio['Dupes'], 0) <= 0,
+                    0, 
+                    np.round(portfolio['Dupes'], 0) - 1
+                )
+            else:
+                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', 'dupes_calc', 'low_own_count', 'Ref_Proj', 'Max_Proj', 'Min_Proj', 'Avg_Ref', 'own_ratio']
+                # 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']]
                 
-                portfolio['dupes_calc'] = (portfolio['avg_own_rank'] / 1000) * (Contest_Size / 100) + ((portfolio['salary'] - (50000 - (portfolio['Own'] * 100))) / 100) - ((49700 - portfolio['salary']) / 100)
-                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * ((portfolio['Own'] * 100) / (100 + (Contest_Size / 1000))) * portfolio['top_x_presence']
+                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']).astype('float32') / 100
+                
+                portfolio['own_product'] = (portfolio[own_columns].product(axis=1)) * max(Contest_Size / 10000, 1)
+                portfolio['own_average'] = (portfolio['Own'].max() * .33) / 100
+                portfolio['own_sum'] = portfolio[own_columns].sum(axis=1)
+                portfolio['avg_own_rank'] = portfolio[dup_count_columns].mean(axis=1)
+                
+                portfolio['dupes_calc'] = (portfolio['own_product'] * portfolio['avg_own_rank']) * Contest_Size + ((portfolio['salary'] - (max_salary - portfolio['Own'])) / 100) - ((max_salary - portfolio['salary']) / 100)
+                portfolio['dupes_calc'] = portfolio['dupes_calc'] * dupes_multiplier * (portfolio['Own'] / (90 + (Contest_Size / 1000)))
                 # Round and handle negative values
                 portfolio['Dupes'] = np.where(
-                    np.round(portfolio['dupes_calc'], 0) <= 0,
+                    portfolio['salary'] == max_salary,
+                    portfolio['dupes_calc'] + (portfolio['dupes_calc'] * .10), 
+                    portfolio['dupes_calc']
+                )
+                portfolio['Dupes'] = np.where(
+                    np.round(portfolio['Dupes'], 0) <= 0,
                     0, 
-                    np.round((portfolio['dupes_calc'] * (1 + portfolio['own_rank_percentile'])), 0) - 1
+                    np.round(portfolio['Dupes'], 0) - 1
                 )
+                
 
     portfolio['Dupes'] = np.round(portfolio['Dupes'], 0)
     portfolio['own_ratio'] = np.where(
@@ -594,7 +455,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
         portfolio['own_sum'] / portfolio['own_average'],
         (portfolio['own_sum'] - max_ownership) / portfolio['own_average']
     )
-    percentile_cut_scalar = portfolio['median'].max()
+    percentile_cut_scalar = portfolio['median'].max()  # Get scalar value
     if type_var == 'Classic':
         if sport_var == 'CS2':
             own_ratio_nerf = 2
@@ -633,8 +494,6 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
     
     # Calculate similarity score based on actual player selection
     portfolio['Diversity'] = calculate_player_similarity_score_vectorized(portfolio, player_columns)
-
-    st.table(portfolio.sort_values(by='Dupes', ascending=False).head(10))
     
     portfolio = portfolio.drop(columns=dup_count_columns)
     portfolio = portfolio.drop(columns=own_columns)