La inteligencia artificial (AI) ha ganado una cantidad significativa de popularidad en los últimos años.
Si es ingeniero de software, informático o entusiasta de la ciencia de datos en general, entonces probablemente esté intrigado por las increíbles aplicaciones de procesamiento de imágenes, reconocimiento de patrones y detección de objetos que ofrece este campo.
El subcampo más importante de la IA del que probablemente haya oído hablar es el aprendizaje profundo. Este campo se enfoca en poderosos algoritmos (instrucciones de programas de computadora) modelados a partir de la funcionalidad del cerebro humano conocida como Redes neuronales.
En este artículo, repasaremos el concepto de redes neuronales y cómo construir, compilar, ajustar y evaluar estos modelos usando Python.
Redes neuronales
Las redes neuronales, o NN, son una serie de algoritmos modelados a partir de la actividad biológica del cerebro humano. Las redes neuronales consisten en nodos, también llamados neuronas.
Una colección de nodos verticales se conocen como capas. El modelo consiste en una entrada, una salida y una serie de capas ocultas. Cada capa consta de nodos, también llamados neuronas, donde se realizan los cálculos.
En el siguiente diagrama, los círculos representan los nodos y la colección vertical de nodos representa las capas. Hay tres capas en este modelo.
Los nodos de una capa están conectados a la siguiente capa a través de líneas de transmisión como se ve a continuación.
Nuestro conjunto de datos consta de datos etiquetados. Esto significa que a cada entidad de datos se le ha asignado un cierto valor de nombre.
Entonces, para un conjunto de datos de clasificación de animales, tendremos imágenes de gatos y perros como nuestros datos, con 'gato' y 'perro' como nuestras etiquetas.
Es importante tener en cuenta que las etiquetas deben convertirse en valores numéricos para que nuestro modelo tenga sentido, por lo que nuestras etiquetas de animales se convierten en '0' para el gato y '1' para el perro. Tanto los datos como las etiquetas se pasan a través del modelo.
Aprendiendo
Los datos se alimentan al modelo una entidad a la vez. Estos datos se dividen en trozos y se pasan a través de cada nodo del modelo. Los nodos realizan operaciones matemáticas en estos fragmentos.
No necesita conocer las funciones o cálculos matemáticos para este tutorial, pero es importante tener una idea general de cómo funcionan estos modelos. Después de una serie de cálculos en una capa, los datos se pasan a la siguiente capa y así sucesivamente.
Una vez completado, nuestro modelo predice la etiqueta de datos en la capa de salida (por ejemplo, en un problema de clasificación de animales, obtenemos una predicción "0" para un gato).
Luego, el modelo procede a comparar este valor predicho con el del valor de la etiqueta real.
Si los valores coinciden, nuestro modelo tomará la siguiente entrada, pero si los valores difieren, el modelo calculará la diferencia entre ambos valores, llamada pérdida, y ajustará los cálculos del nodo para producir etiquetas coincidentes la próxima vez.
Marcos de aprendizaje profundo
Para construir redes neuronales en código, necesitamos importar Marcos de aprendizaje profundo conocidas como bibliotecas que utilizan nuestro entorno de desarrollo integrado (IDE).
Estos marcos son una colección de funciones escritas previamente que nos ayudarán en este tutorial. Usaremos el marco Keras para construir nuestro modelo.
Keras es una biblioteca de Python que utiliza un backend de aprendizaje profundo e inteligencia artificial llamado Flujo tensor para crear NN en forma de modelos secuenciales simples con facilidad.
Keras también viene con sus propios modelos preexistentes que también podrían usarse. Para este tutorial, crearemos nuestro propio modelo usando Keras.
Puede obtener más información sobre este marco de aprendizaje profundo en el Sitio web de Keras.
Construyendo una Red Neuronal (Tutorial)
Pasemos a construir una red neuronal usando Python.
Planteamiento del problema
Las redes neuronales son un tipo de solución a los problemas basados en IA. Para este tutorial, iremos a través de los datos de la diabetes indios de PIMA, que está disponible. esta página.
UCI Machine Learning ha compilado este conjunto de datos y contiene un historial médico de pacientes indios. Nuestro modelo tiene que predecir si el paciente tiene un inicio de diabetes dentro de los 5 años o no.
Cargando conjunto de datos
Nuestro conjunto de datos es un solo archivo CSV llamado 'diabetes.csv' que se puede manipular fácilmente con Microsoft Excel.
Antes de crear nuestro modelo, necesitamos importar nuestro conjunto de datos. Usando el siguiente código puedes hacer esto:
importar pandas como pd
datos = pd.read_csv('diabetes.csv')
x = data.drop(“Resultado”)
y = datos[“Resultado”]
Aquí estamos usando el pandas Biblioteca Para poder manipular nuestros datos de archivos CSV, READSV () es una función incorporada de PANDAS que nos permite almacenar los valores en nuestro archivo en una variable llamada 'DATOS'.
La variable x contiene nuestro conjunto de datos sin los datos de resultado (etiquetas). Logramos esto con la función data.drop() que elimina las etiquetas para x, mientras que y contiene solo los datos de resultado (etiqueta).
Construcción de modelo secuencial
Paso 1: Importación de bibliotecas
Primero, necesitamos importar TensorFlow y Keras, junto con ciertos parámetros requeridos para nuestro modelo. El siguiente código nos permite hacer esto:
importar tensorflow como tf
de tensorflow importar keras
de tensorflow.keras.models import Sequential
de tensorflow.keras.layers importar Activación, Densa
de TensorFlow.keras.optimizers Import ADAM
de tensorflow.keras.metrics import categorical_crossentropy
Para nuestro modelo estamos importando capas densas. Estas son capas completamente conectadas; es decir, cada nodo en una capa está completamente conectado con otro nodo en la siguiente capa.
También estamos importando un activación función necesaria para escalar los datos enviados a los nodos. Optimizadores También se han importado para minimizar la pérdida.
Adam es un optimizador de renombre que hace que nuestros cálculos de nodos de actualización de modelos sean más eficientes, junto con categorical_crossentropy que es el tipo de función de pérdida (calcula la diferencia entre los valores de etiqueta reales y predichos) que usaremos.
Paso 2: Diseñando Nuestro Modelo
El modelo que estoy creando tiene una capa de entrada (con 16 unidades), una oculta (con 32 unidades) y una de salida (con 2 unidades). Estos números no son fijos y dependerán completamente del problema dado.
Establecer el número correcto de unidades y capas es un proceso que se puede mejorar con la práctica. La activación corresponde al tipo de escalado que realizaremos en nuestros datos antes de pasarlos por un nodo.
Relu y Softmax son funciones de activación reconocidas para esta tarea.
modelo = Secuencial([
Denso (unidades = 16, input_shape = (1,), activación = 'relu'),
Denso (unidades = 32, activación = 'relu'),
Denso (unidades = 2, activación = 'softmax')
])
Así es como debería verse el resumen del modelo:
Entrenando el modelo
Nuestro modelo se capacitará en dos pasos, siendo la primera compilación del modelo (colocando el modelo juntos) y la siguiente que se ajusta al modelo en un conjunto de datos dado.
Esto se puede hacer usando la función Model.ContPile () seguida de la función Model.Fit ().
model.compile(optimizador = Adam(índice de aprendizaje = 0.0001), pérdida = 'binary_crossentropy', métricas = ['precisión'])
model.fit(x, y, épocas = 30, tamaño_lote = 10)
Especificar la métrica de 'precisión' nos permite observar la precisión de nuestro modelo durante el entrenamiento.
Dado que nuestras etiquetas tienen la forma de 1 y 0, utilizaremos una función de pérdida binaria para calcular la diferencia entre las etiquetas reales y predichas.
El conjunto de datos también se divide en lotes de 10 (batch_size) y pasará por el modelo 30 veces (épocas). Para un conjunto de datos dado, x serían los datos e y serían las etiquetas correspondientes a los datos.
Modelo de prueba usando predicciones
Para evaluar nuestro modelo, hacemos predicciones sobre los datos de prueba usando la función predict().
predicciones = modelo.predecir(x)
¡Y eso es!
Ahora debe tener una buena comprensión de la Aprendizaje profundo aplicación, Redes Neuronales, cómo funcionan en general y cómo construir, entrenar y probar un modelo en código Python.
Espero que este tutorial le ayude a crear e implementar sus propios modelos de aprendizaje profundo.
Háganos saber en los comentarios si el artículo fue útil.
Deje un comentario