Aplicando el descenso

Muchas gracias por el curso

Puedes usar la función random.uniform de numpy, dando el rango del intervalo con low y high para evitar hacer el rand()*8 + 4

Aca le dejo otra forma de implementar el algoritmo del descenso del gradiente.
aca esta el video donde lo saque, muy buen canal de Ai
https://youtu.be/-_A_AAxqzCg

import numpy as np 
import scipy as sc
import matplotlib.pyplot as plt

func = lambda th: np.sin(1 / 2 * th[0] ** 2 - 1 / 4 * th[1] ** 2 + 3) * np.cos(2*th[0] + 1 -np.e ** th[1])  #funcion anonima, th hace referencia la vector de parametros
res = 100
_X = np.linspace(-2, 2, res)
_Y = np.linspace(-2, 2, res)

_Z = np.zeros((res, res)) # creamos la matriz del mismo tamaño que _X y _Y

for ix, x in enumerate(_X): # guardamos los indices de nuestras matrices en ix, iy y los valores en x, y
  for iy, y in enumerate(_Y):
    _Z[iy, ix] = func([x, y])       # el primer indice se utiliza para guardar el numero de filas y el segundo para referirte el numero de columna


plt.contourf(_X, _Y, _Z, res)
plt.colorbar()


theta = np.random.rand(2) * 4 - 2
_T = np.copy(theta)
grad = np.zeros(2)

h = 0.001
lr = 0.001

plt.plot(theta[0], theta[1], "o", c ="white")

for i in range(1000):
  for it, th in enumerate(theta):
    _T = np.copy(theta)

    _T[it] = _T[it] + h

    deriv = (func(_T) - func(theta)) / h

    grad[it] = deriv

  theta = theta - lr * grad
  if (i % 10 == 0):
    plt.plot(theta[0], theta[1], "o", c ="r")

plt.plot(theta[0], theta[1], "o", c ="black")
plt.show()

Ejemplo con la variante de colores “jet”

surf = ax.plot_surface(X,Y,Z, cmap=cm.jet)
plt.contourf(X, Y, Z, levels=level_map,cmap=cm.jet)

Muy interesante.

from matplotlib import cm
import numpy as np 
import matplotlib.pyplot as plt


def f(x,y):
    return x**2 + y**2 

def derivate(cp, p ,h):
    return (f(cp[0], cp[1]) - f(p[0], p[1]))/h

def gradiente(p, h):
    grad = np.zeros(2)
    for idx, _ in enumerate(p):
        cp = np.copy(p)
        cp[idx] = cp[idx] + h

        dp = derivate(cp, p, h)
        grad[idx] = dp

    return grad

if __name__=='__main__':

    fig, ax = plt.subplots(subplot_kw={"projection":"3d"})
    
    res = 100

    x = np.linspace(-4, 4, res)
    y = np.linspace(-4, 4, res)
    X, Y = np.meshgrid(x,y)

    Z = f(X,Y)

    surf = ax.plot_surface(X, Y, Z,cmap=cm.cool)
    fig.colorbar(surf)
    plt.show()

    fig, ax = plt.subplots(1,1)
    level_map =np.linspace(np.min(Z), np.max(Z), res)
    plt.contourf(X,Y,Z,level_map, cmap=cm.cool)
    plt.colorbar()
    plt.title("Descenso del gradiente")
    #plt.show()

    p = np.random.rand(2) * 8 - 4
    plt.plot(p[0], p[1], 'o', c='k')

    h = 0.01
    lr = 0.01

    for i in range(10000):
        p = p - lr * gradiente(p,h)
        if(i % 10 == 0):
            plt.plot(p[0], p[1], 'o', c='r')
            
    plt.plot(p[0], p[1], 'o', c='w')        
    plt.show()

![](

Bastante complejo el curso pero feliz de haberlo acabado y que todo me saliera como al profe

Mi ‘resumen’ más extenso y completo hasta ahora. por si a alguien le es de utilidad. A mi me fue muy útil para el examen y está he hecho para que en serio me explique en el futuro si olvido algo: https://giant-reward-bfc.notion.site/Semana-5-Curso-de-Matem-ticas-para-Data-Science-C-lculo-B-sico-139495d8ccc0412882c4d359937f0a4c

Mucho cuidado con el learning rate o el rango con el que se itera el desplazamiento del descenso del gradiente.

Así se ve sin el rango correcto:

Así sin el learning rate correcto:

Con todo correcto (tuve que bajar el learning rate de 0.01 a 0.005 porque mi rango de datos era mayor que el del ejemplo de la clase):

Mi prueba con los valores de los puntops inicial y final usando la ultima ecuación np.sin(x) + 2*np.cos(y)
Punto inicial random: [ 2.99119811 -0.13653455] con valor de 2.1312154919188075
Punto final: [ 4.70728864 -3.1465926 ] con valor de -2.9999619938872883

!Gran curso¡

“p = np.random.rand(2) * 8 - 4”

No es mas facil un

p= random.randit(-4,4)

luego de importar el modulo random?

Me confundió la parte de la derivada y todos los métodos nuevos 😕

¡Que buen curso!

Si cambiamos el menos (-) por un mas (+) en la fórmula p = p - lr * gradient(p) calcularíamos máximos y no mínimos, y sería otra forma de usar este algoritmo.

Emocionado de todo lo que practicaré en Python de cálculo.

Genial! Gracias por el curso 😄

Muy bueno el curso, por mi parte tuve que invertir más tiempo para entender cómo se crean las graficas y se escribe el código.

Estuvo un poco agotador el curso, pero siempre interesante!

🐼