Update app.py

app.py

@@ -79,45 +79,34 @@ os.makedirs(app.config['MODEL_FOLDER'], exist_ok=True)
 # ------------------------------
 
 # Prediction analysis models loaded from Hugging Face.
-src_path = hf_hub_download(
-    repo_id="WebashalarForML/Diamond_model_",
-    filename="models_list/mkble/DecisionTree_best_pipeline_mkble_1_to_1.49.pkl",
-    cache_dir=MODEL_FOLDER
-)
-dst_path = os.path.join(MODEL_FOLDER, "DecisionTree_best_pipeline_mkble_1_to_1.49.pkl")
-shutil.copy(src_path, dst_path)
-makable_model = load(dst_path)
 
-'''
 src_path = hf_hub_download(
     repo_id="WebashalarForML/Diamond_model_",
-    filename="models_list/grd/StackingRegressor_best_pipeline_grd_0_to_1.01.pkl",
+    filename="models_list/mkble/DecisionTree_best_pipeline_mkble_0_to_0.99_al.pkl",
     cache_dir=MODEL_FOLDER
 )
-dst_path = os.path.join(MODEL_FOLDER, "StackingRegressor_best_pipeline_grd_0_to_1.01.pkl")
+dst_path = os.path.join(MODEL_FOLDER, "DecisionTree_best_pipeline_mkble_0_to_0.99_al.pkl")
 shutil.copy(src_path, dst_path)
-grade_model = load(dst_path)
- 
+makable_model_0 = load(dst_path)
 
 src_path = hf_hub_download(
     repo_id="WebashalarForML/Diamond_model_",
-    filename="models_list/bygrad/StackingRegressor_best_pipeline_bygrad_0_to_1.01.pkl",
+    filename="models_list/mkble/DecisionTree_best_pipeline_mkble_1_to_1.49.pkl",
     cache_dir=MODEL_FOLDER
 )
-dst_path = os.path.join(MODEL_FOLDER, "StackingRegressor_best_pipeline_bygrad_0_to_1.01.pkl")
+dst_path = os.path.join(MODEL_FOLDER, "DecisionTree_best_pipeline_mkble_1_to_1.49.pkl")
 shutil.copy(src_path, dst_path)
-bygrade_model = load(dst_path)
-
+makable_model_1 = load(dst_path)
 
+# Prediction analysis models loaded from Hugging Face.
 src_path = hf_hub_download(
     repo_id="WebashalarForML/Diamond_model_",
-    filename="models_list/gia/StackingRegressor_best_pipeline_gia_0_to_1.01.pkl",
+    filename="models_list/mkble/DecisionTree_best_pipeline_mkble_1.50_to_1.99.pkl",
     cache_dir=MODEL_FOLDER
 )
-dst_path = os.path.join(MODEL_FOLDER, "StackingRegressor_best_pipeline_gia_0_to_1.01.pkl")
+dst_path = os.path.join(MODEL_FOLDER, "DecisionTree_best_pipeline_mkble_1.50_to_1.99.pkl")
 shutil.copy(src_path, dst_path)
-gia_model = load(dst_path)
-'''
+makable_model_2 = load(dst_path)
 
 #classsification model on the task
 src_path = hf_hub_download(
@@ -129,49 +118,13 @@ dst_path = os.path.join(MODEL_FOLDER, "3_pipeline.pkl")
 shutil.copy(src_path, dst_path)
 mkble_amt_class_model = load(dst_path)
 
-
-
-
-print("makable_model type:", type(makable_model))
+#print("makable_model type:", type(makable_model))
 #print("grade_model type:", type(grade_model))
 #print("bygrade_model type:", type(bygrade_model))
 #print("gia_model type:", type(gia_model))
 print("================================")
 print("mkble_amt_class_model type:", type(mkble_amt_class_model))
 
-#gia_model = load("models/StackingRegressor_best_pipeline_mkble_0_to_1.01.pkl")
-#grade_model = load("models/StackingRegressor_best_pipeline_grd_0_to_1.01.pkl")
-#bygrade_model = load("models/StackingRegressor_best_pipeline_bygrad_0_to_1.01.pkl")
-#makable_model = load("models/StackingRegressor_best_pipeline_gia_0_to_1.01.pkl")
-    
-
-# Classification models loaded using joblib.
-'''
-col_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_col.joblib'))
-cts_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_cts.joblib'))
-cut_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_cut.joblib'))
-qua_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_qua.joblib'))
-shp_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_shp.joblib'))
-
-blk_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_blk.joblib'))
-wht_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_wht.joblib'))
-open_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_open.joblib'))
-pav_eng_to_mkbl_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_mkbl_pav.joblib'))
-blk_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_blk.joblib'))
-wht_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_wht.joblib'))
-open_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_open.joblib'))
-pav_eng_to_grade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_grade_pav.joblib'))
-blk_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_blk.joblib'))
-wht_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_wht.joblib'))
-open_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_open.joblib'))
-pav_eng_to_bygrade_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_bygrade_pav.joblib'))
-blk_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_blk.joblib'))
-wht_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_wht.joblib'))
-open_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_open.joblib'))
-pav_eng_to_gia_model = load(os.path.join(MODEL_DIR, 'classification_LogisticRegression_gia_pav.joblib'))
-'''
-
-
 # List of label encoder names.
 encoder_list = [
     'Tag', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol', 'EngSym', 'EngFlo',
@@ -265,7 +218,7 @@ def process_dataframe(df):
         
         # Create two DataFrames: one for prediction and one for classification.
         df_pred = df[required_columns].copy()
-        df_pred = df_pred[(df_pred[['EngCts']] > 0.99).all(axis=1) & (df_pred[['EngCts']] < 1.50).all(axis=1)] 
+        #df_pred = df_pred[(df_pred[['EngCts']] > 0.99).all(axis=1) & (df_pred[['EngCts']] < 1.50).all(axis=1)] 
         df_pred[['EngBlk', 'EngWht', 'EngOpen', 'EngPav']]=df_pred[['EngBlk', 'EngWht', 'EngOpen', 'EngPav']].fillna("NA")
         df_class = df[required_columns_2].fillna("NA").copy()
         
@@ -297,95 +250,60 @@ def process_dataframe(df):
         # Prediction Report Section
         # -------------------------
         try:
-            x = df_pred.copy()
-            #df_pred['GIA_Predicted'] = pd.DataFrame(np.expm1(gia_model.predict(x)), columns=["Predicted"])
-            #df_pred['Grade_Predicted'] = pd.DataFrame(np.expm1(grade_model.predict(x)), columns=["Predicted"])
-            #df_pred['ByGrade_Predicted'] = pd.DataFrame(np.expm1(bygrade_model.predict(x)), columns=["Predicted"])
-            df_pred['change_in_amt_mkble'] = pd.DataFrame(mkble_amt_class_model.predict(x), columns=["pred_change_in_eng_to_mkble"])
-            #print(df_pred.columns)
-            df_pred = df_pred[['Tag', 'EngCts', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol',
+        
+            # for model 0 to 0.99 
+            df_pred_0 = df_pred[(df_pred[['EngCts']] > 0.00).all(axis=1) & (df_pred[['EngCts']] < 0.99).all(axis=1)] 
+            df_pred_0['change_in_amt_mkble'] = pd.DataFrame(mkble_amt_class_model.predict(df_pred_0), columns=["pred_change_in_eng_to_mkble"])
+            print(df_pred_0.columns)
+            df_pred_0 = df_pred_0[['Tag', 'EngCts', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol',
                                'EngSym', 'EngFlo', 'EngNts', 'EngMikly', 'EngBlk', 'EngWht', 'EngOpen',
                                'EngPav', 'EngAmt', 
                                'change_in_amt_mkble'
                               ]]
-            df_pred['Makable_Predicted'] = pd.DataFrame(np.expm1(makable_model.predict(df_pred)), columns=["Predicted"])
-            print(df_pred.columns)
-            #df_pred['GIA_Diff'] = df_pred['EngAmt'] - df_pred['GIA_Predicted']
-            #df_pred['Grade_Diff'] = df_pred['EngAmt'] - df_pred['Grade_Predicted']
-            #df_pred['ByGrade_Diff'] = df_pred['EngAmt'] - df_pred['ByGrade_Predicted']
-            df_pred['Makable_Diff'] = df_pred['EngAmt'] - df_pred['Makable_Predicted']
+            df_pred_0['Makable_Predicted'] = pd.DataFrame(np.expm1(makable_model_0.predict(df_pred_0)), columns=["Predicted"])
+            print(df_pred_0.columns)
+
+            # for model 1 to 1.49
+
+            df_pred_1 = df_pred[(df_pred[['EngCts']] > 0.99).all(axis=1) & (df_pred[['EngCts']] < 1.50).all(axis=1)] 
+            df_pred_1['change_in_amt_mkble'] = pd.DataFrame(mkble_amt_class_model.predict(df_pred_1), columns=["pred_change_in_eng_to_mkble"])
+            print(df_pred_1.columns)
+            df_pred_1 = df_pred_1[['Tag', 'EngCts', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol',
+                               'EngSym', 'EngFlo', 'EngNts', 'EngMikly', 'EngBlk', 'EngWht', 'EngOpen',
+                               'EngPav', 'EngAmt', 
+                               'change_in_amt_mkble'
+                              ]]
+            df_pred_1['Makable_Predicted'] = pd.DataFrame(np.expm1(makable_model_1.predict(df_pred_1)), columns=["Predicted"])
+            print(df_pred_1.columns)
+
+            # for model 1.50 to 1.99
+
+            df_pred_2 = df_pred[(df_pred[['EngCts']] > 1.49).all(axis=1) & (df_pred[['EngCts']] < 2.00).all(axis=1)] 
+            df_pred_2['change_in_amt_mkble'] = pd.DataFrame(mkble_amt_class_model.predict(df_pred_2), columns=["pred_change_in_eng_to_mkble"])
+            print(df_pred_2.columns)
+            df_pred_2 = df_pred_2[['Tag', 'EngCts', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol',
+                               'EngSym', 'EngFlo', 'EngNts', 'EngMikly', 'EngBlk', 'EngWht', 'EngOpen',
+                               'EngPav', 'EngAmt', 
+                               'change_in_amt_mkble'
+                              ]]
+            df_pred_2['Makable_Predicted'] = pd.DataFrame(np.expm1(makable_model_2.predict(df_pred_2)), columns=["Predicted"])
+            print(df_pred_2.columns)
+
+            
+            df_pred_main = pd.concat([df_pred_0, df_pred_1, df_pred_2])
+            df_pred_main['Makable_Diff'] = df_pred_main['EngAmt'] - df_pred_main['Makable_Predicted']
             
             for col in ['Tag', 'EngShp', 'EngQua', 'EngCol', 'EngCut', 'EngPol', 'EngSym', 'EngFlo', 'EngNts', 'EngMikly','EngBlk', 'EngWht', 'EngOpen', 'EngPav']:
                 try:
-                    df_pred[col] = loaded_label_encoder[col].inverse_transform(df_pred[col].astype(int))
+                    df_pred_main[col] = loaded_label_encoder[col].inverse_transform(df_pred_main[col].astype(int))
                 except ValueError as e:
                     print(f'inverse transform fails value in column {col}: {e}', 'error')
                     
         except ValueError as e:
             print(f'pred model error----->: {e}', 'error')
         
-        # -------------------------
-        # Classification Report Section
-        # -------------------------
-        '''
-        try:
-            x2 = df_class.copy()
-            dx = df_pred.copy()  # Start with the prediction data.
-            dx['col_change'] = col_model.predict(x2)
-            dx['cts_change'] = cts_model.predict(x2)
-            dx['cut_change'] = cut_model.predict(x2)
-            dx['qua_change'] = qua_model.predict(x2)
-            dx['shp_change'] = shp_model.predict(x2)
-        except ValueError as e:
-            print(f'class model error----->: {e}', 'error')
-
-        try:
-            dx['Change_Blk_Eng_to_Mkbl_value'] = blk_eng_to_mkbl_model.predict(x)
-            dx['Change_Wht_Eng_to_Mkbl_value'] = wht_eng_to_mkbl_model.predict(x)
-            dx['Change_Open_Eng_to_Mkbl_value'] = open_eng_to_mkbl_model.predict(x)
-            dx['Change_Pav_Eng_to_Mkbl_value'] = pav_eng_to_mkbl_model.predict(x)
-            dx['Change_Blk_Eng_to_Grd_value'] = blk_eng_to_grade_model.predict(x)
-            dx['Change_Wht_Eng_to_Grd_value'] = wht_eng_to_grade_model.predict(x)
-            dx['Change_Open_Eng_to_Grd_value'] = open_eng_to_grade_model.predict(x)
-            dx['Change_Pav_Eng_to_Grd_value'] = pav_eng_to_grade_model.predict(x)
-            dx['Change_Blk_Eng_to_ByGrd_value'] = blk_eng_to_bygrade_model.predict(x)
-            dx['Change_Wht_Eng_to_ByGrd_value'] = wht_eng_to_bygrade_model.predict(x)
-            dx['Change_Open_Eng_to_ByGrd_value'] = open_eng_to_bygrade_model.predict(x)
-            dx['Change_Pav_Eng_to_ByGrd_value'] = pav_eng_to_bygrade_model.predict(x)
-            dx['Change_Blk_Eng_to_Gia_value'] = blk_eng_to_gia_model.predict(x)
-            dx['Change_Wht_Eng_to_Gia_value'] = wht_eng_to_gia_model.predict(x)
-            dx['Change_Open_Eng_to_Gia_value'] = open_eng_to_gia_model.predict(x)
-            dx['Change_Pav_Eng_to_Gia_value'] = pav_eng_to_gia_model.predict(x)
-        except ValueError as e:
-            print(f'grade_code model error----->: {e}', 'error')
-        
-        # Inverse transform classification predictions.
-        dx['col_change'] = loaded_label_encoder['Change_color_value'].inverse_transform(dx['col_change'])
-        dx['cts_change'] = loaded_label_encoder['Change_cts_value'].inverse_transform(dx['cts_change'])
-        dx['cut_change'] = loaded_label_encoder['Change_cut_value'].inverse_transform(dx['cut_change'])
-        dx['qua_change'] = loaded_label_encoder['Change_quality_value'].inverse_transform(dx['qua_change'])
-        dx['shp_change'] = loaded_label_encoder['Change_shape_value'].inverse_transform(dx['shp_change'])
-        dx['Change_Blk_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Blk_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Blk_Eng_to_Mkbl_value'])
-        dx['Change_Wht_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Wht_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Wht_Eng_to_Mkbl_value'])
-        dx['Change_Open_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Open_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Open_Eng_to_Mkbl_value'])
-        dx['Change_Pav_Eng_to_Mkbl_value'] = loaded_label_encoder['Change_Pav_Eng_to_Mkbl_value'].inverse_transform(dx['Change_Pav_Eng_to_Mkbl_value'])
-        dx['Change_Blk_Eng_to_Grd_value'] = loaded_label_encoder['Change_Blk_Eng_to_Grd_value'].inverse_transform(dx['Change_Blk_Eng_to_Grd_value'])
-        dx['Change_Wht_Eng_to_Grd_value'] = loaded_label_encoder['Change_Wht_Eng_to_Grd_value'].inverse_transform(dx['Change_Wht_Eng_to_Grd_value'])
-        dx['Change_Open_Eng_to_Grd_value'] = loaded_label_encoder['Change_Open_Eng_to_Grd_value'].inverse_transform(dx['Change_Open_Eng_to_Grd_value'])
-        dx['Change_Pav_Eng_to_Grd_value'] = loaded_label_encoder['Change_Pav_Eng_to_Grd_value'].inverse_transform(dx['Change_Pav_Eng_to_Grd_value'])
-        dx['Change_Blk_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Blk_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Blk_Eng_to_ByGrd_value'])
-        dx['Change_Wht_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Wht_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Wht_Eng_to_ByGrd_value'])
-        dx['Change_Open_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Open_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Open_Eng_to_ByGrd_value'])
-        dx['Change_Pav_Eng_to_ByGrd_value'] = loaded_label_encoder['Change_Pav_Eng_to_ByGrd_value'].inverse_transform(dx['Change_Pav_Eng_to_ByGrd_value'])
-        dx['Change_Blk_Eng_to_Gia_value'] = loaded_label_encoder['Change_Blk_Eng_to_Gia_value'].inverse_transform(dx['Change_Blk_Eng_to_Gia_value'])
-        dx['Change_Wht_Eng_to_Gia_value'] = loaded_label_encoder['Change_Wht_Eng_to_Gia_value'].inverse_transform(dx['Change_Wht_Eng_to_Gia_value'])
-        dx['Change_Open_Eng_to_Gia_value'] = loaded_label_encoder['Change_Open_Eng_to_Gia_value'].inverse_transform(dx['Change_Open_Eng_to_Gia_value'])
-        dx['Change_Pav_Eng_to_Gia_value'] = loaded_label_encoder['Change_Pav_Eng_to_Gia_value'].inverse_transform(dx['Change_Pav_Eng_to_Gia_value'])
-     
-        '''
-           
         # Final return with full data for pagination.
-        return df_pred, df_pred
+        return df_pred_main, df_pred_main
     except Exception as e:
         print(f'Error processing file: {e}', 'error')
         return pd.DataFrame(), pd.DataFrame()
@@ -437,4 +355,4 @@ def download_class():
     return send_file(CLASS_OUTPUT_FILE, as_attachment=True)
 
 if __name__ == "__main__":
-    app.run(debug=True)
+    app.run(debug=True)