mlforgex 1.0.2__tar.gz → 1.0.4__tar.gz

{mlforgex-1.0.2/mlforgex.egg-info → mlforgex-1.0.4}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: mlforgex
-Version: 1.0.2
+Version: 1.0.4
 Summary: Lightweight ML utility for automated training, evaluation, and prediction with CLI and Python API support
-Home-page: https://github.com/yourusername/mlforge
 Author: Priyanshu Mathur
 Author-email: mathurpriyanshu2006@gmail.com
 License: MIT
@@ -24,14 +23,13 @@ Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# mlforgex
+# mlforgex [![PyPI Downloads](https://static.pepy.tech/badge/mlforgex)](https://pepy.tech/projects/mlforgex)
 
 **mlforgex** is a Python package that enables easy training, evaluation, and prediction for machine learning models on cleaned dataset. It supports both classification and regression problems, automates preprocessing, model selection, hyperparameter tuning, and generates useful artifacts and plots for analysis.
 

{mlforgex-1.0.2 → mlforgex-1.0.4}/README.md

@@ -1,4 +1,4 @@
-# mlforgex
+# mlforgex [![PyPI Downloads](https://static.pepy.tech/badge/mlforgex)](https://pepy.tech/projects/mlforgex)
 
 **mlforgex** is a Python package that enables easy training, evaluation, and prediction for machine learning models on cleaned dataset. It supports both classification and regression problems, automates preprocessing, model selection, hyperparameter tuning, and generates useful artifacts and plots for analysis.
 

mlforgex-1.0.4/mlforge/predict.py

@@ -0,0 +1,44 @@
+import pickle;
+import pandas as pd;
+def predict(model_path,preprocessor_path,input_data, encoder_path=None):
+        """
+    Load a trained model and make predictions on input data.
+
+    Args:
+        model_path (str): 
+            Path to the serialized trained model file.
+        preprocessor_path (str): 
+            Path to the serialized preprocessor file (used for feature transformation).
+        input_data (str): 
+            Path to the input CSV file containing data for prediction.
+        encoder_path (Optional[str], optional): 
+            Path to the serialized encoder file (for categorical target encoding). Defaults to None.
+
+    Returns:
+        List[Any]: 
+            List of predictions generated by the model.
+
+    Examples:
+        >>> predict("model.pkl", "preprocessor.pkl", "input.csv")
+        [1, 0, 1]
+    """
+        print("Loading the pickled model and preprocessor...")
+        model = pickle.load(open(model_path, 'rb'))
+        preprocessor = pickle.load(open(preprocessor_path, 'rb'))
+        encoder = pickle.load(open(encoder_path, 'rb')) if encoder_path else None
+        df= pd.read_csv(input_data)
+        X = preprocessor.transform(df)
+        predictions = model.predict(X)
+        if encoder_path:
+            predictions = encoder.inverse_transform(predictions)
+        return {"prediction": predictions.tolist()}
+def main():
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_path", required=True,help="Path to the model file")
+    parser.add_argument("--input_data", required=True,help="Path to the input data CSV file")
+    parser.add_argument("--preprocessor_path", required=True,help="Path to the preprocessor file")
+    parser.add_argument("--encoder_path", required=False,help="Path to the encoder file")
+    args = parser.parse_args()
+    print(predict(args.model_path, args.preprocessor_path, args.input_data, args.encoder_path))
+

{mlforgex-1.0.2 → mlforgex-1.0.4}/mlforge/train.py

@@ -26,6 +26,21 @@ from sklearn.model_selection import learning_curve
 import warnings
 warnings.filterwarnings("ignore")
 def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=100,cv=3,artifacts_dir=None):
+    """
+    Trains a machine learning model using the provided dataset and parameters.
+
+    Args:
+        data_path (str): Path to the CSV dataset file.
+        dependent_feature (str): The target column (dependent variable) in the dataset.
+        rmse_prob (float): Probability threshold for RMSE (used in regression).
+        f1_prob (float): Probability threshold for F1 score (used in classification).
+        n_jobs (int, optional): Number of parallel jobs to run (-1 uses all CPUs). Default is -1.
+        n_iter (int, optional): Number of iterations for parameter search. Default is 100.
+        cv (int, optional): Number of cross-validation folds. Default is 3.
+
+    Returns:
+        dict: Model evaluation metrics and trained model object.
+    """
     if artifacts_dir:
         artifacts_path = os.path.join(artifacts_dir, "artifacts")
     else:
@@ -38,7 +53,7 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
     # os.remove(data_path)
     df.head()
     print("Data loaded successfully")
-
+    df.replace(["", "NA", "na", "N/A", "n/a", "?", "--"], np.nan, inplace=True)
     for i in df.columns:
         if df[i].dtype=="object":
             df[i] = df[i].fillna(df[i].mode()[0])
@@ -117,6 +132,8 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
     print("Categorical features : ",cat_features)
     print("Numerical features : ",num_features)
     if classification:
+        is_multiclass = len(set(y_train)) > 2
+        average_type = "weighted" if is_multiclass else "binary"
         print("Balancing the dataset...")
         if mild :
             from imblearn.under_sampling import RandomUnderSampler
@@ -245,7 +262,7 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
         "AdaBoostClassifier":AdaBoostClassifier(),
         "XGBClassifier":XGBClassifier(),
         "KNeighborsClassifier":KNeighborsClassifier(),
-        "SVC":SVC()
+        "SVC":SVC(probability=True)
     }
     
         for i in range(len(list(models))):
@@ -258,15 +275,26 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
 
             # Training set performance
             model_train_accuracy = accuracy_score(y_train, y_train_pred) # Calculate Accuracy
-            model_train_f1 = f1_score(y_train, y_train_pred, average='weighted') # Calculate F1-score
-            model_train_precision = precision_score(y_train, y_train_pred) # Calculate Precision
-            model_train_recall = recall_score(y_train, y_train_pred) # Calculate Recall
-            model_train_rocauc_score = roc_auc_score(y_train, y_train_pred)
+            model_train_f1 = f1_score(y_train, y_train_pred, average=average_type) # Calculate F1-score
+            model_train_precision = precision_score(y_train, y_train_pred, average=average_type) # Calculate Precision
+            model_train_recall = recall_score(y_train, y_train_pred, average=average_type) # Calculate Recall
+            if average_type == "binary":
+                y_train_prob = model.predict_proba(x_train)[:,1]
+                model_train_rocauc_score = roc_auc_score(y_train, y_train_prob)
+            else:
+                y_train_prob=model.predict_proba(x_train)
+                model_train_rocauc_score = roc_auc_score(y_train, y_train_prob,multi_class='ovr',average=average_type) #Calculate Roc Auc Score
             # Test set performance
             model_test_accuracy = accuracy_score(y_test, y_test_pred) # Calculate Accuracy
-            model_test_f1 = f1_score(y_test, y_test_pred, average='weighted') # Calculate F1-score
-            model_test_precision = precision_score(y_test, y_test_pred) # Calculate Precision
-            model_test_recall = recall_score(y_test, y_test_pred) # Calculate Recal
+            model_test_f1 = f1_score(y_test, y_test_pred, average=average_type) # Calculate F1-score
+            model_test_precision = precision_score(y_test, y_test_pred, average=average_type) # Calculate Precision
+            model_test_recall = recall_score(y_test, y_test_pred, average=average_type) # Calculate Recall
+            if average_type == "binary":
+                y_test_prob = model.predict_proba(x_test)[:,1]
+                model_test_rocauc_score = roc_auc_score(y_test, y_test_prob)
+            else:
+                y_test_prob=model.predict_proba(x_test)
+                model_test_rocauc_score = roc_auc_score(y_test, y_test_prob,multi_class='ovr',average=average_type) #Calculate Roc Auc Score
 
             model_dict.append({
                 "model":list(models.keys())[i],
@@ -276,7 +304,6 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
                 "test_f1": model_test_f1,
                 "tuned":False
             })
-            model_test_rocauc_score = roc_auc_score(y_test, y_test_pred) #Calculate Roc
 
 
             # print(list(models.keys())[i])
@@ -447,7 +474,7 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
             ["LogisticRegression", {
                 'penalty': ['l1', 'l2', 'elasticnet', 'none'],
                 'C': np.logspace(-4, 4, 20),
-                'solver': ['newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'],
+                'solver': ['lbfgs', 'liblinear', 'saga'],
                 'max_iter': [100, 200, 500, 1000],
                 'class_weight': [None, 'balanced'],
                 'l1_ratio': [0, 0.25, 0.5, 0.75, 1]  # For elasticnet
@@ -597,7 +624,6 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
         for i in range(len(list(models))):
             model = list(models.values())[i]
             model.fit(x_train, y_train) # Train model
-
             # Make predictions
             y_train_pred = model.predict(x_train)
             y_test_pred = model.predict(x_test)
@@ -658,22 +684,38 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
 
             # Training set performance
             model_train_accuracy = accuracy_score(y_train, y_train_pred) # Calculate Accuracy
-            model_train_f1 = f1_score(y_train, y_train_pred, average='weighted') # Calculate F1-score
-            model_train_precision = precision_score(y_train, y_train_pred) # Calculate Precision
-            model_train_recall = recall_score(y_train, y_train_pred) # Calculate Recall
-            model_train_rocauc_score = roc_auc_score(y_train, y_train_pred)
+            model_train_f1 = f1_score(y_train, y_train_pred, average=average_type) # Calculate F1-score
+            model_train_precision = precision_score(y_train, y_train_pred,average=average_type) # Calculate Precision
+            model_train_recall = recall_score(y_train, y_train_pred,average=average_type) # Calculate Recall
+            if average_type == "binary":
+                y_train_prob = model.predict_proba(x_train)[:,1]
+                model_train_rocauc_score = roc_auc_score(y_train, y_train_prob)
+            else:
+                y_train_prob=model.predict_proba(x_train)
+                model_train_rocauc_score = roc_auc_score(y_train, y_train_prob, multi_class='ovr', average=average_type)
             # Test set performance
             model_test_accuracy = accuracy_score(y_test, y_test_pred) # Calculate Accuracy
-            model_test_f1 = f1_score(y_test, y_test_pred, average='weighted') # Calculate F1-score
-            model_test_precision = precision_score(y_test, y_test_pred) # Calculate Precision
-            model_test_recall = recall_score(y_test, y_test_pred) # Calculate Recal
-
+            model_test_f1 = f1_score(y_test, y_test_pred, average=average_type) # Calculate F1-score
+            model_test_precision = precision_score(y_test, y_test_pred,average=average_type) # Calculate Precision
+            model_test_recall = recall_score(y_test, y_test_pred,average=average_type) # Calculate Recall
+            if average_type == "binary":
+                y_test_prob = model.predict_proba(x_test)[:,1]
+                model_test_rocauc_score = roc_auc_score(y_test, y_test_prob)
+            else:
+                y_test_prob=model.predict_proba(x_test)
+                model_test_rocauc_score = roc_auc_score(y_test, y_test_prob, multi_class='ovr', average=average_type)
             model_dict={
             "model":list(models.keys())[i],
             "train_accuracy": model_train_accuracy,
             "train_f1": model_train_f1,
+            "train_precision": model_train_precision,
+            "train_recall": model_train_recall,
+            "train_rocauc": model_train_rocauc_score,
             "test_accuracy": model_test_accuracy,
             "test_f1": model_test_f1,
+            "test_precision": model_test_precision,
+            "test_recall": model_test_recall,
+            "test_rocauc": model_test_rocauc_score,
             "tuned":True
         }
             best_models_copy = pd.concat(
@@ -727,7 +769,7 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
     if classification:
         combined_score_ranking=combined_score_ranking[combined_score_ranking["train_f1"]-combined_score_ranking["test_f1"]<0.15]
     # print("====="*35)
-    print(combined_score_ranking.iloc[0:1,:])
+    # print(combined_score_ranking.iloc[0:1,:])
     best_model_name = combined_score_ranking.iloc[0]["model"]
     best_param_dict = None
     for name, params in best_params:
@@ -742,36 +784,41 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
     print("Saving the model and preprocessor...")
     model_path = os.path.join(artifacts_path, "model.pkl")
     preprocessor_path = os.path.join(artifacts_path, "preprocessor.pkl")
-    encoder_path = os.path.join(artifacts_path, "encoder.pkl")
 
     with open(model_path, "wb") as f:
         pickle.dump(model, f)
 
     with open(preprocessor_path, "wb") as f:
         pickle.dump(preprocessor, f)
-
+    encoder_path = None
     if classification:
+        encoder_path = os.path.join(artifacts_path, "encoder.pkl")
         with open(encoder_path, "wb") as f:
             pickle.dump(le, f)
         response = {
-        "message": "Training completed successfully",
+        "Message": "Training completed successfully",
         "Problem_type":"Classification",
-        "model_metrics": {
             "Model": combined_score_ranking.iloc[0]["model"],
             "Train_accuracy": float(combined_score_ranking.iloc[0]["train_accuracy"]),
             "Train_f1": float(combined_score_ranking.iloc[0]["train_f1"]),
+            "Train_precision": float(combined_score_ranking.iloc[0]["train_precision"]),
+            "Train_recall": float(combined_score_ranking.iloc[0]["train_recall"]),
+            "Train_rocauc": float(combined_score_ranking.iloc[0]["train_rocauc"]),
             "Test_accuracy": float(combined_score_ranking.iloc[0]["test_accuracy"]),
             "Test_f1": float(combined_score_ranking.iloc[0]["test_f1"]),
+            "Test_precision": float(combined_score_ranking.iloc[0]["test_precision"]),
+            "Test_recall": float(combined_score_ranking.iloc[0]["test_recall"]),
+            "Test_rocauc": float(combined_score_ranking.iloc[0]["test_rocauc"]),
             "Hyper_tuned": bool(combined_score_ranking.iloc[0]["tuned"]),
             "Dropped_Columns":list(dropcorr)
-        }
     }
-        plot_classification_metrics(model,x_train, y_train, x_test, y_test, class_names=['No', 'Yes'],plot_path=plot_path)
+        if(response["Hyper_tuned"]):
+            response["Best_Params"] = best_param_dict
+        plot_classification_metrics(model,x_train, y_train, x_test, y_test,plot_path=plot_path)
     else:
         response={
-             "message": "Training completed successfully",
-             "Problem_type":"Regression",
-            "model_metrics": {
+            "Message": "Training completed successfully",
+            "Problem_type":"Regression",
             "Model": combined_score_ranking.iloc[0]["model"],
             "Train_R2": float(combined_score_ranking.iloc[0]["train_r2"]),
             "Train_RMSE": float(combined_score_ranking.iloc[0]["train_rmse"]),
@@ -779,10 +826,19 @@ def train_model(data_path, dependent_feature,rmse_prob,f1_prob,n_jobs=-1,n_iter=
             "Test_RMSE": float(combined_score_ranking.iloc[0]["test_rmse"]),
             "Hyper_tuned": bool(combined_score_ranking.iloc[0]["tuned"]),
             "Dropped_Columns":list(dropcorr)
-            }
         }
+        if(response["Hyper_tuned"]):
+            response["Best_Params"] = best_param_dict
         plot_regression_metrics(model, x_train, y_train, x_test, y_test,feature_names,plot_path=plot_path)
-    print(response)
+    print("\n")
+    print("="*55)
+    for i in response:
+        print(f"{i}: {response[i]}")
+    print("="*55)
+    print("\n")
+    with open(os.path.join(artifacts_path, "metrices.txt"), "w") as f:
+        for key, value in response.items():
+            f.write(f"{key}: {value}\n")
     print("artifacts_path:", artifacts_path)
     print("model_path:", model_path)
     print("preprocessor_path:", preprocessor_path)
@@ -794,10 +850,10 @@ def plot_classification_metrics(model, X_train, y_train, X_test, y_test, plot_pa
     # Predict
     y_pred = model.predict(X_test)
     y_proba = model.predict_proba(X_test)[:, 1] if hasattr(model, "predict_proba") else None
-
+    unique_classes = model.classes_
     # Confusion Matrix
     cm = confusion_matrix(y_test, y_pred)
-    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=class_names)
+    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=unique_classes)
     disp.plot(cmap="Blues")
     plt.title("Confusion Matrix")
     plt.savefig(os.path.join(plot_path,"confusion_matrix.png"), bbox_inches='tight')
@@ -810,14 +866,15 @@ def plot_classification_metrics(model, X_train, y_train, X_test, y_test, plot_pa
         plt.savefig(os.path.join(plot_path,"roc_curve.png"), bbox_inches='tight')
         plt.close()
     # Precision-Recall Curve
-    if y_proba is not None:
+    if y_proba is not None and unique_classes.shape[0] == 2:
         precision, recall, _ = precision_recall_curve(y_test, y_proba)
         PrecisionRecallDisplay(precision=precision, recall=recall).plot()
         plt.title("Precision-Recall Curve")
         plt.savefig(os.path.join(plot_path,"precision_recall_curve.png"), bbox_inches='tight')
         plt.close()
     # Learning Curve
-    train_sizes, train_scores, val_scores = learning_curve(model, X_train, y_train, cv=5, scoring='accuracy')
+    cv = min(5, np.min(np.bincount(y_train)))
+    train_sizes, train_scores, val_scores = learning_curve(model, X_train, y_train, cv=cv, scoring='accuracy')
     plt.plot(train_sizes, np.mean(train_scores, axis=1), label="Train")
     plt.plot(train_sizes, np.mean(val_scores, axis=1), label="Validation")
     plt.title("Learning Curve (Accuracy)")
@@ -835,6 +892,9 @@ def plot_classification_metrics(model, X_train, y_train, X_test, y_test, plot_pa
     ax[1].set_title("Testing Class Distribution")
     plt.savefig(os.path.join(plot_path,"class_distribution.png"), bbox_inches='tight')
     plt.close()
+    
+    
+    
 def plot_regression_metrics(model, X_train, y_train, X_test, y_test,feature_names,plot_path):
     y_pred = model.predict(X_test)
     residuals = y_test - y_pred
@@ -876,13 +936,12 @@ def plot_regression_metrics(model, X_train, y_train, X_test, y_test,feature_name
 def main():
     import argparse
     parser = argparse.ArgumentParser()
-    parser.add_argument("--data_path", required=True)
-    parser.add_argument("--dependent_feature", required=True)
-    parser.add_argument("--rmse_prob", required=True)
-    parser.add_argument("--f1_prob", required=True)
-    parser.add_argument("--n_jobs", default=-1, type=int)
-    parser.add_argument("--n_iter", default=100, type=int)
-    parser.add_argument("--cv", default=3, type=int)
+    parser.add_argument("--data_path", required=True,help="Path to the dataset CSV file")
+    parser.add_argument("--dependent_feature", required=True,help="Name of the dependent feature (target variable)")
+    parser.add_argument("--rmse_prob", required=True,help="RMSE probability threshold")
+    parser.add_argument("--f1_prob", required=True,help="F1 score probability threshold")
+    parser.add_argument("--n_jobs", default=-1, type=int,help="Number of jobs to run in parallel")
+    parser.add_argument("--n_iter", default=100, type=int,help="Number of iterations for hyperparameter tuning")
+    parser.add_argument("--cv", default=3, type=int,help="Number of cross-validation folds")
     args = parser.parse_args()
     print(train_model(args.data_path, args.dependent_feature, rmse_prob=args.rmse_prob, f1_prob=args.f1_prob, n_jobs=args.n_jobs, n_iter=args.n_iter, cv=args.cv))
-

{mlforgex-1.0.2 → mlforgex-1.0.4/mlforgex.egg-info}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.4
 Name: mlforgex
-Version: 1.0.2
+Version: 1.0.4
 Summary: Lightweight ML utility for automated training, evaluation, and prediction with CLI and Python API support
-Home-page: https://github.com/yourusername/mlforge
 Author: Priyanshu Mathur
 Author-email: mathurpriyanshu2006@gmail.com
 License: MIT
@@ -24,14 +23,13 @@ Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license
 Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# mlforgex
+# mlforgex [![PyPI Downloads](https://static.pepy.tech/badge/mlforgex)](https://pepy.tech/projects/mlforgex)
 
 **mlforgex** is a Python package that enables easy training, evaluation, and prediction for machine learning models on cleaned dataset. It supports both classification and regression problems, automates preprocessing, model selection, hyperparameter tuning, and generates useful artifacts and plots for analysis.
 

{mlforgex-1.0.2 → mlforgex-1.0.4}/setup.py

@@ -5,7 +5,7 @@ this_directory = Path(__file__).parent
 long_description = (this_directory / "README.md").read_text()
 setup(
     name="mlforgex",
-    version="1.0.2",
+    version="1.0.4",
     packages=find_packages(),
     install_requires = [
     "pandas",
@@ -28,7 +28,6 @@ setup(
     author="Priyanshu Mathur",
     author_email="mathurpriyanshu2006@gmail.com",
     description="Lightweight ML utility for automated training, evaluation, and prediction with CLI and Python API support",
-    url="https://github.com/yourusername/mlforge",
     license="MIT",
     classifiers=[
          "License :: OSI Approved :: MIT License",

mlforgex-1.0.4/test/test_basic.py

@@ -0,0 +1,9 @@
+from mlforge import train_model, predict
+
+def test_train_model():
+    result = train_model("StudentsPerformance.csv", "math_score", rmse_prob=0.3, f1_prob=0.7, n_jobs=-1)
+    assert result["status"] == "success"
+
+def test_predict():
+    result =predict("artifacts/model.pkl", "artifacts/preprocessor.pkl", "input.csv")
+    assert "prediction" in result

mlforgex-1.0.2/mlforge/predict.py

@@ -1,23 +0,0 @@
-import pickle;
-import pandas as pd;
-def predict(model_path,preprocessor_path,input_data, encoder_path=None):
-        print("Loading the pickled model and preprocessor...")
-        model = pickle.load(open(model_path, 'rb'))
-        preprocessor = pickle.load(open(preprocessor_path, 'rb'))
-        encoder = pickle.load(open(encoder_path, 'rb')) if encoder_path else None
-        df= pd.read_csv(input_data)
-        X = preprocessor.transform(df)
-        predictions = model.predict(X)
-        if encoder_path:
-            predictions = encoder.inverse_transform(predictions)
-        return {"prediction": predictions.tolist()}
-def main():
-    import argparse
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model_path", required=True)
-    parser.add_argument("--input_data", required=True)
-    parser.add_argument("--preprocessor_path", required=True)
-    parser.add_argument("--encoder_path", required=False)
-    args = parser.parse_args()
-    print(predict(args.model_path, args.preprocessor_path, args.input_data, args.encoder_path))
-

mlforgex-1.0.2/test/test_basic.py

@@ -1,9 +0,0 @@
-from mlforge import train_model, predict
-
-def test_train_model():
-    result = train_model("mlforge/diabetes_cleaned.csv", "Outcome", rmse_prob=0.3, f1_prob=0.7, n_jobs=-1)
-    assert result["status"] == "success"
-
-def test_predict():
-    result =predict("mlforge/artifacts/model.pkl", "mlforge/artifacts/preprocessor.pkl", "mlforge/input.csv", "mlforge/artifacts/encoder.pkl")
-    assert "prediction" in result