Refactor lineup selection logic in large_field_preset.py to improve accuracy and efficiency. Replaced the previous iterative approach with a method that calculates evenly spaced target similarity scores, ensuring a more precise selection of lineups based on similarity while avoiding duplicates.

global_func/large_field_preset.py

@@ -1,30 +1,29 @@
 import pandas as pd
+import numpy as np
 
 def large_field_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols: list):
-
     excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
     player_columns = [col for col in portfolio.columns if col not in excluded_cols]
     
-    for slack_var in range(1, 20):
-        concat_portfolio = pd.DataFrame(columns=portfolio.columns)
-
-        for team in portfolio['Stack'].unique():
-            rows_to_drop = []
-            working_portfolio = portfolio.copy()
-            working_portfolio = working_portfolio[working_portfolio['Stack'] == team].sort_values(by='Similarity Score', ascending = True)
-            working_portfolio = working_portfolio.reset_index(drop=True)
-            curr_own_type_max = working_portfolio.loc[0, 'median'] + (slack_var / 20 * working_portfolio.loc[0, 'median'])
+    concat_portfolio = portfolio.copy()
+    concat_portfolio = concat_portfolio.sort_values(by='Similarity Score', ascending=True).reset_index(drop=True)
 
-            for i in range(1, len(working_portfolio)):
-                if working_portfolio.loc[i, 'median'] < curr_own_type_max:
-                    rows_to_drop.append(i)
-                else:
-                    curr_own_type_max = working_portfolio.loc[i, 'median'] + (slack_var / 20 * working_portfolio.loc[i, 'median'])
-            
-            working_portfolio = working_portfolio.drop(rows_to_drop).reset_index(drop=True)
-            concat_portfolio = pd.concat([concat_portfolio, working_portfolio])
-
-        if len(concat_portfolio) >= lineup_target:
-            return concat_portfolio.sort_values(by='median', ascending = False).head(lineup_target)
-        
-    return concat_portfolio.sort_values(by='median', ascending = False)
+    # Calculate target similarity scores for linear progression
+    similarity_floor = concat_portfolio['Similarity Score'].min()
+    similarity_ceiling = concat_portfolio['Similarity Score'].max()
+    
+    # Create evenly spaced target similarity scores
+    target_similarities = np.linspace(similarity_floor, similarity_ceiling, lineup_target)
+    
+    # Find the closest lineup to each target similarity score
+    selected_indices = []
+    for target_sim in target_similarities:
+        # Find the index of the closest similarity score
+        closest_idx = (concat_portfolio['Similarity Score'] - target_sim).abs().idxmin()
+        if closest_idx not in selected_indices:  # Avoid duplicates
+            selected_indices.append(closest_idx)
+    
+    # Select the lineups
+    concat_portfolio = concat_portfolio.loc[selected_indices].reset_index(drop=True)
+    
+    return concat_portfolio.sort_values(by='median', ascending=False)