Come iniziare con il Machine Learning in 10 minuti

Come iniziare con il Machine Learning in 10 minuti

Con l’avvento del Machine Learning all’interno delle aziende, la necessità di uno strumento potente e di facile utilizzo è diventata sempre più vitale. Python, una stella nascente nella tecnologia Machine Learning, è spesso la prima scelta per portarti al ​​successo.


Introduzione al Machine Learning con Python

Dunque, perché Python? Nella mia esperienza, Python è uno dei linguaggi di programmazione più facili da imparare. Inoltre, è anche quello che più si adatta a gestire la mole di calcoli che il Machine Learning richiede.

Quanto facile?

for anything in the_list:
    print(anything)

Così facile. La sintassi è strettamente correlata al linguaggio parlato (non un linguaggio macchina). E non ci sono stupide parentesi graffe che confondono gli “umani”.

Quindi, i primi fautori del Machine Learning, hanno pensato bene di realizzare librerie di cui discuteremo qui di seguito, scegliendo Python come linguaggio da cui partire. E come data analysts, possiamo semplicemente usare i loro strumenti per aiutarci nello sviluppo. Di seguito ecco le librerire indispensabili per il Machine Learning con Python.

  1. Numpy: La famosa libreria di analisi numerica. Ti aiuterà a fare molte cose, dal calcolo della mediana della distribuzione dei dati, all’elaborazione di array multidimensionali.
  2. Pandas: Per l’elaborazione di file CSV. Ovviamente, dovrai elaborare alcune tabelle e vedere le statistiche, e questo è lo strumento giusto.
  3. Matplotlib: Dopo aver archiviato i dati nei frame di dati di Pandas, potresti aver bisogno di alcune views per comprendere meglio i dati. Questa libreria mette al tuo servizio dei grafici, frutto dell’analisi effettuata con la precedente libreria.
  4. Seaborn: Questo è anche un altro strumento di visualizzazione, ma più focalizzato sulla visualizzazione statistica. Cose come istogrammi o grafici a torta o curve o tabelle di correlazione.
  5. Scikit-Learn: Questo è il boss finale del Machine Learning con Python. Tutte le cose di cui hai bisogno dagli algoritmi ai miglioramenti sono qui.

Un nuovo progetto Machine Learning con Python

Naturalmente, leggere e studiare da solo non ti porterà dove devi andare. Hai bisogno di pratica effettiva. L’apprendimento degli strumenti è inutile se non metti effettivamente mano ai dati. Pertanto, ti mostro un posto dove puoi trovare facilmente i progetti Machine Learning di Python.

Kaggle è una piattaforma con la quale è possibile lavorare direttamente coi dati. Ti aiuterà a risolvere problemi complessi e ti farà diventare davvero bravo nel Machine Learning. Qualcosa che potrebbe renderti più interessato a questo argomento: i concorsi di Machine Learning che detiene possono dare un premio fino a $ 100.000. E potresti voler tentare la fortuna. Haha.

Ma la cosa più importante non sono i soldi: è davvero una risorsa fondamentale, dove puoi trovare diversi progetti Python e Machine Learning. Puoi provarne molti. Ma se sei un principiante, e presumo tu lo sia, vorrai seguire i miei consigli.

Ecco un esempio di progetto che utilizzeremo nel seguente tutorial:

Titanic: Machine Learning from Disaster

Sì, il famigerato Titanic. Un tragico disastro che nel 1912, tolse la vita a 1502 persone da 2224 passeggeri e membri dell’equipaggio. Questa sfida di Kaggle (o posso dire tutorial) ti fornisce i dati reali sul disastro. Il tuo compito è quello di “analizzare” i dati in modo che tu possa prevedere se un personaggio è sopravvissuto o meno durante l’incidente.


Tutorial Machine Learning con Python

Prima di approfondire i dati del Titanic, installiamo alcuni strumenti di cui hai bisogno.

Certo, Python. È necessario installarlo per primo, dal sito Web ufficiale. Devi installare la versione 3.6+ per tenerti aggiornato con le librerie.

Dopo ciò, è necessario installare tutte le librerie tramite Python pip. Pip dovrebbe essere installato automaticamente con la distribuzione di Python appena scaricata.

Quindi installa i pacchetti che ti servono tramite pip. Apri il tuo terminale, riga di comando o PowerShell e scrivi quanto segue:

pip install numpy
pip install pandas
pip install matplotlib
pip install seaborn
pip install scikit-learn
pip install jupyter

Bene, tutto sembra a posto. Ma aspetta, che cos’è jupyter? Jupyter sta per Julia, Python e R, quindi Jupytr. Ma essendo una strana combinazione di parole, l’hanno trasformato in solo Jupyter. È un famoso taccuino in cui è possibile scrivere codice Python in modo interattivo.

Digita semplicemente jupyter notebook nel tuo terminale e aprirai una pagina del browser come questa:

Scrivi il codice all’interno del rettangolo verde e potrai gestirlo in modo interattivo.

Ora hai installato tutti gli strumenti. Muoviamoci!

Esplorazione dei dati

Il primo passo è esplorare i dati. Devi scaricare i dati dalla pagina di Titanic in Kaggle. Quindi inserisci i dati estratti all’interno di una cartella in cui avvii il tuo notebook Jupyter.

Quindi importa le librerie necessarie:

import numpy as np 
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline

Dopo carica i dati:

train_df=pd.read_csv("train.csv")
train_df.head()

Vedrai qualcosa di simile a questo:

Questi sono i nostri dati. Hanno le seguenti colonne:

  1. PassengerId, l’identificatore del passeggero
  2. Survived, se lui/lei è sopravvissuto o no
  3. Pclass, la classe del servizio, ad esempio 1 è economy, 2 è business, 3 è prima classe
  4. Name, il nome del passeggero
  5. Ses, il suo genere
  6. Age, la sua età
  7. Sibsp, o fratelli e coniugi, numero di fratelli e coniugi a bordo
  8. Parch, o genitori e figli, numero di loro a bordo
  9. Ticket, dettagli del biglietto
  10. Cabin, la loro cabina. NaN vuol dire che non avevano nessuna cabina.
  11. Embarked, l’origine dell’imbarco, S sta per Southampton, Q per Queenstown, C per Cherbourg

Durante l’analisi, troviamo spesso dati mancanti. Vediamoli:

def missingdata(data):
    total = data.isnull().sum().sort_values(ascending = False)
    percent = (data.isnull().sum()/data.isnull().count()*100).sort_values(ascending = False)
    ms=pd.concat([total, percent], axis=1, keys=['Total', 'Percent'])
    ms= ms[ms["Percent"] > 0]
    f,ax =plt.subplots(figsize=(8,6))
    plt.xticks(rotation='90')
    fig=sns.barplot(ms.index, ms["Percent"],color="green",alpha=0.8)
    plt.xlabel('Features', fontsize=15)
    plt.ylabel('Percent of missing values', fontsize=15)
    plt.title('Percent missing data by feature', fontsize=15)
    return ms
missingdata(train_df)

Vedremo un risultato come questo:

La cabina, l’età e i dati sull’imbarco, hanno alcuni valori mancanti. E l’informazione della cabina è in gran parte mancante. Dobbiamo fare qualcosa per questo. Questo è ciò che viene definito: Data Cleaning.


Data Cleaning

Questo è ciò che viene fatto il 90% delle volte. Faremo la pulizia dei dati molto spesso per ogni singolo progetto di Machine Learning. Quando i dati saranno puliti, potremo saltare al prossimo punto senza preoccuparci.

La tecnica più comune nel Data Cleaning è il riempimento dei dati mancanti. Puoi riempire i dati mancanti con Mode, Mean o Median. Non esiste una regola assoluta per queste scelte: puoi provare a sceglierne una dopo l’altra e vedere la performance. Ma, per una regola empirica, puoi utilizzare la modalità solo per i dati categorizzati e puoi utilizzare mediana o media per i dati continui.

Quindi riempiamo i dati di imbarco con i dati Mode e Age con Median.

train_df['Embarked'].fillna(train_df['Embarked'].mode()[0], inplace = True)
train_df['Age'].fillna(train_df['Age'].median(), inplace = True)

La prossima tecnica importante è semplicemente rimuovere i dati, soprattutto per i dati in gran parte mancanti. Facciamolo per i dati della cabina.

drop_column = ['Cabin']
train_df.drop(drop_column, axis=1, inplace = True)

Ora possiamo controllare i dati che abbiamo pulito.

print('check the nan value in train data')
print(train_df.isnull().sum())

Perfetto! Nessun dato mancante trovato. Significa che i dati sono stati puliti.

Feature Engineering

Ora abbiamo pulito i dati. La prossima cosa che possiamo fare è il Feature Engineering.

Il Feature Engineering è fondamentalmente una tecnica per trovare Feature o Data dai dati attualmente disponibili. Ci sono diversi modi per attuarla. Ma nella maggior parte dei casi, si tratta di buon senso.

Diamo un’occhiata ai dati sull’imbarco: è pieno di Q, S o C. La libreria Python non sarà in grado di elaborarli, poiché è in grado di elaborare solo numeri. Quindi dovremo attuare una tecnica chiamata One Hot Vectorization, splittando la colonna in tre colonne. Diciamo Embarked_Q, Embarked_S e Embarked_C che sono riempiti con 0 o 1 se la persona si è imbarcata da quel porto o no.

L’altro esempio è SibSp e Parch. Forse non c’è nulla di interessante in entrambe le colonne, ma potresti voler sapere quanto fosse grande la famiglia del passeggero che si è imbarcato sulla nave. Potresti presumere che se la famiglia fosse stata più grande, le possibilità di sopravvivenza sarebbero aumentate, poiché avrebbero potuto aiutarsi a vicenda. D’altra parte, i solisti avrebbero avuto più difficoltà.

Quindi creeremo un’altra colonna chiamata family size, che è composta da sibsp + parch + 1 (il passeggero stesso).

L’ultimo esempio è chiamato bin columns. È una tecnica che crea intervalli di valori per raggruppare più cose insieme, poiché si assume che sia difficile differenziare le cose con un valore simile. Ad esempio, l’età.
Per una persona di 5 o 6 anni, c’è qualche differenza significativa? O per persone di età compresa tra 45 e 46 anni, c’è qualche grande differenza?

Ecco perché creiamo le bin columns. Forse per ogni età creeremo 4 bin (contenitori). Bambini (0-14 anni), Adolescenti (14-20 anni), Adulti (20-40 anni) e Anziani (40+).


Andiamo a scrivere un po’ di codice:

all_data = train_df
for dataset in all_data :
    dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1
import re
# Define function to extract titles from passenger names
def get_title(name):
    title_search = re.search(' ([A-Za-z]+)\.', name)
    # If the title exists, extract and return it.
    if title_search:
        return title_search.group(1)
    return ""
# Create a new feature Title, containing the titles of passenger names
for dataset in all_data:
    dataset['Title'] = dataset['Name'].apply(get_title)
# Group all non-common titles into one single grouping "Rare"
for dataset in all_data:
    dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 
                                                 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')
dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')
    dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
    dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')
for dataset in all_data:
    dataset['Age_bin'] = pd.cut(dataset['Age'], bins=[0,14,20,40,120], labels=['Children','Teenage','Adult','Elder'])
for dataset in all_data:
    dataset['Fare_bin'] = pd.cut(dataset['Fare'], bins=[0,7.91,14.45,31,120], labels ['Low_fare','median_fare', 'Average_fare','high_fare'])
                                                                                
traindf=train_df
for dataset in traindf:
    drop_column = ['Age','Fare','Name','Ticket']
    dataset.drop(drop_column, axis=1, inplace = True)
drop_column = ['PassengerId']
traindf.drop(drop_column, axis=1, inplace = True)
traindf = pd.get_dummies(traindf, columns = ["Sex","Title","Age_bin","Embarked","Fare_bin"],
                             prefix=["Sex","Title","Age_type","Em_type","Fare_type"])

Ora hai completato tutte le funzionalità. Diamo un’occhiata alle correlazioni per ogni caratteristica implementata:

sns.heatmap(traindf.corr(),annot=True,cmap='RdYlGn',linewidths=0.2) #data.corr()-->correlation matrix
fig=plt.gcf()
fig.set_size_inches(20,12)
plt.show()

Le correlazioni con il valore di 1 significano altamente correlato positivamente, -1 significa altamente correlato negativamente. Ad esempio, sesso maschile e sesso femminile si correlano negativamente, poiché i passeggeri dovevano identificarsi come uno o l’altro sesso. Oltre a questo, puoi vedere che nulla è collegato a qualcosa in maniera molto elevata, eccetto quelli creati tramite le tecniche utilizzate precedentemente. Questo significa che siamo a posto.

Che cosa potrebbe accadere se qualcosa fosse altamente correlato con qualcos’altro? Possiamo tranquillamente eliminarne una, poiché aggiungere nuove informazioni tramite una nuova colonna non fornirebbe al sistema nuove informazioni, poiché entrambe sono esattamente le stesse.

Machine Learning con Python

Ora siamo arrivati ​​all’apice del tutorial: modellizzazione e Machine Learning.

from sklearn.model_selection import train_test_split #for split the data
from sklearn.metrics import accuracy_score  #for accuracy_score
from sklearn.model_selection import KFold #for K-fold cross validation
from sklearn.model_selection import cross_val_score #score evaluation
from sklearn.model_selection import cross_val_predict #prediction
from sklearn.metrics import confusion_matrix #for confusion matrix
all_features = traindf.drop("Survived",axis=1)
Targeted_feature = traindf["Survived"]
X_train,X_test,y_train,y_test = train_test_split(all_features,Targeted_feature,test_size=0.3,random_state=42)
X_train.shape,X_test.shape,y_train.shape,y_test.shape

Puoi scegliere molti algoritmi inclusi nella libreria di scikit-learn.

  1. Logistic Regression
  2. Random Forest
  3. SVM
  4. K Nearest Neighbor
  5. Naive Bayes
  6. Decision Trees
  7. AdaBoost
  8. LDA
  9. Gradient Boosting

Potresti confonderti un po’ cercando di capire cosa sia cosa. Non ti preoccupare, basta trattare il tutto come se dovessi pescare da una scatola nera: scegli quella con le migliori prestazioni.

Proviamo con il mio preferito: l’Algoritmo Random Forest

from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier(criterion='gini', n_estimators=700,
                             min_samples_split=10,min_samples_leaf=1,
                             max_features='auto',oob_score=True,
                             random_state=1,n_jobs=-1)
model.fit(X_train,y_train)
prediction_rm=model.predict(X_test)
print('--------------The Accuracy of the model----------------------------')
print('The accuracy of the Random Forest Classifier is', round(accuracy_score(prediction_rm,y_test)*100,2))
kfold = KFold(n_splits=10, random_state=22) # k=10, split the data into 10 equal parts
result_rm=cross_val_score(model,all_features,Targeted_feature,cv=10,scoring='accuracy')
print('The cross validated score for Random Forest Classifier is:',round(result_rm.mean()*100,2))
y_pred = cross_val_predict(model,all_features,Targeted_feature,cv=10)
sns.heatmap(confusion_matrix(Targeted_feature,y_pred),annot=True,fmt='3.0f',cmap="summer")
plt.title('Confusion_matrix', y=1.05, size=15)

Wow! Ci dà l’accuratezza dell’83%. È abbastanza buono per la nostra prima volta!

Il punteggio incrociato indica un metodo di K Fold Validation. Se K = 10, significa che dividi i dati in 10 variazioni e calcoli la media di tutti i punteggi come punteggio finale.

Fine Tuning

Ora hai finito con le procedure Machine Learning con Python. Ma c’è un altro passaggio che può portare a risultati migliori: il Fine Tuning (o messa a punto in Italiano). Il termine significa trovare il parametro migliore per gli algoritmi di apprendimento automatico. Se vedi il codice per il Random Forest sopra:

model = RandomForestClassifier(criterion='gini', n_estimators=700,
                             min_samples_split=10,min_samples_leaf=1,
                             max_features='auto',oob_score=True,
                             random_state=1,n_jobs=-1)

Ci sono molti parametri che devi impostare. Questi sono i valori predefiniti. E puoi modificare i parametri come preferisci. Ma ovviamente ci vorrà molto tempo.

Non preoccuparti: esiste uno strumento chiamato Grid Search, che trova automaticamente i parametri ottimali. Ottimo, vero?

# Random Forest Classifier Parameters tunning 
model = RandomForestClassifier()
n_estim=range(100,1000,100)
## Search grid for optimal parameters
param_grid = {"n_estimators" :n_estim}
model_rf = GridSearchCV(model,param_grid = param_grid, cv=5, scoring="accuracy", n_jobs= 4, verbose = 1)
model_rf.fit(train_X,train_Y)
# Best score
print(model_rf.best_score_)
#best estimator
model_rf.best_estimator_

Bene, puoi provarlo tu stesso. E divertirti col Machine Learning.


Conclusioni

Come è stato? Non sembra molto difficile vero? Il Machine Learning con Python è facile. C’è solo bisogno di tanto esercizio e voglia di apprendere cose nuove per fare grandi cose.

Leave a Comment

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *