Una breve parola introduttiva
Credo che potremmo fare più cose se ci fossero fornite istruzioni passo passo che ci dicessero cosa fare e come farlo. Io stesso ricordo momenti della mia vita in cui non potevo iniziare qualcosa perché semplicemente era difficile capire da dove cominciare. Forse, una volta su Internet hai visto le parole "Data Science" e hai deciso che eri lontano da questo, e le persone che lo fanno erano da qualche parte là fuori, in un altro mondo. No, sono proprio qui. E forse, grazie a persone del settore, un articolo è apparso sul tuo feed. Ci sono molti corsi che ti aiuteranno a familiarizzare con questo mestiere, ma qui ti aiuterò a fare il primo passo.
Bene, sei pronto? Lascia che ti dica subito che dovrai conoscere Python 3, poiché è quello che userò qui. Ti consiglio anche di installarlo preventivamente su Jupyter Notebook o di vedere come usare google colab.
Шаг первый
Kaggle è il tuo assistente significativo in questa faccenda. In linea di principio puoi farne a meno, ma di questo ne parlerò in un altro articolo. Questa è una piattaforma che ospita concorsi di Data Science. In ciascuna di queste competizioni, nelle fasi iniziali acquisirai una quantità irrealistica di esperienza nella risoluzione di problemi di vario genere, esperienza di sviluppo ed esperienza di lavoro in squadra, che è importante ai nostri tempi.
Da lì riprenderemo il nostro compito. Si chiama "Titanic". La condizione è questa: prevedere se ogni singola persona sopravviverà. In generale, il compito di una persona coinvolta nel DS è raccogliere dati, elaborarli, addestrare un modello, fare previsioni e così via. In Kaggle possiamo saltare la fase di raccolta dei dati: vengono presentati sulla piattaforma. Dobbiamo scaricarli e possiamo iniziare!
Puoi farlo come segue:
la scheda Dati contiene file che contengono dati
Abbiamo scaricato i dati, preparato i nostri quaderni Jupyter e...
Шаг второй
Come carichiamo ora questi dati?
Per prima cosa importiamo le librerie necessarie:
import pandas as pd
import numpy as np
Panda ci consentirà di scaricare file .csv per ulteriori elaborazioni.
Numpy è necessario per rappresentare la nostra tabella dati come una matrice con numeri.
Andare avanti. Prendiamo il file train.csv e carichiamocelo:
dataset = pd.read_csv('train.csv')
Faremo riferimento alla nostra selezione dei dati train.csv attraverso la variabile dataset. Vediamo cosa c'è:
dataset.head()
La funzione head() ci permette di guardare le prime righe di un dataframe.
Le colonne Survived sono proprio i nostri risultati, noti in questo dataframe. Per la domanda sull'attività, dobbiamo prevedere la colonna Sopravvissuto per i dati test.csv. Questi dati memorizzano informazioni su altri passeggeri del Titanic, di cui noi, risolvendo il problema, non conosciamo il risultato.
Quindi, dividiamo la nostra tabella in dati dipendenti e indipendenti. Tutto è semplice qui. I dati dipendenti sono quei dati che dipendono dai dati indipendenti presenti nei risultati. I dati indipendenti sono quei dati che influenzano il risultato.
Ad esempio, abbiamo il seguente set di dati:
“Vova ha insegnato informatica - no.
Vova ha ricevuto 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!
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 ]
Cos'è? Con la funzione iloc[:, 2: ] diciamo a Python: voglio vedere nella variabile X i dati a partire dalla seconda colonna (compresa e purché il conteggio parta da zero). Nella seconda riga diciamo che vogliamo vedere i dati nella prima colonna.
[ a:b, c:d ] è la costruzione di ciò che usiamo tra parentesi. Se non specifichi alcuna variabile, queste verranno salvate come predefinite. Cioè possiamo specificare [:,: d] e poi otterremo tutte le colonne del dataframe, tranne quelle che vanno dal numero d in poi. Le variabili a e b definiscono le stringhe, ma ne abbiamo bisogno tutte, quindi la lasciamo come predefinita.Vediamo cosa abbiamo ottenuto:
X.head()
y.head()
Per semplificare questa piccola lezione, rimuoveremo le colonne che richiedono particolare attenzione o che non influiscono affatto sulla sopravvivenza. Contengono dati di tipo str.
count = ['Name', 'Ticket', 'Cabin', 'Embarked']
X.drop(count, inplace=True, axis=1)
Super! Passiamo al passaggio successivo.
Passaggio tre
Qui dobbiamo codificare i nostri dati in modo che la macchina comprenda meglio come questi dati influenzano il risultato. Ma non codificheremo tutto, ma solo i dati str che abbiamo lasciato. Colonna "Sesso". Come vogliamo codificare? Rappresentiamo i dati sul sesso di una persona come un vettore: 10 - maschio, 01 - femmina.
Innanzitutto, convertiamo 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 libreria davvero interessante che ci consente di svolgere un lavoro completo in Data Science. Contiene un gran numero di interessanti modelli di machine learning e ci consente anche di preparare i dati.
OneHotEncoder ci consentirà di codificare il genere di una persona in quella rappresentazione, come abbiamo descritto. Verranno create 2 classi: maschile, femminile. Se una persona è un uomo, allora 1 verrà scritto rispettivamente nella colonna “maschio” e 0 nella colonna “femmina”.
Dopo OneHotEncoder() c'è [1] - questo significa che vogliamo codificare la colonna numero 1 (contando da zero).
Super. Andiamo ancora oltre!
Di norma, accade che alcuni dati vengano lasciati vuoti (ovvero NaN, non un numero). Ad esempio, ci sono informazioni su una persona: il suo nome, sesso. Ma non ci sono informazioni sulla sua età. In questo caso applicheremo il seguente metodo: troveremo la media aritmetica su tutte le colonne e, se nella colonna manca qualche dato, 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)
Consideriamo ora che si verificano situazioni in cui i dati sono molto grandi. Alcuni dati rientrano nell'intervallo [0:1], mentre altri possono andare oltre le centinaia e le migliaia. Per eliminare tale dispersione e rendere il computer più accurato nei suoi calcoli, scansioneremo i dati e li ridimensioneremo. Lascia che tutti i numeri non superino tre. Per fare ciò, utilizzeremo la funzione StandardScaler.
from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
X[:, 2:] = sc.fit_transform(X[:, 2:])
Ora i nostri dati appaiono così:
Classe. Siamo già vicini al nostro obiettivo!
Passo quattro
Addestriamo il nostro primo modello! Dalla libreria Sklearn possiamo trovare un gran numero di cose interessanti. Ho applicato il modello Gradient Boosting Classifier a questo problema. Usiamo un classificatore perché il nostro compito è un compito di classificazione. La prognosi dovrebbe essere assegnata a 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 applicarlo? Vedremo ora!
Passo cinque. Conclusione
Ora dobbiamo caricare una tabella con i nostri dati di test per i quali dobbiamo fare una previsione. Con questa tabella faremo tutte le stesse azioni 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 fatto una previsione. Ora deve essere registrato in CSV e inviato al sito.
np.savetxt('my_gbc_predict.csv', gbc_predict, delimiter=",", header = 'Survived')
Pronto. Abbiamo ricevuto un file contenente le previsioni per ciascun passeggero. Non resta che caricare queste soluzioni sul sito e ottenere una valutazione delle previsioni. Una soluzione così primitiva fornisce non solo il 74% delle risposte corrette al pubblico, ma anche un certo impulso alla scienza dei dati. I più curiosi possono scrivermi in qualsiasi momento nei messaggi privati e porre una domanda. Grazie a tutti!
Fonte: habr.com