Mostrar los tags: n

Mostrando del 61 al 70 de 2.720 coincidencias
Se ha buscado por el tag: n
Imágen de perfil

Descenso de Gradiente Estocástico(SGD)


Python

Publicado el 13 de Septiembre del 2023 por Hilario (129 códigos)
418 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(8)
Actualizado el 12 de Septiembre del 2023 por Adelino (24 códigos) (Publicado el 25 de Enero del 2018)
76.400 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)
6.355 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

(Batch Gradient Descent)


Python

Publicado el 4 de Septiembre del 2023 por Hilario (129 códigos)
323 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 (129 códigos)
349 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

Descenso Gradiente Función seno


Python

Publicado el 27 de Agosto del 2023 por Hilario (129 códigos)
316 visualizaciones desde el 27 de Agosto del 2023
[
b]"""
Hilario Iglesias Martinez.
*****************************************************
seno.py
********************************************************
Descenso de gradiente en una función seno.
----------------------------------------------------------
Función Seno (sin(x)): La función seno es una función trigonométrica
que toma un ángulo como entrada y devuelve la relación entre
la longitud del cateto opuesto a ese ángulo y la longitud de
la hipotenusa en un triángulo rectángulo. En términos más simples,
el valor del seno de un ángulo en un triángulo rectángulo es igual
a la longitud del lado opuesto dividido por la longitud de la hipotenusa.

En el contexto de funciones reales, la función seno asigna un valor
real a un ángulo en radianes. Su gráfica oscila entre -1 y 1,
creando una forma ondulante suave que se repite cada 2π radianes.
--------------------------------------------------------------------[/b]

EJECUCION BAJO CONSOLA LINUX.
python3 seno.py
Imágen de perfil

PARÁBOLA


Python

Publicado el 25 de Agosto del 2023 por Hilario (129 códigos)
544 visualizaciones desde el 25 de Agosto del 2023
"""
*************************************
parabola.py
**************************************
Hilario Iglesias Martínez.
---------------------------------------
El descenso de gradiente es un algoritmo
que estima numéricamente dónde una función
genera sus valores más bajos.
En este ejemplo lo aplicaremos a la sigiente función:
Función de cálculo
f(x)=x**2/3+3x**2
Derivada
20*x/3
-------------------------------------------------
Programa realizado en una Plataforma Linux.
Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
También se puede editar y ejecutar con:
Google Colab.
---------------------------------------
Ejecución bajo consola linux:
python3 parabola.py

"""
Imágen de perfil

SIGMOIDE


Python

Publicado el 23 de Agosto del 2023 por Hilario (129 códigos)
685 visualizaciones desde el 23 de Agosto del 2023

*********************************************************
Hilario Iglesias Martínez
**********************************************************
La función sigmoide es una función matemática que toma
cualquier número real como entrada y la transforma en
un valor en el rango de 0 a 1. Su forma característica
es una curva en forma de "S".
La función sigmoide es comúnmente utilizada en diversos campos,
como la biología, la psicología y el aprendizaje automático,
especialmente en las redes neuronales.

Forma:
f(x)=1 / (1 + e**(-x))
Derivada:
e**(-x) / (1 + e**(-x))**2

La función sigmoide toma valores positivos y negativos de
x y los mapea en el rango (0, 1), de modo que valores grandes de
x resultarán en valores cercanos a 1, y valores pequeños o negativos de
x resultarán en valores cercanos a 0.

Programa realizado bajo linux
Plataforma Ubuntu 20.04.6 LTS.
Editado con Sublime Text.
Ejecucion en consola linux.
python3 SigmoideWeb.py

Tambien se puede editar y ejecutar en Google Colab.
Imágen de perfil

Nuevo_Descenso_Gradiente


Python

Publicado el 19 de Agosto del 2023 por Hilario (129 códigos)
777 visualizaciones desde el 19 de Agosto del 2023
Derivada_Descenso_Gradiente_2.py

Que hace el programa:
Dada la parábola de esta función:
f(x)=(x ** 2 / 2)
Vamos a realizar la derivada inversa con regresión a partir
de un punto dado por:
init_x = 18.
También imprimiremos valores intermedios de x e y, y su valor de gradiente mínimo.

****************************************************************
Ejecucion bajo consola Linux.
python3 Derivada_Descenso_Gradiente_2.py
------------------------------------------------------------
Tambien se puede editar y ejecutar con Google Colab.
Imágen de perfil

Derivada_REGRESIÓN


Python

Publicado el 18 de Agosto del 2023 por Hilario (129 códigos)
1.342 visualizaciones desde el 18 de Agosto del 2023
"""
Derivada_Descenso_Gradiente.py
-----------------------------------
Que hace el programa:

Dada la parábola de esta función:
f(x,t)=(x ** 2 / 2) + t
Vamos a realizar la derivada de los puntos de una parábola
de forma inversa, lo que se define como descenso de gradiente,
a partir de un punto dado por:
init_x = 18.
Muy utilizado en Redes Neuronales.
También imprimiremos su valor al llegar
a la última vuelta del "loop" range(5000)
------------------------------------------------
Ejecución bajo consola de linux, con este comando:
python3 derivada_descenso_gradiente_1.py
-------------------------------------------------

***************************************************************
Programa Realizado Bajo plataforma Ubuntu
de linix.
Editado con Sublime text.
También se puede editar y ejecutar con Google Colab

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

"""