Mostrar los tags: c

Mostrando del 41 al 50 de 2.838 coincidencias
Se ha buscado por el tag: c
Imágen de perfil

Ejercicio_Aula_23_Momentum


Python

Publicado el 26 de Octubre del 2023 por Hilario (124 códigos)
277 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

Repaso-Descen-Grad-Batch.


Python

Publicado el 24 de Octubre del 2023 por Hilario (124 códigos)
261 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 (124 códigos)
487 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

Clasificacion de Datos Arboles de Decision


Python

Publicado el 17 de Octubre del 2023 por Hilario (124 códigos)
419 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.
Imágen de perfil

Mostrar zonas en un plano ("usted está aquí")


FoxPro/Visual FoxPro

Publicado el 9 de Octubre del 2023 por Baldo (17 códigos)
659 visualizaciones desde el 9 de Octubre del 2023
Quizá esto os pueda ayudar.

Tuve necesidad por un cliente de mostrar pasillos en su (inmenso) almacén para que al menos el interesado se aproximara a la zona (y planta, porque el edificio tenía dos alturas).

zonaplano01

El comienzo fue "hard-codeo" puro pero, al hacer cambios de distribución constante me planteé el que el esquema fuera configurable.

Así que... aqui está: Un sistema basado en Una tabla (TMPLANO0.DBF) que contiene definición de las zonas (rectángulos) y sus datos de posición (X/Y), anchura y altura. Al final puede ser útil en una empresa como en un evento (imaginad el plano de mesas de una fiesta, una boda...)

zonaplano02

El sistema es simple (lanzad el Form "MUESTRA_PLANO": la tabla comentada contiene la i nformación de las áreas, que se muestran como objetos (definidos en "PLANO_OBJ.VCX"). Estos objetos son objetos del formulario, con lo que al haber dos planos (planta baja y primera planta, por ejemplo) se coloca "por debajo de los objetos" un pageframe que contiene pestañas con los diferentes mapas (en el ejemplo 2, pero podeis aumentarlo hasta vuestra necesidad). Lo único que hay que hacer es ir mostrando/ocultando objetos en función de la página del frame que en ese momento hay en pantalla.

zonaplano03

Hay dos objetos definidos:

- Zona (el rectángulo)
- Punto (algo así como el "Pin" de Google, para una definición pás exacta ("Vd. está aquí")

Si quereis dar este servicio cerrado a cliente, solo debeis aportar la tabla con las def iniciones propias de cliente, el form de muestra (MUESTRA_PLANO) y otro que simplemente es para mostrar un grid con los diponobles ("consulta_planos")

Para vuestra comodidad (o aportarlo a cliente en su caso), teneis un Form configurador de las zonas y guardado en tabla (MTO_PLANOS).

zonaplano04

Por favor, tomad esto como 'lo que es'. Una herramienta creada ante la necesidad.

Puede que el código no sea óptimo, lo sé, pero ser conscientes de mi simple ánimo de dejar aquí la 'semillita'. Por supuesto, el código es mejorable, pero os aseguro que tal y como está, ya funciona.


Un saludo a toda la comunidad
Baldo Martorell
[email protected]
http://www.baldoweb.eu
Imágen de perfil

Tekla2 – Teclado virtual_Versión_67


Visual Basic

Actualizado el 28 de Septiembre del 2023 por Rafael (22 códigos) (Publicado el 17 de Junio del 2022)
2.760 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

Vectores-Descenso de gradiente.


Python

Publicado el 27 de Septiembre del 2023 por Hilario (124 códigos)
309 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

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)
535 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.