%load_ext dotenv
%dotenv 

%reload_ext dotenv

# Import standard libraries
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import os
import sys

# **Append source directory to Python path**
sys.path.append(os.getenv('SRC_DIR'))

# Load the dataset
from DataManager import get_data

obesity_df = get_data('../data/ObesityDataSet_raw_and_data_sinthetic.csv')
obesity_df.shape

obesity_df.head()

# Rename columns for improved readability
columnName = {'family_history_with_overweight': 'Family_History', 
                                          'FAVC' : 'High_Cal_Foods_Frequently', 
                                          'FCVC': 'Freq_Veg', 'NCP': 'Num_Meals', 
                                          'CAEC': 'Snacking',
                                          'SMOKE': 'Smoke',
                                          'CH2O': 'Water_Intake', 
                                          'SCC': 'Calorie_Monitoring' , 
                                          'FAF': 'Phys_Activity', 
                                          'TUE': 'Tech_Use', 'CALC':
                                          "Freq_Alcohol", 
                                          'MTRANS': 'Transportation', 
                                          'NObeyesdad': 'Obesity_Level'}


obesity_df_renamed = obesity_df.rename(columns=columnName)

obesity_df_renamed.info()

obesity_df_renamed.describe()

num_col = obesity_df_renamed.select_dtypes(include=['float64', 'int64']).columns
cat_col = obesity_df_renamed.select_dtypes(include=['object']).columns

# Find missing values
obesity_df_renamed.isna().sum()

obesity_df_renamed.isnull().sum() # check for null values

unique_values_per_column = {col: obesity_df_renamed[col].unique() for col in cat_col}

# Display unique values for each column
for col, unique_vals in unique_values_per_column.items():
    print(f"Unique values in '{col}': {unique_vals}")

obesity_df_renamed.duplicated().sum()

# Show duplicated values if needed

#obesity_df_renamed[obesity_df_renamed.duplicated(keep=False)]

# remove duplicates from the dataset
from DataManager import drop_duplicates

data = drop_duplicates(obesity_df_renamed)
data.shape

def find_outliers_IQR(df,numeric_col):
   
   q1=df[numeric_col].quantile(0.25)
   q3=df[numeric_col].quantile(0.75)
   IQR=q3-q1
   outliers = df[((df[numeric_col]<(q1-1.5*IQR)) | (df[numeric_col]>(q3+1.5*IQR)))]
   return outliers

numeric_columns = num_col
for column in numeric_columns:
    outliers = find_outliers_IQR(data, column)
    
    if outliers.empty:
        print(f"No outliers detected in column {column}")
    else:
        print(f"{len(outliers)} outliers detected in column {column}")
        print("Max outlier value:", str(outliers[column].max()))
        print("Min outlier value:", str(outliers[column].min()))

for column in num_col:
    outliers = find_outliers_IQR(data, column)
    if not outliers.empty:  # Only plot if outliers are present
        plt.figure(figsize=(8, 6))
        plt.boxplot(data[column].dropna(), vert=False, patch_artist=True)
        plt.title(f"Box Plot for {column} (Outliers Detected)")
        plt.xlabel(column)
        plt.grid(True)
        plt.show()

# Age distribution across different obesity levels (NObeyesdad)

plt.figure(figsize=(10,8))
nobeyesdad_order = ['Insufficient_Weight', 'Normal_Weight', 'Overweight_Level_I','Overweight_Level_II','Obesity_Type_I', 'Obesity_Type_II', 'Obesity_Type_III']  # Adjust according to your dataset
sns.boxplot(x='Obesity_Level', y='Age', data=data, palette='Set3', order=nobeyesdad_order)
plt.title('Age Distribution across Obesity Levels (Obesity_Level)')
plt.xlabel('Obesity Level (Obesity_Level)')
plt.ylabel('Age')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

sns.histplot(data['Age'], kde=True, bins=20, color='skyblue')
plt.title('Age Distribution')

# Define the order of obesity levels based on their frequency
nobeyesdad_order = data['Obesity_Level'].value_counts().index

plt.figure(figsize=(10,8))
sns.countplot(x='Obesity_Level', data=data, palette='Set3', order=nobeyesdad_order)
plt.title('Distribution of Obesity Levels (Obesity_Level)')
plt.xlabel('Obesity Level')
plt.ylabel('Count')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

sns.pairplot(data[['Age', 'Height', 'Weight', 'Freq_Veg', 'Water_Intake', 'Phys_Activity', 'Obesity_Level']], hue='Obesity_Level', palette='Set3')
plt.show()

# Plot categorical variables against Obesity_Level
binary_palette = {"yes": "#8dd3c7", "no": "#fb8072"}
# Define the desired order of obesity levels
obesity_level_order = [
    "Insufficient_Weight", 
    "Normal_Weight", 
    "Overweight_Level_I", 
    "Overweight_Level_II", 
    "Obesity_Type_I", 
    "Obesity_Type_II", 
    "Obesity_Type_III"
]
plt.figure(figsize=(12, 170))
counter = 1
for var in cat_col:
    if counter < len(cat_col):
        plt.subplot(20, 1, counter)
        plt.title(f"{var} vs Obesity_Level")
        
        # Determine the appropriate palette based on variable categories
        if var in ["Family_History", "High_Cal_Foods_Frequently", "Smoke", "Calorie_Monitoring"]:
            palette = binary_palette  # Use "yes" and "no" palette
        else:
            palette = "Set3"  # Default palette for other categorical variables
        
        # Plot with the selected palette
        sns.countplot(
            x="Obesity_Level",
            hue=var,
            data=obesity_df_renamed,
            edgecolor="black",
            palette=palette,
            order=obesity_level_order
        )
    counter += 1
plt.tight_layout()
plt.show()

# Create a heatmap for the correlation matrix using only numerical columns
numerical_columns = obesity_df_renamed.select_dtypes(include=['float64', 'int64']).columns
numerical_correlation_matrix = obesity_df_renamed[numerical_columns].corr()

# Plot the heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(numerical_correlation_matrix, annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Correlation Matrix of Numerical Variables')
plt.show()

# Define new BMI feature
data['BMI'] = data['Weight'] / (data['Height'] ** 2)

plt.figure(figsize=(10,8))
nobeyesdad_order = ['Insufficient_Weight', 'Normal_Weight', 'Overweight_Level_I','Overweight_Level_II','Obesity_Type_I', 'Obesity_Type_II', 'Obesity_Type_III']  # Adjust according to your dataset
sns.boxplot(x='Obesity_Level', y='BMI', data=data, palette='Set3', order=nobeyesdad_order)
plt.title('BMI Distribution across Obesity Levels (Obesity_Level)')
plt.xlabel('Obesity Level (Obesity_Level)')
plt.ylabel('BMI')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

# BMI distribution across different obesity levels (NObeyesdad)

plt.figure(figsize=(10,8))
sns.boxplot(x='Gender', y='BMI', data=data, palette='Set3')
plt.title('BMI Distribution by Gender')
plt.xlabel('Gender')
plt.ylabel('BMI')
plt.tight_layout()
plt.show()

plt.figure(figsize=(15,6))
ax = sns.countplot(x = "Gender", hue = "Obesity_Level",hue_order=nobeyesdad_order, data = data, palette='Set3')

for p in ax.patches:
    ax.annotate(format(p.get_height(), '.0f'),
               (p.get_x() + p.get_width() / 2, p.get_height()),
               ha = 'center', va = 'center',
               xytext = (0,10),
               textcoords = 'offset points')

plt.title("Distribution of Obesity_Level across Gender")
plt.xlabel('')
plt.ylabel('')

plt.show()

plt.figure(figsize=(10,8))
sns.scatterplot(x='Age', y='BMI', data=data, hue_order= nobeyesdad_order,hue='Obesity_Level', palette='Set3')

plt.title('BMI Distribution by Age')
plt.xlabel('Age')
plt.ylabel('BMI')
plt.tight_layout()
plt.show()

nobe_bmi_mean = data.groupby('Obesity_Level')['Age'].mean().reset_index()

nobe_bmi_mean_sorted = nobe_bmi_mean.sort_values(by='Age', ascending = False)

fig, axes = plt.subplots(1,2,figsize=(15,6))
sns.barplot(y='Obesity_Level', x='Age',ax=axes[0],data=nobe_bmi_mean,order=nobe_bmi_mean_sorted['Obesity_Level'],palette='Set3')

for index, row in enumerate(nobe_bmi_mean_sorted.iterrows()):
    axes[0].text(row[1]['Age'], index, f"{row[1]['Age']: .2f}", va = 'center', ha = 'left', fontsize = 10)

axes[0].set_xlabel('Age')
axes[0].set_ylabel('')
axes[0].set_xticklabels(axes[0].get_xticklabels(), rotation=45)

sns.violinplot(y = "Obesity_Level", x= "Age", data= data, ax=axes[1], order=nobe_bmi_mean_sorted['Obesity_Level'],palette='Set3')
axes[1].set_ylabel('')
axes[1].set_yticklabels([])

fig.suptitle('Average Age by NObeyesdad', fontsize = 16)
plt.show()

# Plot BMI distribution by Family History with Overweight across Obesity Levels
binary_palette = {"yes": "#8dd3c7", "no": "#fb8072"}

plt.figure(figsize=(12, 8))
sns.boxplot(
    x='Obesity_Level',
    y='BMI',
    hue ='Family_History',
    data=data,
    palette= binary_palette,
    order=obesity_level_order
)
plt.title("BMI Distribution by Family History with Overweight Across Obesity Levels", fontsize=16)
plt.xlabel("Obesity Level")
plt.ylabel("BMI")
plt.xticks(rotation=45)
plt.legend(title="Family History", loc='upper left')
plt.tight_layout()
plt.show()

# Plot BMI distribution by Family History with Overweight across Obesity Levels
binary_palette = {"yes": "#8dd3c7", "no": "#fb8072"}

plt.figure(figsize=(12, 8))
sns.boxplot(
    x='Obesity_Level',
    y='BMI',
    hue ='High_Cal_Foods_Frequently',
    data=data,
    palette= binary_palette,
    order=obesity_level_order
)
plt.title("BMI Distribution by Frequent Consumption of High-Calorie Food (FAVC)", fontsize=16)
plt.xlabel("Obesity Level")
plt.ylabel("BMI")
plt.xticks(rotation=45)
plt.legend(title="High_Cal_Foods_Frequently", loc='upper left')
plt.tight_layout()
plt.show()

# BMI distribution by Number of Meals (NCP) across different obesity levels (NObeyesdad)

plt.figure(figsize=(10,8))
sns.scatterplot(x='Num_Meals', y='BMI', data=obesity_df_renamed, hue='Obesity_Level', palette='Set3')

plt.title('BMI Distribution by Number of Meals (NCP)')
plt.xlabel('Number of Meals (NCP)')
plt.ylabel('BMI')
plt.tight_layout()
plt.show()

# Plot BMI distribution by Smoking across Obesity Levels
binary_palette = {"yes": "#8dd3c7", "no": "#fb8072"}

plt.figure(figsize=(12, 8))
sns.boxplot(
    x='Obesity_Level',
    y='BMI',
    hue ='Smoke',
    data=data,
    palette= binary_palette,
    order=obesity_level_order
)
plt.title("BMI Distribution by Smoking Habit ", fontsize=16)
plt.xlabel("Obesity Level")
plt.ylabel("BMI")
plt.xticks(rotation=45)
plt.legend(title="smoking", loc='upper left')
plt.tight_layout()
plt.show()

def show_pie_chart(df, column_name):
    
    # Converting string values to categorical
    df[column_name] = df[column_name].astype('category')
    
    # Calculating the frequency of values in the column
    counts = df[column_name].value_counts()

    
    # Sorting the values in the column by their frequency in descending order
    counts_sorted = counts.sort_values(ascending=False)
    
    # subplot
    fig,axes = plt.subplots(1, 2, figsize=(16, 8))
    plt.title(column_name)
    plt.subplots_adjust(wspace = 0.5)
    
   
    axes[0].pie(counts.values, labels=counts_sorted.index, autopct='%1.1f%%', startangle=140, colors=sns.color_palette("pastel"))
    
    sns.countplot(data=df, y=column_name, ax=axes[1], order=counts_sorted.index, palette="pastel", hue=column_name, legend=False, width=0.8)
    axes[1].set_ylabel('')
    axes[1].set_xlabel('')
    
    for i, v in enumerate(counts_sorted.values):
        axes[1].text(v + 0.1, i, str(v), ha='left', va = 'center', color = 'black', fontweight = 'bold')
    #plt.title(column_name)
    plt.show()

 #Create pie chart for MTRANS
show_pie_chart(data, 'Transportation')

data.to_csv('clean_data.csv', index=False)

import pandas as pd

clean_data_df = pd.read_csv(r'../data/clean_data.csv')

clean_data_df.info()
clean_data_df.drop('BMI', axis='columns', inplace=True)

cat_cols = ['Gender', 'Family_History', 'High_Cal_Foods_Frequently', 'Snacking','Smoke', 'Calorie_Monitoring', 'Freq_Alcohol', 'Transportation']

num_cols = ['Age', 'Height', 'Weight', 'Freq_Veg', 'Num_Meals','Water_Intake', 'Phys_Activity', 'Tech_Use']

X = clean_data_df.drop('Obesity_Level',axis=1)  
y = clean_data_df['Obesity_Level'] 

X.shape, y.shape

from sklearn.model_selection import train_test_split

X_train,X_test,y_train,y_test=train_test_split(X,y,stratify=y,test_size=0.2,random_state=42)

X_train.shape, X_test.shape, y_train.shape, y_test.shape

from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import make_column_transformer
from sklearn.preprocessing import StandardScaler
Sscaler = StandardScaler().set_output(transform="pandas")
# Encoding multiple columns. 
transformer = make_column_transformer((Sscaler, num_cols), (OneHotEncoder(handle_unknown='ignore'), 
     cat_cols),verbose=True,verbose_feature_names_out=True, remainder='drop')

transformer

# Transforming
transformed = transformer.fit_transform(X_train)
# Transformating back
transformed_df = pd.DataFrame(transformed, columns=transformer.get_feature_names_out())
# One-hot encoding removed an index. Let's put it back:
transformed_df.index = X_train.index
# Joining tables
X_train = pd.concat([X_train, transformed_df], axis=1)
# Dropping old categorical columns
X_train.drop(cat_cols, axis=1, inplace=True)
# Dropping old num columns
X_train.drop(num_cols, axis=1, inplace=True)
# CHecking result
#print(X_train.head())
print(X_train.columns)
print(X_train.shape)

# Transforming
transformed = transformer.transform(X_test)
# Transformating back
transformed_df = pd.DataFrame(transformed, columns=transformer.get_feature_names_out())
# One-hot encoding removed an index. Let's put it back:
transformed_df.index = X_test.index
# Joining tables
X_test = pd.concat([X_test, transformed_df], axis=1)
# Dropping old categorical columns
X_test.drop(cat_cols, axis=1, inplace=True)
# Dropping old num columns
X_test.drop(num_cols, axis=1, inplace=True)
# CHecking result
X_test.head()

print(X_train.columns, X_train.shape)

# Setting new feature names

X_train.columns = ['Age', 'Height', 'Weight', 'Freq_Veg', 'Num_Meals', 'Water_Intake',
       'Phys_Activity', 'Tech_Use', 'Gender_Female',
       'Gender_Male', 'Family_History_no',
       'Family_History_yes',
       'High_Cal_Foods_Frequently_no',
       'High_Cal_Foods_Frequently_yes',
       'Snacking_Always', 'Snacking_Frequently',
       'Snacking_Sometimes', 'Snacking_no',
       'Smoke_no', 'Smoke_yes',
       'Calorie_Monitoring_no',
       'Calorie_Monitoring_yes',
       'Freq_Alcohol_Always',
       'Freq_Alcohol_Frequently',
       'Freq_Alcohol_Sometimes',
       'Freq_Alcohol_no',
       'Transportation_Automobile',
       'Transportation_Bike',
       'Transportation_Motorbike',
       'Transportation_Public_Transportation',
       'Transportation_Walking']

X_test.columns = ['Age', 'Height', 'Weight', 'Freq_Veg', 'Num_Meals', 'Water_Intake',
       'Phys_Activity', 'Tech_Use', 'Gender_Female',
       'Gender_Male', 'Family_History_no',
       'Family_History_yes',
       'High_Cal_Foods_Frequently_no',
       'High_Cal_Foods_Frequently_yes',
       'Snacking_Always', 'Snacking_Frequently',
       'Snacking_Sometimes', 'Snacking_no',
       'Smoke_no', 'Smoke_yes',
       'Calorie_Monitoring_no',
       'Calorie_Monitoring_yes',
       'Freq_Alcohol_Always',
       'Freq_Alcohol_Frequently',
       'Freq_Alcohol_Sometimes',
       'Freq_Alcohol_no',
       'Transportation_Automobile',
       'Transportation_Bike',
       'Transportation_Motorbike',
       'Transportation_Public_Transportation',
       'Transportation_Walking']
# After renaming the columns

X_train.head()

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
y_train_encoded = le.fit_transform(y_train)

#y_train.head(10) , y_train_encoded[0:10]

le_test = LabelEncoder()
y_test_encoded = le_test.fit_transform(y_test)
y_test.head(10) , y_test_encoded[0:10]

from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier
from xgboost import XGBClassifier

models={'RandomForest':RandomForestClassifier(),
        'DecisionTree':DecisionTreeClassifier(),
        'KNeighbors':KNeighborsClassifier(),
        'xgbc': XGBClassifier()}

from sklearn.metrics import make_scorer, precision_score, recall_score, f1_score
scoring = {
    'accuracy': 'accuracy',
    'precision': make_scorer(precision_score, average='weighted'),
    'recall': make_scorer(recall_score, average='weighted'),
    'f1': make_scorer(f1_score, average='weighted')}

# %load ../models/Models_eval.py

from sklearn.model_selection import GridSearchCV

def grid_search_cv_eval(X,Y, models, param_grid, scorings,cross_validation):
    """Here we evaluate the models using gridsearchcv and returns the dictionary of best models and result."""

    best_models = {}
    result = {}
    print(models)
    for model in models:
        print(result)
        print(f"\nRunning GridSearch for {model}...")
        gsv = GridSearchCV(
            estimator=models[model],
            param_grid=param_grid[model],
            cv=cross_validation,
            scoring=scorings,
            refit='accuracy'  # Primary metric for model selection
        )
        gsv.fit(X, Y)
        best_models[model] = gsv.best_estimator_
        best_index = gsv.best_index_
        print(f'Best parameters for {model}: {gsv.best_params_}')
        print(f'Best accuracy: {gsv.cv_results_["mean_test_accuracy"][best_index]:.4f}')
        print(f'Best precision: {gsv.cv_results_["mean_test_precision"][best_index]:.4f}')
        print(f'Best recall: {gsv.cv_results_["mean_test_recall"][best_index]:.4f}')
        result[model] = {"parameter":gsv.best_params_,"accuracy":gsv.cv_results_["mean_test_accuracy"][best_index], "precision": gsv.cv_results_["mean_test_precision"][best_index],"recall": gsv.cv_results_["mean_test_recall"][best_index]}

    return best_models, result


from sklearn.model_selection import cross_val_score

# Define the function to compare models with default parameters
def evaluate_models(X, Y, models, scorings, cross_validation):
    result = {}
    
    # Loop through models and evaluate each one
    for model_name, model in models.items():
        print(f"\nEvaluating {model_name}...")
        
        # Evaluate using the defined scoring metrics
        model_scores = {}
        for score_name, scorer in scorings.items():
            score = cross_val_score(model, X, Y, cv=cross_validation, scoring=scorer)
            model_scores[score_name] = score.mean()
        
        # Store results
        result[model_name] = model_scores
        
        # Print the results
        print(f"Accuracy: {model_scores['accuracy']:.4f}")
        print(f"Precision: {model_scores['precision']:.4f}")
        print(f"Recall: {model_scores['recall']:.4f}")
        print(f"F1 Score: {model_scores['f1']:.4f}")
    
    return result

result = evaluate_models(X_train, y_train_encoded, models, scoring, 5)

result_df = pd.DataFrame(result).T

# Plot Accuracy
import matplotlib.pyplot as plt 
import seaborn as sns 
plt.figure(figsize=(10, 6))
sns.barplot(x=result_df.index, y='accuracy', data=result_df, palette="Blues_d")
plt.title('Model Comparison: Accuracy', fontsize=16)
plt.ylabel('Accuracy', fontsize=14)
plt.xlabel('Model', fontsize=14)
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Plot Precision
plt.figure(figsize=(10, 6))
sns.barplot(x=result_df.index, y='precision', data=result_df, palette="Greens_d")
plt.title('Model Comparison: Precision', fontsize=16)
plt.ylabel('Precision', fontsize=14)
plt.xlabel('Model', fontsize=14)
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

# Plot Precision
plt.figure(figsize=(10, 6))
sns.barplot(x=result_df.index, y='recall', data=result_df, palette="Oranges_d")
plt.title('Model Comparison: Recall', fontsize=16)
plt.ylabel('Recall', fontsize=14)
plt.xlabel('Model', fontsize=14)
plt.xticks(rotation=45, ha='right')
plt.tight_layout()
plt.show()

models = ['RandomForest', 'DecisionTree', 'KNeighbors', 'xgbc']

result_df['f1_score'] = 2 * (result_df['precision'] * result_df['recall']) / (result_df['precision'] + result_df['recall'])

# Display the updated table with F1 score
display(result_df)

models={'RandomForest_hyper_tuned':RandomForestClassifier(),
        'xgbc_hyper_tuned': XGBClassifier()}

# Hyperparameter grids for tuning models
param_grids = {
    # Random Forest Hyperparameter Grid
    'RandomForest_hyper_tuned': {
        'n_estimators': [50, 100, 200, 400],               # Number of trees in the forest
        'max_depth': [None, 10, 20, 50],                   # Maximum depth of each tree
        'min_samples_split': [2, 5, 10, 15]                # Minimum number of samples to split a node
    },
    # XGBoostClassifier Hyperparameter Grid
    'xgbc_hyper_tuned': {
        'n_estimators': [50, 100, 200, 400],               # Number of boosting rounds
        'max_depth': [3, 5, 7, 10],                        # Maximum depth of each tree
        'learning_rate': [0.001, 0.01, 0.1, 0.3],          # Step size shrinkage
        'objective': ['multi:softmax'],                    # Multi-class classification
        'verbosity': [0],                                  # Silence output
        'nthread': [-1],                                   # Use all available threads
        'random_state': [42]                               # Ensure reproducibility
    }
}

best_models_hyper_tuned, result_hyper_tuned = grid_search_cv_eval(X_train, y_train_encoded, models, param_grids, scoring, cross_validation=5)
best_models_hyper_tuned, result_hyper_tuned

from sklearn.metrics import confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt

y_pred = best_models_hyper_tuned['xgbc_hyper_tuned'].predict(X_test)

cm = confusion_matrix(y_test_encoded, y_pred)

plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
            xticklabels=le.classes_, yticklabels=le.classes_)
plt.xlabel('Predicted')
plt.ylabel('Actual')
plt.title('Confusion Matrix')
plt.show()

from sklearn.ensemble import RandomForestClassifier
import seaborn as sns
import plotly.express as px

from matplotlib import pyplot as plt
from sklearn.model_selection import cross_val_score

palette = ['#008080','#FF6347', '#E50000', '#D2691E'] # Creating color palette for plots

randomForest_model = best_models_hyper_tuned['RandomForest_hyper_tuned']
randomForest_model = randomForest_model.fit(X_train, y_train)

fimp = pd.Series(data=randomForest_model.feature_importances_, index=X_train.columns).sort_values(ascending=False)
plt.figure(figsize=(17,13))
plt.title("Feature importance")
ax = sns.barplot(y=fimp.index, x=fimp.values, palette=palette, orient='h')

xgboot_model = best_models_hyper_tuned.get('xgbc_hyper_tuned')
xgboot_model

import xgboost
xgboost.plot_importance(xgboot_model)
#plt.title("xgboost plot_importance(model)")
plt.show()

xgboost.plot_importance(xgboot_model, importance_type="cover")
plt.title('xgboost.plot_importance(model, importance_type="cover")')
plt.show()

xgboost.plot_importance(xgboot_model, importance_type="gain")
plt.title('xgboost.plot_importance(model, importance_type="gain")')
plt.show()

import shap

# print the JS visualization code to the notebook
shap.initjs()

explainer = shap.TreeExplainer(xgboot_model)
shap_values = explainer.shap_values(X_train)

shap.summary_plot(shap_values, X_train, plot_type="bar")

class_mapping = {
    'Insufficient_Weight': 0,
    'Normal_Weight': 1,
    'Overweight_Level_I': 2,
    'Overweight_Level_II': 3,
    'Obesity_Type_I': 4,
    'Obesity_Type_II': 5,
    'Obesity_Type_III': 6
}

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler, LabelEncoder
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Drop Weight and Height
dataset_cleaned = clean_data_df.drop(columns=['Weight', 'Height'])

#  Separate features and target variable
X_new = dataset_cleaned.drop(columns=['Obesity_Level'])
y_new = dataset_cleaned['Obesity_Level']

# Encode categorical target variable
le = LabelEncoder()
y_encoded_new = le.fit_transform(y)

# Split data into training and testing sets
X_train_new, X_test_new, y_train_new, y_test_new = train_test_split(X_new, y_encoded_new, stratify=y_encoded_new, test_size=0.2, random_state=42)

# One-Hot Encode Categorical Features
categorical_features = ['Gender', 'Family_History', 'High_Cal_Foods_Frequently', 'Snacking', 
                        'Smoke', 'Calorie_Monitoring', 'Freq_Alcohol', 'Transportation']
X_train_new = pd.get_dummies(X_train_new, columns=categorical_features, drop_first=True)
X_test_new = pd.get_dummies(X_test_new, columns=categorical_features, drop_first=True)

# Ensure train and test datasets have the same columns
X_test_new = X_test_new.reindex(columns=X_train_new.columns, fill_value=0)

# Step 2: Apply Min-Max Scaling to Numerical Features
num_cols = ['Age', 'Freq_Veg', 'Num_Meals', 'Water_Intake', 'Phys_Activity', 'Tech_Use']
scaler = MinMaxScaler()

X_train_new[num_cols] = scaler.fit_transform(X_train_new[num_cols])
X_test_new[num_cols] = scaler.transform(X_test_new[num_cols])

xgb_params = {
    'learning_rate': 0.3,
    'n_estimators': 200,
    'nthread': -1,
    'objective': 'multi:softmax',
    'random_state': 42,
    'verbosity': 0
}

#xgb_model = XGBClassifier(xgb_params)
xgb_model = xgboot_model
xgb_model.fit(X_train_new, y_train_new)

# Step 7: Predictions and Performance Metrics
y_pred = xgb_model.predict(X_test_new)
accuracy = accuracy_score(y_test_new, y_pred)
precision = precision_score(y_test_new, y_pred, average='weighted')
recall = recall_score(y_test_new, y_pred, average='weighted')
f1 = f1_score(y_test_new, y_pred, average='weighted')

# Display results
xgb_metrics = {
    'Accuracy': accuracy,
    'Precision': precision,
    'Recall': recall,
    'F1 Score': f1
}
xgb_metrics

from sklearn.ensemble import RandomForestClassifier

# Step 1: Train Random Forest Model
# rf_model = RandomForestClassifier(
#     n_estimators=200,
#     max_depth=None,
#     random_state=42,
#     n_jobs=-1  # Utilize all available cores
# )
rf_model = randomForest_model
rf_model.fit(X_train_new, y_train_new)

# Step 2: Predictions and Performance Metrics
y_pred_rf = rf_model.predict(X_test_new)
rf_accuracy = accuracy_score(y_test_new, y_pred_rf)
rf_precision = precision_score(y_test_new, y_pred_rf, average='weighted')
rf_recall = recall_score(y_test_new, y_pred_rf, average='weighted')
rf_f1 = f1_score(y_test_new, y_pred_rf, average='weighted')

# Display Random Forest Metrics and Feature Importance
rf_metrics = {
    'Accuracy': rf_accuracy,
    'Precision': rf_precision,
    'Recall': rf_recall,
    'F1 Score': rf_f1
}

rf_metrics

# Combine metrics into a DataFrame for comparison which exclude Weight and Height
comparison_df = pd.DataFrame([rf_metrics, xgb_metrics], index=['Random Forest_EWH', 'XGBoost_EWH'])

# Display the comparison table
comparison_df

# Compute Random Forest feature importance
rf_feature_importance = rf_model.feature_importances_

# Create a DataFrame for feature importance
rf_feature_importance_df = pd.DataFrame({
    'Feature': X_train_new.columns,
    'Importance': rf_feature_importance
}).sort_values(by='Importance', ascending=False)

# Sort the feature importances for better visualization
rf_feature_importance_df = rf_feature_importance_df.sort_values(by="Importance", ascending=False)

# Plot Feature Importance
plt.figure(figsize=(12, 8))
plt.barh(rf_feature_importance_df['Feature'], rf_feature_importance_df['Importance'], color='skyblue')
plt.xlabel('Feature Importance')
plt.ylabel('Features')
plt.title('Random Forest Feature Importance')
plt.gca().invert_yaxis()  # Highest importance at the top
plt.tight_layout()
plt.show()

from xgboost import plot_importance

# Built-in plot with 'gain'
plt.figure(figsize=(12, 8))
plot_importance(xgb_model, importance_type='gain', max_num_features=10)
plt.title('XGBoost Feature Importance (Gain)')
plt.show()

# Custom plot with 'gain'
feature_importance = xgb_model.get_booster().get_score(importance_type='gain')
importance_df = pd.DataFrame(list(feature_importance.items()), columns=['Feature', 'Importance']).sort_values(by='Importance', ascending=False)

plt.figure(figsize=(12, 8))
plt.barh(importance_df['Feature'], importance_df['Importance'], color='skyblue')
plt.xlabel('Feature Importance (Gain)')
plt.ylabel('Features')
plt.title('XGBoost Feature Importance (Gain)')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.show()

# SHAP for Random Forest
explainer_rf = shap.TreeExplainer(rf_model)
shap_values_rf = explainer_rf.shap_values(X_train_new)

# SHAP for XGBoost
explainer_xgb = shap.TreeExplainer(xgb_model)
shap_values_xgb = explainer_xgb.shap_values(X_train_new)

# Visualize the SHAP Summary Plot for RF

shap.summary_plot(shap_values_rf, X_train_new, plot_type="bar")

import xgboost as xgb

# Create DMatrix
dtrain = xgb.DMatrix(X_train_new, label=y_train_new)
explainer_xgb = shap.TreeExplainer(xgb_model)
shap_values_xgb = explainer_xgb.shap_values(dtrain)

#the summary plot
shap.summary_plot(shap_values_xgb, X_train_new, plot_type="bar")

# Select the specified features
selected_features = ['Age', 'Freq_Veg', 'Gender_Male', 'Water_Intake', 'Phys_Activity', 'Tech_Use', 'Num_Meals', 'Family_History_yes']

X_train_selected = X_train_new[selected_features]
X_test_selected = X_test_new[selected_features]

# Initialize and train the RandomForestClassifier with selected features
rf_selected = RandomForestClassifier(n_estimators=200, max_depth=20)  # Using the best parameters found earlier.
rf_selected.fit(X_train_selected, y_train_encoded)

# Make predictions on the test set
y_pred_selected = rf_selected.predict(X_test_selected)

# Evaluate the model (example: accuracy)
from sklearn.metrics import accuracy_score
accuracy_selected = accuracy_score(y_test_encoded, y_pred_selected)
precision_selected = precision_score(y_test_encoded, y_pred_selected, average='weighted')
recall_selected = recall_score(y_test_encoded, y_pred_selected, average='weighted')
f1_selected = f1_score(y_test_encoded, y_pred_selected, average='weighted')
print(f"Accuracy with selected features: {accuracy_selected}")

# Display Random Forest Metrics and Feature Importance
rf_metrics_selected = {
    'Accuracy': accuracy_selected,
    'Precision': precision_selected,
    'Recall': recall_selected,
    'F1 Score': f1_selected
}

rf_metrics_selected 

# Combine metrics into a DataFrame for comparison
comparison_models = pd.DataFrame([rf_metrics, rf_metrics_selected], index=['Random Forest_EWH', 'Random Forest Selected'])

# Display the comparison table
comparison_models

rf_metrics_selected_df=pd.DataFrame([ rf_metrics_selected], index=[ 'Random Forest Selected'])

#result_comp= result_df.drop(columns=['parameter'])
result_comp = result_df.rename(columns={
    'accuracy': 'Accuracy',
    'precision': 'Precision',
    'recall': 'Recall',
    'f1_score': 'F1 Score'
})

# Combine the two DataFrames row-wise
combined_df = pd.concat([ result_comp, rf_metrics_selected_df, comparison_df], axis=0)

# Print the combined DataFrame
print(combined_df)

# Create the DataFrame
data = {
    'Model': [
        'RandomForest', 'DecisionTree', 'KNeighbors', 'xgbc',
        'Random Forest Selected', 'Random Forest_EWH', 'XGBoost_EWH',
    ],
    'Accuracy': [0.932303, 0.919117 ,0.811273, 0.962854, 0.801435, 0.837321 , 0.839713 ],
    'Precision': [0.942822,0.923018 , 0.810466, 0.963345,0.799762, 0.840924, 0.841688],
    'Recall': [0.934096, 0.917965, 0.811273, 0.962854, 0.801435, 0.837321 , 0.839713],
    'F1 Score': [0.936499, 0.919860, 0.810869, 0.963100, 0.797581, 0.836898,  0.839632]
}

df = pd.DataFrame(data)

# Rename the models for clarity
df['Model'] = df['Model'].replace({
    'RandomForest': 'Random Forest all features',
    'DecisionTree': 'Decision Tree all features',
    'KNeighbors': 'KNeighbors all features',
    'xgbc': 'XGBoost all features'
})

# Sort by Accuracy in descending order
df = df.sort_values(by='Accuracy', ascending=False)

# Highlight specific rows
def highlight_rows(row):
    if row['Model'] == 'XGBoost all features':
        return ['background-color: ##FFCCCB'] * len(row)  # Gold for XGBoost all features
    elif row['Model'] == 'Random Forest_EWH':
        return ['background-color: ##FFCCCB'] * len(row)  # Light blue for Random Forest EWH
    else:
        return [''] * len(row)

# Apply highlights
styled_table = df.style.apply(highlight_rows, axis=1)

# Display the styled table
styled_table