Algoritmos de clasificación: regresión logística
Introducción a la regresión logística
La regresión logística es un algoritmo de clasificación de aprendizaje supervisado que se utiliza para predecir la probabilidad de una variable objetivo. La naturaleza de la variable objetivo o dependiente es dicotómica, lo que significa que solo habría dos clases posibles.
En palabras simples, la variable dependiente es de naturaleza binaria y tiene datos codificados como 1 (significa éxito / sí) o 0 (significa fracaso / no).
Matemáticamente, un modelo de regresión logística predice P (Y = 1) como una función de X. Es uno de los algoritmos ML más simples que se puede usar para varios problemas de clasificación como detección de spam, predicción de diabetes, detección de cáncer, etc.
Tipos de regresión logística
En general, la regresión logística significa una regresión logística binaria que tiene variables objetivo binarias, pero puede haber dos categorías más de variables objetivo que pueden predecirse. Según ese número de categorías, la regresión logística se puede dividir en los siguientes tipos:
Binario o Binomial
En tal tipo de clasificación, una variable dependiente tendrá solo dos tipos posibles, 1 y 0. Por ejemplo, estas variables pueden representar éxito o fracaso, sí o no, ganar o perder, etc.
Multinomial
En este tipo de clasificación, la variable dependiente puede tener 3 o más tipos desordenados posibles o los tipos que no tienen importancia cuantitativa. Por ejemplo, estas variables pueden representar "Tipo A" o "Tipo B" o "Tipo C".
Ordinal
En tal tipo de clasificación, la variable dependiente puede tener 3 o más tipos ordenados posibles o los tipos que tienen un significado cuantitativo. Por ejemplo, estas variables pueden representar “pobre” o “bueno”, “muy bueno”, “Excelente” y cada categoría puede tener puntuaciones como 0,1,2,3.
Supuestos de regresión logística
Antes de sumergirnos en la implementación de la regresión logística, debemos ser conscientes de los siguientes supuestos sobre lo mismo:
En caso de regresión logística binaria, las variables objetivo deben ser siempre binarias y el resultado deseado está representado por el factor nivel 1.
No debe haber multicolinealidad en el modelo, lo que significa que las variables independientes deben ser independientes entre sí.
Debemos incluir variables significativas en nuestro modelo.
Deberíamos elegir un tamaño de muestra grande para la regresión logística.
Modelo de regresión logística binaria
La forma más simple de regresión logística es la regresión logística binaria o binomial en la que la variable objetivo o dependiente puede tener solo 2 tipos posibles, 1 o 0. Nos permite modelar una relación entre múltiples variables predictoras y una variable objetivo binaria / binomial. En caso de regresión logística, la función lineal se utiliza básicamente como entrada a otra función como en la siguiente relación:
$$ h _ {\ theta} {(x)} = g (\ theta ^ {T} x) ℎ 0≤h _ {\ theta} ≤1 $$Aquí, está la función logística o sigmoidea que se puede dar de la siguiente manera:
$$ g (z) = \ frac {1} {1 + e ^ {- z}} ℎ = \ theta ^ {T} $$A la curva sigmoidea se puede representar con la ayuda del siguiente gráfico. Podemos ver que los valores del eje y se encuentran entre 0 y 1 y cruzan el eje en 0.5.
Las clases se pueden dividir en positivas o negativas. La salida entra en la probabilidad de clase positiva si se encuentra entre 0 y 1. Para nuestra implementación, estamos interpretando la salida de la función de hipótesis como positiva si es ≥0,5, de lo contrario negativa.
También necesitamos definir una función de pérdida para medir qué tan bien se desempeña el algoritmo usando los pesos en las funciones, representadas por theta de la siguiente manera:
ℎ = ()
$$ J (\ theta) = \ frac {1} {m}. (- y ^ {T} log (h) - (1 -y) ^ Tlog (1-h)) $$Ahora, después de definir la función de pérdida, nuestro objetivo principal es minimizar la función de pérdida. Se puede hacer con la ayuda de ajustar los pesos, lo que significa aumentar o disminuir los pesos. Con la ayuda de las derivadas de la función de pérdida de cada peso, podríamos saber qué parámetros deben tener un peso alto y cuáles deben tener un peso menor.
La siguiente ecuación de descenso de gradiente nos dice cómo cambiaría la pérdida si modificáramos los parámetros:
$$ \ frac {()} {\ theta_ {j}} = \ frac {1} {m} X ^ {T} (() -) $$Implementación en Python
Ahora implementaremos el concepto anterior de regresión logística binomial en Python. Para este propósito, estamos usando un conjunto de datos de flores multivariante llamado 'iris' que tiene 3 clases de 50 instancias cada una, pero usaremos las dos primeras columnas de características. Cada clase representa un tipo de flor de iris.
Primero, necesitamos importar las bibliotecas necesarias de la siguiente manera:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn import datasets
A continuación, cargue el conjunto de datos del iris de la siguiente manera:
iris = datasets.load_iris()
X = iris.data[:, :2]
y = (iris.target != 0) * 1
Podemos trazar nuestros datos de entrenamiento a continuación:
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();
A continuación, definiremos la función sigmoidea, la función de pérdida y el gradiente descendente de la siguiente manera:
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)
Ahora, inicialice los pesos de la siguiente manera:
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 la ayuda del siguiente script, podemos predecir las probabilidades de salida:
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()
A continuación, podemos evaluar el modelo y trazarlo de la siguiente manera:
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');
Modelo de regresión logística multinomial
Otra forma útil de regresión logística es la regresión logística multinomial en la que la variable objetivo o dependiente puede tener 3 o más tipos desordenados posibles, es decir, los tipos que no tienen significación cuantitativa.
Implementación en Python
Ahora implementaremos el concepto anterior de regresión logística multinomial en Python. Para este propósito, estamos usando un conjunto de datos de sklearn llamado digit.
Primero, necesitamos importar las bibliotecas necesarias de la siguiente manera:
Import sklearn
from sklearn import datasets
from sklearn import linear_model
from sklearn import metrics
from sklearn.model_selection import train_test_split
A continuación, necesitamos cargar el conjunto de datos de dígitos -
digits = datasets.load_digits()
Ahora, defina la matriz de características (X) y el vector de respuesta (y) de la siguiente manera:
X = digits.data
y = digits.target
Con la ayuda de la siguiente línea de código, podemos dividir X e y en conjuntos de entrenamiento y prueba:
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=1)
Ahora cree un objeto de regresión logística de la siguiente manera:
digreg = linear_model.LogisticRegression()
Ahora, necesitamos entrenar el modelo usando los conjuntos de entrenamiento de la siguiente manera:
digreg.fit(X_train, y_train)
A continuación, haga las predicciones sobre el conjunto de pruebas de la siguiente manera:
y_pred = digreg.predict(X_test)
A continuación, imprima la precisión del modelo de la siguiente manera:
print("Accuracy of Logistic Regression model is:",
metrics.accuracy_score(y_test, y_pred)*100)
Salida
Accuracy of Logistic Regression model is: 95.6884561891516
A partir del resultado anterior, podemos ver que la precisión de nuestro modelo es de alrededor del 96 por ciento.