ANALISIS TECNICO EN PYTHON, CON ‘PANDAS_TA’.

Cuando se trata de análisis financiero, el análisis técnico es una herramienta crucial para comprender el comportamiento de los precios de los activos financieros en el mercado. Python, con su ecosistema de bibliotecas de análisis de datos, ofrece una amplia gama de herramientas para llevar a cabo análisis técnico de manera eficiente. Una de estas bibliotecas es ‘pandas_ta‘, una extensión de la popular biblioteca ‘pandas‘, que proporciona una amplia variedad de indicadores técnicos listos para usar y que instalaremos en nuestro sistema con el comando ‘pip‘:

Tal y como hemos señalado, ‘pandas_ta‘ es una biblioteca de análisis técnico escrita en Python que amplía las capacidades de la biblioteca pandas. Proporcionando una amplia gama de indicadores técnicos comúnmente utilizados en el análisis financiero. Lo cual permite a los usuarios realizar análisis técnico de datos financieros de manera rápida y sencilla. Entre dichos indicadores podemos encontrar los siguientes:

• Medias móviles (SMA, EMA, WMA, etc.)
• Bandas de Bollinger
• Índice de Fuerza Relativa (RSI)
• MACD (Convergencia/Divergencia de Medias Móviles)
• Estocástico
• ATR (Rango Promedio Verdadero)

ALGUNOS EJEMPLOS:

Una vez dadas unas breves pinceladas acerca de en que consiste ‘pandas_ta‘, pasaremos a continuación a mostrar algunos sencillos ejemplos de uso. Dado que en este blog nos gusta utilizar datos reales para nuestros ejemplos, vamos a aplicar estos sobre los datos de cierre de una compañía (Apple en este caso) para el pasado año 2023. Para la obtención de dichos datos, vamos a valernos de otra librería ‘yfinance‘ (de la que ya hemos hablado en ocasiones anteriores) la cual importaremos junto a ‘pandas_ta‘:

OUTPUT:

Una vez obtenidos los datos para el periodo de tiempo deseado, pasaremos a calcular algunos indicadores de interés utilizando ‘pandas_ta‘:

1) MEDIA MOVIL SIMPLE Y EXPONENCIAL (SMA Y EMA):

Con la media móvil simple calculamos el promedio de los precios de cierre durante un período específico. Es útil para suavizar la tendencia general de los datos de precios y para identificar posibles puntos de entrada o salida basados en los cruces de estas. Para ello utilizaremos la función «sma()» la información sobre la que queremos calcularla y la ventana de tiempo que queramos usar:

Igualmente podemos calcular la media móvil exponencial (la cual es semejante a la media móvil simple, solo que dando mayor peso a los valores más recientes) de nuestra serie temporal, mediante la función ‘ema()‘ determinando igualmente la ventana de tiempo antes referida:

2) BANDAS DE BOLLINGER:

Estas consisten en una banda central (media móvil simple) y dos bandas exteriores que se colocan a una cierta distancia (generalmente dos desviaciones estándar) de la central. Son útiles para identificar la volatilidad del mercado y posibles puntos de reversión. Su calculo para nuestra serie temporal de precios de cierre, la obtendremos mediante la función ‘bbands()‘:

Como se ve, la función devuelve un dataframe con la siguiente información por columnas:

• BBL_5_2.0: Banda Baja de las Bandas de Bollinger con una ventana de 5 periodos y un ancho de banda de 2.0 desviaciones estándar.
• BBM_5_2.0: Banda Media de las Bandas de Bollinger con una ventana de 5 periodos y un ancho de banda de 2.0 desviaciones estándar.
• BBU_5_2.0: Banda Alta de las Bandas de Bollinger con una ventana de 5 periodos y un ancho de banda de 2.0 desviaciones estándar.
• BBB_5_2.0: Ancho de Banda de las Bandas de Bollinger con una ventana de 5 periodos y un ancho de banda de 2.0 desviaciones estándar.
• BBP_5_2.0: Porcentaje de Banda de las Bandas de Bollinger con una ventana de 5 periodos y un ancho de banda de 2.0 desviaciones estándar.

3) INDICE DE FUERZA RELATIVA (RSI):

Otro indicador interesante es el RSI. Este es un indicador de momentum que oscila entre 0 y 100. Se utiliza para medir la velocidad y el cambio de los movimientos de precios. Un RSI por encima de 70 generalmente se considera sobrecompra, mientras que un RSI por debajo de 30 se considera sobrevendido. Su computo con ‘pandas_ta‘ lo llevaremos a cabo mediante la función ‘rsi()‘ determinando, una vez más, la correspondiente ventana temporal:

4) OSCILADOR ESTOCASTICO:

Este indicador compara el precio de cierre actual con el rango entre el máximo más alto y el mínimo más bajo durante un período de tiempo específico. Se utiliza para identificar condiciones de sobrecompra o sobreventa en el mercado. Un estocástico por encima de 80 generalmente se considera sobrecompra, mientras que un estocástico por debajo de 20 se considera sobrevendido. Esto último lo obtendremos mediante la función ‘stock()’ a la que pasaremos los valores máximos (‘High’), mínimos (‘Low’) y de cierre (‘Close’), especificando igualmente la ventana de tiempo:

CONCLUSIÓN:

Tal y como hemos visto, ‘pandas_ta‘ es una herramienta poderosa y versátil para realizar análisis técnico en Python. Con su amplia gama de indicadores técnicos (de los que solo hemos visto una pequeña muestra) y su integración perfecta con pandas, es una opción excelente para los analistas financieros y los traders que desean llevar a cabo análisis técnico de manera eficiente y efectiva.

Saludos.

VISUALIZACIÓN DE SEÑALES DE AUDIO EN PYTHON CON ‘Matplotlib’ Y ‘librosa’.

El procesamiento digital de señales de audio es un campo emocionante que abarca una amplia gama de aplicaciones, desde la música y el entretenimiento hasta la comunicación y la ingeniería de audio. Con Python y algunas bibliotecas especializadas, como ‘NumPy‘ y ‘librosa‘, podemos realizar una variedad de tareas de procesamiento de señales de audio de manera efectiva. En este artículo, expondremos algunos ejemplos de cómo podemos utilizar Python para trabajar con señales de audio y realizar tareas como carga, visualización y análisis de dichas señales, ayudándonos de las librerías ‘Matplotlib‘ (de la que ya hemos hablado en repetidas ocasiones) y ‘librosa‘. La cual deberemos instalar previamente en nuestro sistema:

CARGA Y VISUALIZACIÓN DE SEÑALES DE AUDIO:

El primer paso para trabajar con señales de audio en Python es cargarlas desde archivos de audio. Con la biblioteca ‘librosa‘, podemos cargar fácilmente archivos de audio en matrices ‘NumPy‘ para su manipulación posterior. Veamos un ejemplo:

Este código carga un archivo de audio llamado «guitar2.wav» y visualiza su forma de onda utilizando la librería ‘Matplotlib‘. La forma de onda muestra la amplitud de la señal de audio en función del tiempo, lo que nos permite visualizar la señal de audio en dicho dominio.

OUTPUT:

ANALISIS DE LA SEÑAL DE AUDIO:

Una vez que hemos cargado una señal de audio, podemos realizar una variedad de análisis para extraer información útil de dicha señal. Por ejemplo, podemos calcular y visualizar su correspondiente espectrograma, lo cual, nos mostrará el modo en que varía la energía de la señal en diferentes frecuencias a lo largo del tiempo:

Este código calcula el espectrograma de la señal de audio y lo visualiza utilizando nuevamente ‘Matplotlib‘. Aquí, el espectrograma muestra la energía de la señal en diferentes frecuencias a lo largo del tiempo, lo que nos permite identificar características importantes en la señal, como tonos y patrones de sonido.

OUTPUT:

A la representación anterior, podemos, también, añadir las líneas de beat que indican la ubicación de los beats o pulsos rítmicos en la señal de audio. Aquí, los marcadores de beat se mostrarán como líneas verticales discontinuas en la forma de onda de la señal de audio:

OUTPUT:

Un tipo especial de espectrograma que también podemos obtener es el conocido como Espectrograma de Mel, el cual también muestra la variación de energía de una señal de audio en el tiempo y en diferentes bandas de frecuencia, pero con una representación más adaptada a la percepción auditiva humana:

OUTPUT:

Otra representación que puede ser de gran utilidad para el análisis de la señal es el cromagrama, el cual puede proporcionar información valiosa sobre la estructura armónica y rítmica de la señal de audio:

OUTPUT:

CONCLUSIÓN:

Python proporciona una amplia variedad de herramientas y bibliotecas para trabajar con señales de audio de manera efectiva. En este artículo, exploramos cómo podemos cargar, visualizar y analizar señales de audio utilizando Python y librerías como ‘librosa‘ y ‘Matplotlib‘. Al comprender estas técnicas, podemos realizar una amplia gama de tareas de procesamiento de señales de audio y explorar nuevos enfoques para trabajar con datos de audio en nuestros proyectos.

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.

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.

ALGORITMOS DE ORDENACIÓN EN PYTHON: ORDENACIÓN POR MEZCLA.

Continuamos, esta semana, con el repaso a los principales algoritmos existentes, para ordenar los elementos de una lista y sus respectivas implementaciones en Python. Hoy es el turno del llamado ‘ordenamiento por mezcla‘ (‘merge sort‘ en inglés). Consistente en una técnica eficiente basada en la estrategia «divide y vencerás». Esta metodología implica dividir repetidamente el arreglo en partes más pequeñas, ordenar cada parte por separado y luego combinarlas en un arreglo finalmente ordenado.

COMO FUNCIONA.

La singularidad del ‘ordenamiento por mezcla‘ radica en su enfoque recursivo, consistente en dividir el arreglo hasta alcanzar sub-listas de un solo elemento (lo que se conoce como el caso base). Luego, se fusionan estas sub-listas de forma ordenada, creando gradualmente una lista ordenada completa. Este algoritmo es conocido por su eficiencia en la ordenación de grandes conjuntos de datos y su estabilidad al preservar el orden de elementos con claves iguales.

IMPLEMENTACIÓN EN PYTHON.

La implementación de este algoritmo en Python se basa en la división recursiva del arreglo y la combinación de las sub-listas ordenadas. Veamos un sencillo ejemplo en el que usaremos una función (a la que hemos llamado ‘merge_sort()‘) que tomará como argumento una lista de valores desordenados (‘lista_elementos‘) y nos devolverá dicha lista ordenada (que se almacenará en la variable ‘lista_ordenada‘):

Aquí, la función ‘merge_sort()‘ va dividiendo recursivamente un arreglo en mitades más pequeñas hasta que quedan solo elementos individuales. Luego, combina y ordena esas mitades en un solo arreglo ordenado. Todo ello verificando si el arreglo tiene más de un elemento, (dividiéndolo en dos mitades en tal caso). Para después, ordenar recursivamente cada mitad y fusionar las mitades ordenadas en un solo arreglo. El proceso de fusión compara los elementos de las mitades ordenadas y los coloca en orden en el arreglo original. Después, copia cualquier elemento restante de las mitades en el arreglo. Terminado este proceso, devuelve la lista ordenada que será almacenada en la variable «lista_ordenada» que es la finalmente será impresa.

OUTPUT:

CONCLUSION:

El ‘ordenamiento por mezcla‘ destaca por su eficiencia en grandes conjuntos de datos y su estabilidad al mantener el orden entre elementos iguales. Sin embargo, puede requerir más memoria que otros algoritmos debido a su enfoque de dividir y fusionar. Además, la implementación recursiva podría impactar el rendimiento con arreglos enormes. No obstante, constituye una eficaz herramienta de ordenación utilizada en diversas aplicaciones donde se necesita una ordenación estable y eficiente de datos.

Saludos.

CREANDO CALCULADORA DE DIVISAS CON PYTHON Y TKINTER.

Bienvenidos una semana más a vuestro blog sobre programación en Python, en una ocasión en las que nos disponemos a crear una aplicación con interfaz gráfica (usando ‘Tkinter‘) que calcule el cambio actual entre distintas divisas, utilizando los datos actualizados que nos proporciona ‘Yahoo Finance‘.

COMO FUNCIONA.

El manejo de nuestra aplicación es bien sencillo: El usuario elige las dos divisas de una lista desplegable y luego ingresa la cantidad que desea convertir. Al hacer clic en el botón «CALCULATE«, el programa solicita la tasa de cambio actualizada a través de la biblioteca ‘yfinance‘. Así, una vez obtenida la tasa de cambio, se realiza el cálculo y se muestra el monto convertido en la etiqueta central.

Para construir nuestra aplicación, y dado que necesitaremos descargarnos datos actualizados con ‘yfinance‘, deberemos proceder, antes de nada, a instalar esa librería en nuestro sistema:

Una vez que tengamos ‘yfinance‘ descargado, podremos empezar a escribir nuestra aplicación. Para lo que empezaremos importando las librerías y módulos que vayamos a utilizar:

En esta ocasión, usaremos ‘Tkinter‘ para confeccionar la interfaz, ‘yfinance‘ para obtener los datos de cambio entre divisas actualizados, ‘os‘ para mostrar el directorio de ejecución de la aplicación y ‘threading‘ para evitar bloqueos en el programa, cuando este hace la petición a ‘Yahoo Finance‘.

CREANDO LA INTERFAZ.

El primer paso en la elaboración de nuestra aplicación será el consistente en definir algunas variables iniciales, así como la creación de la ventana y elementos gráficos de nuestra aplicación. Para ello crearemos la clase de nuestra aplicación, en cuyo constructor empezaremos definiendo algunas características tales como el nombre de la ventana, sus dimensiones y la variable «currencies«, un diccionario en el que definiremos el nombre y ticker de las distintas divisas entre las que se va a poder efectuar los cálculos:

Tras ello, incluiremos un espacio en la parte superior de la ventana, en la que se mostrará la dirección del directorio en el que se está ejecutando nuestra aplicación. Dicho directorio lo obtendremos con el modulo ‘os‘ y el método ‘.get()‘:

Tras ello, crearemos las dos listas desplegables en las que se van a mostrar las divisas que definimos en la variable ‘currencies‘:

Pasemos ahora a crear tanto el ‘entry‘ para la cantidad a computar (así como a su variable asociada ‘self.amount‘) como la etiqueta en la que se mostrará el resultado final:

Finalmente (en lo que a la elaboración de la interfaz se refiere) incluiremos, en la parte inferior, el conjunto de botones que vamos a usar para interactuar con el programa, para finalizar haciendo la llamada a su ejecución:

Con ello tendríamos completada la parte puramente gráfica de nuestra aplicación. En efecto si ejecutamos lo hecho obtendremos el siguiente resultado:

OUTPUT:

No obstante, nuestra aplicación aún no hace nada (salvo mostrar en los desplegables, las divisas entre las que podemos elegir). Para hacer que podamos obtener la información deseada, tendremos que crear una serie de funciones que se ocupen de la lógica del programa.

PROGRAMANDO LÓGICA.

Puesto que el resultado que queremos obtener depende de la cantidad que ingresemos a través de los botones numéricos, lo lógico será empezar implementando una función que permita construir dicha cantidad y mostrarla en el ‘entry‘. A dicha función la llamaremos ‘btnClick()‘:

Como se ve, se trata de una función bien sencilla que toma el valor (‘num‘) establecido mediante una función lambda, en la variable ‘command‘ del botón correspondiente, y lo agrega a la variable «amount» ocupándose a la vez, de no admitir más que una coma en el entry.

Usando funciones ‘lambda’ para los botones numéricos.

Como es natural, junto a una función que escriba un número en pantalla, implementaremos otra que se encargue de borrarlo. A esta última la llamaremos ‘reset_display()‘ y ejecución vincularemos con el botón ‘RESET‘:

Función ‘reset_display’

Con esto ya tendríamos las funciones encargadas de introducir el input en nuestra aplicación. A partir de aquí usaremos dos funciones: Una que se encargue de crear el ticker cuyos datos de cierre vamos a pedir a la API de Yahoo Finance y otra que multiplique el valor introducido en el entry por el valor de cambio recibido la mencionada API. La primera de ellas, se llamará ‘create_ticker()‘ y devolverá la concatenación de los valores asociados a las claves seleccionadas en las listas desplegables más el string ‘=X‘:

La segunda de ellas es la que hemos llamado ‘calculate()‘ y, después de llamar a la anterior, usa ‘yfinance‘ para descargar el último dato disponible y multiplicarlo por el monto introducido para obtener el resultado final que se mostrará en la etiqueta central:

Una sentencia ‘try‘/’except‘ evitará que el programa falle, en caso de que se produzca algún problema imprevisto o una omisión por parte del usuario a la hora de introducir los datos. Mostrando la correspondiente ventana de error:

Finalmente, para evitar que al realizar la petición, la ventana pueda quedarse congelada o bloqueada, usaremos una tercera función que se encargue de ejecutar esta última de manera concurrente. A esta función la hemos llamado ‘init_task()‘ y es la que finalmente vincularemos con el botón ‘CALCULATE‘:

De este modo los valores ‘command‘ para todos los botones, quedaría como sigue:

OUTPUT:

Y con ello ya tendríamos creada nuestra aplicación para conversión de montos de dinero en diferentes divisas. A partir de este punto, podéis continuar desarrollando la aplicación, añadiendo opciones, funcionalidades o introduciendo más divisas a las listas desplegables.

En el siguiente enlace podéis acceder al código completo del script, para que podáis probarlo por vosotros mismos:

https://github.com/antonioam82/Calcu/blob/master/CURRENCY_CALC.py

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

AJUSTE DE BRILLO Y CONTRASTE EN IMAGENES, CON ‘OpenCV’ Y ‘Python’.

El ajuste de brillo es una técnica común en el procesamiento de imágenes y visión por computadora. Permite corregir imágenes oscuras, realzar detalles en imágenes sobreexpuestas y ajustar la calidad visual en diversas aplicaciones, como fotografía, detección de objetos y más. En este artículo, exploraremos cómo ajustar el brillo de una imagen utilizando ‘OpenCV‘ y Python. Mostrando varios ejemplos para que puedas comprender y aplicar esta técnica de manera efectiva. Como es habitual, utilizaremos una imagen de muestra para realizar las operaciones:

Como es habitual, antes de empezar deberemos asegurarnos de tener instalados los recursos y librerías necesarios para efectuar las operaciones que queremos realizar. Para esta ocasión, deberemos instalar previamente (si no lo hemos hecho ya) las librerías ‘OpenCV‘ (para manipulación de imágenes) y ‘Numpy‘ (para trabajar con arreglos):

Una vez que tengamos instalado todo lo necesario para trabajar, crearemos un nuevo archivo ‘ajuste_brillo.py‘ en el que empezaremos importando las librerías necesarias para, a continuación, cargar la imagen original (bien introduciendo el nombre de la misma si se encuentra en el mismo directorio del de trabajo, bien introduciendo la ruta hasta la misma en caso contrario):

Una vez cargada la imagen, podremos empezar a ajustar el brillo de la misma. Para ello existen dos funciones en ‘OpenCV‘: ‘cv2.add()‘ con la que podremos incrementar el brillo de la imagen y ‘cv2.subtract()‘ para disminuirlo. Ambas funciones toman dos argumentos: El nombre de la imagen fuente, una matriz que contiene valores de brillo (matriz creada con ‘numpy‘) la cual multiplicaremos por un factor de incremento o decremento de brillo. Empecemos con un ejemplo en el que vamos a incrementar el brillo de la imagen original mediante la función ‘cv2.add()‘ y un factor de incremento de 50, almacenado en la variable ‘brightness_increase‘:

OUTPUT:

Tal y como hemos señalado, podemos disminuir el brillo de nuestra imagen, usando la función ‘cv2.subtract’, multiplicando la matriz de la imagen original por un factor de decremento (variable brightness_decrease‘) de 50. Como en el caso anterior, usaremos la función ‘cv2.imshow()‘ para mostrar tanto la imagen original como su versión modificada:

OUTPUT:

Por otra parte, el ajuste de brillo por sí solo puede no ser suficiente en algunos casos. Para un control más completo, podemos combinar el ajuste del brillo con el del contraste. Para ello podemos usar la función ‘cv2.convertScaleAbs()‘. Esta función toma tres argumentos: la imagen, el factor de escala para el contraste (alpha) y el valor de desplazamiento para el brillo (beta). A continuación mostramos dos ejemplos en los que aumentamos y disminuimos el brillo y contraste de nuestra imagen fuente:

OUTPUT:

OUTPUT:

Como se ve, es muy fácil el efectuar el ajuste de brillo y contraste sobre una imagen usando Python y la librería ‘OpenCV‘. Estos ajustes son útiles en diversas aplicaciones, desde el mejoramiento de imágenes hasta la visión por computadora. A partir de aquí puedes experimentar con los ejemplos proporcionados y personalizar los valores para obtener los resultados deseados en tus imágenes.

Saludos.