Una breve introduzione
Credo che potremmo fare molto di più se ci venissero fornite istruzioni passo dopo passo che ci dicano cosa e come fare. Ricordo momenti della mia vita in cui non riuscivo a iniziare un progetto perché era difficile capire da dove cominciare. Forse, tanto tempo fa, hai visto online le parole "Data Science" e hai pensato che fosse qualcosa di troppo lontano da te, con persone che se ne occupano in un altro mondo. Ma no, sono proprio qui. E forse, grazie a qualcuno in questo campo, ti è arrivato un articolo nella tua timeline. Ci sono molti corsi che ti aiuteranno a padroneggiare questo mestiere, e qui ti aiuterò a fare il tuo primo passo.
Allora, sei pronto? Ti dico subito che dovrai conoscere Python 3, poiché sarà quello che utilizzerò qui. Ti consiglio anche di installare Jupyter Notebook in anticipo o di vedere come utilizzare Google Colab.
Passo uno
Kaggle è un tuo importante alleato in questo processo. In teoria, potresti anche farne a meno, ma ne parlerò in un altro articolo. È una piattaforma dove si svolgono competizioni di Data Science. In ogni competizione, nelle fasi iniziali, avrai l'opportunità di accumulare una quantità incredibile di esperienza nella risoluzione di problemi di vario tipo, nello sviluppo e nel lavoro di squadra, il che è fondamentale al giorno d'oggi.
Prenderemo il nostro compito da lì. Si chiama: «Titanic». La condizione è la seguente: prevedere se ogni singola persona sopravviverà. In generale, il compito di chi si occupa di Data Science è raccogliere dati, elaborarli, addestrare un modello, fare previsioni e così via. Su Kaggle ci è consentito saltare la fase di raccolta dei dati: sono già disponibili sulla piattaforma. Dobbiamo solo caricarli e possiamo iniziare a lavorare!
Possiamo farlo in questo modo:
nella scheda Data sono presenti i file contenenti i dati
Abbiamo caricato i dati, preparato i nostri quaderni Jupyter e…
Passo due
Come possiamo caricare questi dati ora?
In primo luogo, importiamo le librerie necessarie:
import pandas as pd
import numpy as np
Pandas ci permette di caricare file .csv per ulteriori elaborazioni.
Numpy è necessario per rappresentare la nostra tabella di dati come una matrice di numeri.
Procediamo. Prendiamo il file train.csv e carichiamolo:
dataset = pd.read_csv('train.csv')
Ci riferiremo al nostro campione di dati train.csv tramite la variabile dataset. Diamo un'occhiata a cosa c'è dentro:
dataset.head()
La funzione head() ci consente di visualizzare le prime righe del dataframe.
La colonna Survived contiene i nostri risultati che sono noti in questo dataframe. Per la nostra sfida, dobbiamo prevedere la colonna Survived per i dati di test.csv. Questi dati contengono informazioni su altri passeggeri del Titanic, per i quali non conosciamo gli esiti.
Quindi, separiamo la nostra tabella in dati dipendenti e indipendenti. Qui è abbastanza semplice. I dati dipendenti sono quelli che dipendono da quelli indipendenti, ovvero ciò che si trova negli esiti. I dati indipendenti sono quelli che influenzano l'esito.
Ad esempio, abbiamo un insieme di dati come questo:
«Vova ha studiato informatica — no.
Vova ha ricevuto un 2 in informatica.»
Il voto in informatica dipende dalla risposta alla domanda: Vova ha studiato informatica? Chiaro? Andiamo avanti, siamo già più vicini all'obiettivo!
Variabile tradizionale per i dati indipendenti è X. Per quelli dipendenti è y.
Facciamo il seguente passaggio:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Cosa significa? Con la funzione iloc[:, 2: ] diciamo a Python: voglio che la variabile X mostri i dati che iniziano dalla seconda colonna (inclusa e contando che l’indice parte da zero). Nella seconda riga diciamo che vogliamo vedere in y i dati della prima colonna.
[ a:b, c:d ] è la struttura che utilizziamo tra le parentesi. Se non specifichiamo alcune variabili, queste verranno mantenute di default. Dunque possiamo indicare [:,: d] e così otterremo nel DataFrame tutte le colonne tranne quelle a partire dal numero d in poi. Le variabili a e b definiscono le righe, ma ne abbiamo bisogno di tutte, quindi le lasciamo di default.
Vediamo cosa abbiamo ottenuto:
X.head() 
y.head() 
Per semplificare questa breve lezione, rimuoveremo le colonne che richiedono particolare "cura" o che non influiscono affatto sulla sopravvivenza. Contengono dati di tipo str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Ottimo! Procediamo al passo successivo.
Passo tre
Dobbiamo codificare i nostri dati in modo che il computer possa comprendere meglio come questi dati influenzano il risultato. Tuttavia, coderemo solo i dati di tipo str che abbiamo lasciato. La colonna «Sesso». Come vogliamo codificare? Immaginiamo i dati sul sesso di una persona come un vettore: 10 — maschile, 01 — femminile.
Iniziamo convertendo le nostre tabelle in una matrice NumPy:
X = np.array(X)
y = np.array(y)
E ora guardiamo:
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X = np.array(ct.fit_transform(X))
La libreria sklearn è una fantastica libreria che ci consente di eseguire operazioni complete in Data Science. Contiene un gran numero di interessanti modelli di machine learning e ci permette di occuparci della preparazione dei dati.
OneHotEncoder ci permetterà di codificare il sesso di una persona nella rappresentazione che abbiamo descritto. Saranno creati 2 classi: maschile, femminile. Se la persona è un uomo, nella colonna «maschile» verrà registrato 1, e in «femminile», rispettivamente, 0.
Dopo OneHotEncoder() c'è [1] — questo significa che vogliamo codificare la colonna numero 1 (indicizzazione a partire da zero).
Ottimo. Procediamo oltre!
In genere, può succedere che alcuni dati rimangano non compilati (cioè NaN — not a number). Ad esempio, ci sono informazioni su una persona: il suo nome, il suo sesso. Ma non ci sono dati sulla sua età. In questo caso, utilizzeremo un metodo: troveremo la media aritmetica di tutte le colonne e, se ci sono dati mancanti in una colonna, riempiremo il vuoto con la media aritmetica.
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X)
X = imputer.transform(X)
Ora consideriamo che ci sono situazioni in cui i dati possono variare molto. Alcuni dati si trovano nell'intervallo [0:1], mentre altri possono raggiungere centinaia o migliaia. Per escludere tale variabilità e per rendere il computer più preciso nei calcoli, scaleremo i dati, li normalizzeremo. Assicuriamoci che tutti i numeri non superino tre. Per questo, utilizziamo la funzione StandardScaler.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Ora i nostri dati appaiono così:
Ottimo. Siamo già vicini al nostro obiettivo!
Fase quattro
Alleniamo il nostro primo modello! Dalla libreria sklearn possiamo scoprire un’infinità di curiosità. Ho applicato a questo compito il modello Gradient Boosting Classifier. Utilizziamo un classificatore perché il nostro obiettivo è una fase di classificazione. Dobbiamo prevedere se classificare in 1 (survived) o 0 (not survived).
from sklearn.ensemble import GradientBoostingClassifier
gbc = GradientBoostingClassifier(learning_rate=0.5, max_depth=5, n_estimators=150)
gbc.fit(X, y)
La funzione fit dice a Python: lascia che il modello cerchi le dipendenze tra X e y.
Meno di un secondo e il modello è pronto.
Come possiamo applicarlo? Lo vedremo subito!
Passo cinque. Conclusione
Ora dobbiamo caricare il file con i nostri dati di test, per i quali dobbiamo fare delle previsioni. Con questo file eseguiremo tutte le stesse operazioni che abbiamo fatto per X.
X_test = pd.read_csv('test.csv', index_col=0)
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X_test.drop(count, inplace=True, axis=1)
X_test = np.array(X_test)
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), [1])],
remainder='passthrough')
X_test = np.array(ct.fit_transform(X_test))
from sklearn.impute import SimpleImputer
imputer = SimpleImputer(missing_values=np.nan, strategy='mean')
imputer.fit(X_test)
X_test = imputer.transform(X_test)
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X_test[:, 2:] = sc.fit_transform(X_test[:, 2:])
Applichiamo ora il nostro modello!
gbc_predict = gbc.predict(X_test)
Tutto. Abbiamo creato la previsione. Ora deve essere salvata in un csv e inviata al sito.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survissuti')
Fatto. Abbiamo ottenuto un file contenente le previsioni per ogni passeggero. Resta solo da caricare queste soluzioni sul sito e ricevere una valutazione della previsione. Questa soluzione semplice fornisce non solo il 74% di risposte corrette in pubblico, ma anche un certo slancio nel Data Science. I più curiosi possono inviarmi messaggi privati in qualsiasi momento e fare domande. Grazie a tutti!
Fonte: habr.com
