Creando una Red Neuronal en Python, con tensorflow.

Saludos y bienvenidos una semana más a vuestro blog sobre programación en lenguaje Python. En el día de hoy vamos a hablar de las Redes Neuronales, las cuales, constituyen una de las herramientas más importantes del aprendizaje automático moderno. Estas se inspiran en el funcionamiento básico del cerebro humano y permiten a los programas aprender patrones a partir de datos, en lugar de seguir reglas programadas de forma explícita. Aunque a menudo se asocian con problemas complejos como reconocimiento de imágenes o lenguaje natural, es posible construir una red neuronal útil y comprensible para resolver problemas reales relativamente simples.

El funcionamiento de estas redes es relativamente simple: Una red neuronal está formada por unidades llamadas neuronas artificiales. Cada una de las cuales recibe valores de entrada, los combina mediante unos coeficientes llamados pesos añadiendo un término adicional conocido como sesgo. El resultado de esa operación se transforma mediante una función matemática que introduce no linealidad, permitiendo que la red aprenda relaciones complejas. A su vez, durante el entrenamiento, estos pesos y sesgos se ajustan automáticamente para reducir el error entre la predicción de la red y el valor real esperado.

A continuación, abordaremos la implementación de una (muy) sencilla Red neuronal en Python mediante la que intentaremos aproximar una función matemática no lineal de una sola variable. El objetivo no es sustituir el cálculo exacto, sino entender cómo una red neuronal aprende patrones, cómo se evalúa su precisión y cómo se comparan los resultados obtenidos con los valores correctos. La función es la siguiente:

Así, a partir de un conjunto limitado de ejemplos, nuestro modelo deberá aprender la forma general de la función y ser capaz de realizar predicciones razonables para valores intermedios que no ha visto durante el entrenamiento. Finalmente, compararemos los valores reales con los valores predichos para evaluar el error de dicho modelo. Pero antes de todo ello, lo primero será importar las librerías a utilizar tensorflow y numpy. Lo haremos todo en Google Collab, por lo que no necesitaremos realizar ninguna instalación adicional.

Una vez hechas las importaciones pertinentes, procederemos a definir el conjunto de datos de entrada:

Aquí x contendrá una sola característica por muestra: el valor de la variable x. Por su parte, el vector y contendrá el valor exacto de la función para cada entrada (cada valor de x). Nos aseguraremos de que ambos arrays tengan el mismo número de muestras, condición imprescindible para entrenar el modelo.

Tras ello, pasaremos a definir la estructura de nuestra red neuronal. La cual construiremos utilizando el modelo secuencial de Keras, que permite definir capas de forma ordenada:

En este caso, la red constará de una única capa densa con una sola neurona. Aquí hemos de decir que aunque esta arquitectura es extremadamente simple, resulta suficiente para ilustrar el proceso de aprendizaje. Su mecánica será también, bastante simple: La neurona recibirá un valor de entrada para producir una salida escalar, ajustando sus pesos durante el entrenamiento. Hecho esto, pasaremos a compilar el modelo para definir el modo en que nuestro modelo va a aprender:

Aquí, el optimizador Adam se encarga de ajustar los pesos del modelo durante el entrenamiento. En este ejemplo se utiliza una tasa de aprendizaje relativamente alta para acelerar la convergencia. La función de pérdida elegida es el error cuadrático medio, adecuada para problemas de regresión numérica. Hecho todo esto, podemos pasar al fin al entrenamiento del modelo:

Aquí, a través de los 1000 epochs (iteraciones del modelo), la red neuronal va ajustando sus parámetros internos para minimizar el error entre los valores predichos y los valores reales. Por su parte, el parámetro verbose=0 evita mostrar información detallada del proceso, manteniendo la salida limpia.

Y con ello, ya tendríamos nuestro modelo, listo para efectuar predicciones con nuevos datos. En este punto, vamos a comparar los valores predichos por la red neuronal con los valores reales de la función que intentamos aprender, para evaluar qué tan bien el modelo aproxima la relación matemática:

Para ello, calculamos primero los valores exactos con la función real_function() para un conjunto de entradas de prueba x_test que no se usaron en el entrenamiento. Luego, obtendremos las predicciones del modelo con model.predict y calcularemos el error como la diferencia entre ambos, mostrando todo en una tabla alineada para visualizar claramente la precisión de la red.

OUTPUT:

Como puede verse, los resultados muestran que la red neuronal consigue aproximar razonablemente la función dentro del rango de valores estudiados, aunque no reproduce exactamente la ecuación matemática. Esto es esperable, ya que el modelo no conoce la fórmula, sino que aprende únicamente a partir de ejemplos.

A su vez podemos mostrar la forma en la que nuestro modelo ha ido aprendiendo durante el entrenamiento usando una gráfica de perdida:

Se genera así un gráfico donde el eje horizontal representa los epochs del entrenamiento y el eje vertical muestra el valor de la función de pérdida (error cuadrático medio). La curva permite observar cómo disminuye el error a medida que la red ajusta sus pesos, error que disminuye de manera muy pronunciada durante las primeras 150 iteraciones, para luego quedar casi estancado.

CONCLUSION:

Este ejemplo demuestra de manera clara cómo una red neuronal sencilla puede aprender a aproximar una función matemática a partir de datos de entrenamiento. La comparación entre valores reales y predichos permite evaluar la precisión del modelo, mientras que la gráfica de pérdida muestra cómo el error disminuye a lo largo de los epochs, evidenciando el proceso de aprendizaje. Aunque la arquitectura es mínima, el ejercicio ilustra conceptos clave del aprendizaje automático: definición de datos, entrenamiento, predicción, evaluación y visualización del rendimiento, sentando una base sólida para trabajar con problemas más complejos y funciones desconocidas.

Saludos.

Detección de Esquinas en Python, con OpenCV y numpy.

La detección de esquinas es una de las técnicas fundamentales en visión por computadora, ya que permite identificar puntos de interés en una imagen que se mantienen estables frente a cambios de iluminación, rotación o escala. Estos puntos son especialmente útiles en tareas como el reconocimiento de patrones, la reconstrucción 3D o la calibración de cámaras. En Python, gracias a la librería OpenCV, podemos implementar de manera sencilla y eficiente el algoritmo de Harris (cornerHarris), uno de los métodos clásicos y más influyentes en la detección de esquinas. En este artículo exploraremos cómo funciona este algoritmo, cómo aplicarlo en imágenes con OpenCV y qué parámetros ajustar para obtener los mejores resultados en distintos escenarios.

Pero entes de empezar, deberemos asegurarnos de tener instalados en nuestro sistema, los recursos y librerías necesarios. Que en este caso serán las librerías OpenCV y numpy:

Una vez que tengamos ambas librerías listas para usar en nuestro equipo, crearemos un nuevo script de Python en el que empezaremos importando ambas:

Hecho esto, ya podemos pasar a cargar la imagen cuyas esquinas queremos detectar. Para ello utilizaremos el método imread(), pasándole el nombre del archivo a leer. Tras lo cual, usaremos imshow() para que se muestre en pantalla nuestra imagen original:

OUTPUT:

Una practica habitual a la hora de realizar operaciones sobre imágenes es la de reducir las dimensiones de sus datos, pasando estas a escala de grises, para agilizar los cálculos a realizar. Eso mismo es lo que haremos a continuación empleando el método cvtColor() almacenando esta nueva versión en la variable gray que, como antes, mostraremos en pantalla con imshow():

OUTPUT:

Tal y como hemos expresado mas arriba, para la detección, vamos a hacer uso del algoritmo de Harris Corner, el cual, para los cálculos de gradientes, necesita que la imagen de entrada esté en un formato numérico de punto flotante. Es por ello que el siguiente paso será utilizar numpy para realizar dicha conversión:

Ahora ya estamos en condiciones de aplicar el referido algoritmo sobre nuestra imagen. Para esta operación usaremos el método de OpenCV, cornerHarris() el cual tomará los siguientes argumentos: 1. La imagen en escala de grises convertida a formato numérico en coma flotante, 2. El tamaño del vecindario considerado para el cálculo de las derivadas, 3. El tamaño del bloque utilizado en la detección y 4. El parámetro libre de Harris que influye en la sensibilidad de la detección de esquinas:

Esto almacenará en la variable dst, una matriz que indica la respuesta del algoritmo en cada punto de la imagen, de modo que donde haya valores más altos, mayores probabilidades habrá de que se correspondan con una esquina en la imagen:

Tras ello pasaremos a dilatar la imagen, expandiendo los valores máximos locales, para resaltar mejor las esquinas detectadas. Con ello, buscamos que las esquinas aparezcan más visibles y definidas en la imagen resultante:

Como último paso en el proceso de detección, estableceremos un umbral para establecer que puntos de la imagen pueden considerarse esquinas:

Aquí estamos utilizando dst.max() para obtener el valor máximo de la respuesta de Harris, de modo que al ser multiplicado por 0.27 se fijará un limite, de modo que los puntos que lo superen serán considerados esquinas que serán marcadas en rojo usando los valores rgb [0,0,255].

Una vez establecidos los puntos que serán considerados esquinas, ya solo restará mostrarlos en pantalla utilizando las mismas funciones que más arriba empleamos para mostrar la imagen en original y escala de grises:

OUTPUT:

Obtenemos así una imagen en la que la mayoría de las esquinas han sido detectadas por nuestro algoritmo. A su vez, podemos intentar mejorar el resultado probando con valores distintos al que hemos multiplicado por dst.max(), de modo que cuanto más bajo sea este más puntos serán detectados (y también más posibilidades habrá de establecer como esquina, puntos que no lo sean).

Para más información al respecto, no duden en consultar la información oficial de OpenCV:

https://docs.opencv.org/4.x/dc/d0d/tutorial_py_features_harris.html

Saludos.

ENTRENANDO MODELOS PARA CLASIFICACIÓN DE IMAGENES CON PYTHON Y ‘TensorFlow’.

En el mundo de la inteligencia artificial y el aprendizaje automático, la clasificación de imágenes es una tarea fundamental. Clasificar imágenes puede implicar identificar objetos, reconocer patrones o incluso diagnosticar enfermedades basadas en imágenes médicas. En este artículo, exploraremos cómo utilizar Python junto con ‘TensorFlow‘, una de las bibliotecas de aprendizaje automático más populares, para entrenar modelos de clasificación de imágenes de manera efectiva. La explicación la dividiremos en cinco sencillos pasos:

INSTALACIÓN DE TENSOR FLOW:

Aunque para nuestro ejemplo vamos a utilizar la plataforma de ‘Google Colab‘ (en donde no es necesaria esta acción) conviene saber como podemos instalar la librería localmente en nuestro sistema. Para ello podremos utilizar el comando ‘pip‘ al que estamos acostumbrados:

PREPARACIÓN DE LOS DATOS:

El primer paso en el entrenamiento de un modelo de clasificación de imágenes es preparar los datos. Para este ejemplo, utilizaremos el conjunto de datos ‘MNIST‘, consistente en una colección de imágenes de dígitos escritos a mano. ‘TensorFlow‘ proporciona, aquí, funciones para cargar y pre-procesar dicho conjunto de datos:

Así, empezaremos a elaborar nuestro modelo, importando la librería ‘TensorFlow‘. Tras ello, cargamos los datos de imágenes MNIST utilizando la función ‘load_data()‘ para después normalizar estos dividiendo los valores de píxeles de las imágenes por 255 y así escalarlos en el rango [0, 1]:

CONSTRUCCIÓN DEL MODELO:

Una vez que los datos están preparados, podemos construir nuestro modelo de clasificación de imágenes. Para este ejemplo, utilizaremos una red neuronal convolucional (CNN), la cual constituye una arquitectura comúnmente utilizada para tareas de visión por computadora como la que pretendemos realizar:

En la construcción del modelo, primero definimos un modelo secuencial utilizando ‘tf.keras.models.Sequential([])‘, permitiéndonos agregar capas secuenciales una tras otra. Luego, agregamos capas de convolución 2D seguidas de capas de agrupación máxima para extraer características de las imágenes y reducir la dimensionalidad. Después de varias iteraciones, aplanamos las características en un vector unidimensional y las alimentamos a capas densas para la clasificación final.

Una vez que el modelo está construido, lo compilamos con ‘model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])‘. Aquí, especificamos el optimizador ‘adam‘, una función de pérdida adecuada para problemas de clasificación de múltiples clases, y las métricas que deseamos monitorear durante el entrenamiento, como la precisión. Este proceso de construcción y compilación establece los parámetros esenciales del modelo, preparándolo para el proceso de entrenamiento.

ENTRENAMIENTO DEL MODELO:

Una vez construido y compilado nuestro modelo, podemos entrenarlo utilizando los datos de entrenamiento que definimos con anterioridad:

El código para entrenar el modelo utiliza el método ‘fit()‘, donde proporcionamos los datos de entrenamiento (‘x_train‘) y sus correspondientes etiquetas de clase (‘y_train‘). A su vez, especificaremos el número de épocas (variable ‘epochs‘) de entrenamiento, que determina cuántas veces el modelo verá todo el conjunto de datos de entrenamiento. Además, utilizamos un conjunto de datos de validación (‘x_test‘ y ‘y_test‘) para evaluar el rendimiento del modelo después de cada época. Durante el entrenamiento, el modelo ajusta sus pesos para minimizar la función de pérdida, y al final de cada época, evalúa su desempeño en el conjunto de validación. Este proceso se repite durante el número especificado de épocas, preparando así el modelo para su evaluación final.

Proceso de entrenamiento del modelo.

EVALUACIÓN DEL MODELO:

Finalmente procederemos a la evaluación de nuestro modelo, obteniendo el valor de perdida en el conjunto de datos de prueba (‘test_loss‘) y la precisión (‘test_acc‘). Para ello utilizaremos el método ‘evaluate()‘ del TensorFlow:

CONCLUSIÓN:

En este artículo, hemos explorado cómo utilizar Python junto con TensorFlow para entrenar un modelo de clasificación de imágenes. Desde la preparación de los datos hasta la construcción, entrenamiento y evaluación del modelo, TensorFlow proporciona herramientas poderosas y fáciles de usar para trabajar con imágenes y realizar tareas de aprendizaje automático. Con este conocimiento, estás listo para comenzar a desarrollar tus propios modelos de clasificación de imágenes y explorar el emocionante campo de la visión por computadora.

Saludos.

TRADUCIENDO TEXTO EN PYTHON, CON ‘translate’.

La traducción de texto es una tarea común en muchas aplicaciones de procesamiento de lenguaje natural y análisis de datos. Python ofrece una variedad de bibliotecas para realizar esta tarea, y una de las opciones más efectivas es la biblioteca ‘translate‘. En este artículo, exploraremos cómo usar dicha librería para traducir texto de un idioma a otro de manera rápida y sencilla.

INTRODUCCIÓN E INSTALACIÓN.

La librería ‘translate‘ es una envoltura simple y elegante alrededor de varios servicios de traducción en línea, como ‘Google Translate‘, ‘Microsoft Translator‘, ‘Yandex Translate‘ y otros que permite a los desarrolladores integrar fácilmente capacidades de traducción en sus aplicaciones de Python con solo unas pocas líneas de código.

Para comenzar a usar la biblioteca ‘translate‘, primero debemos instalarla. Esto se puede hacer fácilmente a través de pip, el gestor de paquetes de Python. Ejecute el siguiente comando en su terminal o símbolo del sistema:

Una vez instalada, podemos comenzar a utilizar la biblioteca en nuestros proyectos de Python.

USO BÁSICO:

A continuación mostraremos un ejemplo básico y muy sencillo que muestra cómo usar ‘translate‘ para traducir texto de inglés a español:

OUTPUT:

Como puede verse facilmente, en este ejemplo, creamos un objeto traductor especificando el idioma al que queremos traducir (en este caso, español) para luego proporcionarle el texto que queremos traducir llamando al método ‘translate()‘ del objeto traductor para realizar la traducción. Finalmente, usaremos ‘print()’ para mostrar el texto traducido.

TRADUCCIÓN ENTRE DIFERENTES IDIOMAS:

Hay que señalar también que la librería ‘translate‘ es muy flexible permitiéndonos traducir texto entre una amplia variedad de idiomas. Podemos especificar tanto el idioma de origen como el idioma de destino al crear el objeto traductor usando las variables ‘from_lang‘ y ‘to_lang‘ respectivamente. Veamos un ejemplo de traducción del español al francés:

OUTPUT:

CONCLUSIÓN:

La librería ‘translate‘ es una herramienta fácil de usar y extremadamente útil para agregar capacidades de traducción a sus proyectos de Python. Con su amplio soporte para diferentes servicios de traducción en línea y una API simple e intuitiva, es una opción excelente para cualquier aplicación que requiera traducción de texto. Experimenta con diferentes idiomas y servicios de traducción para encontrar la combinación que mejor se adapte a tus necesidades.

Saludos.

EJECUTANDO CÓDIGO ‘R’ EN PYTHON, CON ‘rpy2’.

‘R’ es un lenguaje de programación, de código abierto, orientado al análisis estadístico, muy popular en la comunidad académica y de investigación, así como en la industria para el análisis de datos y la modelización estadística y que cuenta con una gran cantidad de paquetes y bibliotecas para una variedad de tareas analíticas. Pues bien, hoy vamos a ver un sencillo ejemplo de como utilizar este potente lenguaje dentro de nuestro código Python, haciendo uso de la librería ‘rpy2‘, creada para ser un puente de comunicación entre ambos lenguajes.

Ejemplo de código escrito en ‘R’.

Pero antes de continuar, deberemos asegurarnos de tener instalados todos lo recursos necesarios. Dado que, tal y como ya hemos señalado, ‘rpy2‘ es una librería que conecta nuestro código Python con los recursos y utilidades del lenguaje ‘R‘, tendremos que tener también instalado este último (al final del artículo dejaremos la dirección de la página desde la que realizar la descarga). Por lo que a la librería ‘rpy2‘ se refiere, haremos la instalación por el procedimiento habitual para las librerías de Python:

Instalación de ‘rpy2’ con ‘pip’.

EJEMPLO DE COMO USAR ‘R’ EN PYTHON:

Veamos ahora un sencillo ejemplo en el que nos proponemos realizar un análisis de regresión lineal simple sobre el conjunto de datos ‘mtcars‘ en ‘R‘ ajustando un modelo lineal que predice la eficiencia del combustible (‘mpg‘) en función del peso del automóvil (‘wt‘) visualizando el correspondiente gráfico de dispersión y línea de regresión mediante la librería ‘ggplot2‘ de ‘R‘.

Así, empezaremos creando un nuevo archivo Python en el que, naturalmente, empezaremos importando las librerías y recursos de los que vamos a hacer uso:

Tras ello, procederemos a activar la conversión automática entre ‘pandas‘ y ‘R‘ e instalar los paquetes de ‘R‘ que vamos a usar en el ejemplo. Entre el que se encuentra el paquete ‘base‘ que es el que nos proporciona la tabla de ejemplo ‘mtcars‘ de la extraeremos nuestra información:

Tras ello procederemos a cargar los datos de muestra correspondientes a cada uno de los modelos de vehículos cuya información se recoge en ‘mtcars‘. Para luego, aplicar el modelo de regresión lineal utilizando ‘mpg‘ y ‘wt‘ como variables dependiente e independiente, respectivamente. Esta operación la definiremos usando la sintaxis de ‘R‘ (‘ linear_model <- lm(mpg ~ wt, data = mtcars)‘). Aplicado el modelo, obtendremos los datos resumidos del mismo mediante la función ‘summary()‘ (también en ‘R‘):

Como se puede apreciar, una vez hecha la regresión, volveremos a convertir los datos obtenidos en un dataframe de pandas de modo que podamos imprimirlos en nuestro editor de Python mediante la función ‘print()‘:

Finalmente, pasaremos a mostrar la relación (inversa en este caso) entre ambas variables mediante un gráfico de dispersión al que incorporaremos la línea de regresión. Dicho grafico lo generaremos, usando nuevamente, la sintaxis de ‘R‘ y su librería para graficas ‘ggplot2‘:

OUTPUT:

Relación entre la eficacia del combustible (mpg) y el peso del vehículo (wt).

CONCLUSIÓN:

Para terminar, el uso de ‘R‘ en combinación con Python a través de la interfaz ‘rpy2‘ ofrece una herramienta de gran utilidad para el análisis de datos y su visualización. En este artículo, hemos demostrado cómo cargar datos, realizar un análisis de regresión lineal y generar gráficos de dispersión con líneas de regresión utilizando el conjunto de datos ‘mtcars‘. Por su parte, la capacidad de integrar funciones estadísticas y de visualización de ‘R‘ con la flexibilidad y facilidad de uso de Python abre un amplio abanico de posibilidades para investigadores y analistas de datos, permitiéndoles aprovechar lo mejor de ambos mundos para abordar sus problemas de análisis de datos de manera eficiente y efectiva.

Enlace a la pagina oficial de ‘R’:

https://www.r-project.org

Saludos.

DETECCIÓN DE TEXTO EN IMAGENES EN PYTHON, CON ‘EasyOCR’.

El Reconocimiento óptico de caracteres (‘ROC‘ u ‘OCR‘ por sus siglas en inglés), consiste en la extracción y detección de texto en imágenes. Se trata una tarea común en el campo de la visión por computadora que es ampliamente utilizada en aplicaciones tales como la captura y digitalización de documentos, traducción, detección de fraudes o reconocimiento de información en imágenes medicas. Así, esta semana vamos a aprender a extraer texto de una imagen, utilizando ‘EasyOCR‘ una librería en Python que nos permitirá realizar dicha tarea de una forma rápida y sencilla. Librería que deberemos instalar previamente en nuestro sistema, mediante el comando ‘pip install easyocr‘.

USO BASICO:

Una vez explicado el objetivo de nuestra practica, pasaremos a la extracción de texto de archivos de imagen. En esta ocasión usaremos el entorno de ‘Google Colab‘ en el que empezaremos realizando la instalación de ‘EasyOCR‘:

Tras ello pasaremos a importar la librería en cuestión, para a continuación, crear el objeto ‘reader‘ especificando el idioma (inglés en este caso) del texto que vamos a extraer:

Empezaremos extrayendo texto, en distintos tamaños, de una imagen en blanco y negro:

image.png

Para la lectura del texto en la imagen, usaremos aquí, la función «readtext()» pasando como argumento la ruta al archivo que contiene el texto que queremos obtener:

Esta función nos devolverá tres informaciones de cada línea de texto detectada: Las coordenadas de la imagen en las que se encuentra el área de texto (concebida como caja), el texto detectado y e nivel de confianza entendida como la probabilidad de que el texto detectado por el algoritmo ‘OCR‘ sea correcto. A su vez, podemos usar un bucle para acceder a estas tres informaciones de modo aislado:

Como se ve, el texto detectado en las líneas coincide con el presente en la imagen, lo que resulta coherente con los valores de probabilidad obtenidos.

A su vez, podemos usar «matplotlib» para mostrar el texto detectado en una etiqueta, para cada línea detectada en la imagen:

También podemos utilizar la información almacenada en la variable ‘bbox‘, para dibujar un recuadro que enmarque el área de la imagen ocupada por el texto:

Lo que hemos hecho sobre una imagen en blanco y negro, podremos hacerlo igualmente sobre una imagen a color como esta a la que hemos dado el nombre de «color_image.png«:

color_image.png

CONCLUSIÓN:

EasyOCR es una herramienta poderosa y fácil de usar para detectar texto en imágenes. Su capacidad para manejar múltiples idiomas, su precisión y su facilidad de integración lo hacen útil para una variedad de aplicaciones, desde la automatización de tareas hasta el procesamiento de documentos. En este artículo hemos visto, de un modo básico, como podemos usarle para extraer la información inherente al texto presente un un archivo de imagen y el modo en que podemos usar dicha información para mostrar gráficamente dicho texto en la imagen.

Saludos.

OPTIMIZACION DE FUNCIONES CON PYTHON Y ‘SciPy’: EXPLORANDO EL METODO ‘SLSQP’ PARA MINIMIZACIÓN DE UNA FUNCION

La minimización de funciones es un proceso matemático que busca encontrar el valor mínimo de una función, es decir, el punto donde la función alcanza su valor más bajo. Este valor mínimo puede representar un punto crítico, como un máximo o mínimo local, o el mínimo absoluto de la función en un intervalo determinado. Esta se usa para un amplio abanico de problemas como puede ser el ajuste de modelos, procesamiento de señales y optimización de funciones en finanzas.

Para ello, contamos en Python con ‘SciPy‘. Una herramienta poderosa que ofrece diversas técnicas para encontrar mínimos y máximos de funciones. En este artículo, usaremos el método ‘Sequential Least Squares Programming‘ (SLSQP) para encontrar el mínimo de una función cuadrática (concretamente de la expresión «Y=(x−1.5)**2«), usando dicha librería, que deberemos tener instalada en nuestro sistema:

Para ello, crearemos un nuevo archivo Python con el nombre «optimize_example.py» que constará de dos funciones:

La primera de ellas es la que hemos llamado «f()«. Esta se encarga de calcular el valor de «Y» en función de «x» según la expresión antes referida, utilizando la fórmula cuadrática. El propósito principal de esta función es representar una función objetivo para el método de optimización. Esta función irá mostrando los valores de «Y» y «x» cada vez que vaya siendo llamada, permitiéndonos rastrear el modo en que van cambiando estos durante el proceso de optimización.

La otra función que utiliza nuestro código es la que hemos llamado «test_run()«:

Esta es la función principal, que se encarga de ejecutar el código de prueba llevándose a cabo la optimización de la función «f()» empleando para ello, el método «spo.minimize()» de la librería «scipy» usando el referido método «SLSQP» y partiendo de un valor inicial para «x» (que será el que tome «f()«) definido en la variable «Xguess«. La ejecución del script nos devolverá una serie de datos (valor mínimo encontrado, el número de iteraciones, evaluación de funciones y gradientes…) entre los que se destaca los valores mínimos de «x» e «Y» (siendo estos 1.5 y 0.5 respectivamente).

OUTPUT:

A su vez, podemos usar la librería «matplotlib» (que deberemos tener también instalada) para representar graficamente dicho punto dentro de la función. Quedando nuestro script de la siguiente manera:

OUTPUT:

Representación grafica del valor mínimo de ‘x’ e ‘Y’.

CONCLUSION:

El método «SLSQP» de «SciPy» es una herramienta de gran utilidad para encontrar mínimos de funciones, especialmente en problemas no lineales. Este ejemplo ilustra cómo utilizar este método para optimizar una función cuadrática y visualizar el resultado. En resumen, «SciPy» proporciona una amplia gama de métodos de optimización que pueden ser aplicados a diferentes problemas, ofreciendo soluciones eficientes y precisas.

Saludos.

INTRODUCCIÓN AL APRENDIZAJE AUTOMATICO CON ‘SCIKIT-LEARN’ EN PYTHON.

El aprendizaje automático es una rama de la inteligencia artificial, la cual, se ha convertido en una herramienta esencial en la resolución de problemas y la toma de decisiones en una amplia variedad de campos. Desde la detección de fraudes hasta la recomendación de productos y la visión por computadora, el aprendizaje automático desempeña un papel crucial en la automatización de tareas complejas. Python, con su rica colección de bibliotecas, es uno de los lenguajes más populares para trabajar en aprendizaje automático, y ‘scikit-learn‘ es una de las bibliotecas más destacadas en este campo.

En este artículo, exploraremos los conceptos básicos del aprendizaje automático y cómo puedes comenzar a usar ‘scikit-learn‘ para crear tus propios modelos de aprendizaje automático en Python.

¿QUE ES EL APRENDIZAJE AUTOMATICO?

El aprendizaje automático es una disciplina que se enfoca en el desarrollo de algoritmos y modelos que permiten a las computadoras mejorar su rendimiento en tareas específicas a través de la experiencia. En lugar de programar reglas explícitas para realizar una tarea, el aprendizaje automático permite a las máquinas aprender de los datos y hacer predicciones o tomar decisiones basadas en esa experiencia. Este proceso suele constar de una serie de pasos que, a continuación, pasamos a enumerar:

1- Recopilación de datos: Reunir un conjunto de datos que contenga ejemplos y etiquetas. Los ejemplos son las entradas, y las etiquetas son las salidas deseadas.

2- Preprocesamiento de datos: Limpiar, normalizar y transformar los datos para que sean adecuados para su uso en modelos de aprendizaje automático.

3- Selección del modelo: Elegir el tipo de modelo de aprendizaje automático adecuado para la tarea, como regresión, clasificación o clustering.

4- Entrenamiento del modelo: Utilizar los datos de entrenamiento para ajustar los parámetros del modelo y permitir que «aprenda» de estos.

5- Evaluación del modelo: Probar el modelo en un conjunto de datos de prueba para evaluar su rendimiento.

6- Predicción y toma de decisiones: Utilizar el modelo entrenado para hacer predicciones o tomar decisiones en función de nuevos datos.

EJEMPLO DE USO DE ‘SCIKIT-LEARN’.

scikit-learn, a menudo abreviado como ‘sklearn‘, es una biblioteca de código abierto ampliamente utilizada en la comunidad de Python para el aprendizaje automático. Proporciona una amplia gama de algoritmos y herramientas para tareas comunes de aprendizaje automático, como clasificación, regresión, clustering y reducción de dimensionalidad. A continuación, veremos cómo comenzar a trabajar con ‘scikit-learn‘.

Para poder empezar a trabajar con ‘scikit-learn‘ antes deberemos realizar la oportuna instalación de esta librería en nuestro sistema:

Una vez hecha la instalación pasaremos a ver un sencillo ejemplo en el que nos propondremos a crear un modelo para clasificar flores, para el cual usaremos el conjunto de datos ‘Iris‘ y el algoritmo ‘K-Nearest Neighbors (KNN)‘. Para ello, empezaremos importando los recursos de ‘scikit-learn‘ que vamos a necesitar. Donde ‘datasets‘ contiene conjuntos de datos de ejemplo, ‘train_test_split‘ se utiliza para dividir los datos en conjuntos de entrenamiento y prueba, y ‘KNeighborsClassifier‘ es una implementación del algoritmo de ‘K-Nearest Neighbors (KNN)‘ para clasificaciones:

Tras ello, pasamos a cargar el conjunto de datos ‘Iris‘ (el cual, se utiliza habitualmente en ejemplos de aprendizaje automático). En este conjunto, ‘iris.data‘ contendrá las características (o atributos) de las flores, e ‘iris.target‘ contendrá las etiquetas (las clases) que nos indican a que especie de flor pertenece cada conjunto de atributos. Estos datos se almacenarán en la variable ‘X‘ y las etiquetas en la variable ‘y‘:

Una vez que tenemos los datos con los que vamos a trabajar, el siguiente paso será dividir estos datos en un conjunto de entrenamiento (‘X_train‘ e ‘y_train‘) y otro para probar el modelo entrenado (‘X_test‘ e ‘y_test‘). Para establecer esta división usaremos el método ‘train_test_split()‘ en donde mediante el argumento ‘test_size = 0.2‘ estaremos indicando que queremos emplear el 20% de los datos como datos de prueba ( y por tanto, el 80% como datos de entrenamiento ):

A partir de esta división de los datos en conjuntos de entrenamiento y prueba, podemos proceder a la creación entrenamiento y prueba de nuestro modelo:

Para ello, empezamos creando un clasificador ‘KNN‘ (que guardamos en la variable ‘knn‘) con un valor de ‘n_neighbors‘ igual a 3. Indicándole al algoritmo ‘KNN‘ que considere los tres vecinos más cercanos para tomar una decisión de clasificación. Tras ello, usaremos el método ‘fit‘ del clasificador ‘KNN‘ para entrenar el modelo a partir del conjunto de datos de entrenamiento. De esta forma, el modelo aprenderá a asignar los datos de entrada ‘X_train‘ a las etiquetas correspondientes de ‘y_train‘.

Una vez que nuestro modelo esté entrenado, pasaremos a realizar las predicciones. Para ello, podremos utilizar el método ‘predict()‘ que realizará las predicciones en el conjunto de prueba ‘X_test‘, almacenándose estas en la variable ‘predictions‘:

OUTPUT:

Finalmente, calculamos la precisión del modelo comparando las predicciones con las etiquetas reales de prueba ‘y_test‘, mediante el método ‘.score()‘. Mostrándose el grado de precisión:

OUTPUT:

CONCLUSION:

‘scikit-learn‘ es una muy útil librería para el aprendizaje automático en Python, la cual, permite crear modelos de manera sencilla y eficaz. Este artículo ha proporcionado una introducción básica al aprendizaje automático y cómo empezar a trabajar con ‘scikit-learn‘. A medida que explores más, descubrirás que esta librería ofrece una amplia gama de algoritmos y herramientas para abordar una variedad de problemas de aprendizaje automático. ¡Así que no dudes en sumergirte en el emocionante mundo del aprendizaje automático con Python y scikit-learn!

Saludos

USANDO ARBOLES DE DECISIÓN EN PYTHON.

Un «árbol de decisión» consiste en un método de clasificación, ampliamente utilizado en el ámbito del «aprendizaje automático» que nos permite la predicción y clasificación de una variable categórica a través de la construcción de un diagrama en arbol (de donde viene su nombre). Así, en el artículo de hoy vamos a construir nuestro propio arbol de decisión, usando varias librerías («numpy«, «pandas«, «matplotlib» y «sklearn«) siendo esta última la que contiene los métodos y funciones tanto para generar el mismo como para realizar el proceso de clasificación y comprobación de su precisión. Y que como el resto de librerías, deberemos instalar previamente en nuestro equipo (aunque en este caso utilizaremos la plataforma «Google Colab» para la ejecución de nuestros scripts):

Así, lo que nos proponemos a hacer en este ejercicio es, a partir de los datos médicos de una serie de pacientes y de su edad, almacenados en un «csv», determinar que pacientes van a desarrollar una enfermedad. Por ello, lo primero que haremos será cargar la información para ver que contiene. Para la lectura de nuestro archivo «csv» (que lleva por nombre «Pacientes2.csv«) usaremos la función «read_csv()» de la librería «pandas«:

Como puede verse en la imagen, obtenemos un dataset con la información de una serie de pacientes, identificados por un número, de los que se indican la presencia o no (representadas por ‘0’ y ‘1’ respectivamente) de determinadas características (hipertensión, hiperglucemia, si es fumador…), el sexo (codificado nuevamente con ‘0’ y ‘1’) y edad. Finalmente en la columna «Enfermedad» se registra si dicho paciente a registrado o no alguna enfermedad (siendo esta variable la que nos disponemos a predecir).

De este modo lo nos proponemos a hacer es construir un «arbol de decisión» que nos sirva para clasificar (o predecir) la posibilidad o no de desarrollar una enfermedad a partir de unos datos de entrenamiento. Hecho esto, pasaremos a evaluar la precisión del mismo.

A continuación, utilizaremos la función «.info()» para obtener algunos datos generales acerca de nuestro dataset como pueden ser el tipo de dato para cada columna, el número de estas y el número de filas:

Vemos así, que nuestra tabla consta de un total de 11 columnas y 985 filas. Esta información es importante de cara a establecer cuales van a ser nuestras variables predictoras, las filas que vamos a utilizar para entrenar el modelo y las filas que usaremos para testearlo. Empezaremos definiendo las variables predictoras y la variable a predecir:

Para ello, creamos dos objetos (‘X‘ e ‘Y‘) en los que almacenamos las variables predictoras (las cuales definimos con la función «.iloc()» pasándole el rango correspondiente a estas) y la variable a predecir (columna 0). Finalmente usamos «.head()» para mostrar las primeras filas de las variables predictoras (lo mismo podemos hacer para la variable a predecir).

También haremos la división entre los datos de entrenamiento y los datos de testeo. Para lo cual, utilizaremos el módulo «train_test_split» de la librería «sklearn«. Estableciendo a su vez, que emplearemos el 80% de los datos para entrenar el modelo (usando el 20% restante para probarlo):

Usando la función «.info()» aplicada a la variable «X_train» (en la que hemos almacenado los datos de entrenamiento) podemos ver como esta se compone de 788 registros. A continuación, pasaremos a usar estos registros para entrenar el modelo, usando la función «fit()» a la que pasaremos las variables predictoras («X_train«) y la variable a predecir («Y_train«) de nuestros datos de entrenamiento:

Esto nos generará el correspondiente arbol de decisión, el cual, podremos representar gráficamente con la ayuda de la librería «matplotlib» y en el que se muestra el proceso de clasificación de los datos seguido para la creación del modelo predictivo:

OUTPUT:

Por su parte podemos guardar nuestra gráfica como un archivo de imagen, mediante la función «savefig()«:

Viendo la figura generada, se ve como esta se compone de una serie de nodos que a su vez se ramifican en otros. Cada uno de dichos nodos viene representado por una caja en la que se muestra información sobre el mismo:

En cada una de las cajas veremos reflejada en primer lugar, la condición concreta que se ha aplicado en la clasificación del nodo (en el caso de la imagen, si el valor de la variable «hiperglucemia» es menor o igual a 0.5), el índice «gini«, que mide el grado de pureza del nodo (como de ordenados están los datos), el número de pacientes incluidos en el nodo, el número de valores «NO» y «SI«, y la categoría predominante («NO» en este caso).

A su vez, podemos ver las predicciones realizada acerca de la variable dependiente (que recordemos era la correspondiente a la columna «Enfermedad«) para el conjunto de datos de prueba:

Una vez generado el modelo y realizada las predicciones sobre los datos de prueba, pasaremos a comprobar la efectividad y grado de acierto de nuestro modelo, mediante la comparación entre los valores predichos para la variable «Enfermedad» y los datos reales para esta misma. Para esto último usaremos la función «confusion_matrix()» de «sklearn.metrics«:

Obtenemos una matriz en cuyas filas superior e inferior se muestran el numero de filas cuya etiqueta real es ‘NO‘ y ‘SI‘ respectivamente (es decir: que tenemos 150 individuos cuyo valor real es ‘NO‘ y 47 cuyo valor real es ‘SI‘). A su vez en cada columna se muestra los valores predichos como ‘NO‘ y ‘SI‘. Con lo que se deduce que los valores predichos acertadamente por el modelo son los correspondientes a la diagonal principal, los cuales suman 190, mientras que la otra diagonal se correspondería con las predicciones incorrectas (7 en total).

Finalmente, haciendo uso de «numpy» podemos hacer el cálculo, tanto de la precisión global del modelo, así como de la precisión para cada categoría:

Obteniendo así, el valor de precisión (entre 0 y 1) tanto a nivel global, así como para cada una de las clases «SI» y «NO«.

Saludos.