train.py

import pandas as pd
import sklearn
#for creating a folder
import os
#for data preprocessing and pipeline creation
from sklearn.model_selection import train_test_split
from sklearn.compose import make_column_transformer
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
#for model traning,tuning and evaluation
import xgboost as xgb
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score, classification_report,recall_score, precision_score, f1_score, confusion_matrix
#for model serialization
import joblib
#for converting text data into numerical representation
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import OneHotEncoder,LabelEncoder
import mlflow # Ensure mlflow is imported

DATASET_PATH = "hf://datasets/grkavi0912/ENG/engine.csv"
df=pd.read_csv(DATASET_PATH)
print("Dataset loaded successfully")

# Define the column name mapping to standardize names to snake_case
column_name_mapping = {
    'Engine rpm': 'engine_rpm',
    'Lub oil pressure': 'lub_oil_pressure',
    'Fuel pressure': 'fuel_pressure',
    'Coolant pressure': 'coolant_pressure',
    'lub oil temp': 'lub_oil_temp',
    'Coolant temp': 'coolant_temp',
    'Engine Condition': 'engine_condition'
}
# Apply the renaming to the DataFrame
df.rename(columns=column_name_mapping, inplace=True)
print("Columns renamed to snake_case.")

#Define a target variable for this classification task
target="engine_condition"

#split into x(features) and y(target)
x=df.drop(columns=[target])
y=df[target]

#perform train and test split
xtrain,xtest,ytrain,ytest = train_test_split(
    x,y, test_size=0.2,random_state=42
)

#set the class weight to handle class imbalance
class_weight = ytrain.value_counts()[0] / ytrain.value_counts()[1]

# Define numeric and categorical features
numeric_features = xtrain.select_dtypes(include=['number']).columns.tolist()
categorical_features = xtrain.select_dtypes(include=['object', 'category']).columns.tolist()

#Define the preprocessing steps
preprocessor = make_column_transformer(
     (StandardScaler(),numeric_features),
     (OneHotEncoder(handle_unknown='ignore'),categorical_features)
)

#Define base XGBoost model
xgb_model = xgb.XGBClassifier(scale_pos_weight=class_weight,random_state=42)

#Define hyperparameter grid
param_grid = {
    'xgbclassifier__n_estimators': [50, 100],
    'xgbclassifier__max_depth': [2, 4],
    'xgbclassifier__colsample_bytree': [0.8, 1.0],
    'xgbclassifier__colsample_bylevel': [0.8, 1.0],
    'xgbclassifier__learning_rate': [0.01, 0.1],
    'xgbclassifier__reg_lambda': [0.4, 0.6]
}

#model pipeline
model_pipeline = make_pipeline(preprocessor,xgb_model)

with mlflow.start_run():
    #Hyperparameter tuning
    grid_search = GridSearchCV(model_pipeline,param_grid,cv=3,n_jobs=-1)
    grid_search.fit(xtrain,ytrain)

    #log all parameter combinations and their mean test scores
    results = grid_search.cv_results_
    for i in range(len(results['params'])):
        params_set = results['params'][i]
        mean_score = results['mean_test_score'][i]
        std_score = results['std_test_score'][i]

        #log each combination as a separate MLflow run
        with mlflow.start_run(nested=True):
             mlflow.log_params(params_set)
             mlflow.log_metric('mean_test_score',mean_score)
             mlflow.log_metric('std_test_score',std_score)

   #log best parameters separately in main run
    mlflow.log_params(grid_search.best_params_)

  #store and evaluate the best model
    best_model = grid_search.best_estimator_

    classification_threshold =0.45

    y_pred_train_proba = best_model.predict_proba(xtrain)[:,1]
    y_pred_train = (y_pred_train_proba >= classification_threshold).astype(int)

    y_pred_test_proba = best_model.predict_proba(xtest)[:,1]
    y_pred_test = (y_pred_test_proba >= classification_threshold).astype(int)

    train_report = classification_report(ytrain, y_pred_train, output_dict=True)
    test_report = classification_report(ytest, y_pred_test, output_dict=True)

    # Log metrics individually
    mlflow.log_metric("train_accuracy", train_report['accuracy'])
    mlflow.log_metric("train_recall", train_report['1']['recall'])
    mlflow.log_metric("train_precision", train_report['1']['precision'])
    mlflow.log_metric("train_f1_score", train_report['1']['f1-score'])
    mlflow.log_metric("test_accuracy", test_report['accuracy'])
    mlflow.log_metric("test_recall", test_report['1']['recall'])
    mlflow.log_metric("test_precision", test_report['1']['precision'])
    mlflow.log_metric("test_f1_score", test_report['1']['f1-score'])

    # Ensure eng/data and eng/model directories exist
    os.makedirs('eng/data', exist_ok=True)
    os.makedirs('eng/model', exist_ok=True)

    # Save preprocessed data to eng/data
    xtrain.to_csv("eng/data/xtrain.csv",index=False)
    ytrain.to_csv("eng/data/ytrain.csv",index=False)
    xtest.to_csv("eng/data/xtest.csv",index=False)
    ytest.to_csv("eng/data/ytest.csv",index=False)
    print("Train/test sets saved to eng/data/ CSV files.")

    #save the model locally to eng/model
    model_path = "eng/model/best_eng_model.joblib"
    joblib.dump(best_model, model_path)

    # log the model artifact
    mlflow.log_artifact(model_path, artifact_path="model")
    print(f"Model saved as artifact at {model_path}")

    #upload to hugging face
    repo_id = "grkavi0912/ENG"
    repo_type="model"

    # Initialize API client within this cell
    from huggingface_hub import HfApi, RepositoryNotFoundError
    api = HfApi(token=os.getenv("HFTOKEN"))

    #step 1:check if the space exists
    try:
        api.repo_info(repo_id=repo_id,repo_type=repo_type)
        print(f"Repo {repo_id} already exists")
    except RepositoryNotFoundError:
        print(f"Repo {repo_id} does not exist, creating...")
        api.create_repo(repo_id=repo_id,repo_type=repo_type)
        print(f"Repo {repo_id} created successfully")

    #create_repo("tour_model",repo_type="model",private=False)
    api.upload_file(
        path_or_fileobj=model_path,
        path_in_repo=os.path.basename(model_path), # Only upload the filename, not the full path
        repo_id=repo_id,
        repo_type=repo_type
    )
    print(f"Model uploaded to {repo_id}")