A√ļn no tienes acceso a esta clase

Crea una cuenta y contin√ļa viendo este curso

Aplicando el descenso

29/30
Recursos

Aportes 24

Preguntas 6

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi√≥n.

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!

ūüźľ