Refactor predict_dupes.py to implement vectorized calculations for ownership and similarity scores, improving performance. Introduce new functions for weighted ownership and player similarity, while maintaining backward compatibility. Update data type handling for portfolio results to optimize memory usage.

global_func/predict_dupes.py

@@ -5,59 +5,64 @@ import time
 import math
 from difflib import SequenceMatcher
 
-def calculate_weighted_ownership(row_ownerships):
+def calculate_weighted_ownership_vectorized(ownership_array):
     """
-    Calculate weighted ownership based on the formula:
-    (AVERAGE of (each value's average with overall average)) * count - (max - min)
+    Vectorized version of calculate_weighted_ownership using NumPy operations.
     
     Args:
-        row_ownerships: Series containing ownership values in percentage form (e.g., 24.2213 for 24.2213%)
+        ownership_array: 2D array of ownership values (rows x players)
         
     Returns:
-        float: Calculated weighted ownership value
+        array: Calculated weighted ownership values for each row
     """
-    # Drop NaN values and convert percentages to decimals
-    row_ownerships = row_ownerships.dropna() / 100
+    # Convert percentages to decimals and handle NaN values
+    ownership_array = np.where(np.isnan(ownership_array), 0, ownership_array) / 100
     
-    # Get the mean of all ownership values
-    row_mean = row_ownerships.mean()
+    # Calculate row means
+    row_means = np.mean(ownership_array, axis=1, keepdims=True)
     
     # Calculate average of each value with the overall mean
-    value_means = [(val + row_mean) / 2 for val in row_ownerships]
+    value_means = (ownership_array + row_means) / 2
     
     # Take average of all those means
-    avg_of_means = sum(value_means) / len(row_ownerships)
+    avg_of_means = np.mean(value_means, axis=1)
     
     # Multiply by count of values
-    weighted = avg_of_means * (len(row_ownerships) * 1)
+    weighted = avg_of_means * ownership_array.shape[1]
     
-    # Subtract (max - min)
-    weighted = weighted - (row_ownerships.max() - row_ownerships.min())
+    # Subtract (max - min) for each row
+    row_max = np.max(ownership_array, axis=1)
+    row_min = np.min(ownership_array, axis=1)
+    weighted = weighted - (row_max - row_min)
     
-    # Convert back to percentage form to match input format
+    # Convert back to percentage form
     return weighted * 10000
 
-def calculate_player_similarity_score(portfolio, player_columns):
+def calculate_weighted_ownership_wrapper(row_ownerships):
     """
-    Calculate a similarity score that measures how different each row is from all other rows
-    based on actual player selection. Optimized for speed using vectorized operations.
-    Higher scores indicate more unique/different lineups.
+    Wrapper function for the original calculate_weighted_ownership to work with Pandas .apply()
     
     Args:
-        portfolio: DataFrame containing the portfolio data
-        player_columns: List of column names containing player names
+        row_ownerships: Series containing ownership values in percentage form
         
     Returns:
-        Series: Similarity scores for each row
+        float: Calculated weighted ownership value
+    """
+    # Convert Series to 2D array for vectorized function
+    ownership_array = row_ownerships.values.reshape(1, -1)
+    return calculate_weighted_ownership_vectorized(ownership_array)[0]
+
+def calculate_player_similarity_score_vectorized(portfolio, player_columns):
     """
-    # Extract player data
-    player_data = portfolio[player_columns].fillna('')
+    Vectorized version of calculate_player_similarity_score using NumPy operations.
+    """
+    # Extract player data and convert to string array
+    player_data = portfolio[player_columns].astype(str).fillna('').values
     
     # Get all unique players and create a mapping to numeric IDs
     all_players = set()
-    for col in player_columns:
-        unique_vals = player_data[col].unique()
-        for val in unique_vals:
+    for row in player_data:
+        for val in row:
             if isinstance(val, str) and val.strip() != '':
                 all_players.add(val)
     
@@ -69,46 +74,207 @@ def calculate_player_similarity_score(portfolio, player_columns):
     n_rows = len(portfolio)
     binary_matrix = np.zeros((n_rows, n_players), dtype=np.int8)
     
-    for i, (_, row) in enumerate(player_data.iterrows()):
-        for val in row.values:
+    # Vectorized binary matrix creation
+    for i, row in enumerate(player_data):
+        for val in row:
             if isinstance(val, str) and str(val).strip() != '' and str(val) in player_to_id:
                 binary_matrix[i, player_to_id[str(val)]] = 1
     
     # Vectorized Jaccard distance calculation
-    # Use matrix operations to compute all pairwise distances at once
-    similarity_scores = np.zeros(n_rows)
-    
-    # Compute intersection and union matrices
-    # intersection[i,j] = number of players in common between row i and row j
-    # union[i,j] = total number of unique players between row i and row j
     intersection_matrix = np.dot(binary_matrix, binary_matrix.T)
-    
-    # For union, we need: |A ∪ B| = |A| + |B| - |A ∩ B|
     row_sums = np.sum(binary_matrix, axis=1)
     union_matrix = row_sums[:, np.newaxis] + row_sums - intersection_matrix
     
     # Calculate Jaccard distance: 1 - (intersection / union)
-    # Avoid division by zero
     with np.errstate(divide='ignore', invalid='ignore'):
         jaccard_similarity = np.divide(intersection_matrix, union_matrix, 
                                      out=np.zeros_like(intersection_matrix, dtype=float), 
                                      where=union_matrix != 0)
     
-    # Convert similarity to distance and calculate average distance for each row
     jaccard_distance = 1 - jaccard_similarity
     
-    # For each row, calculate average distance to all other rows
-    # Exclude self-comparison (diagonal elements)
+    # Exclude self-comparison and calculate average distance for each row
     np.fill_diagonal(jaccard_distance, 0)
-    row_counts = n_rows - 1  # Exclude self
+    row_counts = n_rows - 1
     similarity_scores = np.sum(jaccard_distance, axis=1) / row_counts
     
-    # Normalize to 0-1 scale where 1 = most unique/different
-    if similarity_scores.max() > similarity_scores.min():
-        similarity_scores = (similarity_scores - similarity_scores.min()) / (similarity_scores.max() - similarity_scores.min())
+    # Normalize to 0-1 scale
+    score_range = similarity_scores.max() - similarity_scores.min()
+    if score_range > 0:
+        similarity_scores = (similarity_scores - similarity_scores.min()) / score_range
     
     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))
+            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' 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):
     if strength_var == 'Weak':
         dupes_multiplier = .75
@@ -143,12 +309,14 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             portfolio['FLEX2_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
             portfolio['FLEX3_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
             portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            portfolio['FLEX5_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
 
-            portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']) / 100
-            portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']) / 100
-            portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']) / 100
-            portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']) / 100
-            portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']) / 100
+            portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
+            portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+            portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+            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_average'] = (portfolio['Own'].max() * .33) / 100
@@ -175,7 +343,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             
             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
+                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_average'] = (portfolio['Own'].max() * .33) / 100
@@ -193,35 +361,63 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
 
     elif site_var == 'Draftkings':
         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', 'FLEX5_Own_percent_rank']
-            own_columns = ['CPT_Own', 'FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own']
+            if sport_var == 'GOLF':
+                dup_count_columns = ['FLEX1_Own_percent_rank', 'FLEX2_Own_percent_rank', 'FLEX3_Own_percent_rank', 'FLEX4_Own_percent_rank', 'FLEX5_Own_percent_rank', 'FLEX6_Own_percent_rank']
+                own_columns = ['FLEX1_Own', 'FLEX2_Own', 'FLEX3_Own', 'FLEX4_Own', 'FLEX5_Own', 'FLEX6_Own']
+            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', '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']]
-            
-            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[:,5].map(maps_dict['own_map'])
-            ])
+            if sport_var == 'GOLF':
+                flex_ownerships = pd.concat([
+                    portfolio.iloc[:,0].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'])
+                ])
+            else:
+                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[:,5].map(maps_dict['own_map'])
+                ])
             flex_rank = flex_ownerships.rank(pct=True)
             
             # Assign ranks back to individual columns using the same rank scale
-            portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
-            portfolio['FLEX1_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-            portfolio['FLEX2_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-            portfolio['FLEX3_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-            portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-            portfolio['FLEX5_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+            if sport_var == 'GOLF':
+                portfolio['FLEX1_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX2_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX3_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX5_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX6_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+
+                portfolio['FLEX1_Own'] = portfolio.iloc[:,0].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX2_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX3_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX4_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX5_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX6_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']).astype('float32') / 100
+            else:    
+                portfolio['CPT_Own_percent_rank'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).rank(pct=True)
+                portfolio['FLEX1_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX2_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX3_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['FLEX5_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
 
-            portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']) / 100
-            portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']) / 100
-            portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']) / 100
-            portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']) / 100
-            portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']) / 100
-            portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']) / 100
+                portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
+                portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+                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_average'] = (portfolio['Own'].max() * .33) / 100
@@ -263,12 +459,12 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 portfolio['FLEX4_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
                 portfolio['FLEX5_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
 
-                portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']) / 100
-                portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']) / 100
-                portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']) / 100
-                portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']) / 100
-                portfolio['FLEX4_Own'] = portfolio.iloc[:,4].map(maps_dict['own_map']) / 100
-                portfolio['FLEX5_Own'] = portfolio.iloc[:,5].map(maps_dict['own_map']) / 100
+                portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
+                portfolio['FLEX1_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX2_Own'] = portfolio.iloc[:,2].map(maps_dict['own_map']).astype('float32') / 100
+                portfolio['FLEX3_Own'] = portfolio.iloc[:,3].map(maps_dict['own_map']).astype('float32') / 100
+                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_average'] = (portfolio['Own'].max() * .33) / 100
@@ -295,7 +491,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 
                 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
+                    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_average'] = (portfolio['Own'].max() * .33) / 100
@@ -348,14 +544,25 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
     portfolio['Lineup Edge'] = portfolio['Win%'] * ((.5 - portfolio['Finish_percentile']) * (Contest_Size / 2.5))
     portfolio['Lineup Edge'] = portfolio.apply(lambda row: row['Lineup Edge'] / (row['Dupes'] + 1) if row['Dupes'] > 0 else row['Lineup Edge'], axis=1)
     portfolio['Lineup Edge'] = portfolio['Lineup Edge'] - portfolio['Lineup Edge'].mean()
-    portfolio['Weighted Own'] = portfolio[own_columns].apply(calculate_weighted_ownership, axis=1)
+    portfolio['Weighted Own'] = portfolio[own_columns].apply(calculate_weighted_ownership_wrapper, axis=1)
     portfolio['Geomean'] = np.power((portfolio[own_columns] * 100).product(axis=1), 1 / len(own_columns))
     
     # Calculate similarity score based on actual player selection
-    portfolio['Diversity'] = calculate_player_similarity_score(portfolio, player_columns)
+    portfolio['Diversity'] = calculate_player_similarity_score_vectorized(portfolio, player_columns)
     
     portfolio = portfolio.drop(columns=dup_count_columns)
     portfolio = portfolio.drop(columns=own_columns)
     portfolio = portfolio.drop(columns=calc_columns)
+    
+    int16_columns_stacks = ['Dupes', 'Size', 'salary']
+    int16_columns_nstacks = ['Dupes', 'salary']
+    float32_columns = ['median', 'Own', 'Finish_percentile', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
+
+    try:
+        portfolio[int16_columns_stacks] = portfolio[int16_columns_stacks].astype('uint16')
+    except:
+        portfolio[int16_columns_nstacks] = portfolio[int16_columns_nstacks].astype('uint16')
+
+    portfolio[float32_columns] = portfolio[float32_columns].astype('float32')
 
-    return portfolio
+    return portfolio