restructuring of own_rank mapping

global_func/predict_dupes.py

@@ -125,23 +125,25 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             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']]
-            
+
+            n_rows = len(portfolio)
+
             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'])
-                ])
+                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])
+            portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+            portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
+            portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+            portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+            portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
 
             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
@@ -212,15 +214,33 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
             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']]
+            n_rows = len(portfolio)
+            
+            # Assign ranks back to individual columns using the same rank scale
             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'])
+                    portfolio.iloc[:,5].map(maps_dict['own_map']),
+                    portfolio.iloc[:,6].map(maps_dict['own_map'])
                 ])
+                flex_rank = flex_ownerships.rank(pct=True)
+
+                portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+                portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
+                portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+                portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+                portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
+                portfolio['FLEX6_Own_percent_rank'] = flex_rank.iloc[5*n_rows:6*n_rows].values
+
+                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:
                 flex_ownerships = pd.concat([
                     portfolio.iloc[:,1].map(maps_dict['own_map']),
@@ -229,33 +249,14 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                     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
-            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:    
-                print(portfolio.head(10))
-                print(flex_ownerships.head(10))
-                print(flex_rank.head(10))
+                flex_rank = flex_ownerships.rank(pct=True)
+                
                 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['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+                portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
+                portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+                portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+                portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
 
                 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
@@ -291,7 +292,9 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 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']]
-                
+
+                n_rows = len(portfolio)
+
                 flex_ownerships = pd.concat([
                     portfolio.iloc[:,1].map(maps_dict['own_map']),
                     portfolio.iloc[:,2].map(maps_dict['own_map']),
@@ -300,14 +303,14 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                     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])
+                portfolio['FLEX1_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+                portfolio['FLEX2_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values  
+                portfolio['FLEX3_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+                portfolio['FLEX4_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+                portfolio['FLEX5_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
 
                 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
@@ -343,6 +346,8 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 # 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']]
                 
+                n_rows = len(portfolio)
+
                 flex_ownerships = pd.concat([
                     portfolio.iloc[:,1].map(maps_dict['own_map']),
                     portfolio.iloc[:,2].map(maps_dict['own_map']),
@@ -355,12 +360,12 @@ def predict_dupes(portfolio, maps_dict, site_var, type_var, Contest_Size, streng
                 
                 # 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['TOP_Own_percent_rank'] = portfolio.iloc[:,1].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-                portfolio['JNG_Own_percent_rank'] = portfolio.iloc[:,2].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-                portfolio['MID_Own_percent_rank'] = portfolio.iloc[:,3].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-                portfolio['ADC_Own_percent_rank'] = portfolio.iloc[:,4].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-                portfolio['SUP_Own_percent_rank'] = portfolio.iloc[:,5].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
-                portfolio['Team_Own_percent_rank'] = portfolio.iloc[:,6].map(maps_dict['own_map']).map(lambda x: flex_rank[flex_ownerships == x].iloc[0])
+                portfolio['TOP_Own_percent_rank'] = flex_rank.iloc[0:n_rows].values
+                portfolio['JNG_Own_percent_rank'] = flex_rank.iloc[n_rows:2*n_rows].values
+                portfolio['MID_Own_percent_rank'] = flex_rank.iloc[2*n_rows:3*n_rows].values
+                portfolio['ADC_Own_percent_rank'] = flex_rank.iloc[3*n_rows:4*n_rows].values
+                portfolio['SUP_Own_percent_rank'] = flex_rank.iloc[4*n_rows:5*n_rows].values
+                portfolio['Team_Own_percent_rank'] = flex_rank.iloc[5*n_rows:6*n_rows].values
 
                 portfolio['CPT_Own'] = portfolio.iloc[:,0].map(maps_dict['cpt_own_map']).astype('float32') / 100
                 portfolio['TOP_Own'] = portfolio.iloc[:,1].map(maps_dict['own_map']).astype('float32') / 100