机器学习 -> Machine Learning (III)

# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)

# Input data files are available in the read-only "../input/" directory
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session

import tensorflow as tf
import tensorflow_decision_forests as tfdf
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

import pandas as pd
from keras.regularizers import l2
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.pipeline import make_pipeline
from sklearn.compose import make_column_transformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder, FunctionTransformer
from tensorflow import keras
from tensorflow.keras import layers

# Loading data
train_data = pd.read_csv('/kaggle/input/spaceship-titanic/train.csv')
train_data = train_data.drop(['PassengerId', 'Name'], axis=1)
train_data[["Deck", "Cabin_num", "Side"]] = train_data["Cabin"].str.split("/", expand=True)
train_data = train_data.drop('Cabin', axis=1)
train_data['Transported'] = train_data['Transported'].fillna(value=0).astype(int)

test_data = pd.read_csv("/kaggle/input/spaceship-titanic/test.csv")
test_data = test_data.drop(['PassengerId', 'Name'], axis=1)
test_data[["Deck", "Cabin_num", "Side"]] = test_data["Cabin"].str.split("/", expand=True)
test_data = test_data.drop('Cabin', axis=1)

# Preprocessor
features_num = ["Age", "VIP", "CryoSleep", "RoomService", "FoodCourt", "ShoppingMall", "Spa", "VRDeck", "Cabin_num"]
features_cat = ["HomePlanet", "Destination", "Deck", "Side"]
features_bool = ["VIP", "CryoSleep"]

def bool_to_int(X):
    return X.astype(int)

transformer_bool = FunctionTransformer(bool_to_int, validate=False)

transformer_num = make_pipeline(
    SimpleImputer(strategy="constant", fill_value=0),
    StandardScaler()
)

transformer_cat = make_pipeline(
    SimpleImputer(strategy="constant", fill_value="NA"),
    OneHotEncoder(handle_unknown='ignore')
)

transformer_bool = make_pipeline(
    SimpleImputer(strategy="constant", fill_value=0),
    StandardScaler()
)

preprocessor = make_column_transformer(
    (transformer_num, features_num),
    (transformer_cat, features_cat),
    (transformer_bool, features_bool)
)

# Splitting the data
X = train_data.drop('Transported', axis=1)
y = train_data['Transported']

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size=0.25, random_state=42)

# Applying the preprocessor
X_train = preprocessor.fit_transform(X_train)
X_valid = preprocessor.transform(X_valid)

input_shape = [X_train.shape[1]]

model = keras.Sequential([
    layers.BatchNormalization(input_shape=input_shape),
    
    layers.Dense(1024, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(rate=0.4),
    
    layers.Dense(512, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(rate=0.4),

    layers.Dense(256, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(rate=0.4),
    
    layers.Dense(128, activation='relu'),
    layers.BatchNormalization(),
    layers.Dropout(rate=0.4),
    
    layers.Dense(1, activation='sigmoid')
])

model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.0003),
    loss='binary_crossentropy',
    metrics=['accuracy']
)

early_stopping = keras.callbacks.EarlyStopping(patience=20, min_delta=0.001, restore_best_weights=True)
lr_scheduler = keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=6, verbose=1)
checkpoint = keras.callbacks.ModelCheckpoint('best_model.h5', save_best_only=True)

# Training
history = model.fit(
    X_train, y_train,
    validation_data=(X_valid, y_valid),
    batch_size=512,
    epochs=100,
    callbacks=[early_stopping, lr_scheduler, checkpoint]
)

# Plotting
history_df = pd.DataFrame(history.history)
history_df.loc[:, ['loss', 'val_loss']].plot(title="Cross-entropy")
history_df.loc[:, ['accuracy', 'val_accuracy']].plot(title="Accuracy")

# Validating
val_loss, val_accuracy = model.evaluate(X_valid, y_valid, verbose=0)

print(f"Validation Loss: {val_loss:.4f}")
print(f"Validation Accuracy: {val_accuracy*100:.2f}%")

# Prediction
test_data_processed = preprocessor.transform(test_data)
predictions = model.predict(test_data_processed)
predicted_labels = (predictions > 0.5).astype(bool).flatten()

submission_df = pd.DataFrame({
    "PassengerId": pd.read_csv("/kaggle/input/spaceship-titanic/test.csv")["PassengerId"],  
    "Transported": predicted_labels
})

submission_df.to_csv("submission.csv", index=False)

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder, FunctionTransformer
import pandas as pd

numeric_features = ['num_feature1', 'num_feature2']
categorical_features = ['cat_feature1', 'cat_feature2']
boolean_features = ['bool_feature1']
date_features = ['date_feature1']

numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='constant', fill_value='missing')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

boolean_transformer = FunctionTransformer(lambda x: x.astype(int), validate=False)

date_transformer = FunctionTransformer(lambda x: pd.to_datetime(x).dt.year, validate=False) 

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features),
        ('bool', boolean_transformer, boolean_features),
        ('date', date_transformer, date_features)
    ])
# 理论上，几乎所有的数据预处理操作都可以封装到 preprocessor 中