Códigos Fuente de Python

python3 Repaso_Aula_28.py
*************************


Ejercicio sencillo para Aula-28.
*******************************
Queremos generar un módulo para posteriores entrenamientos utilizando transferencia de aprendizaje.

A nuestro módulo lo llamaremos:MODULO-HIM.h5
Lo guardaré en esta ruta de mi ordenador: save_path = "/home/margarito/python/MODULO-HIM.h5"

Suponemos que en nuestro ordenador tenemos las imagenes de entrenamiento, que deberán guardar básicamente según este este esquema. En el caso de mi ordenador sería el siguiente:

/home/margarito/python/HIM/
|-- train/
| |-- dog/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- flores/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- ...
|
|-- test/
| |-- dog/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- flores/
| | |-- imagen1.jpg
| | |-- imagen2.jpg
| | |-- ...
| |
| |-- ...

Epoch.
*******
Epoch 1/10
2/2 [==============================] - 3s 615ms/step - loss: 0.6765 - accuracy: 0.5472
Epoch 2/10
2/2 [==============================] - 2s 875ms/step - loss: 0.6293 - accuracy: 0.5660
Epoch 3/10
2/2 [==============================] - 2s 566ms/step - loss: 0.5859 - accuracy: 0.6415
Epoch 4/10
2/2 [==============================] - 2s 880ms/step - loss: 0.5429 - accuracy: 0.8491
Epoch 5/10
2/2 [==============================] - 2s 571ms/step - loss: 0.5003 - accuracy: 0.8679
Epoch 6/10
2/2 [==============================] - 2s 564ms/step - loss: 0.4556 - accuracy: 0.8868
Epoch 7/10
2/2 [==============================] - 2s 889ms/step - loss: 0.4191 - accuracy: 0.8868
Epoch 8/10
2/2 [==============================] - 2s 864ms/step - loss: 0.3714 - accuracy: 0.8491
Epoch 9/10
2/2 [==============================] - 2s 884ms/step - loss: 0.3436 - accuracy: 0.9057
Epoch 10/10
2/2 [==============================] - 2s 869ms/step - loss: 0.3403 - accuracy: 0.9245



*************************************************************************************************************
El ejercicio es realizado en plataforma Linux.
Concretamente en:Ubuntu 20.04.6 LTS.
Fue editado con:Sublime text.
Ejecución bajo consola Linux:python3 Repaso_Aula_28.py
***************************************************************************************************************

Utilizar Google Colab junto con Google Drive es una excelente manera de ejecutar y colaborar en proyectos de aprendizaje profundo sin preocuparte por la capacidad de procesamiento y almacenamiento.
Aquí explicamos paso a paso para utilizar Google Colab y Google Drive para generar un modelo de red neuronal convolucional (CNN):
**********************************************************************************************************************************
Paso 1: Preparar tus datos en Google Drive
Crea una carpeta en Google Drive:
Abre Google Drive y crea una carpeta para tu proyecto. Puedes organizar tus datos, cuadernos de Jupyter y modelos en esta carpeta.

Sube tus datos:
Sube tus datos al directorio creado. Pueden ser conjuntos de entrenamiento, validación y prueba en carpetas separadas. Asegúrate de que tus datos estén organizados de manera adecuada.
****************************************************************************************************************************************
Paso 2: Conectar Google Colab a Google Drive
Abre un nuevo cuaderno de Colab:
Abre Google Colab (https://colab.research.google.com/) y crea un nuevo cuaderno de Jupyter.

Monta Google Drive:
Ejecuta el siguiente código en una celda para montar tu Google Drive en Colab. Esto te pedirá autorización y generará un código que debes ingresar.

from google.colab import drive
drive.mount('/content/drive')

Sigue las instrucciones para autorizar y copia el código de autorización en el cuadro de texto de la celda.

*************************************************************************************************************************************
Accede a tus datos:
Después de montar Google Drive, puedes acceder a tu carpeta del proyecto utilizando la ruta /content/drive/MyDrive/:

project_folder = '/content/drive/MyDrive/TuCarpetaDeProyecto'

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

Paso 3: Cargar y Preprocesar Datos
Carga y preprocesa tus datos:
Utiliza las bibliotecas de Python para cargar y preprocesar tus datos. Por ejemplo, si estás trabajando con imágenes en el conjunto de datos CIFAR-10:

import pickle
import numpy as np
from tensorflow.keras.utils import to_categorical

# Cargar datos desde Google Drive
with open(project_folder + '/data/cifar10_data.pkl', 'rb') as file:
data = pickle.load(file)

# Preprocesar datos
x_train, y_train, x_test, y_test = data['train_images'], data['train_labels'], data['test_images'], data['test_labels']
x_train = x_train / 255.0
x_test = x_test / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

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

Paso 4: Construir y Entrenar el Modelo CNN
Definir el modelo CNN:
Construye tu modelo de CNN utilizando TensorFlow y Keras. Aquí hay un ejemplo simple:

from tensorflow.keras import layers, models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

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

Compilar y entrenar el modelo:
Compila y entrena tu modelo utilizando los datos cargados:

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

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

Paso 5: Guardar el Modelo en Google Drive
Guardar el modelo:
Después de entrenar el modelo, guárdalo en tu carpeta de Google Drive:

model.save(project_folder + '/modelo_cnn.h5')

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

Paso 6: Descargar el Modelo (opcional)
Descargar el modelo:
Si lo prefieres, puedes descargar el modelo entrenado desde Google Drive:

from google.colab import files
files.download(project_folder + '/modelo_cnn.h5')

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

Estos pasos deberían ayudarte a ejecutar un proyecto de CNN en Google Colab utilizando Google Drive para almacenar tus datos y modelos. Asegúrate de adaptar el código según tus necesidades específicas y estructura de datos.


------------------------------------------------------------------------------------------------------------------------------------
**************************************************************************************************************************************************************************************************************************************
SALIDA CONSOLA PROCESO DE EJECUCIÓN DEL EJERCICIO EN GOOGLE COLAB.
*****************************************************************************************************

Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz
170498071/170498071 [==============================] - 12s 0us/step
Model: "sequential"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d (Conv2D) (None, 30, 30, 32) 896

max_pooling2d (MaxPooling2 (None, 15, 15, 32) 0
D)

conv2d_1 (Conv2D) (None, 13, 13, 64) 18496

max_pooling2d_1 (MaxPoolin (None, 6, 6, 64) 0
g2D)

conv2d_2 (Conv2D) (None, 4, 4, 64) 36928

flatten (Flatten) (None, 1024) 0

dense (Dense) (None, 64) 65600

dense_1 (Dense) (None, 10) 650

=================================================================
Total params: 122570 (478.79 KB)
Trainable params: 122570 (478.79 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________
Epoch 1/10
1563/1563 [==============================] - 187s 119ms/step - loss: 1.7111 - accuracy: 0.3684 - val_loss: 1.3924 - val_accuracy: 0.4950
Epoch 2/10
1563/1563 [==============================] - 186s 119ms/step - loss: 1.4381 - accuracy: 0.4798 - val_loss: 1.2347 - val_accuracy: 0.5591
Epoch 3/10
1563/1563 [==============================] - 188s 120ms/step - loss: 1.3287 - accuracy: 0.5234 - val_loss: 1.1421 - val_accuracy: 0.5922
Epoch 4/10
1563/1563 [==============================] - 185s 118ms/step - loss: 1.2549 - accuracy: 0.5513 - val_loss: 1.1387 - val_accuracy: 0.5944
Epoch 5/10
1563/1563 [==============================] - 185s 118ms/step - loss: 1.1964 - accuracy: 0.5732 - val_loss: 1.0895 - val_accuracy: 0.6132
Epoch 6/10
1563/1563 [==============================] - 181s 116ms/step - loss: 1.1545 - accuracy: 0.5881 - val_loss: 1.1042 - val_accuracy: 0.6162
Epoch 7/10
1563/1563 [==============================] - 181s 116ms/step - loss: 1.1209 - accuracy: 0.6025 - val_loss: 1.0378 - val_accuracy: 0.6406
Epoch 8/10
1563/1563 [==============================] - 179s 115ms/step - loss: 1.0897 - accuracy: 0.6128 - val_loss: 0.9644 - val_accuracy: 0.6558
Epoch 9/10
1563/1563 [==============================] - 180s 115ms/step - loss: 1.0678 - accuracy: 0.6223 - val_loss: 0.9507 - val_accuracy: 0.6730
Epoch 10/10
1563/1563 [==============================] - 180s 115ms/step - loss: 1.0431 - accuracy: 0.6308 - val_loss: 0.8898 - val_accuracy: 0.6875
/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.
saving_api.save_model(

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


Aula-28-Trabajo_Imagenes.py
**********************************

Ejecución: python3 Aula-28-Trabajo_Imagenes.py



Utilizando los ficheros .npy, guardamos el array original de pixels en un fichero que llamamos: imagen.npy. Luego manipulamos la imagen a escala de grises en el fichero: imagen_gris.npy, que tambien guardamos, y abrimos para mostrar su modificación.

El sencillo ejercicio se puede manipular y modificar parámetros para observar resultados. Se tendrá en cuenta en sustituir la ruta de los archivos a tratar, que deben estar en el mismo directorio donde se encuentra: Aula-28-Trabajo_Imagenes.py

--------------------------------------------------------------------------------------------------------------------------------------

El ejercicio consiste en cargar una imagen en color, convertirla a escala de grises y guardar la imagen en escala de grises en un archivo.

El código del ejercicio se divide esquemáticamente en dos partes principales:

Parte 1: Cargar la imagen y convertirla a un array NumPy.
Parte 2: Convertir la imagen a escala de grises y guardarla en un archivo.
En la parte 1 del código, se utiliza la función Image.open() para cargar la imagen. A continuación, se utiliza la función resize() para cambiar el tamaño de la imagen a 180x180 píxeles. Por último, se utiliza la función img_to_array() para convertir la imagen a un array NumPy.

En la parte 2 del código, se utiliza la función rgb_to_grayscale() de TensorFlow para convertir la imagen a escala de grises. A continuación, se utiliza la función convert_image_dtype() para convertir la imagen a un tipo de datos NumPy de 8 bits. Por último, se utiliza la función save() para guardar la imagen en escala de grises en un archivo.

El código convierte la imagen original a escala de grises de forma correcta. La imagen en escala de grises conserva la información principal de la imagen original, pero pierde los detalles de color.

---------------------------------------------------------------------------------------------------------------------

Exponemos aquí un ejemplo de redes neuronales convolucionales CNN,
basadas en transferencia de estilo. Partiendo de una imagen original, y otra imagen que dará
la forma del estilo(en nuestro caso, un cuadro de Picaso), construiremos otra, basada en las dos anteriores.

El programa que citamos aquí está basado en en un ejemplo
del blog RUBENJROMO
https://rubenjromo.com/
Modificados algunos parámetros.
Editado y ejecutado en GoogleColab.
Archivos de muestra, alojados en DRIVE.
https://drive.google.com/

Modelo vgg19-dcbb9e9d.pth bajado de:
"https://download.pytorch.org/models/vgg19-dcbb9e9d.pth

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

Las redes neuronales convolucionales (CNN) y la transferencia de estilo son conceptos distintos en el campo del aprendizaje profundo, pero a veces se combinan para lograr resultados interesantes en el procesamiento de imágenes. Aquí hay una breve descripción de cada uno:

Redes Neuronales Convolucionales (CNN):

Las CNN son un tipo de arquitectura de red neuronal diseñada específicamente para procesar datos de rejilla, como imágenes. Utilizan capas de convolución para extraer características relevantes de la imagen de entrada.
La convolución implica el uso de filtros o kernels que se deslizan sobre la imagen para realizar operaciones locales, lo que permite detectar patrones específicos, como bordes, texturas o formas.
Están compuestas por capas convolucionales, capas de activación (como la ReLU), capas de agrupación (pooling) y capas completamente conectadas.
Transferencia de Estilo:

La transferencia de estilo es una técnica que utiliza redes neuronales para combinar el contenido de una imagen con el estilo de otra imagen de manera creativa.
Se basa en la idea de separar el contenido y el estilo de una imagen. La información de contenido se extrae de una imagen de referencia, mientras que el estilo se toma de otra imagen.
La red neuronal intenta generar una nueva imagen que conserve el contenido de una imagen de entrada pero adopte el estilo de otra imagen de referencia.
Cuando se combinan estas dos ideas, se puede aplicar la transferencia de estilo utilizando una CNN. La idea es utilizar una red preentrenada, como VGG16 o VGG19, para extraer tanto el contenido como el estilo de las imágenes. Luego, se optimiza una nueva imagen para que coincida con el contenido de una imagen de entrada y el estilo de otra imagen de referencia. Este proceso permite crear imágenes que fusionan el contenido de una imagen con el estilo artístico de otra.

En resumen, las CNN son arquitecturas de redes neuronales diseñadas para el procesamiento de imágenes, mientras que la transferencia de estilo es una técnica que utiliza redes neuronales para combinar el contenido y el estilo de diferentes imágenes. Al aplicar la transferencia de estilo con una CNN, se pueden lograr resultados visualmente atractivos y creativos.

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.
Esta versión incorpora la posibilidad de reproducir secuencialmente la lista de favoritos, para ello se usará el botón "PLAY ALL" (dicha reproducción se podrá finalizar igualmente con el botón "STOP").
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

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

Propongo este sencillo ejercicio llamado:AULA-288_Transf_Apren_CNN.py, si utilizamos nuestro propio editor, Sublime text, y ejecutamos directamente en nuestra consola linux. O también llamado:AULA-288_Transf_Apren_CNN.ipynb, si utlizamos para editar y ejecutar a Google Colab.

En ambos casos, utilizamos indirectamente el método denominado "Transferencia de aprendizaje", con el fin de apreciar cual es el proceso de este sistema de red Convolucional(CNN).

Se trata, utilizando Machine Learning de la mano de TensorFlow y Keras, dos librerías Open Source que nos permiten adentrarnos en el Deep Learning de forma sencilla. De entre las muchas bibliotecas disponibles una de las más importantes es indiscutiblemente es TensorFlow, que se ha impuesto como la librería más popular en Deep Learning. Actualmente, sería difícil imaginar abordar un proyecto de aprendizaje sin ella.

Básicamente, para entenderlo, es una biblioteca de código abierto para realizar operaciones matemáticas de manera eficiente, especialmente diseñada para trabajar con redes neuronales y aprendizaje profundo (deep learning).


Keras, por otro lado, es una interfaz de alto nivel para construir y entrenar modelos de aprendizaje profundo. Facilita la construcción y experimentación con redes neuronales de una manera más simple y amigable.

TensorFlow.keras:
TensorFlow.keras es una implementación de la interfaz de Keras que está integrada directamente en TensorFlow. Esto significa que puedes usar las funciones y herramientas de TensorFlow mientras trabajas con la sencillez y flexibilidad de Keras.

En resumen, TensorFlow.keras es una combinación que aprovecha la potencia de TensorFlow para realizar cálculos eficientes en el fondo, mientras que proporciona una interfaz amigable y fácil de usar para diseñar y entrenar modelos de aprendizaje profundo mediante la simplicidad de Keras. Esto facilita el desarrollo de aplicaciones de inteligencia artificial y aprendizaje profundo de una manera más accesible para los desarrolladores.

En este ejercicio, primero entrenamos el modelo, creando el mismo, alojandolo en el fichero: mnist_model.h5. En un caso, dependiendo el método de ejecución será guardado en Drive, o en nuestro propio ordenador. Luego cargaremos la imagen del número propuesto, que hemos fotografiado con el móvil, una vez dibujado a mano en color negro, sobre fondo blanco.

AQUÍ RESUMIMOS LOS PASOS NECESARIOS.
----------------------------------
Dibujar el número:
Preparar el papel o la superficie: Asegúrate de tener un fondo claro y limpio para que el número se destaque.

Dibuja el número: Utiliza un lápiz o bolígrafo para dibujar claramente el número en el papel. Trata de mantener el trazo claro y definido.

Contraste: Asegúrate de que haya suficiente contraste entre el número y el fondo para que el modelo pueda distinguirlo fácilmente.

Fotografiar el número:
Buena iluminación: Coloca la hoja con el número en un lugar bien iluminado. La iluminación uniforme puede ayudar a obtener una imagen de mejor calidad.

Ángulo y enfoque: Fotografía el número desde arriba para evitar distorsiones. Asegúrate de que la imagen esté enfocada y que el número sea claramente visible.

Fondo simple: Trata de tener un fondo simple y sin distracciones para que el modelo se centre en el número.

Preprocesamiento de la imagen:
Recortar y redimensionar: Recorta la imagen para que solo contenga el número y redimensiona la imagen según sea necesario.

Convertir a escala de grises: Convierte la imagen a escala de grises si es un número en blanco y negro, o a escala de colores si es en color.

Utilizar el número en un modelo de CNN:
Preparar los datos: Dependiendo del modelo y la biblioteca que estés utilizando (por ejemplo, TensorFlow y Keras), es posible que necesites ajustar el formato de la imagen o realizar otras transformaciones.

Entrenar el modelo: Entrena tu modelo de CNN utilizando el conjunto de datos que has creado con las imágenes de los números.

Prueba el modelo: Utiliza nuevas imágenes para probar la capacidad de tu modelo para reconocer los números.

Recuerda que la calidad de las imágenes y la cantidad de datos de entrenamiento son factores críticos para el éxito de tu modelo de CNN. Cuanto más variados y representativos sean los datos de entrenamiento, mejor será la capacidad del modelo para generalizar y reconocer números en situaciones diversas.

COMO EJECUTAR EL EJERCICIO.
---------------------------
Como hemos comentado al inicio, podemos utilizar dos métodos.

1-GOOGLE COLAB.
--------------
En este caso tendremos una cuenta abierta en Google Colab, y en Drive, con el fin de ejecutar online el ejercicio. Montando debidamente Drive.
Deberemos especificar correctamente las rutas tando de la carga de la imagen del número a predecir, como la descarga y alojamiento del fichero.
2-BAJO CONSOLA LINUX.
-------------------
En mi caso el ejercicio se utiliza Ubuntu 20.04.6 LTS, y el editor Sublime Text.

En este caso, también deberemos especificar correctamente las rutas tando de la carga de la imagen del número a predecir, como la descarga y alojamiento del fichero.
*************************************************************

Con el fin de que no haya conflictos con CUDA, hemos colocado esta linea de código en ambos ejercicios:
Para utilizar la CPU de tu ordenador, aunque en el caso de Google Colab, utilizamos su sistema online.

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # Establece la variable de entorno para usar la CPU de tu ordenador, al no tener, en muchos casos una tarjeta NVIDEA.

---------------------------------------------------------
QUE ES CUDA:

CUDA es una plataforma de cómputo paralelo desarrollada por NVIDIA que permite utilizar la potencia de procesamiento de las unidades de procesamiento gráfico (GPU) para realizar cálculos de propósito general. La sigla CUDA proviene de "Compute Unified Device Architecture" (Arquitectura de Dispositivo Unificado para Cómputo, en español).

A continuación, te proporciono algunos puntos clave sobre CUDA:

Programación en paralelo: CUDA proporciona un entorno de programación en paralelo que permite a los desarrolladores aprovechar la capacidad de procesamiento masivo de las GPUs para realizar cálculos intensivos. Esto es especialmente útil para aplicaciones que pueden dividirse en tareas independientes que se pueden ejecutar simultáneamente.

Modelo de programación: CUDA utiliza un modelo de programación basado en el lenguaje de programación C, lo que facilita a los desarrolladores escribir código para ejecutar en las GPUs de NVIDIA.

Núcleos de procesamiento: Las GPUs de NVIDIA están compuestas por un gran número de núcleos de procesamiento, que pueden ejecutar tareas de forma paralela. CUDA permite a los desarrolladores escribir programas que distribuyen estas tareas en los núcleos de manera eficiente.

Aplicaciones comunes: CUDA se utiliza comúnmente en aplicaciones de alto rendimiento, como el procesamiento de imágenes y videos, simulaciones científicas, aprendizaje profundo (deep learning), criptografía y otros campos que requieren un procesamiento intensivo.

Bibliotecas y herramientas: NVIDIA proporciona bibliotecas y herramientas específicas de CUDA, como cuBLAS (para álgebra lineal básica), cuDNN (para redes neuronales profundas), y otras, que facilitan el desarrollo de aplicaciones de alto rendimiento.

Desarrollo de software: Para utilizar CUDA, los desarrolladores suelen escribir código en lenguaje CUDA C y utilizan herramientas proporcionadas por NVIDIA, como el compilador NVCC (NVIDIA CUDA Compiler).

En resumen, CUDA es una tecnología que permite aprovechar la potencia de las GPUs de NVIDIA para realizar cálculos paralelos, lo que resulta especialmente valioso en aplicaciones que requieren un alto rendimiento computacional.

Calculadora que realiza las operaciones básicas y además permite cambiar entre los modos de binario, hexadecimal, decimal y octal.

Proponemos el sencillo ejercicio: Aula_28_CNN-repaso.py, con el fin de realizar un proceso de convolución, sobre una imagen en color gris, por lo que sólo tendremos un canal de profundidad en la misma.

Según le hemos pedido al programa, la imagen tiene las siguientes características:
Características de la imagen:
Dimensiones: (431, 770, 1)
Valor mínimo: 0
Valor máximo: 249
Valor medio: 23.887129498498407.

La particularidad de este ejercicio, es que utilizamos el modulo scipy, creado inicialmente sobre el año 2000, actualizado en revisiones, y aún bastante utilizado.

Las caracteristicas más importantes de este módulo son las siguientes:
***************************************************************************************
SciPy es una biblioteca de código abierto en Python que se utiliza para realizar operaciones científicas y técnicas. Está construida sobre NumPy y proporciona funcionalidades adicionales para la manipulación de datos y el análisis estadístico. El módulo SciPy se divide en varios submódulos, cada uno de los cuales se centra en un área específica de la computación científica. Algunos de los submódulos más importantes son:

scipy.cluster: Algoritmos para clustering (agrupamiento) de datos.

scipy.constants: Constantes físicas y matemáticas.

scipy.fftpack: Transformada rápida de Fourier.

scipy.integrate: Rutinas de integración numérica.

scipy.interpolate: Interpolación de datos y construcción de splines.

scipy.io: Herramientas para la entrada y salida de datos.

scipy.linalg: Álgebra lineal.

scipy.ndimage: Procesamiento de imágenes n-dimensionales.

scipy.odr: Regresión ortogonal.

scipy.optimize: Optimización de funciones.

scipy.signal: Procesamiento de señales.
-------------------------------------------------------------

scipy.sparse: Estructuras de datos y algoritmos para matrices dispersas.

scipy.spatial: Estructuras y algoritmos espaciales.

scipy.special: Funciones matemáticas especiales.

scipy.stats: Estadísticas y distribuciones de probabilidad.


En nuestro caso que nos aplica, nos fijaremos en El módulo scipy.signal, que proporciona una función llamada convolve que se utiliza para realizar convoluciones entre dos secuencias. La convolución es una operación matemática que combina dos conjuntos de datos para producir un tercer conjunto de datos. En el contexto de procesamiento de señales, la convolución se utiliza, por ejemplo, para suavizar señales, encontrar la respuesta de un sistema a una entrada, o para aplicar filtros.

En la actualidad SciPy sigue siendo una biblioteca muy utilizada en la comunidad científica y de ingeniería en Python. Proporciona herramientas esenciales para tareas relacionadas con la computación científica, como álgebra lineal, optimización, procesamiento de señales, interpolación, integración numérica, estadísticas y más.

La biblioteca SciPy se mantiene y actualiza regularmente para incluir nuevas funcionalidades, mejoras de rendimiento y correcciones de errores. Es una parte integral del ecosistema científico de Python junto con NumPy, Matplotlib y otras bibliotecas relacionadas.

Este es un programa en el que inicialmente pide que indiques el dinero que llevas. A continuación empieza el proceso de creación de la pizza. Finalmente indica si te llega o no el dinero, y, en caso de que te llegue, indica el total a devolver.