Este artículo fue publicado como parte del Blogatón de ciencia de datos.

Introducción

La regresión lineal mapea un vector x a un y. Si podemos aplastar la salida de la regresión lineal en el rango de 0 a 1, se puede interpretar como una probabilidad. Podemos tener un clasificador que proporcione la probabilidad de la etiqueta de clase para las tareas de clasificación binaria al aplastar la salida de un modelo de regresión lineal. Este clasificador de aprendizaje supervisado se conoce como clasificador de regresión logística.

Aquí, la función sigmoidea, también conocida como función logística, predice la probabilidad de que ocurra un resultado binario. La función sigmoidea es una función de activación que se utiliza para introducir la no linealidad en un modelo de aprendizaje automático. Toma un valor y lo convierte entre 0 y 1. La función es la siguiente:

Por lo tanto, la regresión logística predice la etiqueta de clase al identificar la conexión entre las variables de características independientes. El límite de decisión es lineal, que se utiliza con fines de clasificación. La función de pérdida es la siguiente:

Ventajas de la regresión logística

Desventajas de la regresión logística

Aplicaciones

1. Clasificar si un correo electrónico es spam o no
2. Clasificar la calidad del agua es buena o no

Conjunto de datos

El conjunto de datos utilizado para este proyecto es el conjunto de datos de clasificación binaria de calidad del vino de Kaggle (https://www.kaggle.com/nareshbhat/wine-quality-binary-classification). Este conjunto de datos contiene información relacionada con los diversos factores que afectan la calidad del vino tinto.

Número de instancias: 1600
Valores perdidos: NA
Número de atributos: 12
Información de atributo:
Variables de entrada: (todas con valores numéricos)
1 – acidez fija
2 – acidez volátil
3 – ácido cítrico
4 – azúcar residual
5 – cloruros
6 – dióxido de azufre libre
7 – dióxido de azufre total
8 – densidad
9 – pH
10 – sulfatos
11-alcohol

Variable de salida: (detectar si la calidad es buena o mala)
12 – calidad (0-malo, 1-bueno)

Importe las bibliotecas de Python requeridas

importar pandas como pd importar numpy como np importar matplotlib.pyplot como plt importar seaborn como sns importar advertencias advertencias.filterwarnings('ignorar')

Cargue el conjunto de datos

Cargaremos nuestro conjunto de datos de vino, un archivo CSV utilizando la biblioteca de Python de panda.

df=pd.read_csv("vino.csv") df.head()

Preprocesamiento de datos

#preprocesamiento #La columna de calidad en el conjunto de datos debe asignarse como 0 para mala y 1 para buena. df = df.replace({'calidad': {'buena': 1, 'mala': 0}}) df.head()

Verificar valores perdidos

#comprobando valores faltantes df.isna().any().any()

Salida: Falso

Estadísticas generales y gráficos

df.describe ()

#Usaremos un gráfico de conteo para visualizar el conteo de observaciones para la columna 'calidad'. sns.countplot(x ='calidad', datos = df)

#Distribución de la columna – datos de alcohol = df['alcohol'] sns.distplot(data) plt.show()

Puntuación de importancia de la función

importar advertencias advertencias.filteradvertencias('ignorar') de sklearn.ensemble importar ExtraTreesClassifier model = ExtraTreesClassifier() model.fit(features,target) print(model.feature_importances_) imp = pd.Series(model.feature_importances_, index=features.columns ) imp.nlargest(10).plot(tipo='barh') plt.show()

Definición de características y la variable de destino

Las #características utilizadas para la clasificación incluyen: #alcohol, sulfatos, dióxido de azufre total, acidez volátil, ácido cítrico y azúcar residual. #objetivo=objetivo de calidad = df.iloc[:,11] características=df.iloc[:,[10,9,6,1,2,3]]

Estandarizar los vectores de características

#estandarizar los vectores de características de sklearn.preprocessing import StandardScaler #StandardScaler() cambiará la escala de los valores de las características para que su desviación estándar sea 1 y .mean sea 0. sc=StandardScaler() scaled_features=sc.fit_transform(features)

Modelo de regresión logística

Usaremos el modelo incorporado de regresión logística de la biblioteca sklearn de Python, donde también podemos definir la función de pérdida y hacer las predicciones.

Comenzaremos primero dividiendo nuestro conjunto de datos en dos partes; uno como conjunto de entrenamiento para el modelo y el otro como conjunto de prueba para validar las predicciones del modelo. Si omitimos este paso, el modelo se entrenará y probará en el mismo conjunto de datos y subestimará la verdadera tasa de error, un fenómeno llamado sobreajuste. Estableceremos el tamaño de prueba en 0.3, es decir, el 70 % de la etiqueta de clase se asignará al conjunto de entrenamiento y el 30 % restante se utilizará como conjunto de prueba. Haremos esto usando el método train_test_split en la biblioteca sklearn de Python. El modelo. El método fit() puede tomar los datos de entrenamiento como argumentos. Aquí nuestro nombre de modelo es LR. Este modelo toma algunos datos no etiquetados del conjunto de datos de prueba y puede asignar efectivamente a cada ejemplo una probabilidad que va de 0 a 1. Esta es la característica crucial de un modelo de regresión logística. Luego evaluaremos nuestro modelo en los datos de prueba.

Regresión logística utilizando el algoritmo de descenso de gradiente estándar con división 70:30

from sklearn.linear_model import LogisticRegression from sklearn.linear_model import SGDClassifier #70% datos de entrenamiento X_train, X_test, y_train, y_test = train_test_split(scaled_features, target, test_size=0.3, random_state=42) lr=LogisticRegression() lr.fit(X_train, y_train) print(classification_report(y_test,lr.predict(X_test)))

Regresión logística usando Gradient Descent from Scratch

La función de costo de un modelo de regresión logística se puede minimizar

Es un algoritmo de optimización iterativo y encuentra el mínimo de una función diferenciable. Primero, debe seleccionar cualquier punto aleatorio de la función. Entonces ayudaría si calcularas la derivada de la función. Ahora puede multiplicar el gradiente resultante con nuestra tasa de aprendizaje. Luego necesitas restar el resultado para obtener el nuevo. Esta actualización debe realizarse simultáneamente para cada iteración.. Repita estos pasos hasta llegar al mínimo local o global. Ha logrado la pérdida más baja posible en su predicción al alcanzar el mínimo global.

de sklearn.datasets.samples_generator importar make_blobs de matplotlib importar pyplot como plt de pandas importar DataFrame importar numpy como np X, Y = make_blobs(n_samples=100, centers=2, n_features=2, cluster_std=5, random_state=11) m = 100

#devuelve una matriz que contiene sigmoid de la matriz de entrada def sigmoid(z): return 1 / (1 + np.exp(-z)) #devuelve una matriz que contiene las predicciones de nuestra matriz de entrada def hy(w,X): z = np.matriz(w[0] + w[1]*np.matriz(X[:,0]) + w[2]*np.matriz(X[:,1])) return sigmoid(z) # cost function def cost(w, X, Y): y_predictions = hy(w,X) #asignar los valores de predicción return -1 * sum(Y*np.log(y_predictions) + (1-Y)*np.log( 1-y_predicciones))

#descenso de gradiente def derivadas_parciales(w, X, Y): y_predicciones = hy(w,X) j = [0]*3 j[0] = -1 * sum(Y*(1-y_predicciones) - (1-Y )*y_predictions) #almacenar derivadas parciales j[1] = -1 * sum(Y*(1-y_predictions)*X[:,0] - (1-Y)*y_predictions*X[:,0]) j[ 2] = -1 * sum(Y*(1-y_predictions)*X[:,1] - (1-Y)*y_predictions*X[:,1]) return j #devuelve una matriz que contiene derivadas parciales def gradiente_descenso(w_nuevo , w_prev, tasa_de_aprendizaje): print(w_prev) print(cost(w_prev, X, Y)) j=0 while True: w_prev = w_new #actualización de pesos en cada iteración w0 = w_prev[0] - tasa_de_aprendizaje*derivadas_parciales(w_prev, X , Y)[0] w1 = w_prev[1] - tasa_de_aprendizaje*derivadas_parciales(w_prev, X, Y)[1] w2 = w_prev[2] - tasa_de_aprendizaje*derivadas_parciales(w_prev, X, Y)[2] w_nueva = [w0 , w1, w2] print(w_new) print(cost(w_new, X, Y)) if (w_new[0]-w_prev[0])**2 + (w_new[1]-w_prev[1])**2 + (w_nuevo[2]-w_anterior[2])**2 100: devuelve w_nuevo j+=1

w=[1,1,1] w = gradiente_descenso(w,w,0.0099) imprimir(w)

def ecuación(x): return (-w[0]-w[1]*x)/w[2] def gráfico(fórmula, x_rango): x = np.array(x_rango) y = fórmula(x) plt. plot(x, y) df = DataFrame(dict(x=X[:,0], y=X[:,1], label=Y)) colores = {0:'rojo', 1:'verde'} fig, ax = plt.subplots() g = df.groupby('label') for key, group in g: group.plot(ax=ax, kind='scatter', x='x', y='y ', etiqueta=clave, color=colores[clave]) gráfico(ecuación, rango(-20,15)) plt.xlabel('x0') plt.ylabel('x1') plt.show()

Lea más artículos basados ​​en Regresión Logística en nuestro página web del NDN Collective .

Conclusión

Por lo tanto, la regresión logística es un método de análisis estadístico. Nuestro modelo ha etiquetado con precisión el 72 % de los datos de prueba, y podríamos aumentar la precisión aún más si usamos un algoritmo diferente para el conjunto de datos.

Los medios que se muestran en este artículo no son propiedad de Analytics Vidhya y se utilizan a discreción del autor. 

Relacionado:

Fuente: https://www.analyticsvidhya.com/blog/2022/01/logistic-regression-an-introductory-note/