Buscar un código de Python
Mostrando del 41 al 50 de 73 coincidencias
Se ha buscado por la cadena: array
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.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.
El descenso de gradiente en el contexto de la regresión lineal múltiple se refiere a un algoritmo de optimización utilizado para encontrar los valores óptimos de los coeficientes de una función de regresión lineal que se ajuste mejor a un conjunto de datos con múltiples características (variables independientes). El objetivo es minimizar una función de costo, generalmente el error cuadrático medio (MSE, por sus siglas en inglés), que mide la diferencia entre las predicciones del modelo y los valores reales.
A continuación, se explica cómo funciona el descenso de gradiente en el contexto de la regresión lineal múltiple:
Inicialización: Se inician los coeficientes del modelo con valores aleatorios o ceros.
Cálculo de las predicciones: Se utilizan los coeficientes actuales para hacer predicciones sobre el conjunto de datos de entrenamiento. Esto implica multiplicar cada característica de entrada por su correspondiente coeficiente y sumar todos estos productos para obtener una predicción.
Cálculo del error: Se calcula la diferencia entre las predicciones y los valores reales (etiquetas) del conjunto de entrenamiento. Esto da como resultado un vector de errores.
Cálculo del gradiente: Se calcula el gradiente de la función de costo con respecto a los coeficientes. El gradiente indica la dirección y la magnitud en la que los coeficientes deben actualizarse para minimizar la función de costo. Para el MSE, el gradiente se calcula como la derivada de la función de costo con respecto a cada coeficiente.
Actualización de coeficientes: Se actualizan los coeficientes multiplicándolos por una tasa de aprendizaje (learning rate) y restando el gradiente. Esta actualización mueve los coeficientes en la dirección que reduce el costo.
Iteración: Los pasos 2-5 se repiten iterativamente durante un número fijo de veces (épocas) o hasta que el costo converja a un valor mínimo.
Resultado final: Después de que el algoritmo haya convergido, los coeficientes resultantes se utilizan como los coeficientes óptimos para el modelo de regresión lineal múltiple.
El proceso se repite hasta que se alcance un criterio de convergencia o se haya realizado un número predeterminado de iteraciones. El descenso de gradiente es una técnica fundamental en el aprendizaje automático y la optimización, y se utiliza para ajustar los parámetros de los modelos de manera que se minimice la diferencia entre las predicciones y los valores reales.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."""
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
"""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.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.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
*******************************************
"""*****************************************************************************************************
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"""
*************************************
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
"""
