code updates

app.py

@@ -150,6 +150,11 @@ if tabs == "Exploratory analysis":
 if tabs == "Model training":
 
     st.header("Model Training")
+    st.write("""
+        In this section, we train a model to predict the uplift effect of different treatments on customer behavior.
+        We use the XGBoost algorithm to train the model. The model can be used to predict the conversion rate or the benefit per user for each treatment group.
+        We can also analyze the economic effects of the treatments by comparing the uplift in conversion rate and benefit per user.
+    """)
 
     if 'uplift_sim' in st.session_state:
 
@@ -177,7 +182,7 @@ if tabs == "Model training":
                 y_name = 'conversion' # st.selectbox('Select target variable for conversion', options=uplift_sim.target_options)
                 model_trainer.y_name = y_name
                 tau = model_trainer.fit_predict_classifier(params, control_name)
-            elif model_type == 'BATE Model':
+            elif model_type == 'Benefit Model':
                 y_name = 'benefit' # st.selectbox('Select target variable for benefit', options=uplift_sim.benefit_options)
                 model_trainer.y_name = y_name
                 tau = model_trainer.fit_predict_regressor(params, control_name)
@@ -203,6 +208,10 @@ if tabs == "Model training":
 if tabs == "Economic effects":
 
     st.header("Economic Effects Analysis")
+    st.write("""
+             We can evaluate our models by looking at the Qini curves. We can use the CATE conversion model to evaluate the performance on both the Conversion and the Benefit as a function of the fraction of users targeted.
+            The Qini curve is a measure of the uplift effect of a model. It shows the difference between the uplift model and a random model.
+        """)
 
     if 'uplift_sim' in st.session_state and 'model_trainer' in st.session_state:
         df_test = st.session_state.model_trainer.df_test
@@ -268,12 +277,15 @@ if tabs == "Economic effects":
             qini_conc_test = pd.concat([qini_conversions[discount][['S']], qini_benefits[discount][['S']]], axis=1)
             qini_conc_test.columns = ['cate_conversion', 'cate_benefit']
             qini_conc_test.plot(ax=ax_comp, x='cate_conversion', y='cate_benefit', color=colors[i], label=f'{discount} model')
+        
+        st.write('To simplify the comparison, we can plot the CATE Benefit as a function of the CATE conversion.')
+        st.write('In the last plot for example we can see that there is a region where offering 15% discount to a targeted group of users is more efficient than giving 10% to everyone. We can obtain the same impact in overall conversion uplift while reducing our benefit loss considerably.')
 
         ax_comp.legend(prop={'size': 10})
         ax_comp.set_xlabel('CATE Conversion')
         ax_comp.set_ylabel('CATE Benefit')
         ax_comp.set_title('CATE Benefit vs CATE Conversion')
         st.pyplot(fig)
-        
+
     else:
         st.error("Please ensure the model is trained and the dataset is prepared.")

models_utils/ml_models.py

@@ -12,10 +12,13 @@ class ModelTraining:
         self.X_names = X_names
         self.df_train = None
         self.df_test = None
-        self.learner_t = None
+
         self.conversion_learner_t = None
         self.benefit_learner_t = None
 
+        self.conversion_learner_t_tau = None
+        self.benefit_learner_t_tau = None
+
     def split_data(self, test_size, random_state):
         self.df_train, self.df_test = train_test_split(
             self.df,
@@ -24,32 +27,69 @@ class ModelTraining:
         )
         
     def fit_predict_classifier(self, params, control_name):
-        self.learner_t = BaseTClassifier(XGBClassifier(**params), control_name=control_name)
-        self.conversion_learner_t = self.learner_t
-        return self._fit_predict()
+        self.conversion_learner_t = BaseTClassifier(XGBClassifier(**params), control_name=control_name)
+        self.conversion_learner_t_tau = self.conversion_learner_t.fit_predict(
+            X=self.df_train[self.X_names].values,
+            treatment=self.df_train['treatment_group_key'].values,
+            y=self.df_train[self.y_name].values
+        )
+        self.conversion_learner_t.feature_names = self.X_names
+        return self.conversion_learner_t_tau
 
     def fit_predict_regressor(self, params, control_name):
-        self.learner_t = BaseTRegressor(XGBRegressor(**params), control_name=control_name)
-        self.benefit_learner_t = self.learner_t
-        return self._fit_predict()
-
-    def _fit_predict(self):
-        self.learner_t_tau = self.learner_t.fit_predict(
+        self.benefit_learner_t = BaseTRegressor(XGBRegressor(**params), control_name=control_name)
+        self.benefit_learner_t_tau = self.benefit_learner_t.fit_predict(
             X=self.df_train[self.X_names].values,
             treatment=self.df_train['treatment_group_key'].values,
             y=self.df_train[self.y_name].values
         )
-        self.learner_t.feature_names = self.X_names
-        return self.learner_t_tau
+        self.benefit_learner_t.feature_names = self.X_names
+        return self.benefit_learner_t_tau
+
+    # def _fit_predict(self):
+    #     self.learner_t_tau = self.learner_t.fit_predict(
+    #         X=self.df_train[self.X_names].values,
+    #         treatment=self.df_train['treatment_group_key'].values,
+    #         y=self.df_train[self.y_name].values
+    #     )
+    #     self.learner_t.feature_names = self.X_names
+    #     return self.learner_t_tau
 
     def compute_feature_importance(self):
-        if self.learner_t is None:
-            raise ValueError("Model must be fitted before computing feature importances.")
+
+        if self.y_name == 'conversion':
+
+            if self.conversion_learner_t is None:
+                raise ValueError("Model must be fitted before computing feature importances.")
+            
+            return self.conversion_learner_t.get_importance(
+                X=self.df_train[self.X_names],
+                tau=self.conversion_learner_t_tau,
+                features=self.X_names,
+                normalize=True,
+                method='auto'
+            )
+        
+        elif self.y_name == 'benefit':
+
+            if self.benefit_learner_t is None:
+                raise ValueError("Model must be fitted before computing feature importances.")
+            
+            return self.benefit_learner_t.get_importance(
+                X=self.df_train[self.X_names],
+                tau=self.benefit_learner_t_tau,
+                features=self.X_names,
+                normalize=True,
+                method='auto'
+            )
+        
+        # if self.learner_t is None:
+        #     raise ValueError("Model must be fitted before computing feature importances.")
         
-        return self.learner_t.get_importance(
-            X=self.df_train[self.X_names],
-            tau=self.learner_t_tau,
-            features=self.X_names,
-            normalize=True,
-            method='auto'
-        )
+        # return self.learner_t.get_importance(
+        #     X=self.df_train[self.X_names],
+        #     tau=self.learner_t_tau,
+        #     features=self.X_names,
+        #     normalize=True,
+        #     method='auto'
+        # )