Algoritmi di classificazione - Regressione logistica

Introduzione alla regressione logistica

La regressione logistica è un algoritmo di classificazione dell'apprendimento supervisionato utilizzato per prevedere la probabilità di una variabile obiettivo. La natura della variabile target o dipendente è dicotomica, il che significa che ci sarebbero solo due classi possibili.

In parole semplici, la variabile dipendente è di natura binaria con i dati codificati come 1 (sta per successo / sì) o 0 (sta per fallimento / no).

Matematicamente, un modello di regressione logistica prevede P (Y = 1) in funzione di X. È uno degli algoritmi ML più semplici che può essere utilizzato per vari problemi di classificazione come il rilevamento dello spam, la previsione del diabete, il rilevamento del cancro, ecc.

Tipi di regressione logistica

In generale, regressione logistica significa regressione logistica binaria con variabili target binarie, ma possono esserci altre due categorie di variabili target che possono essere previste da essa. In base a quel numero di categorie, la regressione logistica può essere suddivisa nei seguenti tipi:

Binario o binomiale

In questo tipo di classificazione, una variabile dipendente avrà solo due tipi possibili, 1 e 0. Ad esempio, queste variabili possono rappresentare successo o fallimento, sì o no, vittoria o sconfitta, ecc.

Multinomiale

In un tale tipo di classificazione, la variabile dipendente può avere 3 o più possibili tipi non ordinati o i tipi che non hanno significato quantitativo. Ad esempio, queste variabili possono rappresentare "Tipo A" o "Tipo B" o "Tipo C".

Ordinale

In un tale tipo di classificazione, la variabile dipendente può avere 3 o più tipi ordinati possibili o i tipi che hanno un significato quantitativo. Ad esempio, queste variabili possono rappresentare "scarso" o "buono", "molto buono", "eccellente" e ogni categoria può avere punteggi come 0,1,2,3.

Presupposti della regressione logistica

Prima di immergerci nell'implementazione della regressione logistica, dobbiamo essere consapevoli delle seguenti ipotesi sullo stesso:

  • In caso di regressione logistica binaria, le variabili target devono essere sempre binarie e il risultato desiderato è rappresentato dal livello di fattore 1.

  • Non dovrebbe esserci alcuna multi-collinearità nel modello, il che significa che le variabili indipendenti devono essere indipendenti l'una dall'altra.

  • Dobbiamo includere variabili significative nel nostro modello.

  • Dovremmo scegliere un campione di grandi dimensioni per la regressione logistica.

Modello di regressione logistica binaria

La forma più semplice di regressione logistica è la regressione logistica binomiale o binomiale in cui la variabile target o dipendente può avere solo 2 tipi possibili, 1 o 0. Ci consente di modellare una relazione tra più variabili predittive e una variabile target binomiale / binomiale. In caso di regressione logistica, la funzione lineare viene fondamentalmente utilizzata come input per un'altra funzione come nella seguente relazione:

$$ h _ {\ theta} {(x)} = g (\ theta ^ {T} x) ℎ 0≤h _ {\ theta} ≤1 $$

Ecco la funzione logistica o sigmoidea che può essere data come segue:

$$ g (z) = \ frac {1} {1 + e ^ {- z}} ℎ = \ theta ^ {T} $$

La curva sigmoidea può essere rappresentata con l'aiuto del grafico seguente. Possiamo vedere i valori dell'asse y compreso tra 0 e 1 e incrocia l'asse a 0,5.

Le classi possono essere suddivise in positive o negative. L'output rientra nella probabilità di classe positiva se è compreso tra 0 e 1. Per la nostra implementazione, interpretiamo l'output della funzione di ipotesi come positivo se è ≥0,5, altrimenti negativo.

Abbiamo anche bisogno di definire una funzione di perdita per misurare il rendimento dell'algoritmo utilizzando i pesi sulle funzioni, rappresentati da theta come segue:

ℎ = ()

$$ J (\ theta) = \ frac {1} {m}. (- y ^ {T} log (h) - (1 -y) ^ Tlog (1-h)) $$

Ora, dopo aver definito la funzione di perdita, il nostro obiettivo principale è ridurre al minimo la funzione di perdita. Può essere fatto con l'aiuto del montaggio dei pesi, il che significa aumentando o diminuendo i pesi. Con l'aiuto di derivati ​​della funzione di perdita rispetto a ogni peso, saremmo in grado di sapere quali parametri dovrebbero avere un peso elevato e quali dovrebbero avere un peso minore.

La seguente equazione di discesa del gradiente ci dice come cambierebbe la perdita se modificassimo i parametri:

$$ \ frac {()} {\ theta_ {j}} = \ frac {1} {m} X ^ {T} (() -) $$

Implementazione in Python

Ora implementeremo il concetto di cui sopra di regressione logistica binomiale in Python. A tale scopo, stiamo utilizzando un set di dati di fiori multivariato denominato "iris" che ha 3 classi di 50 istanze ciascuna, ma utilizzeremo le prime due colonne delle caratteristiche. Ogni classe rappresenta un tipo di fiore di iris.

Innanzitutto, dobbiamo importare le librerie necessarie come segue:

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets

Quindi, carica il set di dati iris come segue:

iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1

Possiamo tracciare i nostri dati di allenamento come segue:

plt.figure(figsize=(6, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend();

Successivamente, definiremo la funzione sigmoide, la funzione di perdita e il gradiente discendente come segue:

class LogisticRegression:
   def __init__(self, lr=0.01, num_iter=100000, fit_intercept=True, verbose=False):
      self.lr = lr
      self.num_iter = num_iter
      self.fit_intercept = fit_intercept
      self.verbose = verbose
   def __add_intercept(self, X):
      intercept = np.ones((X.shape[0], 1))
      return np.concatenate((intercept, X), axis=1)
   def __sigmoid(self, z):
      return 1 / (1 + np.exp(-z))
   def __loss(self, h, y):
      return (-y * np.log(h) - (1 - y) * np.log(1 - h)).mean()
   def fit(self, X, y):
      if self.fit_intercept:
         X = self.__add_intercept(X)

Ora inizializza i pesi come segue:

self.theta = np.zeros(X.shape[1])
   for i in range(self.num_iter):
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      gradient = np.dot(X.T, (h - y)) / y.size
      self.theta -= self.lr * gradient
      z = np.dot(X, self.theta)
      h = self.__sigmoid(z)
      loss = self.__loss(h, y)
      if(self.verbose ==True and i % 10000 == 0):
         print(f'loss: {loss} \t')

Con l'aiuto del seguente script, possiamo prevedere le probabilità di output:

def predict_prob(self, X):
   if self.fit_intercept:
      X = self.__add_intercept(X)
   return self.__sigmoid(np.dot(X, self.theta))
def predict(self, X):
   return self.predict_prob(X).round()

Successivamente, possiamo valutare il modello e tracciarlo come segue:

model = LogisticRegression(lr=0.1, num_iter=300000)
preds = model.predict(X)
(preds == y).mean()

plt.figure(figsize=(10, 6))
plt.scatter(X[y == 0][:, 0], X[y == 0][:, 1], color='g', label='0')
plt.scatter(X[y == 1][:, 0], X[y == 1][:, 1], color='y', label='1')
plt.legend()
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
grid = np.c_[xx1.ravel(), xx2.ravel()]
probs = model.predict_prob(grid).reshape(xx1.shape)
plt.contour(xx1, xx2, probs, [0.5], linewidths=1, colors='red');

Modello di regressione logistica multinomiale

Un'altra forma utile di regressione logistica è la regressione logistica multinomiale in cui la variabile target o dipendente può avere 3 o più possibili tipi non ordinati, ovvero i tipi che non hanno significato quantitativo.

Implementazione in Python

Ora implementeremo il concetto di cui sopra di regressione logistica multinomiale in Python. A tale scopo, stiamo utilizzando un set di dati da sklearn named digit.

Innanzitutto, dobbiamo importare le librerie necessarie come segue:

Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split

Successivamente, dobbiamo caricare il set di dati digit -

digits = datasets.load_digits()

Ora, definisci la matrice delle caratteristiche (X) e il vettore di risposta (y) come segue:

X = digits.data
y = digits.target

Con l'aiuto della riga di codice successiva, possiamo dividere X e y in set di addestramento e test -

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)

Ora crea un oggetto di regressione logistica come segue:

digreg = linear_model.LogisticRegression()

Ora, dobbiamo addestrare il modello utilizzando i set di addestramento come segue:

digreg.fit(X_train, y_train)

Quindi, fare le previsioni sul set di test come segue:

y_pred = digreg.predict(X_test)

Quindi stampare la precisione del modello come segue:

print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)

Produzione

Accuracy of Logistic Regression model is: 95.6884561891516

Dall'output di cui sopra possiamo vedere la precisione del nostro modello è di circa il 96 percento.