Estás leyendo la publicación: Un viaje corto hacia el aprendizaje profundo: hacia la IA
Publicado originalmente en Hacia la IA, la empresa líder mundial en noticias y medios de IA y tecnología. Si está creando un producto o servicio relacionado con la IA, lo invitamos a considerar convertirse en patrocinador de la IA. En Hacia la IA, ayudamos a escalar las empresas emergentes de IA y tecnología. Permítanos ayudarlo a dar rienda suelta a su tecnología a las masas.
¿Entendiendo las redes neuronales artificiales (ANN) con un ejemplo…?
Resumen del artículo
Este artículo trata principalmente sobre la comprensión de las redes neuronales artificiales (ANN) y su flujo de trabajo. Cuando escuche estas palabras, es posible que tenga muchas preguntas como:
¿Qué es el aprendizaje profundo?
¿Cómo funciona la Neurona Biológica y Artificial?
¿Qué es un perceptrón (ANN)?
¿Cómo se entrena un modelo de aprendizaje profundo?
Todas estas preguntas se abordan en el artículo. Se incluye una explicación detallada del ejemplo en el artículo que tiene pasos como:
Descripción del conjunto de datos
Importar los paquetes y el conjunto de datos
Análisis exploratorio de datos
Preprocesamiento de datos
Crear, entrenar, predecir y evaluar un modelo ANN
Empecemos
¿Qué es el aprendizaje profundo?
El aprendizaje profundo es una parte del aprendizaje automático que se centra principalmente en las redes neuronales artificiales que intentarían imitar al cerebro. El aprendizaje profundo se introdujo a principios de los años 50, pero se hizo popular en los últimos años debido al aumento de las aplicaciones orientadas a la IA y los datos que generan las empresas.
Desde mi punto de vista, es fácil entender los conceptos individualmente pero cuando los implementas juntos sería difícil seguir lo que sucede dentro del modelo. Es por eso que los modelos de aprendizaje profundo a menudo se denominan modelo de caja negra. Sin embargo, daría resultados sorprendentes a nuestro problema comercial y tiene muchas aplicaciones.
¿Cómo funciona la Neurona Biológica y Artificial?
Permítame explicarle una situación en la que toca un objeto caliente con la mano, siente el dolor y retira la mano de inmediato. Esta acción y reacción se realizan en una fracción de segundo. ¿Alguna vez has tenido la sensación de que esto está sucediendo?
Bueno, son trillones de neuronas conectadas en el cuerpo cuando tocas un objeto caliente, el impulso eléctrico viajará desde las neuronas de tu mano hasta las neuronas de tu cerebro. Luego se toma la decisión e inmediatamente el impulso eléctrico viaja de regreso a las neuronas en la mano indicándoles que lo eliminen.
Dentro de las neuronas, dendritas actúan como neurorreceptores nada más que el capa de entrada. axones actúan como neurotransmisores nada más que el capa de salida El núcleo es donde el potencial de acción se compara con el umbral. Si el potencial de acción es mayor que que el umbral, el impulso eléctrico transmitir a otra neurona. Si el potencial de acción es menor que el umbral, el impulso eléctrico no transmitirá a otra neurona.
Del mismo modo, las neuronas artificiales recibir la información de la capa de entrada y transmitir la información a otras neuronas a través de la capa de salida Aquí, las neuronas están conectadas y se asignan ciertos pesos a esa conexión en particular. Estos pesos representan el fortaleza de la conexión y juegan un papel importante en la activación de la neurona. El inclinación es como un interceptar en la ecuación lineal.
Aquí, las entradas (x1 a xn) se multiplican con los pesos correspondientes (w1 a wn) y luego se suman junto con el sesgo. El resultado se tomaría como entrada para la función de activación, aquí es donde ocurre la decisión y la salida de la función de activación se transfiere a otras neuronas. Existen diferentes tipos de funciones de activación, algunas son lineales, escalonadas, sigmoideas, RelU, etc.
¿Qué es un perceptrón?
Perceptron es un algoritmo que hace que las neuronas aprendan de la información dada. es de dos tipos, Perceptrón de una sola capa hace no contener capas ocultas. Mientras que, Perceptrón multicapa contiene una o más capas ocultas. Perceptrón de una sola capa es el la forma mas simple de una red neuronal artificial (ANA).
¿Cómo se entrena un modelo de aprendizaje profundo?
En propagación hacia adelanteel información va desde el aporte capa hacia producción capa. Aquí, las entradas se multiplican con los pesos correspondientes, luego se suman junto con el sesgo y luego se aplica la función de activación a ese resultado. Este proceso continúa hasta que llega a la capa de salida con el valor predicho (salida). El función de pérdida encontraría el error Entre los predicho y real producción.
toda la idea de propagación hacia atrás Es para disminuir el error actualizando los pesos. Esto se puede lograr con la ayuda de optimizadores. Aquí, los pesos se actualizan desde la última capa a la primera mediante la implementación de la regla derivada. Entonces, estos dos pasos continúan hasta que obtenga la precisión deseada.
Ejemplo
Considere un ejemplo, Trabajemos en el Predicción de insuficiencia cardíaca conjunto de datos Este es un problema de clasificación, estaremos prediciendo si un paciente tiene insuficiencia cardíaca o no.
Acerca del conjunto de datos
El conjunto de datos contiene 299 entradas recopiladas en el Instituto de Cardiología de Faisalabad en 2015. Hay 105 mujeres y 194 hombres en el rango de edad entre 40 y 95 años en el conjunto de datos. Contiene 13 características que son:
- edad: edad del paciente
- anemia: si la hemoglobina del paciente está por debajo del rango normal o no
- creatinine_phosphokinase: Nivel de creatina fosfoquinasa en la sangre (mcg/L)
- diabetes: si el paciente era diabético o no
- fracción_de_eyección: Es una medida de la sangre que bombea el ventrículo izquierdo en cada contracción.
- high_blood_pression: si el paciente tiene hipertensión
- plaquetas: Recuento de plaquetas en la sangre (kiloplaquetas/mL)
- serum_creatinine: Nivel de creatinina sérica en la sangre (mg/dL)
- suero_sodio: nivel de sodio sérico en la sangre (mEq/L)
- sex: Género del paciente
- Tabaquismo: Si el paciente fuma o no.
- tiempo: tiempo de visita de seguimiento del paciente sobre la enfermedad en meses
- DEATH_EVENT: si el paciente falleció debido a una insuficiencia cardíaca
Importar los paquetes
En primer lugar, importe los paquetes necesarios para explorar, visualizar y preprocesar los datos. Esto se puede hacer con la ayuda de las bibliotecas pandas, Scipy, NumPy, matplolib y seaborn. Importemos también la biblioteca de advertencias para ignorar la advertencia generada por el código.
Código:
importar pandas como pd
importar numpy como np
importar scipy
importar matplotlib.pyplot como plt
importar seaborn como sns
% matplotlib en línea
advertencias de importación
advertencias.filterwarnings(‘ignorar’)
Importar el conjunto de datos
Importar el conjunto de datos (heart_failure_clinical_records_dataset.csv) con la ayuda del método read_csv en el paquete pandas.
Código:
df=pd.read_csv(‘heart_failure_clinical_records_dataset.csv’)
df.cabeza()
Análisis exploratorio de datos
Hay muchas cosas que explorar sobre el conjunto de datos. Comencemos con la descripción y la información del conjunto de datos con la ayuda de los métodos describe e info.
Código:
df.describe() df.info()
Compruebe los valores nulos
Siempre es importante verificar si hay valores nulos en el conjunto de datos. Si están presentes, deben manejarse porque podría afectar la precisión del modelo y podría obtener resultados no deseados.
Código:
df.isnull().sum()
Afortunadamente, el conjunto de datos no contiene ningún valor faltante. De lo contrario, debían manejarse con la ayuda de técnicas como la imputación, la eliminación, etc.
Visualización de datos
Es una forma de analizar los datos visualizando las tendencias y patrones en forma de gráficos, cuadros, plots, etc. Son diferentes tipos de visualizaciones:
- Análisis univariable: trata con una variable y encuentra el patrón dentro de la variable
- Análisis bivariante: se ocupa de dos variables y se centra principalmente en la relación entre ellas.
- Análisis multivariante: se ocupa de más de dos variables y comprueba el comportamiento general de las variables al mismo tiempo.
1. Comencemos la visualización de datos con el objetivo variable para verificar el número de pacientes recuperados y fallecidos utilizando el método de conteo de la biblioteca marina.
Código:
plt.figure(figsize=(3,3),dpi=150)
sns.countplot(x=”EVENTO_DEATH”, data=df,palette=’cohete’)
plt.title(‘0 – Sobrevivido, 1 – Fallecido’)
plt.ylabel(“Recuento”)
plt.mostrar()
De la trama, la tasa de recuperación es casi el doble de la tasa de fallecidos de los pacientes. Aquí, los datos están un poco desequilibrados. Generalmente, la técnica SMOTE se utiliza para equilibrar los datos. A partir de ahora, vamos a mantenerlo así.
2. Comprobar el variables categóricasy cómo se están comportando en relación con la variable de destino.
Código:
plt.figure(figsize=(4,3),dpi=150)
sns.countplot(x=”sexo”,hue=’DEATH_EVENT’, data=df,palette=’viridis’)
plt.ylabel(“Recuento”)
plt.xlabel(“Género”)
plt.title(‘0 — Femenino, 1 — Masculino’)
plt.mostrar()
De la trama, el número de pacientes masculinos es casi el doble de pacientes femeninos. Podemos concluir que la tasa de mortalidad es casi la mitad de la tasa de supervivencia en ambas categorías.
Código:
plt.figure(figsize=(4,3),dpi=150)
sns.countplot(x=”presión_sanguínea_alta”,hue=’EVENTO_DEATH’, data=df)
plt.ylabel(“Recuento”)
plt.xlabel(“Presión arterial”)
plt.mostrar()
De la gráfica, el número de pacientes que no tienen hipertensión es casi el doble de los pacientes que tienen hipertensión. Podemos concluir que hay más posibilidades de insuficiencia cardíaca cuando una persona tiene presión arterial alta.
Código:
plt.figure(figsize=(4,3),dpi=150)
sns.countplot(x=”fumar”,hue=’DEATH_EVENT’, data=df,palette=’mako’)
plt.ylabel(“Recuento”)
plt.mostrar()
De la trama, el número de pacientes que no fuman es casi el doble de los pacientes fumadores. Podemos concluir que la tasa de mortalidad es casi la mitad de la tasa de supervivencia en ambas categorías.
3. Comprobar el Variables continuasy cómo se distribuyen sus tendencias y patrones.
Código:
print(‘El valor medio es’, df[‘age’].significar())
print(‘El valor de la curtosis es’, df[‘age’].kurt())
plt.figure(figsize=(4,3),dpi=150)
sns.distplot(df[‘age’],color=’naranja’)
plt.mostrar()
Del gráfico, podemos decir que el valor promedio de la edad de un paciente es de alrededor de 60 años y el rango está entre 40 y 95 años. El valor de asimetría es positivo, lo que significa que hay más número de observaciones presentes en el lado derecho del gráfico y concluye que más personas son menores de 60 años.
print(‘El valor medio es’, df[‘serum_sodium’].significar())
print(‘El valor de la curtosis es’, df[‘serum_sodium’].kurt())
print(‘El valor de asimetría es’, df[‘serum_sodium’].sesgar())
plt.figure(figsize=(4,3),dpi=150)
sns.distplot(df[‘serum_sodium’],color=’negro’)
plt.mostrar()
Del gráfico anterior, podemos decir que el valor promedio del nivel de sodio sérico en la mayoría de los pacientes es 136 (mEq/L) y la mayoría de los pacientes tienen un valor mayor que eso.
Código:
plt.figure(figsize=(4,3),dpi=150)
sns.boxplot(data=df,x=’DEATH_EVENT’,y=’plaquetas’)
plt.mostrar()
Del gráfico anterior, podemos decir que hay valores más extremos presentes en el recuento de pacientes sobrevivientes. Los valores medios de ambas categorías son casi iguales. Parece que hay algunos valores atípicos presentes en esta función y también deben manejarse.
4. Repasemos el análisis de múltiples variables para verificar cómo las características exhiben las tendencias entre sí. Puede ser posible con la ayuda de mapa de calor y el Parcela métodos. El método de mapa de calor determina qué tan fuerte están relacionadas las variables entre sí. Mientras que el método pairplot determina cómo se ve la forma de la relación entre las variables.
A partir de los gráficos, podemos decir que las características no están fuertemente correlacionadas entre sí. Entonces, aquí, debe preocuparse por el problema de la covarianza y puede considerar todas las características para predecir la salida.
5. Finalmente, en el análisis exploratorio de datos hay un paquete mágico y poderoso que automáticamente haría todas las cosas por las que hemos pasado hasta ahora, que es el pandas_perfiles paquete. Es mejor preferir EDA automatizado cuando tiene menos tiempo y quiere concentrarse mucho en el modelo. Adjunto la primera página de la plantilla HTML generada por el Informe de perfil método y podrías explorarlo más adelante.
Código:
de pandas_profiling importar ProfileReport
perfil = Informe de perfil (df)
perfil
Preprocesamiento de datos
Detección de valores atípicos
Los valores atípicos en el conjunto de datos pueden afectar drásticamente la salida del modelo del resultado esperado. Por lo tanto, es mejor detectarlos primero con la ayuda de técnicas como la Rango intercuartil método, DBSCAN, etc. El IQR método considera los valores que son menos que la cola inferior y los valores que son mayor que que la cola superior como valores atípicos.
Código:
def iqr_method(data_frame,column_name):
q1 = marco_datos[column_name].cuantil(0.25)
q3 = marco_datos[column_name].cuantil(0.75)
iqr = q3-q1
Cola_inferior = q1 – 1.5 * iqr
Upper_tail = q3 + 1.5 * iqr
return(pd.concat([data_frame[data_frame[column_name]
método_iqr(df[:],’suero_sodio’)
Los anteriores son los valores atípicos presentes en el suero_sodio. Del mismo modo, también hay algunos valores atípicos presentes en las otras características.
Manejo de valores atípicos
Para que podamos transformar la variable que elimina los valores atípicos. Porque es mejor no borrar las entradas como el conjunto de datos es de menor tamaño. Aquí, usé el transformación boxcox para manejar los valores atípicos y escribió un código para manipulación automática de los valores atípicos.
Código:
def manejo_automatizado_valores atípicos(df1):
nombres_atípicos_de_características=[]
para i en df1.columns:
si len(iqr_method(df1[:],yo))>0:
imprimir (yo)
outlier_feature_names.append(i)
para i en outlier_feature_names:
df1[i],fitted_lambda= scipy.stats.boxcox(df1[i] ,lmbda=Ninguno)
volver(df1)
df=automated_handling_outliers(df[:])
Dividir el conjunto de datos
El propósito de este paso es dividir el conjunto de datos en conjuntos de datos de prueba y entrenamiento para que haya diferentes datos presentes para el entrenamiento y la predicción del modelo. Esto se puede hacer usando la función train_test_split. Generalmente, el (70–30)% o (60–40)% Se considera que la proporción divide el conjunto de datos en datos de entrenamiento y de prueba.
Código:
X = df.drop(‘EVENTO_DEATH’,eje=1)
y = gl[‘DEATH_EVENT’]
de sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.35,random_state=101)
Escalar los datos
El escalado de datos es un paso esencial en los pasos de preprocesamiento de datos. Si los datos tienen varios rangos de magnitud, sería difícil para el modelo ANN establecer los pesos y modificarlos para obtener el mejor resultado. Entonces, aquí, el escalador min-max se usa para llevar todos los datos a un cierto rango entre 0 y 1 al mismo tiempo que conserva el comportamiento (tendencia) de los datos.
Código:
desde sklearn.preprocessing import MinMaxScaler
escalador = MinMaxScaler()
Tren_X= escalador.fit_transform(tren_X)
X_test = escalador.transformar(X_test)
Crear un modelo ANN
Para crear un modelo, tenemos algunas bibliotecas poderosas como la tensorflow y Keras paquetes que hacen este proceso muy simple en menos tiempo. El Keras El paquete facilitaría el trabajo porque tiene todas las funcionalidades que solo necesita para definirlas y usarlas donde quiera. Anteriormente, estos paquetes estaban separados pero ahora son integrado en el reciente versión del TensorFlow paquete. Importemos estos paquetes para crear un modelo.
Código:
de tensorflow.keras.models import Sequential
de tensorflow.keras.layers import Dense
de tensorflow.keras.optimizers import Adam
de tensorflow.keras.callbacks importar EarlyStopping
Una vez importados los paquetes y las funcionalidades, cree un modelo utilizando las funcionalidades. Primero, tenemos que crear un diseño del modelo eso funcionaría secuencialmente.
Código:
modelo = Secuencial()
Ahora, agregar el capas densas al modelo secuencial. Cada capa densa tiene neuronas y cada neurona tiene un correspondiente función de activación. siempre un capa de entrada vendrá primero con el neuronas igual a el número de características en el conjunto de datos. En general, la mayoría de la gente considera que la Unidad lineal rectificada (relu) como la función de activación para todas las neuronas en esa capa a menos que sea una capa de salida.
Agregue las capas ocultas como desee, también habría algunas reglas para eso. La mayoría de la gente sugiere tener el número de neuronas en 2 potencias como (16,32,64,..) con el relu funciones de activación en una sola capa. Para la capa de salida, podemos tener una neurona con la sigmoideo función de activación como esta clasificación binaria.
Código:
modelo = Secuencial()
modelo.add(Dense(12,activation=’relu’))
modelo.add(Dense(24,activation=’relu’))
modelo.add(Dense(24,activation=’relu’))
model.add(Dense(1,activation=’sigmoid’))
Luego, compile el modelo definiendo la función de pérdida y el optimizador. Aquí el función de pérdida se considera entropía_cruzada_binaria como esto es un clasificación binaria problema y optimizador como Adán para el óptimo funcionamiento del modelo.
Código:
model.compile(pérdida=’binary_crossentropy’, optimizador=’adam’)
Entrenar y evaluar el modelo
El entrenamiento del modelo se realiza con la ayuda del adaptar método dando el conjunto de datos de entrenamiento de características y la objetivo variable. Aquí a este método, podemos pasar el datos de validación como parámetro entonces eso sería determinar el pérdida de validación mientras que el modelo de formación. En este caso, los datos de prueba pueden tomarse con fines de validación.
Hay un parámetro más importante época. Si una epoca se completa eso significa el modelo pasa por el datos entrenados para una vez. Ese valor se puede establecer para un valor grande pero no demasiado grande. Si el época parámetro se establece en un grande valor entonces el sobreajuste podría ocurrir un problema.
Código:
model.fit(x=X_train,y=y_train.values,validation_data=(X_test,y_test.values),epochs=200)
Una vez que el modelo se entrena en el conjunto de datos de entrenamiento, es mejor verificar el historial del modelo, lo que significa su rendimiento en los datos de validación.
Código:
model_loss_1 = pd.DataFrame(modelo.historia.historia)
plt.figure(figsize=(4,3),dpi=150)
plt.plot(model_loss_1[‘loss’],color=’r’,data=model_loss_1,label=’loss’)
plt.plot(model_loss_1[‘val_loss’],color=’g’,data=model_loss_1,label=’val_loss’)
plt.leyenda()
plt.mostrar()
Del gráfico, podemos decir que la pérdida de entrenamiento y la pérdida de validación disminuyeron por un tiempo. Después del valor umbral de las épocas, el pérdida de validación comenzó creciente mientras que el pérdida de entrenamiento permanecer decreciente. Este problema se llama sobreajuste.
Para superar el problema anterior, existe un concepto llamado Detención anticipada de las devoluciones de llamada en la biblioteca de Keras. Esta técnica de parada temprana se detiene el modelo de ser capacitado además en base al parámetro dado. Implementemos esto recreando el modelo. Defina el método de parada anticipada configurando el monitor parámetro a pérdida de validación. Aquí el paciencia el parámetro no es más que cuánto tiempo tiene que esperar el modelo y continuar el entrenamiento incluso después de notar los cambios drásticos en el parámetro de seguimiento.
Código:
modelo = Secuencial()
model.add(Dense(units=12,activation=’relu’))
model.add(Dense(units=24,activation=’relu’))
model.add(Dense(units=24,activation=’relu’))
model.add(Dense(units=1,activation=’sigmoid’))
model.compile(pérdida=’binary_crossentropy’, optimizador=’adam’)
early_stop = EarlyStopping(monitor=’val_loss’, mode=’min’, detallado=1, paciencia=2)
model.fit(x=X_train, y=y_train,epochs=600,validation_data=(X_test, y_test),verbose=1,callbacks=[early_stop])
Cuando agrega la funcionalidad de parada anticipada al modelo, no es depender sobre el número de las épocas incluso si es un gran número. Ahora, revisemos el historial del modelo trazando la pérdida de entrenamiento y la pérdida de validación del modelo.
A partir del gráfico, podemos interpretar que el entrenamiento del modelo se ha detenido durante alrededor de 100 épocas. No se ha producido ningún sobreajuste durante el entrenamiento del modelo.
Predecir los datos
Este paso se puede hacer con la ayuda del adaptar método en el que probaría los datos como parámetro del modelo.
Código:
df_y=pd.Marco de datos()
df_y[‘y’]=y_prueba
df_y[‘y_hat’]=modelo.predecir(X_test)
df_y[‘y_hat’]=df_y[‘y_hat’].apply(lambda x: 1 si x>0.5 sino 0)
Importemos los módulos que determinan la puntuación de exactitud, precisión y recuperación del modelo del paquete sklearn.
Código:
print(“Puntaje de precisión del modelo:”, Accuracy_score(df_y[‘y’],df_y[‘y_hat’]))
print(“Puntuación de precisión del modelo:”,precision_score(df_y[‘y’],df_y[‘y_hat’]))
print(“Puntaje de recuperación del modelo:”,recall_score(df_y[‘y’],df_y[‘y_hat’]))
imprimir (clasificación_informe (df_y[‘y’],df_y[‘y_hat’]))
Bueno, tengo una precisión general del 82% que no está mal. Es posible que obtenga una precisión diferente según el preprocesamiento de datos y el ajuste del modelo. Además de eso, puede intentar integrar capas de abandono también entre el modelo para reducir la posibilidad de que el modelo se sobreajuste. Antes de concluir, comparemos el rendimiento del modelo con parada temprana y sin parada temprana trazando su historia.
Código:
plt.figure(figsize=(8,6),dpi=100)
plt.plot(model_loss_1[‘loss’],data=model_loss_1,label=’pérdida sin parada anticipada’)
plt.plot(model_loss_2[‘loss’],data=model_loss_2,label=’pérdida con parada anticipada’)
plt.leyenda()
plt.mostrar()
Código:
plt.figure(figsize=(8,6),dpi=100)
plt.plot(model_loss_1[‘val_loss’],data=model_loss_1,label=’val_loss sin parada anticipada’)
plt.plot(model_loss_2[‘val_loss’],data=model_loss_2,label=’val_loss con parada anticipada’)
plt.leyenda()
plt.mostrar()
Código fuente
Conclusión
Por lo tanto, me gustaría decir que existen muchas aplicaciones geniales para trabajar y que puede implementarlas con ANN. Pensé en incluir algunas cosas más interesantes en el artículo, pero ya es largo. Intentaré agregar esas cosas en el próximo artículo.
Espero que tengas una lectura interesante y que este artículo te sea útil…
Avíseme si tiene alguna duda y corríjame si algo está mal con el artículo. Se aceptan todas las sugerencias…✌
¿Feliz aprendizaje?
A Short Journey To Deep Learning se publicó originalmente en Towards AI en Medium, donde las personas continúan la conversación destacando y respondiendo a esta historia.
Publicado a través de Hacia la IA
