In questo tutorial passeremo in rassegna il dataset del Titanic, lo analizzeremo e invieremo i risultati alla competizione reale. Hai già imparato come recuperare i dati e importarli nel tuo Kaggle Notebook in questo tutorial. Ora useremo DataLab come notebook di data science. Imparerai a usare entrambi gli strumenti su piattaforme diverse, così da poter scegliere il tuo preferito.
Per prima cosa, vai alla sezione "Competitions" su Kaggle e cerca Titanic (Figura 5.4). Prima di entrare direttamente nel notebook, dovresti comprendere tutte le informazioni condivise nelle sezioni "Description and Rules". È importante anche dare un'occhiata ai notebook degli altri utenti, perché possono darti nuove idee per la soluzione.
La competizione riguarda l'uso del machine learning per creare un modello che preveda quali passeggeri sarebbero sopravvissuti al naufragio del Titanic. Useremo un dataset che include informazioni sui passeggeri come nome, genere, età, ecc. Ci sono 2 dataset diversi che utilizzeremo. Il primo si chiama 'train.csv'. In questo dataset, oltre alle informazioni sui passeggeri, ci sono anche i valori di verità a terra, come 'survived' e 'not survived'. Nel secondo dataset, che si chiama 'test.csv', non ci saranno valori di ground truth, perché dobbiamo predirli e inviare i nostri risultati.
Il file di submission avrà solo 2 colonne: PassengerId e Survived. Il sistema di invio produrrà errori se provi a caricare un file con più di 2 valori. Nota che puoi inviare fino a 10 submission al giorno.
Con le informazioni fornite nella sezione "Competition Description", il passo successivo è recuperare i dati nel nostro DataLab e analizzarli.
Per prima cosa, devi scaricare il dataset in Data Explorer andando nella scheda Data (Figura 5.5). Dovresti scaricare sia 'train.csv' che 'test.csv'.
Dopo aver scaricato i file, vai su DataLab. Nota che devi prima creare un account. Creare un account e usare DataLab è gratuito.
Puoi facilmente trascinare e rilasciare i file sul lato sinistro del notebook (Figura 5.6).
Il passo successivo è controllare il data dictionary nella sezione di descrizione del dataset. Questo ci aiuterà a decidere quali colonne visualizzare.
- survival: Sopravvivenza
- pclass: Classe del biglietto
- sex: Sesso
- Age: Età in anni
- sibsp: numero di fratelli/sorelle e coniugi a bordo del Titanic
- parch: numero di genitori e figli a bordo del Titanic
- ticket: Numero del biglietto
- fare: Tariffa del passeggero
- cabin: Numero di cabina
- embarked: Porto d'imbarco
Importazione dei dati
Puoi usare comandi bash nei notebook Jupyter anteponendo un punto esclamativo alla cella. Controlleremo la posizione dei file del dataset caricati usando i comandi pwd e ls.
!pwd; ls
/work/files/workspace
notebook.ipynb test.csv train.csv
Pandas è una libreria Python usata per la manipolazione e l'analisi dei dati. Ora abbiamo rimosso le colonne Ticket, Name e PassengerId perché non contengono dati numerici o categoriali significativi. Ora potrai vedere il resto delle feature da usare.
Nelle prossime righe, i file del training e del test set vengono letti usando il metodo read_csv di Pandas. Nota che le colonne Survived e PassengerId sono aggiunte rispettivamente ai dataframe di train e test. Alimenteremo il modello separatamente usando le feature in columns_to_be_added_as_features e le etichette nella colonna Survived. Ma, per semplificare il preprocessing, per ora possiamo combinarle. La variabile test_df_matcher include anche PassengerId. La useremo per abbinare il PassengerId con le predizioni del test set, per generare il file CSV che sarà caricato su Kaggle come nostro risultato.
import pandas as pd
columns_to_be_added_as_features = ['Sex','Age','SibSp','Parch','Pclass','Fare','Embarked']
train_df = pd.read_csv('train.csv', usecols=columns_to_be_added_as_features + ['Survived'])
test_df_matcher = pd.read_csv('test.csv', usecols=columns_to_be_added_as_features + ['PassengerId'])
test_df = test_df[columns_to_be_added_as_features]
Con il metodo head() possiamo vedere le prime 5 righe insieme ai nomi delle colonne. Puoi definire quante righe iniziali mostrare passando il numero come parametro dentro il metodo head(). Il numero di righe nel training set e nel test set viene stampato rispettivamente nella cella seguente.
print(train_df.head())
print("Number of rows in training set: {}".format(len(train_df)))
print("Number of rows in test set: {}".format(len(test_df)))
Number of rows in training set: 891 Number of rows in test set: 418
Preprocessing
Dovremmo convertire il tipo dei valori in float, che sarà usato come feature nel modello. Questa conversione ci permetterà di eseguire alcune operazioni numeriche durante la normalizzazione dei dati.
for column_title in columns_to_be_added_as_features:
if column_title in ['Embarked', "Sex"]:
continue
train_df[column_title] = pd.to_numeric(train_df[column_title], downcast="float")
test_df[column_title] = pd.to_numeric(test_df[column_title], downcast="float")
train_df["Survived"] = pd.to_numeric(train_df["Survived"], downcast="float")
Dobbiamo alimentare il modello usando valori numerici. Nel pezzo di codice sotto, le stringhe sono convertite in valori numerici
train_df['Embarked'].replace('Q', 0,inplace=True)
train_df['Embarked'].replace('S', 1,inplace=True)
train_df['Embarked'].replace('C', 2,inplace=True)
test_df['Embarked'].replace('Q', 0,inplace=True)
test_df['Embarked'].replace('S', 1,inplace=True)
test_df['Embarked'].replace('C', 2,inplace=True)
train_df['Sex'].replace('male', 0,inplace=True)
train_df['Sex'].replace('female', 1,inplace=True)
test_df['Sex'].replace('male', 0,inplace=True)
test_df['Sex'].replace('female', 1,inplace=True)
print(train_df.head())
Qui sotto, tutte le feature vengono normalizzate, cioè scalate tra 0 e 1 in questo caso.
#Credit: Michael Aquilina,
#https://stackoverflow.com/questions/26414913/normalize-columns-of-pandas-data-frame
def normalize(df):
result = df.copy()
for feature_name in df.columns:
max_value = df[feature_name].max()
min_value = df[feature_name].min()
result[feature_name] = (df[feature_name] - min_value) / (max_value - min_value)
return result
train_df = normalize(train_df)
test_df = normalize(test_df)
print(train_df.head())
Poiché il dataset sarà suddiviso in training e validation, prima mescoleremo il dataset per evitare raggruppamenti in un solo set.
#Credit: Kris, https://stackoverflow.com/questions/29576430/shuffle-dataframe-rows
train_df = train_df.sample(frac=1).reset_index(drop=True)
Tutti i valori vuoti saranno sostituiti con 0; questa scelta è stata fatta per risparmiare tempo. Tuttavia, puoi leggere questo tutorial per imparare a gestire i valori mancanti nel machine learning.
train_df = train_df.fillna(0)
test_df = test_df.fillna(0)
Di seguito, il rapporto per la validation è impostato a 0,2, il che significa che il 20% dei dati sarà usato per validare. Per dividere il dataset in training e validation set, useremo il metodo train_test_split di Sklearn. Poi separeremo feature ed etichette come mostrato nelle ultime 4 righe del codice seguente.
validation_set_ratio = 0.2
validation_set_size = int(len(train_df)*validation_set_ratio)
training_set_size = len(train_df) - validation_set_size
print("Total set size: {}".format(len(train_df)))
print("Training set size: {}".format(training_set_size))
print("Validation set size: {}".format(validation_set_size))
from sklearn.model_selection import train_test_split
train, val = train_test_split(train_df, test_size=validation_set_ratio)
train_X = train[columns_to_be_added_as_features]
train_Label = train[['Survived']]
val_X = val[columns_to_be_added_as_features]
val_Label = val[['Survived']]
Training
Le support vector machine sono modelli di apprendimento supervisionato usati per classificazione e regressione. Questo modello è stato scelto con i parametri sotto. Dovresti provare anche altri modelli con diverse combinazioni di parametri. Non è necessario avviare e fermare il codice ogni volta che vuoi modificare un parametro o provare un altro modello, perché puoi automatizzare questo processo. Se ti interessano le Support Vector Machines, puoi consultare il tutorial Support Vector Machines con Scikit-learn su DataCamp.
from sklearn.svm import SVC
SVM_KERNEL = "linear"
SVM_C = 10
SVM_GAMMA = 0.00001
svm_model = SVC(kernel = SVM_KERNEL, C = SVM_C, gamma = SVM_GAMMA)
svm_model.fit(train_X, train_Label)
Ottenere le predizioni sul validation set
In questa parte, passeremo al modello le feature del validation set e otterremo le predizioni. Poi le confronteremo con i valori di ground truth. Il metodo metrics.accuracy_score di Sklearn è stato usato per semplificare il calcolo dell'accuratezza. L'accuratezza sul validation set è calcolata come 0,799, un buon inizio.
from sklearn import metrics
y_pred = svm_model.predict(val_X)
print("Accuracy:",metrics.accuracy_score(val_Label, y_pred))
Accuracy: 0.7988826815642458
Ottenere le predizioni sul test set
Ora procediamo a ottenere le predizioni per il test set effettivo. Poiché non ci sono valori di ground truth per il test set, potremo conoscere l'accuratezza solo dopo che il file delle predizioni sarà caricato su Kaggle.
test_pred = svm_model.predict(test_df)
Generare il dataframe di output
La colonna PassengerId viene recuperata dal dataframe chiamato test_df_matcher. Se restituita direttamente, il tipo di valore restituito sarà Series. Per questo motivo, la convertiremo in tipo DataFrame di Pandas. Poi inseriremo le predizioni del test set come seconda colonna del dataframe.
result = pd.DataFrame(test_df_matcher['PassengerId'])
print(result.head(10))
result.insert(1, "Survived", test_pred, True)
result["Survived"] = pd.to_numeric(result["Survived"], downcast="integer")
print(result.head(10))
Generare il file di output
Infine, il formato di output è pronto. Come ultimo passo, i valori dell'indice verranno rimossi passando False al parametro index. Ora puoi scaricare il file generato e caricarlo su Kaggle. In questo modo conoscerai l'accuratezza sul test set, dopodiché verrai inserito nella classifica.
result.to_csv("out.csv", index=False)
Ora torneremo alla pagina della competizione, cliccheremo su "Submit Predictions" e poi caricheremo il file con le predizioni. Dopo pochi secondi, otterrai la tua accuratezza sul test (Figura 5.12).
Conclusione
In questo tutorial hai imparato come analizzare un dataset e inviare i tuoi risultati a una competizione Kaggle. Se ti piace partecipare a competizioni di data science, puoi saperne di più sulle DataCamp Competitions qui.
