# Data setup (Pima Indians Diabetes Dataset)
import warnings; warnings.filterwarnings("ignore")
import pandas as pd
import numpy as np
np.random.seed(42)
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv'
cols = ['Pregnancies','Glucose','BloodPressure','SkinThickness','Insulin','BMI','DiabetesPedigree','Age','Outcome']
df = pd.read_csv(url, names=cols)
print(df.shape)
print(df.head(3))

# Checking for missing values
print(df.isnull().sum())

# Basic stats: mean, median, and spread
print(df.describe())

# Preparing data for modeling
from sklearn.model_selection import train_test_split
X = df.drop('Outcome', axis=1)
y = df['Outcome']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

# Using a Decision Tree (single model)
from sklearn.tree import DecisionTreeClassifier
tree = DecisionTreeClassifier(random_state=42)
tree.fit(X_train, y_train)
print('Accuracy on test set:', tree.score(X_test, y_test))

# Using Random Forest for bagging
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=50, random_state=42)
rf.fit(X_train, y_train)
print('Accuracy on test set:', rf.score(X_test, y_test))

# Feature importance from Random Forest
import numpy as np
import matplotlib.pyplot as plt
importances = rf.feature_importances_
indices = np.argsort(importances)[::-1]
plt.title('Feature Importance (Random Forest)')
plt.bar(range(X.shape[1]), importances[indices], color='teal')
plt.xticks(range(X.shape[1]), X.columns[indices], rotation=45)
plt.tight_layout()
plt.show()

# Trying AdaBoost
from sklearn.ensemble import AdaBoostClassifier
ada = AdaBoostClassifier(n_estimators=50, random_state=42)
ada.fit(X_train, y_train)
print('AdaBoost test accuracy:', ada.score(X_test, y_test))

# Trying Gradient Boosting
from sklearn.ensemble import GradientBoostingClassifier
gb = GradientBoostingClassifier(n_estimators=50, random_state=42)
gb.fit(X_train, y_train)
print('Gradient Boosting test accuracy:', gb.score(X_test, y_test))

# Simple stacking ensemble
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.ensemble import StackingClassifier
base_learners = [
    ('lr', LogisticRegression()),
    ('knn', KNeighborsClassifier()),
    ('dt', DecisionTreeClassifier(random_state=42))
]
stack = StackingClassifier(estimators=base_learners, final_estimator=LogisticRegression(), cv=5)
stack.fit(X_train, y_train)
print('Stacked model accuracy:', stack.score(X_test, y_test))

# Quick user experiment: try your own test size!
test_size_input = input("Choose a test set size between 0.2 and 0.4 (like 0.25): ")
test_size = float(test_size_input)
X_train2, X_test2, y_train2, y_test2 = train_test_split(X, y, test_size=test_size, random_state=42)
rf2 = RandomForestClassifier(n_estimators=50, random_state=42)
rf2.fit(X_train2, y_train2)
print('New test size random forest accuracy:', rf2.score(X_test2, y_test2))

# Challenge: Can you improve accuracy even more?
from sklearn.model_selection import GridSearchCV
params = { 'n_estimators': [30, 50, 70], 'max_depth': [None, 3, 5] }
grid = GridSearchCV(RandomForestClassifier(random_state=42), params, cv=3)
grid.fit(X_train, y_train)
print('Best accuracy:', grid.best_score_)
print('Best parameters:', grid.best_params_)