# Before we begin, let us ensure we do not see distracting warnings.
import warnings
warnings.filterwarnings("ignore")

# First, let us import the tools we will need for ensembles.
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
 
 

# Let us load Titanic data from the internet.
url = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
df = pd.read_csv(url)
print("Shape:", df.shape)
df.head()

# Let us check how many people survived or not.
df['Survived'].value_counts()

# Let us pick a few features to make things simple.
features = ['Pclass', 'Sex', 'Age', 'Fare', 'SibSp', 'Parch']
data = df[features + ['Survived']].copy()
# Convert Sex to numbers: male = 0, female = 1
data['Sex'] = data['Sex'].map({'male': 0, 'female': 1})
# Fill missing Ages with median age
data['Age'] = data['Age'].fillna(data['Age'].median())
 
 

# Time to split into training and test data!
X = data[features]
y = data['Survived']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
 

# A decision tree is a simple model that makes choices by asking questions.
from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)
dt_preds = dt.predict(X_test)
print("Decision Tree accuracy:", accuracy_score(y_test, dt_preds))

# Logistic regression is a simple way to predict yes or no by learning patterns.
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=500)
lr.fit(X_train, y_train)
lr_preds = lr.predict(X_test)
print("Logistic Regression accuracy:", accuracy_score(y_test, lr_preds))

# Random Forest uses many trees and averages their answers.
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rf.fit(X_train, y_train)
rf_preds = rf.predict(X_test)
print("Random Forest accuracy:", accuracy_score(y_test, rf_preds))

# VotingClassifier lets us blend several models at once.
from sklearn.ensemble import VotingClassifier
voting = VotingClassifier(estimators=[
    ("logreg", lr),
    ("dtree", dt),
    ("rforest", rf)
])
voting.fit(X_train, y_train)
voting_preds = voting.predict(X_test)
print("Voting Ensemble accuracy:", accuracy_score(y_test, voting_preds))

# Let us do stacking with StackingClassifier.
from sklearn.ensemble import StackingClassifier
stack = StackingClassifier(estimators=[
    ("lr", lr),
    ("dt", dt),
    ("rf", rf)
], final_estimator=LogisticRegression(max_iter=500), passthrough=False, cv=5)
stack.fit(X_train, y_train)
stack_preds = stack.predict(X_test)
print("Stacking accuracy:", accuracy_score(y_test, stack_preds))

# Mini-Project Part 1: Try stacking with a new meta-model.
from sklearn.svm import SVC
svc = SVC(probability=True, random_state=42)
stack2 = StackingClassifier(estimators=[
    ("lr", lr),
    ("dt", dt),
    ("rf", rf)
], final_estimator=svc, passthrough=False, cv=5)
stack2.fit(X_train, y_train)
stack2_preds = stack2.predict(X_test)
print("Stacking (SVC as meta-model) accuracy:", accuracy_score(y_test, stack2_preds))

# Let us see which models do best -- Mini-Project Part 2!
results = pd.DataFrame({
    "Decision Tree": [accuracy_score(y_test, dt_preds)],
    "Logistic Regression": [accuracy_score(y_test, lr_preds)],
    "Random Forest": [accuracy_score(y_test, rf_preds)],
    "Voting Ensemble": [accuracy_score(y_test, voting_preds)],
    "Stacking (LR)": [accuracy_score(y_test, stack_preds)],
    "Stacking (SVC)": [accuracy_score(y_test, stack2_preds)]
})
results.T.rename(columns={0: 'Accuracy'}).sort_values('Accuracy', ascending=False)

# Sometimes ensembles need careful balancing.
print("Class balance in test set:")
print(y_test.value_counts())

# Quick best practice: always shuffle the data before splitting.
shuffled = data.sample(frac=1, random_state=99).reset_index(drop=True)
shuffled.head()

# Challenge: Can you add an input model name and report its accuracy?
print("Which model? (dt, lr, rf, voting, stack, stack2)")
choice = input("Model code: ").strip()
model_scores = {
    "dt": accuracy_score(y_test, dt_preds),
    "lr": accuracy_score(y_test, lr_preds),
    "rf": accuracy_score(y_test, rf_preds),
    "voting": accuracy_score(y_test, voting_preds),
    "stack": accuracy_score(y_test, stack_preds),
    "stack2": accuracy_score(y_test, stack2_preds)
}
if choice in model_scores:
    print("Accuracy:", model_scores[choice])
else:
    print("Sorry, code not found.")