Mostrar los tags: mi

Mostrando del 1 al 10 de 262 coincidencias
<<>>
Se ha buscado por el tag: mi
Imágen de perfil
Actualizado

Suavizado de imagen en archivos de vídeo por 'Filtrado bilateral', (aplicación en línea de comandos)


Python

Actualizado el 6 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 20 de Marzo del 2023)
6.566 visualizaciones desde el 20 de Marzo del 2023
Programa para realizar filtrado de imagen en archivos de vídeo (preferiblemente de corta duración) utilizando el algoritmo de 'filtrado bilateral' pudiendo especificar los valores sigma de espacio y color y el diámetro del vecindario para cada pixel. Los vídeos filtrados se generan, por defecto, conservando su sonido, aunque se pueden generar sin este introduciendo el argumento '-ae'/'--exclude_audio'.

ARGUMENTOS:
-src/--source: Nombre del vídeo original (OBLIGATORIO)
-dest/--destination: Nombre del video a generar ('NewFilteredVid.mp4' por defecto)
-sgc/--sigma_color: Valor sigma para espacio de color (75 por defecto)
-sgs/--sigma_space: Valor sigma espacial (75 por defecto)
-pd/--pixel_diameter: Diámetro de la vecindad de píxeles (9 por defecto)
-ae/--exclude_audio: Excluir audio y generar video sin sonido (OPCIONAL)

PARA CUALQUIER DUDA U OBSERVACIÓN UTILIZEN LA SECCIÓN DE COMENTARIOS
bvf
bvf2
bvf3
bvf4
Imágen de perfil
Actualizado

Generador de gifs a partir de video (nueva version)


Python

Actualizado el 5 de Mayo del 2024 por Antonio (76 códigos) (Publicado el 29 de Enero del 2024)
1.076 visualizaciones desde el 29 de Enero del 2024
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.

imagge
Imágen de perfil

Juego de la Serpiente (en ASCII)


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 12 de Abril del 2024 por Antonio (76 códigos) (Publicado el 30 de Marzo del 2020)
6.853 visualizaciones desde el 30 de Marzo del 2020
Versión, con caracteres ASCII del popular "Juego de la Serpiente" que incorpora una pantalla de opciones. El control de la serpiente se efectúa mediante las teclas de dirección del teclado. También puede pausarse la partida, presionando la barra espaciadora y una función para salir de partida, mediante la tecla "q".
sg4
sg7
sng
Imágen de perfil

Evaluación con datos MINIST.


Python

Publicado el 10 de Marzo del 2024 por Hilario (124 códigos)
273 visualizaciones desde el 10 de Marzo del 2024
NÚMERO A PREDECIR.
--------------------------------
numero

*******************************************************************************************************************
Evaluamos como aprendizaje este ejercicio: Aula_18_Evaluar_CNN_Datos_Minist.py.
Este ejercicio propuesto está entrenado con datos MINIST.
Con el fin de que el Alunno, pueda apreciar la configuracion, y la estructura de datos,
guardamos el módulo entrenado en nuestro ordenador, en formato directorio, con el nombre :
MI-MODULO-MINIST


MNIST se refiere a un conjunto de datos muy utilizado
en el ámbito de la visión por computadora y el aprendizaje profundo.

El conjunto de datos MNIST consiste en imágenes de dígitos escritos
a mano, del 0 al 9. Cada imagen es en escala de grises y tiene un
tamaño de 28x28 píxeles. El conjunto está dividido en un conjunto
de entrenamiento y un conjunto de prueba, y se utiliza comúnmente
como punto de partida para probar algoritmos y modelos de aprendizaje
automático, especialmente en el contexto de reconocimiento de dígitos.

En nuestro código, estamos utilizando el conjunto de datos MNIST
proporcionado por TensorFlow para entrenar y evaluar tu red neuronal
convolucional (CNN) en el reconocimiento de estos dígitos manuscritos.

Como podemos apreciar, la evaluación del ejercicio, no es del todo positiva.
El alumno puede modificarlo para intentar ajustarlo.

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

El ejercicio propuesto podríamos describirlo, por pasos de la siguiente
forma:

Importaciones de Bibliotecas:
********************************

Se importa TensorFlow, una biblioteca popular para aprendizaje profundo y otras tareas de machine learning.
Se importan clases y funciones específicas de TensorFlow, como Dense, Flatten, Conv2D, Model, y otras necesarias para construir y entrenar modelos de redes neuronales.
Carga de Datos MNIST:

Utiliza TensorFlow para cargar el conjunto de datos MNIST, que consiste en imágenes de dígitos escritos a mano y sus respectivas etiquetas de clase (números del 0 al 9).
Normaliza las imágenes dividiendo los valores de píxeles por 255.0.

Preparación de Datos:
************************
Añade una dimensión extra a las imágenes para representar los canales de color (en este caso, escala de grises).
Crea conjuntos de datos (train_ds y test_ds) usando TensorFlow Dataset API para facilitar el manejo y la alimentación de datos durante el entrenamiento y prueba.

Definimos el Modelo:
***********************
Define una clase MyModel que hereda de la clase Model. Esta clase representa el modelo de la red neuronal convolucional (CNN) que se construirá.
En el constructor (__init__), se definen capas de convolución, aplanado (flatten), y capas densas.
En el método call, se define la secuencia de operaciones para la propagación hacia adelante.

Configuración de Entrenamiento:
************************************
Define funciones de pérdida, optimizador y métricas para la fase de entrenamiento.
Define funciones train_step y test_step utilizando decoradores de TensorFlow (@tf.function) para ejecutar estas funciones de manera eficiente en modo gráfico.

Bucle de Entrenamiento:
***************************
Itera a través de un número de épocas predefinido (EPOCHS).
En cada época, realiza un bucle de entrenamiento y otro de prueba.
Muestra métricas como pérdida y precisión durante el entrenamiento y la prueba.

Guardamos del Modelo:
*******************
Guarda el modelo entrenado en un directorio especificado.

Carga de Imagen para Predicción:
*******************************
Intenta cargar una imagen (numero.jpg) para realizar una predicción utilizando el modelo entrenado.
Se produce un error debido a que el archivo no se encuentra en la ubicación especificada.

Impresión de Resultados:
*****************************
Imprime el número predicho y el porcentaje de precisión para la clase predicha.

****************************************************************************
SALIDA POR CONSOLA, SIN ACIERTO.

****************************************************************************
SALIDA POR CONSOLA, SIN ACIERTO.

TensorFlow version: 2.13.1
Por favor, ESPERA A REALIZAR LAS 10 EPOCHS
Epoch 1, Loss: 0.13401952385902405, Accuracy: 95.94000244140625, Test Loss: 0.06022726744413376, Test Accuracy: 98.1500015258789
Epoch 2, Loss: 0.04087728634476662, Accuracy: 98.68333435058594, Test Loss: 0.055624209344387054, Test Accuracy: 98.18999481201172
Epoch 3, Loss: 0.02175530232489109, Accuracy: 99.288330078125, Test Loss: 0.05986746773123741, Test Accuracy: 98.12999725341797
Epoch 4, Loss: 0.013109182007610798, Accuracy: 99.57167053222656, Test Loss: 0.05405193939805031, Test Accuracy: 98.32999420166016
Epoch 5, Loss: 0.008494390174746513, Accuracy: 99.70832824707031, Test Loss: 0.06368830800056458, Test Accuracy: 98.44999694824219
Epoch 6, Loss: 0.008195172995328903, Accuracy: 99.7249984741211, Test Loss: 0.07445775717496872, Test Accuracy: 98.33999633789062
Epoch 7, Loss: 0.005741223692893982, Accuracy: 99.8066635131836, Test Loss: 0.07288998365402222, Test Accuracy: 98.38999938964844
Epoch 8, Loss: 0.003435570513829589, Accuracy: 99.8933334350586, Test Loss: 0.08180861920118332, Test Accuracy: 98.32999420166016
Epoch 9, Loss: 0.0059661963023245335, Accuracy: 99.80500030517578, Test Loss: 0.0844760537147522, Test Accuracy: 98.25999450683594
Epoch 10, Loss: 0.002849259879440069, Accuracy: 99.90166473388672, Test Loss: 0.08755964040756226, Test Accuracy: 98.3499984741211
Salvamos MI-MODULO-MINIST
1/1 [==============================] - 0s 49ms/step
Número predicho: 3 <-------------------En esta predicción hemos tenido éxito.
Porcentaje de precisión: 39.92%

************************************************************
-------------------------------------------------------------------
Este ejercicio ha sido realizado bajo una plataforma Linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime text.

El alumno, deberá tener cargadas las librerias necesarias en el sistema.
import tensorflow as tf
from tensorflow.keras.models import load_model
from tensorflow.keras.preprocessing import image
import numpy as np

------------------------------------------------------------
Ejecución bajo consola Linux.
python3 Aula_18_Evaluar_CNN_Datos_Minist.py
Imágen de perfil

Juego de la Serpiente, en ASCII (versión con sonido)


Python

estrellaestrellaestrellaestrellaestrella(5)
Actualizado el 22 de Enero del 2024 por Antonio (76 códigos) (Publicado el 8 de Junio del 2020)
11.145 visualizaciones desde el 8 de Junio del 2020
Nueva versión del Juego de la Serpiente, en la que se ha incluido sonido y 3 archivos de audio (incluidos en la carpeta). Para usar el programa adecuadamente, simplemente hay que descomprimir la carpeta en la que se encuentra.
BOTONES:
Mover serpiente: Botónes de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.
sgm
sg6
sg4
ggggg
Imágen de perfil

ButtonOn-Off


Visual Basic

Publicado el 5 de Diciembre del 2023 por Leonardo
430 visualizaciones desde el 5 de Diciembre del 2023
Les traigo un OCX simple, que les servirá para representar el típico estado On-Off.

Button-OnOff-OCX

Reacciona al hacer un Click sobre el elemento, llamando al Evento Change. Desde ahí capturan el valor (TRUE ó FALSE) y realizar la acción que quieran de acuerdo a éso.

Les adjunto el código fuente, junto al OCX compilado. Espero les sea de utilidad.
Imágen de perfil

Programa para aplicación de filtros, en archivos de vídeo.


Python

estrellaestrellaestrellaestrellaestrella(4)
Actualizado el 20 de Noviembre del 2023 por Antonio (76 códigos) (Publicado el 24 de Mayo del 2021)
12.136 visualizaciones desde el 24 de Mayo del 2021
El presente programa se encarga de aplicar filtros sobre los fotogramas de un archivo de video empleando diferentes funciones. El programa realiza el filtrado frame a frame para a continuación generar un nuevo video con la secuencia de frames procesados (aplicando el frame rate del vídeo original). También usa el software "ffmpeg" para copiar el audio del vídeo original y añadirlo al vídeo resultante.

USO: Primeramente seleccionaremos el vídeo a filtrar mediante el botón "SEARCH". Una vez seleccionado iniciaremos el proceso con "START FILTERING" con el que empezaremos seleccionando la ubicación del nuevo vídeo, para a continuación iniciar el proceso (NOTA: La ruta del directorio de destino no deberá contener espacios en blanco). El proceso de filtrado podrá ser cancelado medinate el botón "CANCEL".
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.

vf
Imágen de perfil

Juego de la Serpiente, en ASCII (versión nueva)


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 15 de Noviembre del 2023 por Antonio (76 códigos) (Publicado el 4 de Noviembre del 2020)
5.904 visualizaciones desde el 4 de Noviembre del 2020
Nueva versión del juego de la serpiente con caracteres ASCII. Esta versión se diferencia de las dos anteriores (que pueden verse en mi lista de códigos) en que se acompaña de un archivo (de nombre "hiScore") que irá almacenando de modo permanente, la puntuación máxima alcanzada por el jugador.

BOTONES:
Mover serpiente: Botones de dirección
Pause y reanudar partida pausada : Barra espaciadora.
Finalizar partida en curso: tecla "q"
PARA CUALQUIER PROBLEMA, NO DUDEN EN COMUNICÁRMELO.

5ede3abe2db24-sg4
5ee33cfe068e9-sgm
sms
Imágen de perfil

MiniBatch-Datos-Aleatorios


Python

Publicado el 20 de Septiembre del 2023 por Hilario (124 códigos)
395 visualizaciones desde el 20 de Septiembre del 2023
MiniBatch_Aula-228-G.py


El ejercicio se configura y ejecuta con parámetros mínimos con el fin de
que las salidas impresas por consola no sean grandes. Se puede jugar con estos
valores:
np.random.seed(0)
X = 2 * np.random.rand(20, 1)
y = 4 + 3 * X + np.random.randn(20, 1)
learning_rate = 0.1
batch_size = 10
epochs = 10


***************************************************************************************************************
El descenso de gradiente Mini-Batch es una técnica de optimización ampliamente utilizada en el aprendizaje automático y la optimización numérica. Permite entrenar modelos de manera eficiente al actualizar los pesos del modelo en función de un subconjunto (mini-lote o mini-batch) de datos de entrenamiento en lugar de utilizar el conjunto de datos completo en cada iteración. Además, en algunos casos, se introducen elementos de aleatoriedad en la selección de estos mini-lotes para mejorar la convergencia y evitar que el algoritmo quede atrapado en mínimos locales.

Aquí hay un resumen de cómo funciona el descenso de gradiente Mini-Batch con entrada de datos aleatorios:

División del conjunto de datos: En lugar de usar todo el conjunto de datos de entrenamiento en cada iteración (como se hace en el descenso de gradiente por lotes), el conjunto de datos se divide en mini-lotes más pequeños. La elección del tamaño del mini-lote es un hiperparámetro importante que debe ajustarse según las características de los datos y el modelo.

Aleatorización de los datos: Para introducir aleatoriedad, el conjunto de datos se suele barajar (mezclar) al comienzo de cada época (una época se completa después de que el modelo haya visto todos los mini-lotes). Esto evita que el modelo se ajuste a patrones específicos del orden en que se presentan los datos y mejora la generalización.

Iteración: El algoritmo recorre las épocas, y en cada época, se selecciona un mini-lote aleatorio de datos. Los pesos del modelo se actualizan en función del gradiente calculado utilizando solo los ejemplos en ese mini-lote. La actualización de los pesos se realiza de acuerdo con la dirección del gradiente descendente, como en el descenso de gradiente estándar.

Convergencia: El proceso se repite durante varias épocas hasta que el algoritmo alcance un criterio de convergencia predefinido (por ejemplo, una pérdida baja o un número máximo de épocas).

La aleatorización de los mini-lotes y la aleatorización de los datos en cada época ayudan a evitar que el descenso de gradiente Mini-Batch quede atrapado en mínimos locales y mejora la capacidad del algoritmo para generalizar a nuevos datos. También hace que el entrenamiento sea más eficiente en términos de tiempo y memoria en comparación con el descenso de gradiente por lotes.

El descenso de gradiente Mini-Batch es especialmente útil cuando se trabaja con grandes conjuntos de datos que no caben en la memoria, ya que permite entrenar modelos de manera más rápida y escalable utilizando recursos computacionales limitados.
Imágen de perfil

Mini Batch. Descenso de gradiente.


Python

Publicado el 19 de Septiembre del 2023 por Hilario (124 códigos)
532 visualizaciones desde el 19 de Septiembre del 2023
Descenso de gradiente Mini Batch.
********************************
MiniBatch-Aula_228-B.py

******************************************************************************************
El descenso de gradiente mini batch, también conocido como Mini Batch Gradient Descent, es una variante del algoritmo de optimización del descenso de gradiente utilizado en el aprendizaje automático y la optimización de modelos de redes neuronales. A diferencia del descenso de gradiente estocástico (SGD) y el descenso de gradiente por lotes (Batch Gradient Descent), el descenso de gradiente mini batch combina características de ambos enfoques.

En el descenso de gradiente mini batch, los datos de entrenamiento se dividen en lotes más pequeños, cada uno de los cuales se utiliza para calcular una actualización parcial de los pesos del modelo. Estos lotes más pequeños se llaman "mini lotes". La idea detrás de esta técnica es encontrar un equilibrio entre la eficiencia de la actualización de parámetros y la variabilidad de las actualizaciones en comparación con el SGD y el Batch Gradient Descent.

Aquí hay una descripción paso a paso del proceso del descenso de gradiente mini batch:

División de los datos: Los datos de entrenamiento se dividen en mini lotes de tamaño fijo. El tamaño del mini lote es un hiperparámetro que se puede ajustar según las necesidades del problema. Por lo general, los tamaños de mini lotes varían desde 16 hasta 256 ejemplos, pero esto puede variar según el conjunto de datos y la arquitectura de la red.

Inicialización de pesos: Se inicializan los pesos del modelo de manera aleatoria o utilizando algún método de inicialización específico.

Cálculo del gradiente: Para cada mini lote, se calcula el gradiente de la función de pérdida con respecto a los pesos del modelo utilizando solo los ejemplos en ese mini lote. Esto se hace utilizando retropropagación (backpropagation).

Actualización de pesos: Los pesos del modelo se actualizan utilizando el gradiente calculado. La fórmula de actualización es similar a la del descenso de gradiente estocástico, pero en lugar de utilizar un solo ejemplo, se promedian los gradientes de todos los ejemplos en el mini lote. Esto suaviza las actualizaciones y reduce la variabilidad en comparación con el SGD.

Iteración: Se repiten los pasos 3 y 4 para cada mini lote. Este proceso se repite a lo largo de múltiples épocas hasta que se alcance un criterio de parada, como un número máximo de épocas o una convergencia satisfactoria.

Ventajas del descenso de gradiente mini batch:

Mayor eficiencia computacional en comparación con el Batch Gradient Descent, ya que se aprovecha el paralelismo en las operaciones matriciales.
Menor variabilidad en las actualizaciones de peso en comparación con el SGD, lo que puede llevar a una convergencia más rápida y estable.
El descenso de gradiente mini batch es una elección común para entrenar modelos de redes neuronales en la práctica, ya que combina las ventajas de SGD y Batch Gradient Descent. El tamaño del mini lote es un hiperparámetro crítico que debe ajustarse según el problema y la memoria disponible.