Regressione logistica in Python - Guida rapida
La regressione logistica è un metodo statistico di classificazione degli oggetti. Questo capitolo darà un'introduzione alla regressione logistica con l'aiuto di alcuni esempi.
Classificazione
Per comprendere la regressione logistica, dovresti sapere cosa significa classificazione. Consideriamo i seguenti esempi per capirlo meglio:
- Un medico classifica il tumore come maligno o benigno.
- Una transazione bancaria può essere fraudolenta o autentica.
Per molti anni, gli esseri umani hanno svolto tali compiti, anche se sono soggetti a errori. La domanda è: possiamo addestrare le macchine a svolgere questi compiti per noi con una maggiore precisione?
Uno di questi esempi di macchina che esegue la classificazione è l'e-mail Clientsulla tua macchina che classifica ogni posta in arrivo come "spam" o "non spam" e lo fa con una precisione abbastanza ampia. La tecnica statistica della regressione logistica è stata applicata con successo nel client di posta elettronica. In questo caso, abbiamo addestrato la nostra macchina a risolvere un problema di classificazione.
La regressione logistica è solo una parte dell'apprendimento automatico utilizzato per risolvere questo tipo di problema di classificazione binaria. Esistono molte altre tecniche di apprendimento automatico che sono già sviluppate e sono in pratica per risolvere altri tipi di problemi.
Se hai notato, in tutti gli esempi precedenti, il risultato della predicazione ha solo due valori - Sì o No. Li chiamiamo classi - così da dire che il nostro classificatore classifica gli oggetti in due classi. In termini tecnici, possiamo dire che il risultato o la variabile obiettivo è di natura dicotomica.
Esistono altri problemi di classificazione in cui l'output può essere classificato in più di due classi. Ad esempio, dato un cesto pieno di frutta, ti viene chiesto di separare frutti di diverso tipo. Ora, il cestino può contenere arance, mele, mango e così via. Quindi, quando separi i frutti, li separi in più di due classi. Questo è un problema di classificazione multivariata.
Considera che una banca ti si avvicina per sviluppare un'applicazione di machine learning che la aiuterà a identificare i potenziali clienti che aprirebbero con loro un deposito a termine (chiamato anche deposito fisso da alcune banche). La banca conduce regolarmente un sondaggio tramite chiamate telefoniche o moduli web per raccogliere informazioni sui potenziali clienti. L'indagine è di natura generale e viene condotta su un pubblico molto vasto al quale molti potrebbero non essere interessati a trattare con questa banca stessa. Del resto, solo pochi potrebbero essere interessati ad aprire un deposito a termine. Altri potrebbero essere interessati ad altri servizi offerti dalla banca. Quindi il sondaggio non è necessariamente condotto per identificare i clienti che aprono i TD. Il tuo compito è identificare tutti quei clienti con un'alta probabilità di aprire TD dai dati del sondaggio che la banca condividerà con te.
Fortunatamente, un tale tipo di dati è pubblicamente disponibile per coloro che aspirano a sviluppare modelli di machine learning. Questi dati sono stati preparati da alcuni studenti della UC Irvine con finanziamenti esterni. Il database è disponibile come parte diUCI Machine Learning Repositoryed è ampiamente utilizzato da studenti, educatori e ricercatori in tutto il mondo. I dati possono essere scaricati da qui .
Nei prossimi capitoli, eseguiamo ora lo sviluppo dell'applicazione utilizzando gli stessi dati.
In questo capitolo, comprenderemo il processo coinvolto nella creazione di un progetto per eseguire la regressione logistica in Python, in dettaglio.
Installazione di Jupyter
Useremo Jupyter, una delle piattaforme più utilizzate per l'apprendimento automatico. Se non hai Jupyter installato sul tuo computer, scaricalo da qui . Per l'installazione, puoi seguire le istruzioni sul loro sito per installare la piattaforma. Come suggerisce il sito, potresti preferire usareAnaconda Distributionche viene fornito con Python e molti pacchetti Python comunemente usati per il calcolo scientifico e la scienza dei dati. Ciò allevierà la necessità di installare questi pacchetti individualmente.
Dopo la corretta installazione di Jupyter, avvia un nuovo progetto, la schermata in questa fase apparirà come la seguente pronta per accettare il tuo codice.
Ora cambia il nome del progetto da Untitled1 to “Logistic Regression” facendo clic sul nome del titolo e modificandolo.
Innanzitutto, importeremo diversi pacchetti Python di cui avremo bisogno nel nostro codice.
Importazione di pacchetti Python
A tale scopo, digita o taglia e incolla il seguente codice nell'editor di codice:
In [1]: # import statements
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn import preprocessing
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_splitIl tuo Notebook dovrebbe essere simile al seguente in questa fase:
Esegui il codice facendo clic su Runpulsante. Se non vengono generati errori, hai installato correttamente Jupyter e ora sei pronto per il resto dello sviluppo.
Le prime tre istruzioni di importazione importano i pacchetti panda, numpy e matplotlib.pyplot nel nostro progetto. Le tre istruzioni successive importano i moduli specificati da sklearn.
Il nostro prossimo compito è scaricare i dati richiesti per il nostro progetto. Lo impareremo nel prossimo capitolo.
I passaggi necessari per ottenere i dati per eseguire la regressione logistica in Python sono discussi in dettaglio in questo capitolo.
Download del set di dati
Se non hai ancora scaricato il set di dati UCI menzionato in precedenza, scaricalo ora da qui . Fare clic sulla cartella dei dati. Vedrai la seguente schermata:
Scarica il file bank.zip facendo clic sul link indicato. Il file zip contiene i seguenti file:
Useremo il file bank.csv per lo sviluppo del nostro modello. Il file bank-names.txt contiene la descrizione del database che ti servirà in seguito. Il bank-full.csv contiene un set di dati molto più ampio che puoi utilizzare per sviluppi più avanzati.
Qui abbiamo incluso il file bank.csv nello zip sorgente scaricabile. Questo file contiene i campi delimitati da virgole. Abbiamo anche apportato alcune modifiche al file. Si consiglia di utilizzare il file incluso nel codice sorgente del progetto per l'apprendimento.
Caricamento dati
Per caricare i dati dal file CSV appena copiato, digita la seguente istruzione ed esegui il codice.
In [2]: df = pd.read_csv('bank.csv', header=0)Sarai anche in grado di esaminare i dati caricati eseguendo la seguente istruzione di codice:
IN [3]: df.head()Una volta eseguito il comando, vedrai il seguente output:
Fondamentalmente, ha stampato le prime cinque righe dei dati caricati. Esamina le 21 colonne presenti. Useremo solo poche colonne da queste per lo sviluppo del nostro modello.
Successivamente, dobbiamo pulire i dati. I dati possono contenere alcune righe conNaN. Per eliminare tali righe, utilizzare il seguente comando:
IN [4]: df = df.dropna()Fortunatamente, bank.csv non contiene righe con NaN, quindi questo passaggio non è veramente richiesto nel nostro caso. Tuttavia, in generale è difficile scoprire tali righe in un enorme database. Quindi è sempre più sicuro eseguire l'istruzione precedente per pulire i dati.
Note - È possibile esaminare facilmente la dimensione dei dati in qualsiasi momento utilizzando la seguente dichiarazione:
IN [5]: print (df.shape)
(41188, 21)Il numero di righe e colonne verrebbe stampato nell'output come mostrato nella seconda riga sopra.
La prossima cosa da fare è esaminare l'idoneità di ogni colonna per il modello che stiamo cercando di costruire.
Ogni volta che un'organizzazione conduce un sondaggio, cerca di raccogliere quante più informazioni possibili dal cliente, con l'idea che queste informazioni sarebbero utili all'organizzazione in un modo o nell'altro, in un secondo momento. Per risolvere il problema attuale, dobbiamo raccogliere le informazioni che sono direttamente rilevanti per il nostro problema.
Visualizzazione di tutti i campi
Vediamo ora come selezionare i campi dati a noi utili. Eseguire la seguente istruzione nell'editor di codice.
In [6]: print(list(df.columns))Vedrai il seguente output:
['age', 'job', 'marital', 'education', 'default', 'housing', 'loan',
'contact', 'month', 'day_of_week', 'duration', 'campaign', 'pdays',
'previous', 'poutcome', 'emp_var_rate', 'cons_price_idx', 'cons_conf_idx',
'euribor3m', 'nr_employed', 'y']L'output mostra i nomi di tutte le colonne nel database. L'ultima colonna "y" è un valore booleano che indica se questo cliente ha un deposito a termine presso la banca. I valori di questo campo sono "y" o "n". È possibile leggere la descrizione e lo scopo di ciascuna colonna nel file banks-name.txt scaricato come parte dei dati.
Eliminazione di campi indesiderati
Esaminando i nomi delle colonne, saprai che alcuni campi non hanno alcun significato per il problema in questione. Ad esempio, campi comemonth, day_of_week, campagna, ecc. non ci servono. Elimineremo questi campi dal nostro database. Per rilasciare una colonna, usiamo il comando drop come mostrato di seguito -
In [8]: #drop columns which are not needed.
df.drop(df.columns[[0, 3, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17, 18, 19]],
axis = 1, inplace = True)Il comando dice che rilascia la colonna numero 0, 3, 7, 8 e così via. Per assicurarti che l'indice sia selezionato correttamente, usa la seguente dichiarazione:
In [7]: df.columns[9]
Out[7]: 'day_of_week'Stampa il nome della colonna per l'indice specificato.
Dopo aver eliminato le colonne che non sono necessarie, esaminare i dati con l'istruzione head. L'output dello schermo è mostrato qui -
In [9]: df.head()
Out[9]:
job marital default housing loan poutcome y
0 blue-collar married unknown yes no nonexistent 0
1 technician married no no no nonexistent 0
2 management single no yes no success 1
3 services married no no no nonexistent 0
4 retired married no yes no success 1Ora, abbiamo solo i campi che riteniamo importanti per la nostra analisi e previsione dei dati. L'importanza diData Scientistentra in scena a questo punto. Il data scientist deve selezionare le colonne appropriate per la costruzione del modello.
Ad esempio, il tipo di jobanche se a prima vista potrebbe non convincere tutti per l'inclusione nel database, sarà un campo molto utile. Non tutti i tipi di clienti apriranno il TD. Le persone a basso reddito potrebbero non aprire i TD, mentre le persone a reddito più alto di solito parcheggiano i loro soldi in eccesso in TD. Quindi il tipo di lavoro diventa significativamente rilevante in questo scenario. Allo stesso modo, seleziona attentamente le colonne che ritieni siano rilevanti per la tua analisi.
Nel prossimo capitolo prepareremo i nostri dati per costruire il modello.
Per creare il classificatore, dobbiamo preparare i dati in un formato richiesto dal modulo di costruzione del classificatore. Prepariamo i dati facendoOne Hot Encoding.
Codifica dei dati
Discuteremo brevemente cosa si intende per codifica dei dati. Innanzitutto, eseguiamo il codice. Eseguire il comando seguente nella finestra del codice.
In [10]: # creating one hot encoding of the categorical columns.
data = pd.get_dummies(df, columns =['job', 'marital', 'default', 'housing', 'loan', 'poutcome'])Come dice il commento, l'istruzione sopra creerà l'unica codifica a caldo dei dati. Vediamo cosa ha creato? Esamina i dati creati chiamati“data” stampando i record della testina nel database.
In [11]: data.head()Vedrai il seguente output:
Per comprendere i dati di cui sopra, elencheremo i nomi delle colonne eseguendo il data.columns comando come mostrato di seguito -
In [12]: data.columns
Out[12]: Index(['y', 'job_admin.', 'job_blue-collar', 'job_entrepreneur',
'job_housemaid', 'job_management', 'job_retired', 'job_self-employed',
'job_services', 'job_student', 'job_technician', 'job_unemployed',
'job_unknown', 'marital_divorced', 'marital_married', 'marital_single',
'marital_unknown', 'default_no', 'default_unknown', 'default_yes',
'housing_no', 'housing_unknown', 'housing_yes', 'loan_no',
'loan_unknown', 'loan_yes', 'poutcome_failure', 'poutcome_nonexistent',
'poutcome_success'], dtype='object')Ora, spiegheremo come viene eseguita l'unica codifica a caldo da get_dummiescomando. La prima colonna nel database appena generato è il campo "y" che indica se questo client ha sottoscritto o meno un TD. Ora, esaminiamo le colonne che sono codificate. La prima colonna codificata è“job”. Nel database, troverai che la colonna "lavoro" ha molti valori possibili come "amministratore", "operaio", "imprenditore" e così via. Per ogni possibile valore, abbiamo una nuova colonna creata nel database, con il nome della colonna aggiunto come prefisso.
Pertanto, abbiamo colonne chiamate "job_admin", "job_blue-collar" e così via. Per ogni campo codificato nel nostro database originale, troverai un elenco di colonne aggiunte nel database creato con tutti i possibili valori che la colonna assume nel database originale. Esamina attentamente l'elenco delle colonne per capire come i dati vengono mappati su un nuovo database.
Comprensione della mappatura dei dati
Per comprendere i dati generati, stampiamo tutti i dati utilizzando il comando data. Di seguito viene mostrato l'output parziale dopo l'esecuzione del comando.
In [13]: data
La schermata sopra mostra le prime dodici righe. Se scorri ulteriormente verso il basso, vedrai che la mappatura viene eseguita per tutte le righe.
Un output della schermata parziale più in basso nel database viene mostrato qui per una rapida consultazione.
Per comprendere i dati mappati, esaminiamo la prima riga.
Dice che questo cliente non si è abbonato a TD come indicato dal valore nel campo "y". Indica anche che questo cliente è un cliente "operaio". Scorrendo orizzontalmente verso il basso, ti dirà che ha un “alloggio” e non ha preso “prestito”.
Dopo questa codifica a caldo, abbiamo bisogno di ulteriore elaborazione dei dati prima di poter iniziare a costruire il nostro modello.
Eliminare lo "sconosciuto"
Se esaminiamo le colonne nel database mappato, troverai la presenza di poche colonne che terminano con "sconosciuto". Ad esempio, esamina la colonna all'indice 12 con il seguente comando mostrato nello screenshot:
In [14]: data.columns[12]
Out[14]: 'job_unknown'Ciò indica che il lavoro per il cliente specificato è sconosciuto. Ovviamente, non ha senso includere tali colonne nella nostra analisi e costruzione del modello. Pertanto, tutte le colonne con il valore "sconosciuto" dovrebbero essere eliminate. Questo viene fatto con il seguente comando:
In [15]: data.drop(data.columns[[12, 16, 18, 21, 24]], axis=1, inplace=True)Assicurati di specificare i numeri di colonna corretti. In caso di dubbio, è possibile esaminare il nome della colonna in qualsiasi momento specificandone l'indice nel comando colonne come descritto in precedenza.
Dopo aver rilasciato le colonne indesiderate, puoi esaminare l'elenco finale di colonne come mostrato nell'output di seguito:
In [16]: data.columns
Out[16]: Index(['y', 'job_admin.', 'job_blue-collar', 'job_entrepreneur',
'job_housemaid', 'job_management', 'job_retired', 'job_self-employed',
'job_services', 'job_student', 'job_technician', 'job_unemployed',
'marital_divorced', 'marital_married', 'marital_single', 'default_no',
'default_yes', 'housing_no', 'housing_yes', 'loan_no', 'loan_yes',
'poutcome_failure', 'poutcome_nonexistent', 'poutcome_success'],
dtype='object')A questo punto, i nostri dati sono pronti per la costruzione del modello.
Abbiamo circa quarantunomila record dispari. Se utilizziamo tutti i dati per la costruzione del modello, non ci resteranno dati per i test. Quindi, in generale, dividiamo l'intero set di dati in due parti, diciamo una percentuale 70/30. Utilizziamo il 70% dei dati per la creazione del modello e il resto per testare l'accuratezza nella previsione del modello creato. È possibile utilizzare un rapporto di divisione diverso in base alle proprie esigenze.
Creazione di array di funzionalità
Prima di dividere i dati, separiamo i dati in due array X e Y. L'array X contiene tutte le caratteristiche (colonne di dati) che vogliamo analizzare e l'array Y è un array monodimensionale di valori booleani che è l'output di la previsione. Per capirlo, eseguiamo del codice.
Innanzitutto, esegui la seguente istruzione Python per creare l'array X:
In [17]: X = data.iloc[:,1:]Per esaminare il contenuto di X uso headper stampare alcuni record iniziali. La schermata seguente mostra il contenuto dell'array X.
In [18]: X.head ()
La matrice ha diverse righe e 23 colonne.
Successivamente, creeremo un array di output contenente "y" valori.
Creazione di array di output
Per creare un array per la colonna del valore previsto, utilizzare la seguente istruzione Python:
In [19]: Y = data.iloc[:,0]Esaminare il suo contenuto chiamando head. L'output dello schermo di seguito mostra il risultato:
In [20]: Y.head()
Out[20]: 0 0
1 0
2 1
3 0
4 1
Name: y, dtype: int64Ora, dividi i dati usando il seguente comando:
In [21]: X_train, X_test, Y_train, Y_test = train_test_split(X, Y, random_state=0)Questo creerà i quattro array chiamati X_train, Y_train, X_test, and Y_test. Come prima, puoi esaminare il contenuto di questi array usando il comando head. Useremo gli array X_train e Y_train per l'addestramento del nostro modello e gli array X_test e Y_test per il test e la convalida.
Ora siamo pronti per costruire il nostro classificatore. Lo esamineremo nel prossimo capitolo.
Non è necessario che tu debba costruire il classificatore da zero. La creazione di classificatori è complessa e richiede la conoscenza di diverse aree come statistica, teorie della probabilità, tecniche di ottimizzazione e così via. Sul mercato sono disponibili diverse librerie predefinite che hanno un'implementazione completamente testata e molto efficiente di questi classificatori. Useremo uno di questi modelli precostruiti dalsklearn.
Il classificatore sklearn
La creazione del classificatore di regressione logistica da sklearn toolkit è banale e viene eseguita in una singola istruzione del programma come mostrato qui -
In [22]: classifier = LogisticRegression(solver='lbfgs',random_state=0)Una volta creato il classificatore, inserirai i tuoi dati di allenamento nel classificatore in modo che possa regolare i suoi parametri interni ed essere pronto per le previsioni sui tuoi dati futuri. Per ottimizzare il classificatore, eseguiamo la seguente istruzione:
In [23]: classifier.fit(X_train, Y_train)Il classificatore è ora pronto per il test. Il codice seguente è l'output dell'esecuzione delle due istruzioni precedenti:
Out[23]: LogisticRegression(C = 1.0, class_weight = None, dual = False,
fit_intercept=True, intercept_scaling=1, max_iter=100,
multi_class='warn', n_jobs=None, penalty='l2', random_state=0,
solver='lbfgs', tol=0.0001, verbose=0, warm_start=False))Ora siamo pronti per testare il classificatore creato. Ne tratteremo nel prossimo capitolo.
Dobbiamo testare il classificatore creato sopra prima di metterlo in uso in produzione. Se il test rivela che il modello non soddisfa la precisione desiderata, dovremo tornare indietro nel processo precedente, selezionare un altro set di caratteristiche (campi dati), costruire nuovamente il modello e testarlo. Questo sarà un passaggio iterativo fino a quando il classificatore non soddisfa il tuo requisito di accuratezza desiderata. Quindi testiamo il nostro classificatore.
Previsione dei dati di test
Per testare il classificatore, utilizziamo i dati di test generati nella fase precedente. Chiamiamo il filepredict sull'oggetto creato e passare il X matrice dei dati del test come mostrato nel seguente comando:
In [24]: predicted_y = classifier.predict(X_test)Questo genera una matrice unidimensionale per l'intero set di dati di addestramento che fornisce la previsione per ogni riga nella matrice X. È possibile esaminare questo array utilizzando il seguente comando:
In [25]: predicted_yQuello che segue è l'output dopo l'esecuzione dei due comandi precedenti:
Out[25]: array([0, 0, 0, ..., 0, 0, 0])L'output indica che i primi e gli ultimi tre clienti non sono i potenziali candidati per Term Deposit. È possibile esaminare l'intero array per individuare i potenziali clienti. Per fare ciò, usa il seguente frammento di codice Python:
In [26]: for x in range(len(predicted_y)):
if (predicted_y[x] == 1):
print(x, end="\t")L'output dell'esecuzione del codice sopra è mostrato di seguito:
L'output mostra gli indici di tutte le righe che sono probabili candidati per la sottoscrizione a TD. È ora possibile inviare questo output al team di marketing della banca che raccoglierà i dettagli di contatto per ogni cliente nella riga selezionata e procederà con il proprio lavoro.
Prima di mettere in produzione questo modello, dobbiamo verificare l'accuratezza della previsione.
Verifica della precisione
Per verificare l'accuratezza del modello, utilizzare il metodo di punteggio sul classificatore come mostrato di seguito:
In [27]: print('Accuracy: {:.2f}'.format(classifier.score(X_test, Y_test)))L'output sullo schermo dell'esecuzione di questo comando è mostrato di seguito:
Accuracy: 0.90Mostra che la precisione del nostro modello è del 90%, il che è considerato molto buono nella maggior parte delle applicazioni. Pertanto, non è richiesta alcuna ulteriore messa a punto. Ora, il nostro cliente è pronto per eseguire la prossima campagna, ottenere l'elenco dei potenziali clienti e inseguirli per l'apertura del TD con un probabile alto tasso di successo.
Come hai visto dall'esempio precedente, l'applicazione della regressione logistica per l'apprendimento automatico non è un compito difficile. Tuttavia, ha i suoi limiti. La regressione logistica non sarà in grado di gestire un gran numero di caratteristiche categoriali. Nell'esempio che abbiamo discusso finora, abbiamo ridotto il numero di funzionalità in misura molto ampia.
Tuttavia, se queste caratteristiche fossero importanti nella nostra previsione, saremmo stati costretti a includerle, ma poi la regressione logistica non riuscirebbe a darci una buona precisione. Anche la regressione logistica è vulnerabile all'overfitting. Non può essere applicato a un problema non lineare. Funzionerà male con variabili indipendenti che non sono correlate all'obiettivo e sono correlate tra loro. Pertanto, dovrai valutare attentamente l'idoneità della regressione logistica al problema che stai cercando di risolvere.
Esistono molte aree dell'apprendimento automatico in cui vengono specificate altre tecniche. Per citarne alcuni, abbiamo algoritmi come k-Nearest Neighbors (kNN), Linear Regression, Support Vector Machines (SVM), Decision Trees, Naive Bayes e così via. Prima di finalizzare un particolare modello, dovrai valutare l'applicabilità di queste varie tecniche al problema che stiamo cercando di risolvere.
La regressione logistica è una tecnica statistica di classificazione binaria. In questo tutorial, hai imparato come addestrare la macchina all'uso della regressione logistica. Creando modelli di machine learning, il requisito più importante è la disponibilità dei dati. Senza dati adeguati e rilevanti, non puoi semplicemente fare in modo che la macchina apprenda.
Una volta acquisiti i dati, la successiva attività principale consiste nella pulizia dei dati, nell'eliminazione delle righe e dei campi indesiderati e nella selezione dei campi appropriati per lo sviluppo del modello. Al termine, è necessario mappare i dati in un formato richiesto dal classificatore per la sua formazione. Pertanto, la preparazione dei dati è un'attività importante in qualsiasi applicazione di machine learning. Una volta che sei pronto con i dati, puoi selezionare un particolare tipo di classificatore.
In questo tutorial, hai imparato come utilizzare un classificatore di regressione logistica fornito in sklearnbiblioteca. Per addestrare il classificatore, utilizziamo circa il 70% dei dati per l'addestramento del modello. Usiamo il resto dei dati per i test. Testiamo l'accuratezza del modello. Se questo non è entro limiti accettabili, torniamo a selezionare il nuovo set di funzionalità.
Ancora una volta, segui l'intero processo di preparazione dei dati, addestra il modello e testalo, finché non sei soddisfatto della sua accuratezza. Prima di intraprendere qualsiasi progetto di apprendimento automatico, è necessario apprendere ed essere esposti a un'ampia varietà di tecniche che sono state sviluppate finora e che sono state applicate con successo nel settore.