Similarity Score > Diversity

app.py

@@ -824,7 +824,7 @@ with tab2:
                     if submitted:
                         del st.session_state['working_frame']
         
-        excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
+        excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
 
         if 'working_frame' not in st.session_state:
             st.session_state['working_frame'] = st.session_state['origin_portfolio'].copy()
@@ -954,7 +954,7 @@ with tab2:
                     'Lineup Edge': st.session_state['working_frame']['Lineup Edge'],
                     'Weighted Own': st.session_state['working_frame']['Weighted Own'],
                     'Geomean': st.session_state['working_frame']['Geomean'],
-                    'Similarity Score': st.session_state['working_frame']['Similarity Score']
+                    'Diversity': st.session_state['working_frame']['Diversity']
                 }
 
             if 'trimming_dict_maxes' not in st.session_state:
@@ -964,7 +964,7 @@ with tab2:
                     'Weighted Own': st.session_state['working_frame']['Weighted Own'].max(),
                     'median': st.session_state['working_frame']['median'].max(),
                     'Finish_percentile': st.session_state['working_frame']['Finish_percentile'].max(),
-                    'Similarity Score': st.session_state['working_frame']['Similarity Score'].max()
+                    'Diversity': st.session_state['working_frame']['Diversity'].max()
                 }
 
         with st.sidebar:
@@ -975,7 +975,7 @@ with tab2:
                     'Weighted Own': 500.0,
                     'median': 500.0,
                     'Finish_percentile': 1.0,
-                    'Similarity Score': 1.0
+                    'Diversity': 1.0
                 }
             with st.expander('Macro Filter Options'):
                 with st.form(key='macro_filter_form'):
@@ -1083,7 +1083,7 @@ with tab2:
                     with perf_var:
                         performance_type = st.selectbox("Sorting variable", ['median', 'Own', 'Weighted Own'], key='sort_var')
                     with own_var:
-                        own_type = st.selectbox("Trimming variable", ['Own', 'Geomean', 'Weighted Own', 'Similarity Score'], key='trim_var')
+                        own_type = st.selectbox("Trimming variable", ['Own', 'Geomean', 'Weighted Own', 'Diversity'], key='trim_var')
 
                     trim_slack_var = st.number_input("Trim slack (percentile addition to trimming variable ceiling)", value=0.0, min_value=0.0, max_value=1.0, step=0.1, key='trim_slack')
 
@@ -1112,13 +1112,13 @@ with tab2:
             with st.expander('Presets'):
                 st.info("Still heavily in testing here, I'll announce when they are ready for use.")
                 with st.form(key='Small Field Preset'):
-                    preset_choice = st.selectbox("Preset", options=['Small Field (Heavy Own)', 'Large Field (Manage Similarity)', 'Hedge Chalk (Manage Leverage)', 'Volatility (Heavy Lineup Edge)'], index=0)
+                    preset_choice = st.selectbox("Preset", options=['Small Field (Heavy Own)', 'Large Field (Manage Diversity)', 'Hedge Chalk (Manage Leverage)', 'Volatility (Heavy Lineup Edge)'], index=0)
                     lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1)
                     submitted = st.form_submit_button("Submit")
                     if submitted:
                         if preset_choice == 'Small Field (Heavy Own)':
                             parsed_frame = small_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
-                        elif preset_choice == 'Large Field (Manage Similarity)':
+                        elif preset_choice == 'Large Field (Manage Diversity)':
                             parsed_frame = large_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
                         elif preset_choice == 'Volatility (Heavy Lineup Edge)':
                             parsed_frame = volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
@@ -1221,7 +1221,7 @@ with tab2:
                         min_value=-1.0,
                         max_value=1.0
                     ),
-                    "Similarity Score": st.column_config.NumberColumn(
+                    "Diversity": st.column_config.NumberColumn(
                         "Diversity",
                         help="Projected lineup diversity",
                         width="small",

global_func/hedging_preset.py

@@ -5,7 +5,7 @@ from global_func.large_field_preset import large_field_preset
 
 def hedging_preset(portfolio: pd.DataFrame, lineup_target: int, projections_file: pd.DataFrame):
     
-    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Similarity Score']
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
     list_size = 3
 
     check_own_df = projections_file.copy()
@@ -81,7 +81,7 @@ def hedging_preset(portfolio: pd.DataFrame, lineup_target: int, projections_file
                 print(f"No lineups found with {team} stacked")
                 concat_portfolio = pd.concat([concat_portfolio, removed_lineups])
 
-        concat_portfolio = concat_portfolio.drop_duplicates(subset=['median', 'Own', 'Lineup Edge', 'Similarity Score'])
+        concat_portfolio = concat_portfolio.drop_duplicates(subset=['median', 'Own', 'Lineup Edge', 'Diversity'])
 
         if len(concat_portfolio) >= lineup_target:
             return concat_portfolio.head(lineup_target)

global_func/large_field_preset.py

@@ -2,15 +2,15 @@ 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']
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
     player_columns = [col for col in portfolio.columns if col not in excluded_cols]
     
     concat_portfolio = portfolio.copy()
-    concat_portfolio = concat_portfolio.sort_values(by='Similarity Score', ascending=True).reset_index(drop=True)
+    concat_portfolio = concat_portfolio.sort_values(by='Diversity', ascending=True).reset_index(drop=True)
 
     # Calculate target similarity scores for linear progression
-    similarity_floor = concat_portfolio['Similarity Score'].min()
-    similarity_ceiling = concat_portfolio['Similarity Score'].max()
+    similarity_floor = concat_portfolio['Diversity'].min()
+    similarity_ceiling = concat_portfolio['Diversity'].max()
     
     # Create evenly spaced target similarity scores
     target_similarities = np.linspace(similarity_floor, similarity_ceiling, lineup_target)
@@ -19,7 +19,7 @@ def large_field_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols
     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()
+        closest_idx = (concat_portfolio['Diversity'] - target_sim).abs().idxmin()
         if closest_idx not in selected_indices:  # Avoid duplicates
             selected_indices.append(closest_idx)
     

global_func/predict_dupes.py

@@ -353,7 +353,7 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
     portfolio['Geomean'] = np.power((portfolio[own_columns] * 100).product(axis=1), 1 / len(own_columns))
     
     # Calculate similarity score based on actual player selection
-    portfolio['Similarity Score'] = calculate_player_similarity_score(portfolio, player_columns)
+    portfolio['Diversity'] = calculate_player_similarity_score(portfolio, player_columns)
     
     portfolio = portfolio.drop(columns=dup_count_columns)
     portfolio = portfolio.drop(columns=own_columns)

global_func/small_field_preset.py

@@ -1,7 +1,7 @@
 import pandas as pd
 
 def small_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']
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
     player_columns = [col for col in portfolio.columns if col not in excluded_cols]
 
     for slack_var in range(1, 20):

global_func/trim_portfolio.py

@@ -9,7 +9,7 @@ def trim_portfolio(portfolio: pd.DataFrame, trim_slack: float, performance_type:
     curr_own_type_max = working_portfolio.loc[0, own_type] + (trim_slack * working_portfolio.loc[0, own_type])
 
     for i in range(1, len(working_portfolio)):
-        if own_type == 'Similarity Score':
+        if own_type == 'Diversity':
             if working_portfolio.loc[i, own_type] < curr_own_type_max and \
             working_portfolio.loc[i, performance_type] > performance_threshold_low and \
             working_portfolio.loc[i, performance_type] <= performance_threshold_high and \

global_func/volatility_preset.py

@@ -2,7 +2,7 @@ import pandas as pd
 import numpy as np
 
 def volatility_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']
+    excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean', 'Diversity']
     player_columns = [col for col in portfolio.columns if col not in excluded_cols]
 
     for slack_var in range(1, 20):
@@ -13,13 +13,13 @@ def volatility_preset(portfolio: pd.DataFrame, lineup_target: int, exclude_cols:
             working_portfolio = portfolio.copy()
             working_portfolio = working_portfolio[working_portfolio['Stack'] == team].sort_values(by='Lineup Edge', ascending = False)
             working_portfolio = working_portfolio.reset_index(drop=True)
-            curr_own_type_max = working_portfolio.loc[0, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[0, 'Similarity Score'])
+            curr_own_type_max = working_portfolio.loc[0, 'Diversity'] + (slack_var / 20 * working_portfolio.loc[0, 'Diversity'])
 
             for i in range(1, len(working_portfolio)):
-                if working_portfolio.loc[i, 'Similarity Score'] < curr_own_type_max:
+                if working_portfolio.loc[i, 'Diversity'] < curr_own_type_max:
                     rows_to_drop.append(i)
                 else:
-                    curr_own_type_max = working_portfolio.loc[i, 'Similarity Score'] + (slack_var / 20 * working_portfolio.loc[i, 'Similarity Score'])
+                    curr_own_type_max = working_portfolio.loc[i, 'Diversity'] + (slack_var / 20 * working_portfolio.loc[i, 'Diversity'])
 
             working_portfolio = working_portfolio.drop(rows_to_drop).reset_index(drop=True)
             concat_portfolio = pd.concat([concat_portfolio, working_portfolio])