Historial de los últimos códigos añadidos

Listado de los últimos códigos introducidos.
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 28 de Septiembre del 2023 por Antonio (73 códigos) (Publicado el 20 de Marzo del 2023)
2.448 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

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


Python

estrellaestrellaestrellaestrellaestrella(1)
Actualizado el 27 de Septiembre del 2023 por Antonio (73 códigos) (Publicado el 26 de Marzo del 2021)
11.176 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

Vectores-Descenso de gradiente.


Python

Publicado el 27 de Septiembre del 2023 por Hilario (84 códigos)
50 visualizaciones desde el 27 de Septiembre del 2023
Vectores-27-Denso-Gradiente-AULA-G-86-SEP.py

Este código define una función cuadrática de ejemplo, inicia en un punto y realiza el descenso de gradiente para minimizar la función. Luego, grafica la superficie de la función y muestra la trayectoria del descenso de gradiente en 3D. A medida que el algoritmo de descenso de gradiente avanza, se acerca al mínimo de la función cuadrática.

Asegúrate de tener instaladas las bibliotecas NumPy y Matplotlib para ejecutar este código.
Imágen de perfil
Actualizado

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


Python

estrellaestrellaestrellaestrellaestrella(2)
Actualizado el 27 de Septiembre del 2023 por Antonio (73 códigos) (Publicado el 9 de Diciembre del 2022)
5.457 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
Imágen de perfil
Actualizado

Cx_Contabilidad Financiera


Visual Basic

estrellaestrellaestrellaestrellaestrella(5)
Actualizado el 27 de Septiembre del 2023 por Rafael (22 códigos) (Publicado el 21 de Diciembre del 2022)
5.228 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

Mini Batch


Python

Publicado el 26 de Septiembre del 2023 por Hilario (84 códigos)
50 visualizaciones desde el 26 de Septiembre del 2023
Cuaderno-Aula-B78-26-Sep-Rv-0.py

El Descenso de Gradiente Mini Batch (Mini Batch Gradient Descent en inglés) es una variante del algoritmo de Descenso de Gradiente que se utiliza comúnmente para entrenar modelos de aprendizaje automático, especialmente en problemas de optimización de grandes conjuntos de datos. El Descenso de Gradiente Mini Batch combina las ideas del Descenso de Gradiente Estocástico (SGD) y el Descenso de Gradiente por Lotes (Batch Gradient Descent).

Aquí están los conceptos clave del Descenso de Gradiente Mini Batch:

Descenso de Gradiente por Lotes (Batch Gradient Descent): En este enfoque, se calcula el gradiente de la función de pérdida utilizando todo el conjunto de datos de entrenamiento en cada iteración del algoritmo. Esto significa que se actualizan los parámetros del modelo una vez por ciclo completo a través del conjunto de datos. El enfoque Batch GD puede ser costoso en términos de memoria y tiempo de cómputo, especialmente para conjuntos de datos grandes.


Descenso de Gradiente Estocástico (SGD): En este enfoque, se calcula y actualiza el gradiente utilizando un solo ejemplo de entrenamiento en cada iteración. Esto conduce a actualizaciones de parámetros más frecuentes, pero a menudo más ruidosas y menos precisas. Aunque es más rápido y consume menos memoria que el enfoque por lotes, puede ser menos estable en la convergencia y requerir más iteraciones.

Descenso de Gradiente Mini Batch: En lugar de utilizar todo el conjunto de datos o un solo ejemplo de entrenamiento, el Descenso de Gradiente Mini Batch se encuentra en algún punto intermedio. Divide el conjunto de datos de entrenamiento en pequeños subconjuntos llamados mini lotes o mini-batches. Luego, en cada iteración, calcula y aplica las actualizaciones de gradiente utilizando uno de estos mini lotes en lugar del conjunto de datos completo o un solo ejemplo.

Las ventajas del Descenso de Gradiente Mini Batch incluyen:

Eficiencia computacional: Al utilizar mini lotes, se pueden aprovechar las ventajas del procesamiento paralelo y reducir la carga en la memoria, lo que lo hace más eficiente que el Descenso de Gradiente por Lotes en términos de tiempo y recursos.

Mayor estabilidad y convergencia: Comparado con SGD, el Descenso de Gradiente Mini Batch tiende a proporcionar actualizaciones de parámetros más estables y una convergencia más suave hacia el mínimo global de la función de pérdida.

Mejor generalización: En muchos casos, el Descenso de Gradiente Mini Batch puede conducir a modelos que generalizan mejor en comparación con SGD, ya que los mini lotes proporcionan un término medio entre el ruido de SGD y la lentitud de Batch GD.

El tamaño del mini lote es un hiperparámetro que debe ajustarse durante el entrenamiento del modelo. Suele ser un valor entre 16 y 256, pero puede variar según el problema y el conjunto de datos. El Descenso de Gradiente Mini Batch es una técnica muy comúnmente utilizada en el entrenamiento de redes neuronales y otros modelos de aprendizaje automático debido a su eficiencia y capacidad para encontrar mínimos globales de manera efectiva.
sin imagen de perfil

Flor


Basic

Publicado el 25 de Septiembre del 2023 por Omar
45 visualizaciones desde el 25 de Septiembre del 2023
Es una flor con programa phyton
Imágen de perfil

MiniBatch-Datos-Aleatorios


Python

Publicado el 20 de Septiembre del 2023 por Hilario (84 códigos)
101 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

Actualizado el 20 de Septiembre del 2023 por Hilario (84 códigos) (Publicado el 19 de Septiembre del 2023)
73 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.
Imágen de perfil

Estocástico-gradiente MSE.


Python

Publicado el 18 de Septiembre del 2023 por Hilario (84 códigos)
69 visualizaciones desde el 18 de Septiembre del 2023
[
]Estocastico-MSE-AULA-U856.py
************************************


El descenso de gradiente estocástico (SGD, por sus siglas en inglés, Stochastic Gradient Descent) es un algoritmo de optimización utilizado para entrenar modelos de aprendizaje automático, como regresiones lineales o redes neuronales, minimizando una función de costo, como el error cuadrático medio (MSE). El SGD es una variante del descenso de gradiente que utiliza un solo ejemplo de entrenamiento (o un pequeño grupo de ejemplos, conocido como mini-lote o minibatch) en cada paso de actualización en lugar de utilizar todo el conjunto de datos en cada paso.
Imágen de perfil

Historial de Costos. Descenso estocástico


Python

Publicado el 17 de Septiembre del 2023 por Hilario (84 códigos)
60 visualizaciones desde el 17 de Septiembre del 2023
Ejercicio sencillo para aprendizaje de un descenso de gradiente tipo estocástico.
----------------------------------------------------------------------------------------------------------
Descenso de Gradiente Estocástico (Stochastic Gradient Descent, SGD):

El descenso de gradiente estocástico es un enfoque de optimización en el que se actualizan los parámetros del modelo utilizando un solo ejemplo de entrenamiento o un pequeño subconjunto de ejemplos (mini-batch) en cada iteración.

En cada iteración, se selecciona aleatoriamente un ejemplo o un mini-batch para calcular el gradiente y actualizar los parámetros.

SGD es mucho más eficiente computacionalmente que el muestreo histórico de costos y es especialmente útil cuando se tienen grandes conjuntos de datos, ya que permite un entrenamiento más rápido y escalable.

En resumen, el muestreo histórico de costos utiliza todo el conjunto de datos en cada iteración, mientras que el descenso de gradiente estocástico utiliza un subconjunto aleatorio de datos en cada iteración. SGD tiende a ser más ruidoso debido a su aleatoriedad, pero puede converger a una solución aceptable en menos iteraciones. Ambos enfoques tienen sus ventajas y desventajas, y la elección entre ellos depende de las características del problema y los recursos computacionales disponibles. También existen variantes intermedias, como el Mini-batch Gradient Descent, que utilizan un tamaño de mini-batch moderado para combinar eficiencia y estabilidad en el entrenamiento de modelos.
Imágen de perfil

Generador de valores hash para contraseñas.


Python

Actualizado el 16 de Septiembre del 2023 por Antonio (73 códigos) (Publicado el 20 de Noviembre del 2022)
1.400 visualizaciones desde el 20 de Noviembre del 2022
El siguiente programa genera valores hash para una contraseña, utilizando distintos algoritmos. También permite la copia de las salidas generadas.
ph
Imágen de perfil

ESTOCÁSTICO


Python

Publicado el 15 de Septiembre del 2023 por Hilario (84 códigos)
84 visualizaciones desde el 15 de Septiembre del 2023
"""
Hilario Iglesias Martínez.
*****************************************
Ejercicio:
CuadernoEstocas-Aula-48-15-SEP-RV-2.py
-----------------------------------------
Ejecución:python3 CuadernoEstocas-Aula-48-15-SEP-RV-2.py
******************************************
Se prueba con los valores con pareamétros mínimos,
con el fin de apreciar su funcionamiento:

learning_rate = 0.01
n_iterations = 4
np.random.seed(0)
X = 2 * np.random.rand(4, 1)
y = 4 + 3 * X + np.random.randn(4, 1)

-------------------------------------------
Creado bajo plataforma Linux.
Ubuntu 20.04.6 LTS
Editado con Sublime Text.
Ejecutado bajo consola linux:
python3 CuadernoEstocas-Aula-48-15-SEP-RV-2.py

"""
Imágen de perfil

Descenso de Gradiente Estocástico (SGD)


Python

Publicado el 14 de Septiembre del 2023 por Hilario (84 códigos)
63 visualizaciones desde el 14 de Septiembre del 2023
Hilario Iglesias Marínez

*******************************************************************
Ejercicio:
Estocástico_Aula_F-890.py
Ejecucion bajo Consola Linux:
python3 Estocástico_Aula_F-890.py

******************************************************************
Diferencias.
El descenso de gradiente es un algoritmo de optimización utilizado comúnmente en el aprendizaje automático y la optimización de funciones. Hay dos variantes principales del descenso de gradiente: el descenso de gradiente tipo Batch (también conocido como descenso de gradiente por lotes) y el descenso de gradiente estocástico. Estas dos variantes difieren en la forma en que utilizan los datos de entrenamiento para actualizar los parámetros del modelo en cada iteración.

Descenso de Gradiente Tipo Batch:

En el descenso de gradiente tipo Batch, se utiliza el conjunto completo de datos de entrenamiento en cada iteración del algoritmo para calcular el gradiente de la función de costo con respecto a los parámetros del modelo.
El gradiente se calcula tomando el promedio de los gradientes de todas las muestras de entrenamiento.
Luego, se actualizan los parámetros del modelo utilizando este gradiente promedio.
El proceso se repite hasta que se alcanza una convergencia satisfactoria o se ejecuta un número predefinido de iteraciones.

Descenso de Gradiente Estocástico (SGD):

En el descenso de gradiente estocástico, en cada iteración se selecciona una sola muestra de entrenamiento al azar y se utiliza para calcular el gradiente de la función de costo.
Los parámetros del modelo se actualizan inmediatamente después de calcular el gradiente para esa única muestra.
Debido a la selección aleatoria de muestras, el proceso de actualización de parámetros es inherentemente más ruidoso y menos suave que en el descenso de gradiente tipo Batch.
SGD es más rápido en cada iteración individual y a menudo converge más rápidamente, pero puede ser más ruidoso y menos estable en términos de convergencia que el descenso de gradiente tipo Batch.
Diferencias clave:

Batch GD utiliza todo el conjunto de datos en cada iteración, lo que puede ser costoso computacionalmente, mientras que SGD utiliza una sola muestra a la vez, lo que suele ser más eficiente en términos de tiempo.
Batch GD tiene una convergencia más suave y estable debido a que utiliza gradientes promedio, mientras que SGD es más ruidoso pero a menudo converge más rápido.
Batch GD puede quedar atrapado en óptimos locales, mientras que SGD puede escapar de ellos debido a su naturaleza estocástica.
En la práctica, también existen variantes intermedias como el Mini-Batch Gradient Descent, que utiliza un pequeño conjunto de datos (mini-lote) en lugar del conjunto completo, equilibrando así los beneficios de ambas técnicas. La elección entre estas variantes depende de la naturaleza del problema y las restricciones computacionales.


sin imagen de perfil

Programa


C/Visual C

Publicado el 13 de Septiembre del 2023 por Hugo
68 visualizaciones desde el 13 de Septiembre del 2023
codigo de sistema operativo
Imágen de perfil

Descenso de Gradiente Estocástico(SGD)


Python

Publicado el 13 de Septiembre del 2023 por Hilario (84 códigos)
72 visualizaciones desde el 13 de Septiembre del 2023
[
b]AulaF_658-Gradiente_Estocastico.py
*************************************************[/b]

El descenso de gradiente estocástico (SGD por sus siglas en inglés, Stochastic Gradient Descent) es un algoritmo de optimización ampliamente utilizado en el campo del aprendizaje automático y la inteligencia artificial para entrenar modelos de machine learning, especialmente en el contexto de aprendizaje profundo (deep learning). SGD es una variante del algoritmo de descenso de gradiente clásico.

La principal diferencia entre el descenso de gradiente estocástico y el descenso de gradiente tradicional radica en cómo se actualizan los parámetros del modelo durante el proceso de entrenamiento. En el descenso de gradiente tradicional, se calcula el gradiente de la función de pérdida utilizando todo el conjunto de datos de entrenamiento en cada paso de la optimización, lo que puede ser computacionalmente costoso en conjuntos de datos grandes.

En contraste, en SGD, en cada paso de optimización se utiliza un único ejemplo de entrenamiento (o un pequeño lote de ejemplos de entrenamiento) de forma aleatoria. Esto introduce estocasticidad en el proceso, ya que el gradiente calculado en cada paso se basa en una muestra aleatoria de datos. Como resultado, el proceso de optimización es más rápido y puede converger a un mínimo local o global de la función de pérdida de manera más eficiente en muchos casos.

Los pasos generales del algoritmo de descenso de gradiente estocástico son los siguientes:

Inicializar los parámetros del modelo de manera aleatoria o utilizando algún valor inicial.

Mezclar aleatoriamente el conjunto de datos de entrenamiento.

Realizar iteraciones sobre el conjunto de datos de entrenamiento, tomando un ejemplo (o un pequeño lote) a la vez.

Calcular el gradiente de la función de pérdida con respecto a los parámetros utilizando el ejemplo seleccionado.

Actualizar los parámetros del modelo utilizando el gradiente calculado y una tasa de aprendizaje predefinida.

Repetir los pasos 3-5 durante un número fijo de iteraciones o hasta que se cumpla un criterio de convergencia.

El uso de SGD es beneficioso en situaciones donde el conjunto de datos es grande o cuando se necesita un entrenamiento rápido. Sin embargo, la estocasticidad puede hacer que el proceso sea más ruidoso y requiera una sintonización cuidadosa de hiperparámetros, como la tasa de aprendizaje. Además, existen variantes de SGD, como el Mini-Batch Gradient Descent, que toman un pequeño lote de ejemplos en lugar de uno solo, lo que ayuda a suavizar las actualizaciones de parámetros sin la necesidad de calcular el gradiente en todo el conjunto de datos.
Imágen de perfil

Juego de tetris


C/Visual C

estrellaestrellaestrellaestrellaestrella(6)
Actualizado el 12 de Septiembre del 2023 por Adelino (24 códigos) (Publicado el 25 de Enero del 2018)
70.982 visualizaciones desde el 25 de Enero del 2018
Juego de tetris en pantalla grafica (modo 13), se maneja con las teclas de dirección y escape, para cambiar nivel + y -.
Imágen de perfil

Tetris en modo texto


C/Visual C

Actualizado el 12 de Septiembre del 2023 por Adelino (24 códigos) (Publicado el 25 de Enero del 2018)
5.416 visualizaciones desde el 25 de Enero del 2018
Juego de tetris en pantalla de texto, se maneja con las teclas de dirección y escape.
Para subir o bajar de nivel + y -.
5a72583eee6a3-tetrix
Imágen de perfil

Peso,Sesgo,Costo


Python

Publicado el 12 de Septiembre del 2023 por Hilario (84 códigos)
74 visualizaciones desde el 12 de Septiembre del 2023
Hilario Iglesias Martínez.
******************************************************************************************
ClaseAula-F896.py
***************************************************************************************
Este ejercicio, sencillo, para aprendizaje y seguimiento de los parámetros: peso,sesgo,costo, en un descenso de gradiente tipo Batch.
***************************************************************************************
Los términos "peso", "sesgo" y "costo" pueden tener diferentes significados dependiendo del contexto en el que se utilicen. Aquí te proporcionaré una breve descripción de cada uno de estos términos en diversos contextos:

Peso (Weight):

En el contexto de la física, el peso se refiere a la fuerza gravitatoria que actúa sobre un objeto debido a la atracción de la gravedad de la Tierra. Se mide en unidades de fuerza, como newtons o libras.
En el aprendizaje automático y la inteligencia artificial, un "peso" se refiere a los coeficientes asociados con las conexiones entre neuronas en una red neuronal. Estos pesos determinan la fuerza y dirección de la influencia de una neurona en otra dentro de la red. Los pesos se ajustan durante el proceso de entrenamiento de la red para que la red pueda aprender y realizar tareas específicas.

Sesgo (Bias):

En el contexto de la estadística y el análisis de datos, el sesgo se refiere a la tendencia sistemática de un conjunto de datos o un modelo estadístico a producir resultados que se desvían de la verdad o de la población real debido a errores sistemáticos en el proceso de recopilación o modelado de datos.
En el aprendizaje automático, el sesgo (bias) es un término que se utiliza para referirse a un valor constante añadido a la salida de una función en una red neuronal. El sesgo permite que la red pueda modelar funciones más complejas, desplazando la función de activación. Es una especie de "ajuste" que ayuda a la red a aprender y generalizar mejor.

Costo (Cost):

En el ámbito empresarial y financiero, el costo se refiere a la cantidad de recursos (dinero, tiempo, esfuerzo, etc.) que se requiere para producir o realizar algo. Puede incluir costos directos e indirectos.
En matemáticas y optimización, el costo es una medida de la cantidad que se desea minimizar o maximizar en un problema. Por ejemplo, en la optimización lineal, se busca minimizar una función de costo sujeta a ciertas restricciones.
En el contexto del aprendizaje automático y la optimización de modelos, el costo es una medida de cuán bien está funcionando un modelo en relación con los datos de entrenamiento y se utiliza para ajustar los parámetros del modelo durante el proceso de entrenamiento. El objetivo es minimizar el costo para que el modelo se ajuste mejor a los datos y pueda realizar predicciones precisas en nuevos datos.
Estos son conceptos que pueden ser ampliamente aplicados en diversos campos y contextos, por lo que su significado puede variar según el contexto específico en el que se utilicen.
Imágen de perfil

Descenso Gradiente Batch-Error Cuadrático MSE


Python

Publicado el 11 de Septiembre del 2023 por Hilario (84 códigos)
84 visualizaciones desde el 11 de Septiembre del 2023
Hilario Iglesias Martínez.

DescensoGradienteAula-F876.py

El descenso de gradiente tipo "Batch" (también conocido como descenso de gradiente en lotes) es uno de los algoritmos de optimización más utilizados en el aprendizaje automático y la optimización numérica. Este algoritmo se utiliza para minimizar una función de pérdida (también llamada función de costo) al ajustar los parámetros de un modelo de aprendizaje automático. El objetivo principal del descenso de gradiente es encontrar los valores de los parámetros que minimizan la función de pérdida.

Aquí te explico cómo funciona el descenso de gradiente tipo Batch:

Inicialización de parámetros: Se comienza con valores iniciales para los parámetros del modelo. Esto puede ser aleatorio o basado en algún conocimiento previo.

Selección de un lote (batch): En cada iteración del algoritmo, se selecciona un conjunto de ejemplos de entrenamiento del conjunto de datos. Este conjunto de ejemplos se denomina "lote" o "batch". En el descenso de gradiente tipo Batch, se utilizan todos los ejemplos de entrenamiento en cada iteración, es decir, el tamaño del lote es igual al tamaño completo del conjunto de entrenamiento.

Cálculo del gradiente: Para el lote seleccionado, se calcula el gradiente de la función de pérdida con respecto a los parámetros del modelo. El gradiente representa la dirección y la magnitud en la que debe ajustarse cada parámetro para reducir la pérdida.

Actualización de parámetros: Se ajustan los parámetros del modelo en la dirección opuesta al gradiente calculado. Esto se hace multiplicando el gradiente por una tasa de aprendizaje (learning rate) y restando el resultado de los parámetros actuales. La tasa de aprendizaje controla qué tan grande es el paso que se da en cada iteración.

Iteración: Se repiten los pasos 2 a 4 durante un número fijo de iteraciones o hasta que se alcance algún criterio de convergencia (como una pequeña disminución en la función de pérdida o un número máximo de iteraciones).

El proceso se repite hasta que se considera que el modelo ha convergido o alcanzado una solución aceptable.

El descenso de gradiente tipo Batch tiene algunas ventajas, como la convergencia más estable y la posibilidad de aprovechar la paralelización en el hardware moderno. Sin embargo, también puede ser más lento en comparación con variantes más rápidas como el descenso de gradiente estocástico (SGD) o el descenso de gradiente mini-batch, que utilizan subconjuntos más pequeños de los datos en cada iteración. La elección del algoritmo de descenso de gradiente depende de la naturaleza del problema y de las características del conjunto de datos.
****************************************************************************************************************
El Error Cuadrático Medio (MSE, por sus siglas en inglés, Mean Squared Error) es una métrica comúnmente utilizada en estadísticas y machine learning para evaluar el rendimiento de un modelo de regresión o de predicción. MSE se utiliza para medir la calidad de las predicciones de un modelo al calcular la media de los cuadrados de las diferencias entre los valores predichos por el modelo y los valores reales (observados) en un conjunto de datos.

La fórmula del MSE se expresa de la siguiente manera:

MSE = (1/n) Σ(yi - ŷi)²

Donde:

MSE es el Error Cuadrático Medio.
n es el número de muestras en el conjunto de datos.
yi representa el valor real u observado de la muestra i.
ŷi representa el valor predicho por el modelo para la muestra i.
En otras palabras, para calcular el MSE, se toma la diferencia entre el valor predicho y el valor real para cada punto de datos, se eleva al cuadrado, y luego se calcula el promedio de todas estas diferencias al cuadrado.


El MSE es útil para determinar cuán bien se ajusta un modelo de regresión a los datos, y se prefiere minimizarlo. Cuanto menor sea el MSE, mejor será el ajuste del modelo a los datos. Sin embargo, es importante recordar que el MSE puede verse afectado por valores atípicos en los datos y puede no ser la métrica más apropiada en todos los casos. En algunos escenarios, como la detección de valores atípicos, otras métricas como el Error Absoluto Medio (MAE) o el Error Cuadrático Medio Raíz (RMSE) pueden ser más adecuadas.
Imágen de perfil

matrix full screen


Python

Publicado el 10 de Septiembre del 2023 por Cruz Francisco
79 visualizaciones desde el 10 de Septiembre del 2023
el codigo despliega una cascada de letras y caracteres simulando a la conocidisima matrix
para desactivarlo solo preciona ctrl+alt+supr
Imágen de perfil

Batch-sin: MSE


Python

Publicado el 8 de Septiembre del 2023 por Hilario (84 códigos)
97 visualizaciones desde el 8 de Septiembre del 2023
Aula_F-488-8-SepEjercicioBatch.py
[/b]
Hilario Iglesias Martínez.

**********************************************************************************************************
El Descenso de Gradiente Tipo Batch (Batch Gradient Descent en inglés) es un algoritmo de optimización utilizado en el aprendizaje automático y la optimización numérica. Es una variante del Descenso de Gradiente, que es una técnica para ajustar los parámetros de un modelo de manera que minimice una función de costo.

La principal característica del Descenso de Gradiente Tipo Batch es que utiliza todo el conjunto de datos de entrenamiento en cada iteración para calcular el gradiente de la función de costo. Aquí está el proceso básico:

Inicialización: Se comienzan con valores iniciales para los parámetros del modelo.

Cálculo del Gradiente: Se calcula el gradiente de la función de costo con respecto a los parámetros del modelo utilizando todo el conjunto de entrenamiento. El gradiente indica la dirección y la magnitud del cambio necesario para reducir el costo.

Actualización de Parámetros: Se actualizan los parámetros del modelo en la dirección opuesta al gradiente, multiplicados por una tasa de aprendizaje. Esto ajusta los parámetros para minimizar el costo.

Repetición: Los pasos 2 y 3 se repiten para un número determinado de iteraciones o hasta que se cumpla algún criterio de convergencia.

El Descenso de Gradiente Tipo Batch tiene algunas ventajas, como la convergencia a un mínimo global si la función de costo es convexa y una mejor estabilidad en términos de convergencia en comparación con otras variantes del Descenso de Gradiente. Sin embargo, puede ser más lento en términos de tiempo de cómputo cuando se trabaja con conjuntos de datos grandes, ya que requiere el cálculo del gradiente en todo el conjunto de datos en cada iteración.

Existen otras variantes del Descenso de Gradiente, como el Descenso de Gradiente Estocástico (Stochastic Gradient Descent, SGD) y el Descenso de Gradiente Mini-Batch, que combinan características del Descenso de Gradiente Tipo Batch y otras estrategias para lograr un equilibrio entre eficiencia y convergencia. Cada variante tiene sus propias ventajas y se elige según el problema específico y las características de los datos.
Imágen de perfil

Tekla2 – Teclado virtual_Versión_67


Visual Basic

Actualizado el 4 de Septiembre del 2023 por Rafael (22 códigos) (Publicado el 17 de Junio del 2022)
1.708 visualizaciones desde el 17 de Junio del 2022
Si está preparando un documento y el teclado se daña, este programa puede sacarlo del problema pues hace aparecer dentro de una pequeña ventana un teclado virtual que se sitúa encima del documento, ventana que usted puede arrastrar y situar donde mejor convenga, y ahí se mantendrá la ventana, obediente, hasta que la cambie de nuevo de lugar.
Este teclado virtual tiene todos los caracteres que contiene un teclado de 104 teclas y aún muchas cosas más. Además de poder escribir usted todas las letras y números con este teclado, incluyendo los caracteres especiales habidos y por haber, o vocales acentuadas, puede retroceder un carácter o avanzar un carácter, situarse al inicio de una palabra o al final de la misma, situarse al inicio de la línea o al final, situarse en la primera página del documento, o en la última. Puede poner la fecha del documento, o la hora. Todo esto con un clic. Pero, mejor no le molesto más, lea la guía del usuario adjunta y usted quedará sorprendido de todo lo que Tecla2 – Teclado Virtual puede hacer.

Untitled-1
Imágen de perfil

(Batch Gradient Descent)


Python

Publicado el 4 de Septiembre del 2023 por Hilario (84 códigos)
117 visualizaciones desde el 4 de Septiembre del 2023
ClaseB-238_Lunes_Sep_23.py
-----------------------------------
Hilario Iglesias Martínez
*************************************
Este es un programa en Python
se realiza una regresión lineal
utilizando el método de gradiente descendente
(Batch Gradient Descent)
El programa realiza una regresión lineal utilizando
el método de gradiente descendente
y visualiza los resultados a través de
gráficas. Es una implementación simple
pero efectiva de un modelo de regresión lineal.
***********************************************
Programa realizado bajo una plataforma Linux:
Ubuntu 20.04.6 LTS.
Editado con: Sublime Text.
*********************************
Ejecución bajo consola Linux.
python3 ParaClaseLunes-Sep-F543.PY
*******************************************
"""
Imágen de perfil

Descenso Gradiente Batch(GD)


Python

Publicado el 2 de Septiembre del 2023 por Hilario (84 códigos)
112 visualizaciones desde el 2 de Septiembre del 2023
*****************************************************************************************************
Hilario Iglesias Martínez


ClaseViernes-F543.py


DESCENSO DE GRADIENTE BATCH

*********************************************************************************************************
El "descenso de gradiente tipo Batch" es una técnica de optimización utilizada en el aprendizaje automático y la estadística para ajustar los parámetros de un modelo matemático, como una regresión lineal o una red neuronal, de manera que se minimice una función de costo específica. Es una de las variantes más simples y fundamentales del descenso de gradiente.

Aquí tienes una explicación de cómo funciona el descenso de gradiente tipo Batch:

Inicialización de parámetros: Comienza con un conjunto inicial de parámetros para tu modelo, que generalmente se eligen de manera aleatoria o se establecen en valores iniciales.

Selección de lote (Batch): En el descenso de gradiente tipo Batch, se divide el conjunto de datos de entrenamiento en lotes o subconjuntos más pequeños. Cada lote contiene un número fijo de ejemplos de entrenamiento. Por ejemplo, si tienes 1000 ejemplos de entrenamiento, puedes dividirlos en lotes de 32 ejemplos cada uno.

Cálculo del gradiente: Para cada lote, calculas el gradiente de la función de costo con respecto a los parámetros del modelo. El gradiente es una medida de cómo cambia la función de costo cuando se hacen pequeños ajustes en los parámetros. Indica la dirección en la que debes moverte para minimizar la función de costo.

Actualización de parámetros: Después de calcular el gradiente para cada lote, promedias los gradientes de todos los lotes y utilizas ese gradiente promedio para actualizar los parámetros del modelo. Esto se hace multiplicando el gradiente promedio por una tasa de aprendizaje (learning rate) y restando ese valor de los parámetros actuales. El learning rate controla el tamaño de los pasos que das en la dirección del gradiente.

Repetición: Los pasos 2-4 se repiten varias veces (llamadas épocas) a través de todo el conjunto de datos de entrenamiento. Cada época consiste en procesar todos los lotes y ajustar los parámetros del modelo.

Convergencia: El proceso de ajuste de parámetros continúa hasta que se alcanza un criterio de convergencia, que generalmente se establece en función de la precisión deseada o el número de épocas.

El descenso de gradiente tipo Batch es eficiente en términos de cómputo, ya que utiliza todos los datos de entrenamiento en cada paso de actualización de parámetros. Sin embargo, puede ser lento en conjuntos de datos grandes, y su convergencia puede ser más lenta en comparación con otras variantes del descenso de gradiente, como el descenso de gradiente estocástico (SGD) o el mini-batch SGD.

En resumen, el descenso de gradiente tipo Batch es una técnica de optimización que ajusta los parámetros de un modelo mediante el cálculo y la actualización de gradientes en lotes de datos de entrenamiento, con el objetivo de minimizar una función de costo. Es una parte fundamental en la optimización de modelos de aprendizaje automático.


*********************************************************************************************************
Ejecucion.
Bajo consola de Linux.
python3 ClaseViernes-F543.py
Imágen de perfil

TelecoAula-A


Python

Publicado el 30 de Agosto del 2023 por Hilario (84 códigos)
1.090 visualizaciones desde el 30 de Agosto del 2023
"""
*********************************
Hilario Iglesias Martinez.
*********************************
clasedeterceroamiercoles.py

--------------------------------
Función de partida:
f(x)=3*x+5*x**2/7


**********************************************
Derivada:f'(x) = 3 + (10/7)*x
***********************************************
El descenso de gradiente es un algoritmo iterativo
que utiliza la derivada (o el gradiente)
de la función objetivo en un punto específico
para determinar la dirección, y el tamaño del
paso que debes tomar para moverte hacia una región
de menor valor de la función. La derivada de
la función objetivo se calcula en cada iteración,
y se utiliza para ajustar los parámetros,
con el objetivo de acercarte al mínimo de la función.

En resumen, el descenso de gradiente es una técnica
fundamental en el campo de la optimización y el aprendizaje
automático, ya que permite encontrar valores óptimos para los
parámetros de una función de manera iterativa utilizando
información sobre la pendiente de la función en diferentes puntos.

-----------------------------------------------
Aquí hay una descripción, paso a paso, del proceso del descenso de gradiente:

Inicialización: Comienza con un valor inicial para
los parámetros de la función que deseas optimizar.

Cálculo del Gradiente:
Calcula la derivada (gradiente) de la función en el punto actual.

Actualización de Parámetros:
Ajusta los parámetros en la dirección opuesta al gradiente
multiplicado por una tasa de aprendizaje.
La tasa de aprendizaje controla el tamaño de
los pasos que tomas en cada iteración.

Repetición: Repite los pasos 2 y 3 para un
número predeterminado de iteraciones,
hasta que se alcance cierto criterio de convergencia.

Convergencia:
El algoritmo converge cuando los cambios
en los parámetros se vuelven muy pequeños,
indicando que se ha llegado a una región
cercana al mínimo (o máximo) de la función.

*************************************************
Programa realizado sobre paltaforma Linux:
Ubuntu 20.04.6 LTS.
Editado en Sublime Text.

-----------------------------------------
Ejecución en consola Linux:

python3 clasedeterceroamiercoles.py
*******************************************************