Regresión logística de PySpark

Regresion Logistica De Pyspark



En esta guía de PySpark, analizaremos cómo realizar la regresión logística para predecir si una persona está afectada por un accidente cerebrovascular o no. En general, el accidente cerebrovascular ocurre cuando una persona es adicta al humo o la bebida. Otras razones, como enfermedades cardíacas y niveles altos de glucosa en la sangre (diabetes), también causan un accidente cerebrovascular. Con la ayuda del modelo de aprendizaje automático de regresión logística, predeciremos y mostraremos la precisión de nuestro modelo en los datos de muestra.

En esta guía, primero veremos el enfoque y luego predeciremos el golpe de cada persona analizando los datos paso a paso.

Regresión logística

La regresión logística, también llamada 'Modelo Logit', se utiliza en el análisis predictivo para problemas de clasificación. Este es un modelo de Machine Learning que funciona solo en la clasificación para clasificar las clases (categorías). Por ejemplo, hay dos categorías en nuestro escenario (una persona afectada por un accidente cerebrovascular y una persona que no está afectada por un accidente cerebrovascular). Las mejores aplicaciones del modelo son la predicción de enfermedades cardíacas, la predicción de género, la predicción de la vida útil de los cultivos, etc.







Pasos:

1. Recopilación de datos: Los datos son necesarios para realizar cualquier predicción/análisis. Puede ser en formato CSV/XLSX, entre otros. Podemos cargar esto en el entorno Spark (DataFrame) usando el método spark.read.csv().



2. Análisis de datos : El análisis de los atributos/columnas se conoce como “análisis de datos”. Las columnas que ayudan a predecir la clase se conocen como 'atributos independientes'. La columna que da como resultado la predicción se conoce como 'atributo dependiente o de destino'. En este escenario, podemos usar la propiedad de columnas para mostrar todas las columnas. El método distinto() se utiliza para ver los valores únicos.



3. Preprocesamiento de datos: Filtrar los valores nulos/faltantes se conoce como 'preprocesamiento'. Eliminamos todos los valores faltantes en esta etapa. La máquina solo conoce el lenguaje binario. Por lo tanto, todas las categorías de cadenas deben convertirse en valores categóricos numéricos. En PySpark, podemos usar el 'StringIndexer', que es la clase disponible en el módulo pyspark.ml.feature para convertir las categorías de cadenas en numéricas. Automáticamente los convierte internamente. No necesitamos proporcionar los valores. Puede utilizar la siguiente sintaxis:





indexer_data=StringIndexer(inputCol= 'String_Category_ColumnName' ,salidaCol= 'Nueva_columna_nombre' )

4. Montaje de vectores: Ahora, tienes los datos que la máquina puede entender. En esta etapa, todos los atributos independientes deben ser vectorizados en una sola columna. Esto se puede hacer usando la clase VectorAssembler. Toma dos parámetros: El primer parámetro es inputCols que toma una lista de atributos independientes. El segundo parámetro es el outputCol que vectoriza todos los inputCols en esta variable.

ensamblador=VectorAssembler(inputCols=[columnas…],outputCol=datos_vectorizados)

5. Transformación: Ahora, prepare sus datos transformando las columnas actualizadas (Paso 3) usando la función transform().



ensamblador.transform(inxed_data)

6. Preparación de los datos para entrenamiento y pruebas: En esta etapa, dividimos los datos en 'entrenamiento' y 'prueba'. Será mejor si dividimos el 70 % de los datos para entrenar el modelo y el 30 % de los datos para probar el modelo. Esto se puede lograr usando el método randomSplit(). Toma una lista que contiene dos valores flotantes: uno para la división de prueba y otro para la división del tren.

train_data,test_data=final_data.select([ 'características' ,columna_objetivo]).División aleatoria([0.70.0.30])

7. Ajuste y evaluación del modelo : Es hora de ajustar el modelo de regresión logística. El modelo de regresión logística está disponible en el módulo pyspark.ml.classification. Toma la etiqueta de clase/columna de destino. Esto da como resultado columnas rawPrediction, probabilidad y predicción. Nuestros resultados se almacenan en la columna de predicción.

# Ajuste del modelo

logistic_regression_model=LogisticRegression(labelCol=target_column).fit(train_data)

# Evaluación del modelo

train_results=logistic_regression_model.evaluate(train_data).predictions

8. Precisión y resultados: Esta es la etapa final en la que probamos la precisión del modelo utilizando cualquier técnica de prueba.

Veamos el siguiente proyecto donde predecimos si una persona se ve afectada por un accidente cerebrovascular o no usando el modelo de regresión logística.

Predicción de carrera

9. Instale el módulo PySpark en su entorno. El siguiente es el comando para instalar:

pip instalar pyspark

10. Vamos a crear un PySpark DataFrame con 10 registros que están relacionados con los detalles del trazo de 10 personas. Para demostración, creamos un DataFrame sin CSV. Hay 7 columnas en este DataFrame. “Sexo”, “Nivel_de_glucosa”, “Casado”, “Edad”, “Enfermedad_del_corazón”, “Hipertensión” son atributos independientes y “Accidente cerebrovascular” es la etiqueta de clase o atributo dependiente. Eso significa que el trazo de una persona depende de estos atributos independientes.

importar pyspark

desde pyspark.sql importar SparkSession

linuxhint_spark_app = SparkSession.builder.appName( 'Sugerencia de Linux' ).getOrCreate()

avivar_datos =[

{ 'Género' : 'Femenino' , 'edad' : 50 , 'cardiopatía' : 'Sí' ,

'hipertensión' : 'Sí' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 130 , 'Ataque' : 1 },

{ 'Género' : 'Masculino' , 'edad' : 20 , 'cardiopatía' : 'No' ,

'hipertensión' : 'Sí' , 'casado' : 'No' , 'nivel_de_glucosa' : 97 , 'Ataque' : 0 },

{ 'Género' : 'Masculino' , 'edad' : 12 , 'cardiopatía' : 'No' ,

'hipertensión' : 'No' , 'casado' : 'No' , 'nivel_de_glucosa' : 98 , 'Ataque' : 0 },

{ 'Género' : 'Femenino' , 'edad' : 90 , 'cardiopatía' : 'No' ,

'hipertensión' : 'No' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 170 , 'Ataque' : 1 },

{ 'Género' : 'Masculino' , 'edad' : 43 , 'cardiopatía' : 'Sí' ,

'hipertensión' : 'Sí' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 150 , 'Ataque' : 1 },

{ 'Género' : 'Femenino' , 'edad' : 21 , 'cardiopatía' : 'No' ,

'hipertensión' : 'No' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 110 , 'Ataque' : 0 },

{ 'Género' : 'Femenino' , 'edad' : 50 , 'cardiopatía' : 'Sí' ,

'hipertensión' : 'No' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 100 , 'Ataque' : 0 },

{ 'Género' : 'Masculino' , 'edad' : 34 , 'cardiopatía' : 'No' ,

'hipertensión' : 'Sí' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 190 , 'Ataque' : 1 },

{ 'Género' : 'Masculino' , 'edad' : 10 , 'cardiopatía' : 'No' ,

'hipertensión' : 'No' , 'casado' : 'No' , 'nivel_de_glucosa' : 90 , 'Ataque' : 0 },

{ 'Género' : 'Femenino' , 'edad' : 56 , 'cardiopatía' : 'Sí' ,

'hipertensión' : 'Sí' , 'casado' : 'Sí' , 'nivel_de_glucosa' : 145 , 'Ataque' : 1 }

]

# crear el marco de datos a partir de los datos anteriores

stroke_df = linuxhint_spark_app.createDataFrame(stoke_data)

# Stoke_df real

stroke_df.show()

Producción:

11. Muestre las columnas independientes utilizando el método select().

# Mostrar atributos independientes

trazo_df.select(stroke_df[ 'Género' ],stroke_df[ 'nivel_de_glucosa' ],stroke_df[ 'casado' ],stroke_df[ 'edad' ],stroke_df[ 'cardiopatía' ],stroke_df[ 'hipertensión' ]).espectáculo()

Producción:

12. Muestre los valores únicos que están presentes en el atributo de destino (Stroke).

# valores únicos de atributos de destino

trazo_df.select(stroke_df[ 'Ataque' ]).distinto().mostrar()

Producción:

13. Devuelva el tipo de datos de todas las columnas usando la función printSchema().

# Devuelve el tipo de datos de todas las columnas.

trazo_df.imprimirEsquema()

Producción:

Podemos ver que 4 columnas son de tipo cadena. Vamos a convertirlos en valores numéricos categóricos.

14. Vamos a convertir los valores categóricos de cadena en valores categóricos numéricos usando StringIndexer en las columnas 'Gender', 'heart_disease', 'hyper_tension' y 'casado' y escribirlos en las columnas Categotical_Gender, Categotical_heart_disease, Categotical_hyper_tension y Categotical_married. Almacene las columnas en el marco de datos indexed_data usando el método fit().

de pyspark.ml.feature importar StringIndexer

# Convierta valores categóricos de cadena en valores categóricos numéricos en la columna 'Género'.

indexer_data=StringIndexer(inputCol= 'Género' ,salidaCol= 'Categotical_Gender' )

indexed_data=indexer_data.fit(stroke_df).transform(stroke_df)

# Convierta los valores categóricos de cadena en valores categóricos numéricos en la columna 'heart_disease'.

indexer_data=StringIndexer(inputCol= 'cardiopatía' ,salidaCol= 'Categotical_heart_disease' )

indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)

# Convierta los valores categóricos de cadena en valores categóricos numéricos en la columna 'hiper_tensión'.

indexer_data=StringIndexer(inputCol= 'hipertensión' ,salidaCol= 'Categotical_hyper_tension' )

indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)

# Convierta valores categóricos de cadena en valores categóricos numéricos en la columna 'casado'.

indexer_data=StringIndexer(inputCol= 'casado' ,salidaCol= 'Categotical_casado' )

indexed_data=indexer_data.fit(indexed_data).transform(indexed_data)

# Mostrar el actualizado

indexed_data.show()

Producción:

15. Convierta las columnas independientes en un vector usando el ensamblador de vectores. El nombre del vector es 'características'.

desde pyspark.ml.feature importar VectorAssembler

ensamblador= VectorAssembler(inputCols=[ 'Categotical_Gender' , 'Categotical_heart_disease' , 'Categotical_hyper_tension' , 'Categotical_casado' , 'edad' ,

'nivel_de_glucosa' ],colSalida= 'características' )

16. Transforme los datos anteriores en un DataFrame final usando la función transform() y muéstrelo usando la función show().

 

Producción:

17. Prepare los datos para entrenamiento y prueba dividiéndolos en 70-30. Las 'características' se almacenan en train_data y 'Stroke' se almacenan en test_data.

# Preparar datos para entrenamiento y pruebas

train_data,test_data=final.select([ 'características' , 'Ataque' ]).División aleatoria([ 0.70 , 0.30 ])

18. Ajuste el modelo de regresión logística y evalúelo.

de pyspark.ml.classification import LogisticRegression

# Ajuste del modelo

logistic_regression_model=Regresion Logistica(labelCol= 'Ataque' ).fit(tren_datos)

# Evaluación del modelo

train_results=logistic_regression_model.evaluate(train_data).predictions

train_results.show()

Producción:

19. Utilice BinaryClassificationEvaluator para verificar la precisión del modelo. Podemos ver que nuestro modelo es 100% exacto.

de pyspark.ml.evaluacion importar BinaryClassificationEvaluator

# llamar al BinaryClassificationEvaluator

resultados = BinaryClassificationEvaluator(rawPredictionCol= 'predicción' ,etiquetaCol= 'Ataque' )

ROC_AUC = resultados.evaluar(tren_resultados)

imprimir(ROC_AUC * 100 , '% Exactitud' )

Conclusión

Puede predecir el problema de clasificación de mosaico real utilizando el modelo de regresión logística en PySpark. Es importante eliminar los valores nulos/ausentes, ya que disminuyen la evaluación y la precisión del modelo. El preprocesamiento es un paso necesario antes de ajustar cualquier modelo de aprendizaje automático. Asegúrese de realizar este paso correctamente y con precisión.