Códigos Fuente de Python

Propongo el sencillo ejercicio en phyton : Aula_28_Ag.24_Espectro_Masas.py. Este ejercicio elabora una pequeña simulación planteando una espectrometría de una molécula de agua. Explicaremos, previamente un poco, en que consiste las espectrometría de masas.
-----------------------------------------------------------------------------------------------------------------------------------

La espectrometría de masas (MS, por sus siglas en inglés) es una técnica analítica utilizada para medir la relación masa/carga (m/z) de los iones presentes en una muestra. En el contexto de una molécula, como la del agua (H₂O), la espectrometría de masas permite identificar y cuantificar los fragmentos iónicos que resultan de la ionización de la molécula, lo que a su vez proporciona información sobre su estructura molecular y su composición.

Principios Básicos de la Espectrometría de Masas

Ionización:
-------------
La muestra, que puede ser un sólido, líquido o gas, se introduce en el espectrómetro de masas, donde se somete a un proceso de ionización. Este proceso convierte las moléculas en iones cargados (generalmente positivos) al agregar o quitar electrones.
Existen varios métodos de ionización, como la ionización por impacto electrónico (EI), electrospray (ESI), y ionización química (CI), entre otros.

Aceleración:
---------------
Los iones generados se aceleran mediante un campo eléctrico, de modo que todos los iones con la misma carga tengan la misma energía cinética.

Deflexión:
------------
Los iones acelerados pasan a través de un campo magnético o eléctrico que los desvía en función de su relación masa/carga (m/z). Los iones más ligeros y con una mayor carga se desvían más que los iones más pesados.

Detección:
-------------
Los iones desviados impactan en un detector que mide la intensidad de la señal, la cual está relacionada con la cantidad de iones presentes. La intensidad se registra para cada valor de m/z, generando así un espectro de masas.
Interpretación del Espectro de Masas

El resultado de la espectrometría de masas es un gráfico denominado espectro de masas, donde:

Eje X: Representa la relación masa/carga (m/z) de los iones.
Eje Y: Representa la intensidad o abundancia relativa de los iones detectados.
Cada pico en el espectro corresponde a un ion con una relación m/z específica. La altura del pico indica la cantidad relativa de ese ion en la muestra.

Aplicación a la Molécula de Agua (H₂O)
-----------------------------------------------------------
Para una molécula simple como el agua, la espectrometría de masas puede revelar varios iones, dependiendo del método de ionización:
----------------------------------------------------------------------------------------------------------------------------------
H₂O⁺ (m/z = 18): Ion molecular de agua sin fragmentar.
OH⁺ (m/z = 17): Fragmento ionizado que resulta de la pérdida de un átomo de hidrógeno.
O⁺ (m/z = 16): Ion de oxígeno, que podría resultar de la fragmentación de la molécula.
H⁺ (m/z = 1): Ion de hidrógeno.
En un espectro de masas de agua, podrías ver picos en estos valores de m/z, reflejando la presencia de estos fragmentos iónicos.

Ejemplo de Uso en Química y Biología.
---------------------------------------------------
Identificación de Compuestos: Al comparar el espectro de masas de una muestra con espectros de referencia, los químicos pueden identificar compuestos desconocidos.
Determinación de Estructuras Moleculares: La forma en que una molécula se fragmenta puede proporcionar pistas sobre su estructura química.
Cuantificación de Análisis: La espectrometría de masas también se usa para cuantificar la cantidad de un compuesto en una muestra, especialmente en el análisis de mezclas complejas.
Conclusión
La espectrometría de masas es una herramienta poderosa para estudiar las propiedades de las moléculas al identificar sus fragmentos iónicos y medir sus relaciones masa/carga. En la práctica, esta técnica tiene aplicaciones en química, biología, farmacología y muchas otras disciplinas científicas.

******************************************************************************************



Simulación del Espectro de Masas
--------------------------------------------------------
El espectro de masas para una molécula de agua podría incluir los siguientes iones:

H₂O → m/z = 18 (ion molecular)
OH → m/z = 17
O → m/z = 16
H → m/z = 1



Explicación del Código:
Fragmentos y sus m/z: Definimos las relaciones m/z para diferentes fragmentos posibles de la molécula de agua (H2O+, OH+, O+, H+).

Intensidades Relativas: Asignamos intensidades relativas a estos picos basadas en la probabilidad de fragmentación.

Espectro Simulado: Generamos un espectro de masas añadiendo picos gaussianos centrados en los valores de m/z definidos.

Visualización: El gráfico muestra la relación masa/carga (m/z) en las abscisas y la intensidad relativa en las ordenadas.

Resultado:
Al ejecutar este código, obtendrás un gráfico que simula un espectro de masas para una molécula de agua, donde se visualizan los diferentes iones generados por la fragmentación de la molécula. Este es un modelo simplificado, pero proporciona una base para entender cómo se podrían visualizar los datos obtenidos en un espectrómetro de masas.
-------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma linux. Concretamente en: Ubuntu 20.04.6 LTS.
Fue editado con Sublime text.
Ejecutado bajo consola Linux con el siguiente comando:
python3 Aula_28_Ag.24_Espectro_Masas.py

Se deberán tener cargados los siguientes módulos:
import numpy as np
import matplotlib.pyplot as plt

Ejecutado con python en versión:3
-------------------------------------------------------

Programa para generar gifs animados a partir de vídeos, que se ejecuta en la línea de comandos.
ARGUMENTOS:
-src/--source: Nombre del vídeo original (obligatorio).
-dest/--destination: Nombre del archivo a generar (opcional).
-sz/--size: Tamaño en porcentaje del gif respecto al vídeo original (opcional).
-shw/--show: Muestra resultado en ventana emergente al finalizar el proceso de generado (opcional).
-st/--start: Segundo inicial para gif (opcional).
-e/--end: Segundo final (opcional).
-spd/--speed: Velocidad relativa de la animación (opcional)

PARA CUALQUIER DUDA U OBSERVACIÓN, USEN LA SECCIÓN DE COMENTARIOS.

Programa para reproducir archivos de audio que incorpora la posibilidad de crear una lista de favoritos.
El programa necesita de un archivo "json" que se generará al ejecutarse por primera vez.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

Programa para mostrar el precio de cierre, apertura, máximo y mínimo de las acciones de un activo para un determinado periodo de tiempo. También incluye representación de 'bandas de bollinger' y la media movil de 20 sesiones. Para mostrar la gráfica correspondiente a la información deseada, hacer click en el botón 'SHOW GRAPH'. Para cualquier duda u observación, utilicen la sección de comentarios.

*********************************************************************************************************

Aula_26_Tecnología.py
******************************

Realizamos en lenguaje python. En un hipotetico espacio de Hilbert. La multiplicacion de dos ondas acusticas, con estos parámetros que os pongo a continuación:

Parámetros de las ondas:
frecuencia1 = 38 # Frecuencia de la primera onda (A4)
frecuencia2 = 36 # Frecuencia de la segunda onda (E5)
duracion = 12.0 # Duración en segundos
fs = 47100 # Frecuencia de muestreo

Mostraremos el resultado final graficamente. Al mismo tiempo deberemos guardar el archivo
resultante de sonido en (Debes de modificarla en tu caso) en esta ruta: /home/margarito/python/Mi_Archivo.wav.
Tambien se ejecutará el archivo de sonido incluyendo el código en el propio programa python.


Resumen del Ejercicio

En este ejercicio, hemos creado un programa en Python que realiza las siguientes tareas:

Definición de Parámetros:

Se definen dos frecuencias (38 Hz y 36 Hz), una duración de 12 segundos y una frecuencia de muestreo de 47100 Hz.

Generación de Ondas:

Se generan dos ondas sinusoidales (onda1 y onda2) con las frecuencias especificadas utilizando numpy.

Multiplicación de Ondas:

Las dos ondas generadas se multiplican para obtener una onda resultante (resultado).

Guardado de la Onda Resultante:

La onda resultante se guarda en un archivo de sonido WAV, usando soundfile.

Visualización Gráfica:

Se muestran gráficas de las dos ondas originales y la onda resultante en una figura con tres subgráficos utilizando matplotlib.

Reproducción del Sonido:

El archivo de sonido resultante se reproduce utilizando sounddevice.

----------------------------------------------------------------
Ejercicio realizado bajo Linux, con Ubuntu 20.04.6 LTS.
Editado con Sublime text. Ejecutado bajo consola Linux.


Para que todo funcione, deberemos instalar sounddevice.
Abre una terminal y ejecuta el siguiente comando para instalar portaudio:


sudo apt-get install portaudio19-dev
Paso 2: Instalar sounddevice usando pip.
Si pip no lo tienes instalado deberás instalarlo.

sudo apt-get install python3-pip
Luego, instala sounddevice:

pip3 install sounddevice

-------------------------------------------
Ejecución del ejercicio, bajo consola linux:
python3 Aula_26_Tecnología.py

--------------------------------------------------------------------------------------------------------------
**********************************************************************************************


Fourier_Aula_28_Junio_24.py
**********************************

Antes de empezar,queridos alunmnos, vamos a explicar, para entendernos lo mejor posible, que es una serie de Fourier:

Imagina que tienes una onda compuesta por varias frecuencias mezcladas, como la melodía de una canción. Las series de Fourier son como una herramienta matemática que te permite descomponer esa onda compleja en sus partes más simples: ondas sinusoidales (ondas de seno y coseno) de diferentes frecuencias.

Es como si tuvieras un prisma que descompone la luz blanca en los colores del arcoíris. Las series de Fourier hacen lo mismo con las ondas: las descomponen en sus "colores" individuales, que son las ondas sinusoidales de diferentes frecuencias.

En resumen:
**************

¿Qué son? Las series de Fourier: son una forma de representar funciones periódicas (que se repiten a lo largo del tiempo) como una suma de ondas sinusoidales más simples.

Y te preguntarás ¿Para qué sirven? Sirven para analizar y comprender mejor las funciones periódicas, como las ondas de sonido, las señales de audio o las vibraciones.

¿Cómo funcionan? Descomponen la función periódica en una suma infinita de ondas sinusoidales de diferentes frecuencias. Cada onda sinusoidal tiene una amplitud y una frecuencia específica, y juntas reconstruyen la función original.

Un ejemplo sencillo:
*************************
Imagina una onda triangular, como la de los dientes de una sierra. Las series de Fourier la descompondrían en una suma de ondas sinusoidales, una con la frecuencia fundamental de la onda triangular (la frecuencia más baja), y otras con frecuencias que son múltiplos de la fundamental (2 veces, 3 veces, 4 veces...). Cada onda sinusoidal tendría una amplitud específica, y juntas recrearían la forma de la onda triangular original.

Aplicaciones:
*****************
Las series de Fourier tienen muchas aplicaciones en diversos campos, como:

*Procesamiento de señales:
*******************************
Se utilizan para analizar y modificar señales de audio, video e imágenes.

*Comunicaciones:
*******************
Se utilizan para transmitir señales de forma eficiente a través de canales de comunicación.

*Física:
*******
Se utilizan para modelar fenómenos como la vibración, la onda y la transferencia de calor.

*Matemáticas:
***************
Se utilizan para estudiar la convergencia de series infinitas y la teoría de las funciones.

En resumen, las series de Fourier son una herramienta matemática poderosa para analizar y comprender funciones periódicas. Son esenciales en muchos campos, desde la ingeniería hasta la física y la música.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
EJERCICIO PROPUESTO.
-----------------------------------

El ejercicio propuesto lo llamaremos: Fourier_Aula_28_Junio_24.py.
A continuación os hago un pequeño resumen del mismo. No obstante, en la próxima clase podremos solucionar las dudas surgidas. El ejercicio, como véis, esta desarrollado en python.

Resumen del ejercicio:

Objetivo:
********
Este código en Python genera una onda sonora compuesta por la suma de armónicos de una frecuencia base, la visualiza y la guarda como un archivo de audio tipo .wav.

Explicación paso a paso:
---------------------------------
Importación de librerías:

numpy: Para realizar operaciones matemáticas con arrays.
matplotlib.pyplot: Para crear gráficos.
IPython.display.Audio: Para reproducir audio en el notebook (opcional).
scipy.io.wavfile: Para guardar la señal como un archivo de audio .wav.
pydub (opcional): Para reproducir el archivo de audio guardado (requiere instalación).

Definición de parámetros:

frecuencia_base: Frecuencia base de la onda (en Hz, por ejemplo, 440 Hz para la nota A4).
num_armonicos: Número de armónicos a sumar (por ejemplo, 10).
duracion: Duración total de la señal en segundos (por ejemplo, 4 segundos).
frecuencia_muestreo: Frecuencia de muestreo en Hz (determina la calidad del audio, 44100 Hz es común).

Creación del vector de tiempo:

t: Un array de numpy que contiene valores de tiempo desde 0 hasta duracion con frecuencia_muestreo muestras por segundo.

Inicialización de la señal:

señal: Un array de numpy inicializado con ceros del mismo tamaño que t.

Sumar armónicos:

Se realiza un bucle for desde 1 hasta num_armonicos.
Dentro del bucle, se calcula la frecuencia de cada armónico (frecuencia_n).
Se suma a la señal una onda sinusoidal con la frecuencia frecuencia_n y amplitud 1.

Normalizar la señal:

Se divide la señal por su valor máximo absoluto para que la amplitud esté entre -1 y 1.

Graficar la señal:

Se crea una figura de matplotlib.
Se grafica un segmento de la señal (t[:1000]) vs su amplitud (senal[:1000]).
Se añade un título, etiquetas de eje y se muestra el gráfico.

Reproducir el audio en el notebook (opcional):

Se crea un objeto Audio de IPython con la señal y la frecuencia de muestreo.
Se reproduce el sonido utilizando el objeto Audio.
Guardar la señal como un archivo de audio .wav:

Se utiliza la función write de scipy.io.wavfile para guardar la señal multiplicada por 32767 (para valores de audio de 16 bits) como un archivo .wav llamado serie_fourier.wav.

Reproducir el archivo de audio guardado (esto lo hacemos opcional, requiere pydub):
También podemos ejecutar el archivo una vez guardado.

Se importa AudioSegment y play de pydub.
Se carga el archivo de audio como un objeto AudioSegment.
Se reproduce el audio utilizando la función play.
En resumen, este código genera una onda sonora rica en armónicos a partir de una frecuencia base, la visualiza y la guarda en un formato de audio estándar (.wav) para que pueda ser escuchada.


*************************************************************************
Ejercicio realizado bajo linux.
Con Ubuntu 20.04.6 LTS.
Editado con Sublime text.
Ejecutado bajo consola con el sieguiente comando:
python3 Fourier_Aula_28_Junio_24.py
-------------------------------------------------------------------------
Para el correcto funcionamiento del ejercicio, deberemos de tener instalado en nuestro
sistema las siguientes librerías:

import numpy as np
import matplotlib.pyplot as plt
from IPython.display import Audio

También deberemos de tener instalados estos módulos,
instalańdolos bajo consola de linux, con los siguientes comandos:

sudo apt-get install ffmpeg
pip install pydub
----------------------------------------------------------

****************************************************************************************
-----------------------------------------------------------------------------------------------------


Gráfica_integral_Aula_28.py
********************************
Por petición de varios alumnos del Aula 28. Proponemos hoy el siguiente ejercicio en python, donde explicamos el concepto de la integración, como contrario a la derivación, mostrando gráficamente los resultados. Con el mismo, pretendemos que los alumnos, repasen este concepto matématico, y al mismo tiempo, se familiaricen con los gráficos en el potente lenguaje python, de los mejores en este aspecto.

Básicamente dentro del cálculo matemático, podemos decir, de la forma más sencilla posible que:

La integración en matemáticas es una operación que permite calcular el área bajo una curva o función. En términos sencillos, imagina que tienes un gráfico y quieres saber el espacio que ocupa una parte de él, por ejemplo, el área entre la curva y el eje horizontal (el eje x). La integración te ayuda a encontrar ese área de forma precisa.

Por ejemplo, si tienes una función que describe la velocidad de un coche a lo largo del tiempo, la integración de esa función te dirá la distancia total que ha recorrido el coche en ese periodo de tiempo.

La integración es la inversa de la derivación. Mientras que la derivada de una función te da la pendiente o la tasa de cambio de esa función, la integral te da el acumulado de esa tasa de cambio.

La integración es un concepto fundamental del cálculo y del análisis matemático. Se puede pensar en ella como la operación inversa a la derivación.

Interpretaciones geométricas:
Área bajo la curva: La integral definida de una función f(x) entre a y b representa el área encerrada entre la gráfica de f(x), el eje x y las líneas verticales x = a y x = b.

Acumulación:
La integral definida de una función f(x) entre a y b puede interpretarse como la acumulación de la cantidad f(x) a lo largo del intervalo [a, b].

Definición formal:
Integral indefinida: La integral indefinida de una función f(x) se define como la función F(x) cuya derivada es f(x). Se escribe como ∫ f(x) dx.

Integral definida:
La integral definida de una función f(x) entre a y b se define como el límite de las sumas de Riemann cuando el número de subintervalos tiende a infinito. Se escribe como ∫_a^b f(x) dx.

Aplicaciones:
La integración tiene una gran variedad de aplicaciones en matemáticas, física, ingeniería y otras áreas. Entre ellas se encuentran:

*Cálculo de áreas, volúmenes y longitudes de curvas.
*Estudio del movimiento de objetos.
*Análisis de circuitos eléctricos.
*Probabilidad y estadística.
*etc

BREVE DESCRIPCIÓN DE LO QUE HACE EL EJERCICIO.
********************************************************************

Aunque el código va siendo explicado en cada paso del ejercicio.Para no redundar a continuación os pongo los pasos más importantes del código.

*Definimos una función que vamos a integrar.
*Calculamos el área bajo la curva de esa función entre dos puntos.
*Generamos puntos para dibujar la función.
*Dibujamos la función en una gráfica.
*Sombreamos el área bajo la curva para mostrar visualmente la integral.
*Añadimos una etiqueta que muestra el área total calculada.
*Dividimos el área en pequeños segmentos y calculamos el área de cada uno.
*Etiquetamos los segmentos en la gráfica para mostrar sus áreas individuales.
*El gráfico final muestra la función, el área total bajo la curva y las áreas de pequeños segmentos, ayudando a entender cómo se suma el área total.

***********************************************************************************************************
-----------------------------------------------------------------------------------------------------------------------------
Proponemos este sencillo código: Aula_28_orbital.py . Con el fin de familiarizarmos con los entornos gráficos de Python.

El código genera gráficos 3D de orbitales atómicos utilizando matplotlib y mpl_toolkits.mplot3d.
Este tipo de visualización es excelente para representar la forma de los orbitales s, p y d en tres dimensiones.

Aquí está el análisis del código y una revisión para asegurarnos de que funcione correctamente:

Importar módulos:

mpl_toolkits.mplot3d se importa para poder crear gráficos 3D.
matplotlib.pyplot se importa como plt para funciones de trazado.
numpy se importa como np para cálculos numéricos.

Crear la figura y los subgráficos:

Se crea una figura (fig) con tamaño de 15x5 pulgadas.
Se crean tres subgráficos (ax1, ax2, ax3) con proyección 3D.

Definir los datos de los orbitales:

Para el orbital s, se utilizan coordenadas esféricas.
Para el orbital p, se utilizan coordenadas que representan la forma lobular.
Para el orbital d, se utilizan coordenadas que representan una forma de doble lóbulo.

Trazar superficies:

Cada subgráfico (ax1, ax2, ax3) utiliza plot_surface para trazar la forma del orbital en el espacio 3D.
Se ajustan los límites de los ejes (set_xlim, set_ylim, set_zlim) para asegurar que todos los gráficos tengan la misma escala y sean comparables.

Configuración de etiquetas y títulos:

Se establecen etiquetas para los ejes (set_xlabel, set_ylabel, set_zlabel) y títulos (set_title) para cada subgráfico.

Mostrar el gráfico:

plt.show() se utiliza al final para mostrar la figura completa con los tres subgráficos.
El código parece estar bien estructurado para visualizar los orbitales s, p y d en 3D.
-----------------------------------------------------------------------------------------------------------------------
Asegúrate de tener matplotlib y numpy instalados en tu entorno de Python para que funcione correctamente.

-------------------------------------------------------------------------------------------------------
El ejercicio fue realizado en un entorno Linux.
Plataforma Ubuntu 20.04.6 LTS.
Editado con Sublime txt.

El programa tiene como objeto principal, la lectura, haciendo uso de la cámara web, de códigos QR. Para ello, simplemente pulsaremos el botón "INICIAR LECTURA POR CAMARA" (que desplegará el visor de la cámara) y colocaremos el código a leer, delante de la cámara. A su vez, también podremos leer códigos QR, en formato "png" y "jpg" almacenados en nuestra computadora (para lo que usaremos la opción "CARGAR ARCHIVO". Finalmente, también podremos leer, directamente, un código que se encuentre visible en pantalla (botón "DETECTAR EN PANTALLA").

***********************************************************************************************************************
------------------------------------------------------------------------------------------------------------------------------------------






Aula_28_Aprendizaje_RedNeuronal_CNN.py
-----------------------------------------------------------
**************************************************

Pretendemos alojar en esta ruta de mi ordenador:/home/margarito/python/PetImages, el directorio PetImages, que a su vez contiene otros dos directorios con el nombre cat y dog. Los mismos contienen imagenes de gatos y perros. Vamos a construir una red neuronal convolucional, que dada la imagen en esta ruta:/home/margarito/python/imagen.jpeg, determine si pertenece a un gato, o a un perro. También s deberá mostrar la imagen.

Lo primero que debemos hacer es el código que descargará los datos.

# Descargar el archivo de datos
url = "https://download.microsoft.com/download/3/E/1/3E1C3F21-ECDB-4869-8368-6DEBA77B919F/kagglecatsanddogs_5340.zip"
filename = "kagglecatsanddogs_5340.zip"
r = requests.get(url)
with open(filename, 'wb') as f:
f.write(r.content).
------------------------------------------------------------------------------------------------------------------------
Las partes del ejercicio a resaltar, son las siguientes:

En general, este ejercicio describe el proceso completo de implementación de una red neuronal convolucional (CNN) usando TensorFlow para clasificar imágenes de gatos y perros. A continuación se presenta un resumen de las partes más importantes:

1. Configuración Inicial y Descarga de Datos.
---------------------------------------------------------------
Se importa TensorFlow y otras bibliotecas necesarias.
Se descarga el dataset de gatos y perros desde una URL proporcionada y se descomprime en el directorio de trabajo.

2. Preparación de los Datos.
------------------------------------
Verificación de Imágenes: Se recorren las carpetas de imágenes para verificar que no haya archivos corruptos y se eliminan los que no son válidos.
Organización del Directorio: Se aseguran que las carpetas para las categorías cat y dog existan en el directorio base.

3. Preprocesamiento de los Datos.
---------------------------------------------
Se utiliza ImageDataGenerator para realizar una reescalado de las imágenes y dividir el conjunto de datos en entrenamiento y validación.
Generadores de Datos: Se crean generadores de datos para el conjunto de entrenamiento y de validación, especificando
el tamaño de las imágenes, el tamaño del batch, y el modo de clasificación binaria.

4. Construcción del Modelo CNN.
-------------------------------------------
Se define una arquitectura secuencial de la red neuronal con capas de:
Convolución: Tres capas convolucionales con activación ReLU.
Max-Pooling: Después de cada capa convolucional.
Flatten: Para convertir los mapas de características 2D a un vector 1D.
Densa: Una capa densa con 512 neuronas y activación ReLU.
Dropout: Con una tasa del 50% para reducir el sobreajuste.
Salida: Una capa de salida con activación sigmoide para la clasificación binaria.

5. Compilación del Modelo.
-----------------------------------
El modelo se compila utilizando el optimizador Adam y la función de pérdida de binary_crossentropy, con métrica de precisión.

6. Entrenamiento del Modelo.
------------------------------------------
El modelo se entrena durante 10 épocas utilizando los generadores de datos creados anteriormente.
Se calculan los pasos por época basados en el tamaño del conjunto de entrenamiento y validación.

7. Evaluación del Modelo.
--------------------------------------
Se evalúa el modelo usando el conjunto de validación y se imprime la precisión de validación.

8. Predicción de Nuevas Imágenes.
----------------------------------------------
Se carga una nueva imagen, se preprocesa y se realiza una predicción utilizando el modelo entrenado.
Se muestra la imagen junto con la predicción (gato o perro).

9- Características del EQUIPO donde se realizó el ejercicio.
----------------------------------------------------------------------------------
El ejercicio fue realizado en una plataforma Linux.
Con el sistema operativo Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El adware del mismo es:
------------------------------------
Intel® Core™ i5-10400 CPU @ 2.90GHz × 12
Intel® UHD Graphics 630 (CML GT2)

Para llegar a esta exactitud o accuracy
157/157 [==============================] - 9s 56ms/step - loss: 0.8151 - accuracy: 0.8177
Validation accuracy: 81.77%, tardamos 2258.9 segundos.

Como se puede apreciar, mucho tiempo de ejecución, y muy forzado el equipo a dedicación completa.

------------------------------------------------------------------------------------------------
Ejecución bajo consola Linux:
python3 Aula_28_Aprendizaje_RedNeuronal_CNN.py.
Quien desee salvar el modelo, para experimentar con él
puede hacerlo añadiendo esta línea de código
a continuación del proceso de compilación:
# Guardar el modelo
model.save('modelo_cnn_gatos_perros.h5')
# Guarda en formato HDF5, indicando la ruta de tu ordenador donde se desee salvarlo.