Una breve introduzione
Ritengo che potremmo realizzare molte più cose se ci venissero fornire istruzioni passo passo su cosa e come fare. Ricordo momenti della mia vita in cui non sapevo come iniziare un compito perché era difficile capire da dove cominciare. Forse, molto tempo fa, hai visto le parole "Data Science" su internet e hai pensato che fosse qualcosa di lontano, un campo praticato da persone in un altro mondo. Eppure, sono qui, proprio accanto a te. E, forse, grazie a qualcuno di questo settore, hai trovato un articolo nel tuo feed. Esistono molti corsi che ti aiuteranno a padroneggiare questo mestiere; qui ti aiuterò a fare il tuo primo passo.
Allora, sei pronto? Ti dirò subito che dovrai conoscere Python 3, poiché lo utilizzerò qui. Ti consiglio inoltre di installare in anticipo Jupyter Notebook o di scoprire come usare Google Colab.
Primo passo
Kaggle sarà un grande alleato in questo compito. In effetti, puoi anche farne a meno, ma di questo parlerò in un altro articolo. È una piattaforma dove si svolgono competizioni di Data Science. In ognuna di queste competizioni, in una fase iniziale, guadagnerai un'enorme esperienza nella risoluzione di problemi di vario tipo, nello sviluppo e nel lavoro di squadra, che è fondamentale al giorno d'oggi.
Prenderemo il nostro compito da lì. Si chiama: "Titanic". Il compito è: prevedere se ciascun individuo sopravvivrà o meno. In generale, il compito di chi si occupa di DS è raccogliere dati, elaborarli, addestrare un modello, fare previsioni e così via. Su Kaggle, ci viene permesso di saltare la fase di raccolta dei dati — sono già presenti sulla piattaforma. Dobbiamo solo caricarli e possiamo iniziare a lavorare!
Puoi farlo nel seguente modo:
nella scheda Data ci sono i file contenenti i dati
Abbiamo caricato i dati, preparato i nostri notebook Jupyter e…
Secondo passo
Come carichiamo ora questi dati?
Innanzitutto, importiamo le librerie necessarie:
import pandas as pd
import numpy as np
Pandas ci permetterà di caricare i file .csv per ulteriori elaborazioni.
Numpy è necessario per rappresentare la nostra tabella di dati come una matrice di numeri.
Proseguiamo. Prendiamo il file train.csv e carichiamolo:
dataset = pd.read_csv('train.csv')
Faremo riferimento 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 rappresenta i nostri risultati noti in questo dataframe. Per quanto riguarda il compito, dobbiamo prevedere la colonna Survived per i dati di test.csv. Questi dati contengono informazioni su altri passeggeri del Titanic, per i quali noi, che stiamo risolvendo il compito, non conosciamo gli esiti.
Quindi, separiamo la nostra tabella in dati dipendenti e indipendenti. Qui è semplice. I dati dipendenti sono quelli che dipendono dai dati indipendenti, cioè ciò che si trova negli esiti. I dati indipendenti sono quelli che influenzano l'esito.
Per esempio, abbiamo un insieme di dati come questo:
«Vova ha studiato informatica — no.
Vova ha ottenuto 2 in informatica.»
Il punteggio in informatica dipende dalla risposta alla domanda: Vova ha studiato informatica? Chiaro? Procediamo, siamo già più vicini all'obiettivo!
La variabile tradizionale per i dati indipendenti è X. Per i dati dipendenti è y.
Facciamo quanto segue:
X = dataset.iloc[ : , 2 : ]
y = dataset.iloc[ : , 1 : 2 ]
Cosa significa? Con la funzione iloc[:, 2: ] diciamo a Python: voglio vedere nella variabile X i dati a partire dalla seconda colonna (inclusa, considerando che il conteggio parte da zero). Nella seconda riga diciamo che vogliamo vedere in y i dati della prima colonna.
[ a:b, c:d ] — questa è la costruzione che utilizziamo tra le parentesi. Se non specifichiamo alcune variabili, esse rimarranno impostate su default. Cioè possiamo specificare [:,: d] e allora otterremo nel dataframe tutte le colonne, tranne quelle che iniziano con il numero d e oltre. Le variabili a e b definiscono le righe, ma ci servono tutte, quindi lasciamo impostate su default.
Vediamo cosa abbiamo ottenuto:
X.head() 
y.head() 
Per semplificare questa breve lezione, rimuoveremo le colonne che richiedono una particolare ‘cura’, oppure che non influenzano affatto la sopravvivenza. Contengono dati di tipo str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Ottimo! Passiamo al prossimo passo.
Passo tre
Qui dobbiamo codificare i nostri dati in modo che la macchina comprenda meglio come questi dati influenzano il risultato. Ma coderemo solo quelli di tipo str che abbiamo lasciato. Colonna «Sex». Come vogliamo codificare? Immaginiamo i dati sul genere di una persona come un vettore: 10 — maschile, 01 — femminile.
Iniziamo a convertire le nostre tabelle in una matrice NumPy:
X = np.array(X)
y = np.array(y)
E ora diamo un'occhiata:
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 libreria fantastica che ci permette di svolgere un lavoro completo in Data Science. Contiene un gran numero di modelli interessanti di machine learning e ci aiuta nella preparazione dei dati.
OneHotEncoder ci permetterà di codificare il genere di una persona nella rappresentazione che abbiamo descritto. Verranno creati 2 classi: maschile e femminile. Se la persona è un uomo, nella colonna «maschile» verrà registrato 1, mentre in «femminile», 0.
Dopo OneHotEncoder() c'è [1] — significa che vogliamo codificare la colonna numero 1 (contando da zero).
Super. Andiamo avanti!
Di solito, si verifica che alcuni dati rimangano incompleti (cioè NaN — not a number). Ad esempio, ci sono informazioni su una persona: il suo nome, genere. Ma non abbiamo dati sulla sua età. In questo caso applicheremo un metodo: troveremo la media aritmetica di tutte le colonne e, se alcuni dati in una colonna sono mancanti, 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)
E ora consideriamo che ci sono situazioni in cui i dati sono molto sgranati. Alcuni dati si trovano nell'intervallo [0:1], mentre altri possono superare le centinaia e le migliaia. Per escludere tale dispersione e rendere il computer più preciso nei calcoli, scaleremo i dati. Facciamo in modo che tutti i numeri non superino tre. Per questo utilizzeremo 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 trovare una quantità enorme di interessi. Ho applicato a questo compito il modello Gradient Boosting Classifier. Usiamo un classificatore poiché il nostro obiettivo è una questione di classificazione. Dobbiamo prevedere se sia 1 (sopravvissuto) o 0 (non sopravvissuto).
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 ora!
Passo cinque. Conclusione
Ora dobbiamo caricare il file con i nostri dati di test, per i quali dobbiamo fare una previsione. Per questo file faremo esattamente 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 già il nostro modello!
gbc_predict = gbc.predict(X_test)
Tutto. Abbiamo fatto la previsione. Ora dobbiamo salvarla in un csv e inviarla al sito.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Fatto. Abbiamo ottenuto un file contenente previsioni per ogni passeggero. Resta solo da caricare queste decisioni sul sito e ottenere un punteggio per la previsione. Questa soluzione primitiva fornisce non solo il 74% di risposte corrette in pubblico, ma anche un certo impulso nel Data Science. I più curiosi possono contattarmi in qualsiasi momento in privato e porre domande. Grazie a tutti!
Fonte: habr.com
