Historial de los últimos códigos añadidos

Listado de los últimos códigos introducidos.
Imágen de perfil
Actualizado

Generador de gifs a partir de video, en línea de comandos.


Python

estrellaestrellaestrellaestrellaestrella(4)
Actualizado el 9 de Diciembre del 2023 por Antonio (74 códigos) (Publicado el 9 de Diciembre del 2022)
6.491 visualizaciones desde el 9 de Diciembre del 2022
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.

mk
sin imagen de perfil

PHP inico


PHP

Publicado el 8 de Diciembre del 2023 por Angel
60 visualizaciones desde el 8 de Diciembre del 2023
<?php

// Función para leer los datos del grupo
function leerDatosGrupo() {
$analistas = (int) readline("Ingrese la cantidad de analistas en el grupo: ");
$coordinadores = (int) readline("Ingrese la cantidad de coordinadores en el grupo: ");
$casosPorDia = (int) readline("Ingrese la cantidad promedio de casos que llegan por día: ");

return array(
"analistas" => $analistas,
"coordinadores" => $coordinadores,
"casosPorDia" => $casosPorDia
);
}

// Función para calcular la distribución de los casos
function calcularDistribucionCasos($grupo, $casosPorDia) {
$casosPorAnalista = $casosPorDia / $grupo['analistas'];

echo "Cada analista deberá atender en promedio " . $casosPorAnalista . " casos por día." . PHP_EOL;
}

// Función para asignar los casos a cada analista
function asignarCasos($grupo, $casosPorDia) {
$casosPorAnalista = $casosPorDia / $grupo['analistas'];

$primerAnalistaCasos = floor($casosPorAnalista); // Tomar los casos enteros
$segundoAnalistaCasos = $casosPorAnalista - $primerAnalistaCasos; // Tomar los casos restantes

echo "El primer analista tomará " . $primerAnalistaCasos . " casos." . PHP_EOL;
echo "El segundo analista tomará " . $segundoAnalistaCasos . " casos." . PHP_EOL;
}

$grupo = leerDatosGrupo();
calcularDistribucionCasos($grupo, $grupo['casosPorDia']);
asignarCasos($grupo, $grupo['casosPorDia']);

?>
Imágen de perfil
Actualizado

Reproductor de música.


Python

Actualizado el 8 de Diciembre del 2023 por Antonio (74 códigos) (Publicado el 20 de Abril del 2021)
20.680 visualizaciones desde el 20 de Abril del 2021
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.
mp
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 8 de Diciembre del 2023 por Antonio (74 códigos) (Publicado el 20 de Marzo del 2023)
3.835 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

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(5)
Actualizado el 8 de Diciembre del 2023 por Rafael (22 códigos) (Publicado el 21 de Diciembre del 2022)
8.742 visualizaciones desde el 21 de Diciembre del 2022
Cx es un programa para Windows.
Sirve para gestionar la contabilidad.
Produce: libro diario, auxiliar,
balanzas, recapitulación, estados financieros,
balance general, estado de pérdidas y ganancias,
estado de resultados y estados de cuentas.
Servosistema que administra
la oficina sin papeles.
Multiusuario cliente/servidor, red inalámbrica.
Código abierto. Trabajo a distancia.
Adjunto Cx Guía del rey de la creación

Sin-titulo
Imágen de perfil

Binarizar imagen


Python

Publicado el 7 de Diciembre del 2023 por Hilario (95 códigos)
76 visualizaciones desde el 7 de Diciembre del 2023
En Python, el módulo pickle proporciona una forma de serializar y deserializar objetos. La serialización es el proceso de convertir un objeto en una secuencia de bytes, mientras que la deserialización es la reconstrucción del objeto a partir de esa secuencia de bytes. El propósito principal de pickle es facilitar el almacenamiento y recuperación de objetos complejos, como estructuras de datos, clases y otros objetos de Python.

El uso típico de pickle es para guardar objetos Python en archivos y luego recuperarlos más tarde. Sin embargo, debes tener precaución al usar pickle con datos no confiables o no seguros, ya que la deserialización de datos no confiables puede ser un riesgo de seguridad. No debes cargar archivos pickle de fuentes no confiables o desconocidas.

Alternativamente, si estás trabajando solo con datos simples y no necesitas interoperabilidad con otros lenguajes, podrías considerar otros formatos de serialización más seguros y eficientes, como JSON, que son humanamente legibles y no ejecutan código durante la deserialización.
Imágen de perfil

ButtonOn-Off


Visual Basic

Publicado el 5 de Diciembre del 2023 por Leonardo
88 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 (74 códigos) (Publicado el 24 de Mayo del 2021)
11.717 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

Vista 'grid' (demo)


Python

Actualizado el 19 de Noviembre del 2023 por Antonio (74 códigos) (Publicado el 31 de Julio del 2023)
861 visualizaciones desde el 31 de Julio del 2023
El siguiente código muestra un grid en pantalla por el que se puede desplazar usando los botones de dirección:

Botón de dirección derecha: Desplazamiento hacia la derecha.
Botón de dirección izquierdo: Desplazamiento a la izquierda.
Botón de dirección superior: Desplazamiento hacia adelante.
Botón de dirección inferior: Desplazamiento hacia atrás.
Botones 'o', 'p', 'k' y 'l': Desplazamientos en diagonal.

grid
Imágen de perfil

El Ahorcado en Kotlin


Otros

Publicado el 19 de Noviembre del 2023 por Xcevhx
94 visualizaciones desde el 19 de Noviembre del 2023
El ahorcado o Hangman es un mini juego clásico en el cual se debe adivinar la palabra, desarrollado en lenguaje kotlin, a modo de practica, Obviamente es una primera versión, se puede mejorar, compartiré el codigo fuente que esta en mi GitHub por si quieren descargar el codigo y modificarlo a su gusto

ahorcado1
ahorcado2
ahorcado3

Codigo Fuente

https://github.com/x-cevh-x/ElAhorcadoKotlin
Imágen de perfil

Reproductor de música (nueva versión).


Python

Actualizado el 16 de Noviembre del 2023 por Antonio (74 códigos) (Publicado el 31 de Mayo del 2021)
8.175 visualizaciones desde el 31 de Mayo del 2021
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.
mpr
sin imagen de perfil

grafica1


Python

Publicado el 16 de Noviembre del 2023 por Johan
79 visualizaciones desde el 16 de Noviembre del 2023
import matplotlib.pyplot as plt
import numpy as np

n_values = np.arange(1, 301, 1)
a_values = (5 - 3 * n_values**2) / (1 - 2 * n_values**2)

plt.plot(n_values, a_values, label=r'$a_n = \frac{5-3n^2}{1-2n^2}$')
plt.xlabel('n')
plt.ylabel('a_n')
plt.title('Gráfico de la función $a_n$')
plt.legend()
plt.show()
Imágen de perfil

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


Python

estrellaestrellaestrellaestrellaestrella(5)
Actualizado el 15 de Noviembre del 2023 por Antonio (74 códigos) (Publicado el 8 de Junio del 2020)
10.684 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

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


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 15 de Noviembre del 2023 por Antonio (74 códigos) (Publicado el 4 de Noviembre del 2020)
5.550 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

Stock Monitor


Python

Actualizado el 15 de Noviembre del 2023 por Antonio (74 códigos) (Publicado el 22 de Octubre del 2023)
812 visualizaciones desde el 22 de Octubre del 2023
El siguiente script muestra en tiempo real las cotizaciones en bolsa, de acciones e índices bursátiles.
El programa utiliza un bucle en el que va realizando sucesivas peticiones de datos, usando 'yfinance'. Entre una petición y la siguiente, media un tiempo en segundos que viene determinado por la opción '-delay/--time_delay', teniendo un valor por defecto de 5 segundos y no pudiendo ser inferior a 0.5
Para detener la obtención de datos, pulsar la barra espaciadora. Al hacerlo, el programa mostrará el texto 'wait until application ends..' ya que tendrá que esperar el tiempo que quede restante del especificado por '-delay/--time_delay'. Finalizando definitivamente, transcurrido dicho tiempo restante.

ARGUMENTOS:
'-tick/--ticker' : Ticker o símbolo del valor cuya cotización se quiere obtener.
'-delay/--time_delay': Periodicidad, en segundos, entre una petición de datos y la siguiente.
'-clr/--color': Mostrar precio de cierre en color, en función de su fluctuación respecto del valor anterior.
'-uind/--use_index': Incluir esta opción para obtener cotizaciones de índices bursátiles (ej: ^IXIC, ^DJI..)

La petición de valores se interrumpe pulsando la barra espaciadora.
PARA CUALQUIER DUDA U OBSERVACIÓN, UTILICEN LA SECCIÓN DE COMENTARIOS.

sm1
sm2
sm3
Imágen de perfil

ChessPDFBrowser


Java

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 14 de Noviembre del 2023 por Francisco Javier Rojas Garrido (24 códigos) (Publicado el 22 de Noviembre del 2017)
11.363 visualizaciones desde el 22 de Noviembre del 2017
chessPDF

Aplicación de ajedrez que permite trabajar con las partidas de los libros de ajedrez en PDF (siempre que los libros no sean escaneados y las partidas estén escritas en formato algebraico).

La nueva versión (v1.26), también permite extraer partidas en notación algebraica de figuras

También permite trabajar con listas de partidas leídas/escritas en formato PGN, y modificar los TAGs, NAGs y comentarios.

Los árboles de variantes pueden se modificados realizando movimientos con las piezas situadas en un tablero.

Permite trabajar con partidas incompletas (es decir, que empiecen en un movimiento posterior al inicial)

- Multi-idioma
- Multi-precisión
- Modo oscuro
- Conexión con motores tipo UCI
- OCR que convierte imágenes con una posición en un tablero, en una cadena estándar FEN

Compatible con el JDK-17

Vídeo de demostración de la nueva funcionalidad (v1.26)
(entrenamiento del reconocedor de figuras para la extracción de partidas en notación algebraica de figuras)

https://frojasg1.com:8443/resource_counter/resourceCounter?operation=countAndForward&url=https%3A%2F%2Ffrojasg1.com%2Fdemos%2Faplicaciones%2FChessPdfBrowser%2Fv1.26.ES.02.extraer.partidas.notacion.algebraica.de.figuras.mp4%3Forigin%3Dlawebdelprogramador&origin=web
Imágen de perfil

Sencilla red neuronal. Repaso.


Python

Publicado el 11 de Noviembre del 2023 por Hilario (95 códigos)
201 visualizaciones desde el 11 de Noviembre del 2023
descarga
descarga-1

********************************************************************************************************************
Aula_18_B.py
******************************************************************************************************************
Se trata de una sencilla red neuronal, ya resuelta en otro ejercicio,
utilizando la librería keras. Ahora lo planteamos de nuevo, utilizando
solamente las librerias numpy y matplotlib.

Se trataba de una red neuronal con este esquema:

input_size = 1
hidden_layer1_size = 8
hidden_layer2_size = 8
output_size = 1


Una neurona de entrada, con dos capas ocultas intermedias de 8 neuronas
cada una, y 1 neurona de salida.

Los datos generales y sencillos de la idea son los siguientes:
Se trata de cinco hermanos que a los 30 años median lo siguiente:
Antonio 1,70 cm. Pedrito 1,75. Juanito 1,78 . Carlitos 1,69. Ignacio 1,87.
Ramón 1,79.
Hace 6 meses ha nacido Santiaguito.
Cuales son las previsiones de estatura
cuando también tenga 30 años. Haremos graficas de salida de columnas.
También haremos gráficas de costos MSE, con salida imprimida por consola
de los valores de los mismos por cada iteración.
También se imprime en la salida la previsión que hace la red neuronal
de la estatura futura

Los hiperparámetros que adoptamos, son los siguientes:
learning_rate = 0.01
epochs = 40

Se puede jugar con los mismos con el fin de afinar los
resultados.
*************************************************************
Este ejercicio ha sido realizado en una plataforma Linux.
Ubuntu 20.04.6 LTS.
Se utiliza el editor Sublime text
*********************************************************
Ejecucion bajo consola linux con el comando:
python3 Aula_18_B.py
sin imagen de perfil

index


HTML

Publicado el 7 de Noviembre del 2023 por Anthony David
215 visualizaciones desde el 7 de Noviembre del 2023
Formulario de Registro basico
Imágen de perfil

Clasificación_Datos_por_Regresión Logística


Python

Publicado el 30 de Octubre del 2023 por Hilario (95 códigos)
218 visualizaciones desde el 30 de Octubre del 2023
Presentamos para nuestra aula, un sencillo ejercicio propuesto, para clasificar una serie de datos sintéticos, utilizando el sistema de regresión logística.
El ejercicio, es el siguiente:
Ejercicio_Clas_Regre_Log-Aula-28.py

La clasificación de datos por regresión logística es una técnica de aprendizaje automático que se utiliza para predecir la pertenencia de un conjunto de datos a una o más clases. Aunque el nombre "regresión" logística incluye la palabra "regresión", este enfoque se utiliza para problemas de clasificación en lugar de regresión.

La regresión logística se emplea cuando se desea predecir la probabilidad de que una observación pertenezca a una categoría o clase específica, generalmente dentro de un conjunto discreto de clases. Por lo tanto, es una técnica de clasificación que se utiliza en problemas de clasificación binaria (dos clases) y clasificación multiclase (más de dos clases). Por ejemplo, se puede usar para predecir si un correo electrónico es spam (clase positiva) o no spam (clase negativa) o para clasificar imágenes en categorías como gatos, perros o pájaros.

La regresión logística utiliza una función logística (también conocida como sigmoide) para modelar la probabilidad de pertenecer a una clase particular en función de variables de entrada (características). La función sigmoide tiene la propiedad de que produce valores entre 0 y 1, lo que es adecuado para representar probabilidades. El modelo de regresión logística utiliza coeficientes (pesos) para ponderar las características y calcular la probabilidad de pertenencia a una clase.

Durante el entrenamiento, el modelo busca ajustar los coeficientes de manera que las probabilidades predichas se ajusten lo más cerca posible a las etiquetas reales de los datos de entrenamiento. Una vez que se ha entrenado el modelo, se puede utilizar para predecir la probabilidad de pertenencia a una clase para nuevos datos y tomar decisiones basadas en esas probabilidades, como establecer un umbral para la clasificación en una clase específica.
*************************************************************************************************************
Los pasos que realizamos en el ejercicio, son los siguientes:

1-Generamos datos sintéticos donde la clase se determina por la suma de las dos características.
2-Implementamos la regresión logística desde cero sin el uso de scikit-learn, incluyendo el cálculo de 3-gradientes y la actualización de pesos.
4-Dibujamos los datos de entrada en un gráfico, junto con la línea de decisión que separa las clases.


En resumen, la regresión logística es una técnica de clasificación que modela las probabilidades de pertenencia a clases utilizando la función sigmoide y es ampliamente utilizada en una variedad de aplicaciones de aprendizaje automático.
sin imagen de perfil

asc


Python

Publicado el 30 de Octubre del 2023 por Juan David
89 visualizaciones desde el 30 de Octubre del 2023
import matplotlib.pyplot as plt
from matplotlib_venn import venn2

# Conjunto de asistentes que conocen el primer lenguaje (A)
A = {1, 2, 3, 4, 5}

# Conjunto de asistentes que conocen el segundo lenguaje (B)
B = {3, 4, 5, 6, 7}

# Conjunto de asistentes que conocen exactamente dos lenguajes (C)
C = A.intersection(B)

# Crear el diagrama de Venn
venn_labels = {'100': len(A - B), '010': len(B - A), '110': len(C)}
venn2(subsets=(len(A - B), len(B - A), len(C)), set_labels=('Lenguaje 1', 'Lenguaje 2'))

# Mostrar el gráfico
plt.show()

# Imprimir la cantidad de asistentes que conocen exactamente dos lenguajes
print(f"Número de asistentes que conocen exactamente dos lenguajes: {len(C)}")
Imágen de perfil

Descenso de Gradiente Aula-28


Python

Publicado el 29 de Octubre del 2023 por Hilario (95 códigos)
168 visualizaciones desde el 29 de Octubre del 2023
[center]descarga

descarga-2

En este sencillo ejercicio:Descn_Mult_Momentun_Ejemp_Aula-28-Oct.py, tratamos de explicar como realizar un descenso de gradiente multiple, aplicando al mismo un momentum, para regular un descenso de gradiente , digamos, rápido de forma que el mismo no sea errático.

Una regresión múltiple es un tipo de análisis de regresión en el que se busca modelar la relación entre una variable de respuesta (dependiente) y múltiples variables predictoras (independientes o características). En otras palabras, en lugar de predecir una única variable de respuesta a partir de una única característica, se intenta predecir una variable de respuesta a partir de dos o más características. La regresión múltiple puede ser útil para comprender cómo varias características influyen en la variable de respuesta.

Cuando aplicas "momentum" a un algoritmo de regresión, normalmente estás utilizando una variante del descenso de gradiente llamada "descenso de gradiente con momentum." El momentum es una técnica que ayuda a acelerar la convergencia del algoritmo de descenso de gradiente, especialmente en problemas en los que el parámetro de costo es irregular, o tiene pendientes pronunciadas. En lugar de utilizar únicamente el gradiente instantáneo en cada iteración, el descenso de gradiente con momentum tiene en cuenta un promedio ponderado de los gradientes pasados, lo que le permite mantener una especie de "momentum" en la dirección de la convergencia.

A continuación, os proporcionaré un ejemplo de regresión múltiple con descenso de gradiente con momentum,y datos sintéticos en Python. En el mismo utilizamos, aparte de otras, la biblioteca NumPy para generar datos sintéticos, y aplicar el descenso de gradiente con momentum.

También se incluye en el ejercicio, una disposición de graficas, para hacerlo más didactico. El alunmno, podrá jugar, o experimentar con los parámetros iniciales e hiperparámetros, para seguir su evolución.

En resumen este es un ejercicio sencillo, que explicaremos en clase, paso a paso, para su comprensión. Como siempre utilizaremos en nuestros ordenadores la plataforma Linux, con Ubuntu 20. También realizaremos la práctica en Google Colab.
Imágen de perfil

Generador de contraseñas.


Python

estrellaestrellaestrellaestrellaestrella(3)
Actualizado el 27 de Octubre del 2023 por Antonio (74 códigos) (Publicado el 2 de Agosto del 2021)
8.398 visualizaciones desde el 2 de Agosto del 2021
Programa para generar contraseñas de forma aleatoria, de hasta 50 caracteres. Cuenta con un campo "LENGTH" para especificar la longitud de la contraseña, un campo "MIN LOWERCASE" para especificar el número mínimo de caracteres en minúsculas, un campo "MIN UPPERCASE" para el número mínimo de caracteres en mayúsculas y un campo "MIN NUMBERS" para especificar el número mínimo de caracteres numéricos.
PARA CUALQUIER DUDA U OBSERVACIÓN USEN LA SECCIÓN DE COMENTARIOS.
pg
Imágen de perfil

Ejercicio_Aula_23_Momentum


Python

Publicado el 26 de Octubre del 2023 por Hilario (95 códigos)
162 visualizaciones desde el 26 de Octubre del 2023
python3 Ejercicio_Aula_23_Momentum.py

Sencillo ejercicio sobre un descenso de gradiente con momento, (Gradient Descent with Momentum en inglés).
Se trata de aplicar este algoritmo a una funcion parabolica del tipo: f(x) = x^2 / 6.
Cuya derivada es:x**2 / 6.
El descenso de gradiente con momento es una variante del algoritmo de descenso de gradiente utilizado en la optimización y entrenamiento de modelos de aprendizaje automático, particularmente en el contexto de redes neuronales y problemas de optimización no convexos. Su objetivo es acelerar la convergencia del descenso de gradiente y ayudar a evitar quedarse atrapado en óptimos locales.

La principal diferencia entre el descenso de gradiente con momento y el descenso de gradiente estándar es la adición de un término de "momentum" o impulso. En el descenso de gradiente estándar, en cada iteración, el gradiente actual se utiliza directamente para actualizar los parámetros del modelo. En cambio, en el descenso de gradiente con momento, se mantiene un promedio ponderado exponencial de los gradientes anteriores y se utiliza ese promedio para actualizar los parámetros.

El objetivo del término de momento es suavizar las actualizaciones de los parámetros y reducir las oscilaciones que pueden ocurrir cuando el gradiente varía significativamente en diferentes direcciones. Esto puede ayudar a acelerar la convergencia y a sortear barreras o mínimos locales en la función de costo

En este sencillo ejercicio que propongo, en vez de utilizar datos sintéticos de caráctear aleatorio de entrada, lo vamos a aplicar a una función parabólica.


descarga
descarga-1
Imágen de perfil

Aplicación para ocultar información de texto en imágenes o fotografías (nueva versión).


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 25 de Octubre del 2023 por Antonio (74 códigos) (Publicado el 26 de Marzo del 2021)
11.620 visualizaciones desde el 26 de Marzo del 2021
Aplicación para codificar y decodificar mensajes de texto en imágenes.

La imagen se selecciona mediante el botón "SEARCH".
En el modo "Encode" el texto a ocultar se introduce en el espacio superior. (el programa generará un nuevo archivo de imagen cuyo nombre tendrá el prefijo "encoded_" delante del título del archivo original.
En el modo "Decode" el texto oculto se muestra en el espacio superior.

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

Repositorio en GitHub:
https://github.com/antonioam82/Steganography
Imágen de perfil

Repaso-Descen-Grad-Batch.


Python

Publicado el 24 de Octubre del 2023 por Hilario (95 códigos)
166 visualizaciones desde el 24 de Octubre del 2023
*****************************************************************************************************************
Repaso-Des-Gra-Batch-Aula-E.28-OCT-24.py
******************************************************************************************************************
Realizar un descenso de gradiente tipo Batch, en código python, desde el punto x=8.03, y=5.846. De la funcion f(x)=x**2/x+3. Cuya derivada es: f'(x)=x+3. Se incluye grafica de costos MSE, y grafica de la parábola, con los valores del descenso, marcado en puntos sobre la misma.
Imágen de perfil

Descenso de gradiente tipo Adam.


Python

Publicado el 19 de Octubre del 2023 por Hilario (95 códigos)
269 visualizaciones desde el 19 de Octubre del 2023
El descenso de gradiente tipo Adam, o simplemente Adam (por Adaptive Moment Estimation), es un algoritmo de optimización utilizado en el campo del aprendizaje automático y la inteligencia artificial para ajustar los parámetros de un modelo de manera que se minimice una función de pérdida. Adam es una variante del descenso de gradiente estocástico (SGD) que combina técnicas de otros algoritmos de optimización para mejorar la convergencia y la eficiencia en la búsqueda de los mejores parámetros del modelo.

Aquí hay una explicación simplificada de cómo funciona el algoritmo Adam:

Inicialización de parámetros: Se inician los parámetros del algoritmo, como la tasa de aprendizaje (learning rate), los momentos de primer y segundo orden, y se establece un contador de iteraciones.

Cálculo del gradiente: En cada iteración, se calcula el gradiente de la función de pérdida con respecto a los parámetros del modelo. Esto indica en qué dirección deben ajustarse los parámetros para reducir la pérdida.

Cálculo de momentos de primer y segundo orden: Adam mantiene dos momentos acumulativos, uno de primer orden (media móvil de los gradientes) y otro de segundo orden (media móvil de los gradientes al cuadrado).

Actualización de parámetros: Se utilizan los momentos calculados en el paso anterior para ajustar los parámetros del modelo. Esto incluye un término de corrección de sesgo para tener en cuenta el hecho de que los momentos se inicializan en cero. La tasa de aprendizaje también se aplica en esta etapa.

Iteración y repetición: Los pasos 2-4 se repiten durante un número especificado de iteraciones o hasta que se cumpla un criterio de parada, como la convergencia.

Adam se considera una elección popular para la optimización de modelos de aprendizaje profundo debido a su capacidad para adaptar la tasa de aprendizaje a medida que se entrena el modelo, lo que lo hace efectivo en una variedad de aplicaciones y evita problemas como la convergencia lenta o la divergencia en el entrenamiento de redes neuronales. Sin embargo, es importante ajustar adecuadamente los hiperparámetros de Adam, como la tasa de aprendizaje y los momentos, para obtener un rendimiento óptimo en un problema específico.
Imágen de perfil

Descenso Gradiente tipo Nesterov


Python

Publicado el 18 de Octubre del 2023 por Hilario (95 códigos)
109 visualizaciones desde el 18 de Octubre del 2023
Sencillo ejemplo de un descenso de gradiente del tipo Nesterov.

Descen_Grad_Nesterov_Aula_B_28_18_OCT_github.py
----------------------------------------------------------------------------------------------------

El descenso de gradiente tipo Nesterov, también conocido como el "descenso de gradiente acelerado de Nesterov" o "NAG" por sus siglas en inglés (Nesterov Accelerated Gradient Descent), es una variante del algoritmo de optimización de descenso de gradiente utilizado en el entrenamiento de redes neuronales y en la optimización de funciones en el aprendizaje automático.

Fue propuesto por Yurii Nesterov en 1983 y es una mejora con respecto al descenso de gradiente estándar, especialmente en términos de velocidad de convergencia. El descenso de gradiente Nesterov se diferencia del descenso de gradiente tradicional en cómo se actualizan los parámetros del modelo.

En el descenso de gradiente Nesterov, en lugar de calcular el gradiente de la función de costo en la posición actual de los parámetros, se calcula el gradiente en una posición ligeramente adelantada de los parámetros. Luego, se utiliza ese gradiente para realizar la actualización de los parámetros. Esto tiene el efecto de "mirar hacia adelante" antes de dar el paso de actualización, lo que puede ayudar a reducir la oscilación y mejorar la velocidad de convergencia.

La fórmula para la actualización de los parámetros en el descenso de gradiente tipo Nesterov es la siguiente:

v = γ * v - η * ∇J(θ - γ * v)
θ = θ + v


Donde:

θ son los parámetros del modelo.
∇J(θ - γ * v) es el gradiente de la función de costo evaluado en la posición adelantada de los parámetros.
v es una especie de "momentum" que acumula la velocidad de los pasos anteriores.
η es la tasa de aprendizaje.
γ es un hiperparámetro que controla la influencia del momentum en la actualización.
En resumen, el descenso de gradiente tipo Nesterov es una técnica de optimización que tiene la ventaja de converger más rápidamente que el descenso de gradiente estándar, lo que lo hace especialmente útil en el entrenamiento de redes neuronales profundas y otros problemas de optimización en el aprendizaje automático.



Imágen de perfil

Clasificacion de Datos Arboles de Decision


Python

Publicado el 17 de Octubre del 2023 por Hilario (95 códigos)
160 visualizaciones desde el 17 de Octubre del 2023
CuadernoAula-B-28-OCT-18.py
-----------------------------------------------------------------------------
La clasificación de datos mediante árboles de decisiones es un método de aprendizaje automático que se utiliza para categorizar o etiquetar datos en diferentes clases o categorías. Es una técnica de modelado predictivo que se basa en la creación de un "árbol" de decisiones, donde cada nodo interno del árbol representa una pregunta o una prueba sobre una característica específica de los datos, y las ramas que salen de ese nodo conducen a diferentes resultados o decisiones basadas en el valor de esa característica. Los nodos hoja del árbol representan las categorías o clases en las que se divide el conjunto de datos.

El proceso de clasificación a través de árboles de decisión implica:

Construcción del árbol: Se inicia con un nodo raíz que representa todo el conjunto de datos. Luego, se selecciona una característica y un umbral que se utilizará para dividir los datos en dos subconjuntos. Este proceso se repite recursivamente en cada subconjunto hasta que se alcanza un criterio de parada, como un tamaño máximo de profundidad del árbol, una cantidad mínima de muestras en los nodos hoja, o una impureza mínima.

Selección de características: En cada paso de división, se elige la característica que mejor separa los datos, lo que se logra al minimizar alguna métrica de impureza, como el índice de Gini o la entropía. La característica y el umbral que minimizan la impureza se utilizan para dividir los datos en dos ramas.

Predicción: Una vez construido el árbol, se utiliza para hacer predicciones sobre datos nuevos. Los datos nuevos se introducen en el árbol, siguiendo las ramas que corresponden a las características de esos datos, hasta llegar a un nodo hoja que representa la clase predicha.

Los árboles de decisión son atractivos porque son interpretables y fáciles de visualizar. Sin embargo, pueden ser propensos al sobreajuste (overfitting), especialmente si se construyen árboles muy profundos. Para abordar este problema, se pueden utilizar técnicas como la poda (pruning) o el uso de bosques aleatorios (random forests) que combinan múltiples árboles para mejorar la precisión y reducir el sobreajuste.

En resumen, la clasificación de datos mediante árboles de decisión es una técnica poderosa y ampliamente utilizada en aprendizaje automático para tareas de clasificación, donde el objetivo es predecir la categoría o clase a la que pertenecen los datos de entrada en función de sus características.