Aprendizaje automático con redes neuronales usando scikit-learn

En esta guía, seguiremos los siguientes pasos:

Paso 1 – Cargando las bibliotecas y módulos necesarios.

Paso 2 – Lectura de los datos y realización de comprobaciones de datos básicos.

Paso 3 – Crear arreglos para las características y la variable de respuesta.

Paso 4 – Creación de los conjuntos de datos de entrenamiento y pruebas.

Paso 5 – Construir, predecir y evaluar el modelo de red neuronal.

Las siguientes secciones cubrirán estos pasos.

Paso 1 – Carga de las bibliotecas y módulos requeridos

12345678910111213# Importar bibliotecas requeridasimportar pandas como pdimport numpy como np importar matplotlib.pyplot como pltimport sklearnfrom sklearn.neural_network importar MLPClassifierfrom sklearn. neural_network import MLPRegressor# Importar los módulos necesariosdesde sklearn.model_selection importar train_test_splitfrom sklearn.metrics importar mean_squared_errorfrom math importar sqrtfrom sklearn.metrics importar r2_score

pitón

Paso 2 – Lectura de los datos y realización de comprobaciones de datos básicos

La primera línea de código se lee en los datos como un cuadro de datos de pandas, mientras que la segunda línea imprime la forma – 768 observaciones de 9 variables. La tercera línea da las estadísticas resumidas transpuestas de las variables.

Si observamos el resumen de la variable «diabetes», observamos que el valor medio es 0,35, lo que significa que alrededor del 35 por ciento de las observaciones del conjunto de datos tienen diabetes. Por lo tanto, la precisión de la línea de base es del 65 por ciento y nuestro modelo de red neural debería superar definitivamente este punto de referencia.

123df = pd.read_csv($0027diabetes.csv$0027)print(df.shape)df.describe().transpose()

pitón

Salida:

12345678910111213(768, 9) | | conteo | media | std | min | 25% | 50% | 75% | max ||-------------|-----|----------------------------------------------------------------------------------------------------------------------------------------------------- embarazos | 768.0 | 3.845052 | 3.369578 | 0.000 | 1.00000 | 3. 6.00000, 17.00, glucosa, 768.0, 120.894531, 31.972618, 0.000, 99.00000, 117.0000, 140.25000, 199. Diastólica 768,0, 69.105469, 19.355807, 0.000, 62.00000, 72.0000, 80.00000, 122.00, tríceps 768,0, 20.536458, 15. 952218 0.000 0.00000 0.00000 23.0000 32.00000 99.00 insulina 768.0 79.799479 115.244002 0.000 0.00000 30. 5.000, 127.25000, 846.00, BMI, 768.0, 31.992578, 7.884160, 0.000, 27.30000, 32.0000, 36.60000, 67.10, dpf, 768. 0 | 0.471876 | 0.331329 | 0.078 | 0.24375 | 0.3725 | 0.62625 | 2.42 | edad | 768.0 | 33.240885 | 11.760232 | 21.000 | 24. 00000 | 29.0000 | 41.00000 | 81.00 || diabetes | 768.0 | 0.348958 | 0.476951 | 0.000 | 0.00000 | 0.0000 | 1.00000 | 1.00 |

Paso 3 – Creación de arreglos para las características y la variable de respuesta

La primera línea de código crea un objeto de la variable objetivo llamado $0027columna_objetivo$0027. La segunda línea nos da la lista de todas las características, excluyendo la variable objetivo $0027unemploy$0027, mientras que la tercera línea normaliza los predictores.

En la cuarta línea se muestra el resumen de los datos normalizados. Podemos ver que todas las variables independientes se han escalado ahora entre 0 y 1. La variable objetivo permanece sin cambios.

1234target_column =[$0027diabetes$0027] predictores =list(set(list(df.columns))-set(target_column))df[predictores]= df[predictores]/df[predictores].max()df.describe().transpose()

pitón

Salida:

<...cuenta, media, std, min, 25%, 50%, 75%, máximo, embarazos, 768.0, 0.226180, 0.198210, 0.000000, 0.058824, 0.176471, 0... 352941 1,0 glucosa 768,0 0,607510 0,160666 0,000000 0,497487 0,587940 0,704774 1,0 diastólica 768. 0 | 0.566438 | 0.158654 | 0.000000 | 0.508197 | 0.590164 | 0.655738 | 1.0 | tríceps | 768.0 | 0.207439 | 0.161134 | 0. 000000 | 0.000000 | 0.232323 | 0.323232 | 1.0 || insulina | 768.0 | 0.094326 | 0.136222 | 0.000000 | 0.000000 | 0.036052 | 0. 150414 1.0 | bmi 768.0 | 0.476790 0.117499 0.000000 0.406855 0.476900 0.545455 1.0 dpf 768.0 0. 194990 | 0.136913 | 0.032231 | 0.100723 | 0.153926 | 0.258781 | 1.0 | edad | 768.0 | 0.410381 | 0.145188 | 0.259259 | 0.296296 | 0. 358025 | 0.506173 | 1.0 || diabetes | 768.0 | 0.348958 | 0.476951 | 0.000000 | 0.000000 | 0.000000 | 1.000000 | 1.0 |

Paso 4 – Creación de los conjuntos de datos de entrenamiento y prueba

El primer par de líneas de código a continuación crea matrices de las variables independientes (X) y dependientes (y), respectivamente. La tercera línea divide los datos en conjunto de datos de entrenamiento y de prueba, y la cuarta línea imprime la forma de los datos de entrenamiento y de prueba.

12345X = df[predictores].valuesy = df[columna_objetivo].valuesX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=40)print(X_train.shape);print(X_test.shape)

pitón

Salida:

12(537, 8)(231, 8)

Paso 5 – Construir, predecir y evaluar el modelo de red neuronal

En este paso, construiremos el modelo de red neural usando el objeto estimador de la biblioteca scikit-learn, el $0027Clasificador de Percepción Multicapa$0027. La primera línea de código (que se muestra a continuación) importa el $0027MLPClassifier$0027.

La segunda línea instancializa el modelo con el argumento $0027hidden_layer_sizes$0027 establecido en tres capas, que tiene el mismo número de neuronas que el recuento de características en el conjunto de datos. También seleccionaremos $0027relu$0027 como la función de activación y $0027adam$0027 como el solucionador para la optimización del peso. Para aprender más sobre $0027relu$0027 y $0027adam$0027, por favor consulte las guías de Aprendizaje Profundo con Keras , cuyos enlaces se dan al final de esta guía.

La tercera línea de código ajusta el modelo a los datos de capacitación, mientras que la cuarta y quinta líneas utilizan el modelo capacitado para generar predicciones sobre el conjunto de datos de capacitación y de prueba, respectivamente.

1234567de sklearn.neural_network import MLPClassifiermlp = MLPClassifier(hidden_layer_sizes=(8,8,8), activation=$0027relu$0027, solver=$0027adam$0027, max_iter=500)mlp.fit(X_train,y_train)predict_train = mlp.predict(X_train)predict_test = mlp.predict(X_test)

pitón

Una vez generadas las predicciones, podemos evaluar el rendimiento del modelo. Al ser un algoritmo de clasificación, primero importaremos los módulos necesarios, lo que se hace en la primera línea de código a continuación. La segunda y tercera línea de código imprimen la matriz de confusión y los resultados del informe de confusión sobre los datos de capacitación.

123de sklearn.metrics import classification_report,confusion_matrixprint(confusion_matrix(y_train,predict_train))print(classification_report(y_train,predict_train))

pitón

Salida:

12345678[[319 39][ 78 101]]] precisión en la recuperación f1-score support 0 0.80 0.89 0.85 358 1 0.72 0.56 0.63 179 avg / total 0.78 0.78 0.77 537

El resultado anterior muestra el rendimiento del modelo con respecto a los datos de entrenamiento. La precisión y la puntuación de la F1 es de alrededor de 0,78 y 0,77, respectivamente. Idealmente, el modelo perfecto tendrá el valor de 1 para ambas métricas, pero eso es casi imposible en los escenarios del mundo real.

El siguiente paso es evaluar el rendimiento del modelo en los datos de la prueba que se realiza con las líneas de código que se indican a continuación.

12print(confusion_matrix(y_test,predict_test))print(classification_report(y_test,predict_test))

pitón

Salida:

12345678[[123 19][ 38 51]]] memoria de precisión f1-score support 0 0.76 0.87 0.81 142 1 0.73 0.57 0.64 89 avg / total 0.75 0.75 0.75 231

El resultado anterior muestra el rendimiento del modelo con los datos de la prueba. La precisión y los resultados de la F1 están alrededor de 0,75.