# Import the warnings library to keep our notebook clean
import warnings
warnings.filterwarnings('ignore')

# We are setting this up to get fewer distracting messages.

# Machine learning always starts with data.
# Let's use the famous Titanic dataset.

import pandas as pd
titanic = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Show how many rows and columns we have.
print("Shape:", titanic.shape)

# See the top few rows.
titanic.head()

# Let us look at the columns in our data.
print(titanic.columns.tolist())

# Each column is a piece of information we can use.

# Let us see how many people survived.
print(titanic['Survived'].value_counts())

# Survived is our target  this is what we want to predict.

# Let us prepare our data for the computer.
# We will only use columns that have no missing values for now.
features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare']

# Drop rows with missing values in these columns.
titanic_clean = titanic.dropna(subset=features)

# Fill in the Sex column as numbers: male is 0, female is 1.
titanic_clean['Sex'] = titanic_clean['Sex'].map({'male': 0, 'female': 1})

# Set up our feature data (X) and our target (y).
X = titanic_clean[features]
y = titanic_clean['Survived']

# Split our data into a train set and a test set.
from sklearn.model_selection import train_test_split

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

print('Train shape:', X_train.shape, 'Test shape:', X_test.shape)

# Make our model: a decision tree classifier.
from sklearn.tree import DecisionTreeClassifier
model = DecisionTreeClassifier(random_state=42)

# Fit (train) the model using training data.
model.fit(X_train, y_train)

# Use our trained model to make predictions.
y_pred = model.predict(X_test)

# Compare predictions to the true answers.

from sklearn.metrics import accuracy_score
acc = accuracy_score(y_test, y_pred)
print("Accuracy:", acc)

# Show predictions for the first 10 passengers in our test set.
print("Predicted:", y_pred[:10])
print("Actual:   ", y_test.values[:10])

# We can see which input features are most important to our model.
import matplotlib.pyplot as plt
importance = model.feature_importances_
plt.bar(features, importance)
plt.title("Feature Importance")
plt.show()

# What happens if you give the model unexpected input? Try running this cell:
try:
    model.predict([[3, 1, 30, 0, 0]])
except Exception as e:
    print("Error:", e)
    

# Let us let a user try their own passenger! Enter values when prompted.
pclass = int(input("Enter Pclass (1, 2, or 3): "))
sex = int(input("Enter Sex (0 for male, 1 for female): "))
age = float(input("Enter Age: "))
sibsp = int(input("Enter number of siblings/spouses aboard: "))
parch = int(input("Enter number of parents/children aboard: "))
fare = float(input("Enter Fare: "))

my_features = [[pclass, sex, age, sibsp, parch, fare]]
result = model.predict(my_features)
if result[0] == 1:
    print("The model predicts: Survived")
else:
    print("The model predicts: Did not survive")
    

# Try another model: logistic regression.
from sklearn.linear_model import LogisticRegression

log_model = LogisticRegression()
log_model.fit(X_train, y_train)

log_acc = log_model.score(X_test, y_test)
print("Logistic Regression accuracy:", log_acc)

# Challenge: What do you think will happen if you use only one feature?
X_age = X_train[['Age']]
model_one = DecisionTreeClassifier(random_state=42)
model_one.fit(X_age, y_train)
score_one = model_one.score(X_test[['Age']], y_test)
print('Accuracy with Age only:', score_one)

# Quick recap: What is in a machine learning pipeline?
# 1. Data loading
# 2. Data cleaning and prep
# 3. Split data train/test
# 4. Model building
# 5. Model testing
# 6. Use the model for new predictions

# Extra: Save your results to a CSV file.
output = X_test.copy()
output['Predicted'] = y_pred
output.to_csv('my_titanic_predictions.csv', index=False)
print('Saved to my_titanic_predictions.csv')