Implementación de regresión lineal en Pytorch, Regresión logística, Implementación de regresión logística en Pytorch

Clase 7 de 27 • Curso de Introducción a Machine Learning 2019

Contenido del curso

Conceptos básicos de Machine Learning

Trabajando con Pytorch

Implementaciones de algoritmos de Machine Learning en Pytorch

Redes Neurales y reconocimiento de imágenes

Reconocimiento de imágenes

Collab con Scikit

Algoritmos más usados en Machine Learning

Bonus: Redes neuronales y herramientas

Cierre

27
Conclusiones y siguientes pasos
03:32 min

Tomar examen

Resumen

En esta clase vamos a trabajar en una implementación práctica de la regresión lineal, el ejemplo que vimos sobre el precio de los tacos, calcular el loss function y lo implementaremos con PyTorch con alguno de sus módulos. También veremos cómo graficar datos.

Comentarios

Mauricio Gomez

student•

Tengo la sensación que me falta un curso entre la clase pasada y esta...

Pedro Alejandro Rodríguez García

student•

x2 Encontraste cuál fue? Jaja

Mauricio Gomez

student•

Después de 2 meses de haber hecho este comentario, llegue a la conclusión que antes de hacer este curso hay que hacer los siguientes:

Curso de Fundamentos de Álgebra Lineal Curso de Estadística y Análisis de Datos Curso de Introducción a Machine Learning 2018

Usuario anónimo

user•

La verdad siento que falta detallar mucho más que hace cada método

Alex Tovar

student•

Si, menos mal que es un curso introductorio xD

Usuario anónimo

user•

Comparto el código de la actividad de modelado en red neuronal de esta sesión de clase así: Importación de las librerías necesarias para la elaboración del modelo de red neuronal.

import torch
import numpy as np
import torch.nn as nn
import torch.optim as optim

import matplotlib.pyplot as plt

Creación de las listas de precios de carros y unidades vendidas, elaboración de la gráfica de la relación lineal entre las dos variables:

car_prices = [5, 6, 7, 8, 9, 10]
units_sold = [8.5, 8, 7.5, 7.0, 6.5, 6.0]
plt.scatter(car_prices, units_sold)

Conversión de las dos variables a arreglos de numpy:

prices_array = np.array(car_prices).reshape(-1, 1)
units_array = np.array(units_sold).reshape(-1, 1)

prices_array

Construcción del tensor de cada variable a partir de los arreglos generados por numpy:

prices = torch.from_numpy(prices_array).float().requires_grad_(True)
units = torch.from_numpy(units_array).float()
prices, prices.shape

Elaboración del modelo de red neuronal teniendo en cuenta las perdidas por error de mínimo cuadrado, el tamaño de valor de entrada y salida y el valor de los pesos:

model = nn.Linear(1, 1)
loss_function = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr = 0.015)

Entrenamiento del modelo con los datos almacenados en los tensores de las dos variables:

losses = []
iterations = 2000

for i in range(iterations):
  pred = model(prices)
  loss = loss_function(pred, units)
  losses.append(loss.data)

  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

Presentación de la perdida y gráfica de las respuesta del modelo neuronal:

print(float(loss))
plt.plot(range(iterations), losses)

Prueba del modelo con un valor bajo de precio de auto, respuesta más unidades vendidas:

x = torch.Tensor([[4.0]])
px = model(x)
px

Prueba del modelo con un valor alto de precio de auto, respuesta menos unidades vendidas:

y = torch.Tensor([[14.0]])
py = model(y)
py

Davis Álvarez

student•

Gracias por compartir el código.

Angel Armando Martínez Blanco

student•

No tengo ninguna aportación importante. Sólo quiero agradecer a los que están poniendo enlaces. De verdad se rifaron estaba más perdido que un niño en el supermercado :(

Deyvi Jhonny Bustamante Perez

student•

la explicación debe ser mas ilustrada a la hora de hacer los códigos, es ahí la dificultad del tema, ese es el bajón en la instrucción

Christian Mahonry Colorado Bulbarela

student•

Por a quines aun les esta costando entender el codigo les recomiendo esta lectura:

https://www.juanbarrios.com/google-machine-learning/#objetivo_del_machine_learning

Carli Code

teacher•

Que increíble!!! y está en español :3 muchas gracias!

Luis Fernando Pedroza Taborda

student•

Gracias Christian, excelente aporte.

Fernado Michael Acosta Panchez

student•

Se podría resumir la clase de la siguiente manera:

Importar las bibliotecas pytorch, numpy y matplotlib Ubicar los datos de las variables a analizar en vectores y graficarlos con matplotlib Pasar los datos anteriores a arreglos con numpy Pasar los datos anteriores a tensores con torch, además activar el gradiente en la variable dependiente Escribir el modelo con: modelo lineal usando nn.Linear(1,1) función de pérdida con nn.MSELoss() función de optimización con optim.SGD(modelo, tasa de aprendizaje lr) Crear un arreglo para almacenar las perdidas Variable con el numero de iteraciones Crear un ciclo for con: valores calculados de la variable dependiente en cada iteración valores calculados de las perdidas en cada iteración inicialización del gradiente Graficar los resultados Probar el modelo elebarado

Gabriel Salvador

student•

Creo que no explica bien para que sirve el codigo loss backward(). Spoiler: esa pregunta esta en el exámen. En el siguiente enlace está mejor explicado .

loss.backward() calcula dloss/dx para cada parametro x que tiene requires_grad=True. Esto se acumula en x.grad para cada parámetro x. En pseudo-código:

x.grad += dloss/dx

optimizer.step actualiza el valor de x usando x.grad. Por ejemplo, el optimizador SDG hace:

x += -lr * x.grad

optimizer.zero_grad() limpia x.grad para cada parámetro x en el optimizador. Es importante llamar a esta función antes de loss.backward(), caso contrario acumularas gradientes de multiples pasos.

María José Medina

student•

El link: https://discuss.pytorch.org/t/what-does-the-backward-function-do/9944

rusbel bermúdez rivera

student•

Les comparto humildemente mis notas del curso y los notbooks utilizados con algunas anotaciones adicionales. Espero les sirvan. https://github.com/rb-one/Curso_introduccion_a_machine_learning/blob/master/Notes/notes.md

Rodrigo Urquizo Yepez

student•

Los que no entendieron casi nada al inicio como yo, aca hay documentacion muy buena que lo explica mas detalladamente: https://pytorch.org/tutorials/beginner/pytorch_with_examples.html Debemos aprender a leer docs tambien

Mauricio Gomez

student•

Muchas gracias!

Usuario anónimo

user•

Gracias pero la verdad se me dificulta entender la documentación de las cosas de programación, no las entiendo

Andres Marin Hernandez

student•

Hola, me no entendi bien que son los gradientes y para que sirven, agradezco me puedan ayudar. Saludos

rusbel bermúdez rivera

student•

Te recomiendo este articulo https://www.javatpoint.com/gradient-with-pytorch.

Los gradientes te permiten encontrar la derivada de la función.

Este canal explica muy bien el descenso del gradiente.

https://www.youtube.com/watch?v=A6FiCDoz8_4&ab_channel=DotCSV

Andres Marin Hernandez

student•

Me ha quedado my claro, muchas gracias @rusbelBermudez, ha sido un gran aporte para mi

Usuario anónimo

user•

okey ... que curso me perdí para no haber entendido esto

María José Medina

student•

Algoritmo del descenso de gradiente estocástico

¿Para qué se usa? Para hallar el punto más bajo de una función. Por ejemplo, dada una relación y = mx + b, el objetivo de este algoritmo es hallar un x tal que y sea el valor mínimo.
¿Cómo funciona el algoritmo?

Dada una función, el algoritmo empieza por tomar un punto aleatorio dentro de esa función (de ahí el nombre estocástico) y evalua el gradiente en ese punto.
El gradiente dará como resultado la dirección que hace máxima la función, así que el algoritmo recorre una serie de pasos definidos en dirección contraria.
Una vez en este nuevo punto, se repite el paso 1 y 2 (evaluar gradiente y moverse) hasta llegar al valor mínimo de la función.

¿Cuantos pasos recorre el algoritmo? Los pasos que recorre está directamente relacionado con el learning rate. Si los pasos son pocos, puede pasar que el algoritmo no avance lo suficiente para llegar al punto mínimo, haciendo que se necesiten muchas iteraciones para alcanzarlo, o en cambio, si los pasos son muchos, se puede sobrepasar eternamente el punto mínimo creando un bucle infinito, como se muestra en la imagen:

Video super recomendado: DotCSV

Usuario anónimo

user•

Para usar la regresión lineal se necesita un arreglo de 2D, por eso es necesario usar la función reshape()

Anderson Steven Mendez Chipatecua

student•

Es decir que si no tengo mi arreglo 2D no la puedo utilizar? o simplemente es por norma que se debe tener el arreglo 2D?

Eday Alix González Manjarrés

student•

Qué significa reshape(-1, 1) . ?

Gracias.

Usuario anónimo

user•

https://stackoverflow.com/questions/18691084/what-does-1-mean-in-numpy-reshape

Marcelo Sánchez

student•

El -1 es propio de la función reshape(), la cual le dice a numpy (atrevés del -1) que calcule el tamaño ADECUADO de las filas

reshape(-1, 1) -> reshape( filas, columnas )

filas = numpy se hace cargo de calcularlas.

David Alsina

student•

Para que sea más facil recordar que hace cada función o parte del código suele ser útil saber que significa, si a alguien le es útil:

nn.Linear(), el nn asumo que proviene de NeuralNetwork.

nn.MSELoss(), el MSE significa MeanSquareError, media de cuadrado de errores.

.SGD(), SGD StochasticGradientDescent, siendo Stochastic = Estocástico(Un proceso estocástico es aquel cuyo comportamiento es no determinista, en la medida que el subsiguiente estado del sistema está determinado tanto por las acciones predecibles del proceso como por elementos aleatorios.)

Usuario anónimo

user•

Aqui agrego un codigo que implementa regresión lineal sin el uso de las librerias mencionadas en el curso,para er lo que hay detras del Objeto .Model() :

import numpy as np
import matplotlib.pyplot as plt
import random

x = np.array([ x+random.uniform(0,1) for x in range(0,10)])
y = np.array([ y+random.uniform(0,1) for y in range(0,10)])

#Compute prediction
def prediction(w,b,x):
  return w*x+b

n = len(y) 

#Compute loss function and gradient's
def loss_function(y,y_p):
  return (1/n)* sum([val**2 for val in (y-y_p)])

def w_slope(y,y_p,x):
  return -(2/n)*sum(x*(y-y_p))

def b_slope(y,y_p,x):
  return -(2/n)*sum(y-y_p)

#Define new Steps to change the values of w & b
def w_new(y,y_p,x,w,lr):
  return w - lr* w_slope(y,y_p,x)
def b_new(y,y_p,x, b,lr):
  return b - lr* b_slope(y,y_p,x)

#Starting values for w & b
def gradient_descent(y,x,w,b, lr):

  y_prediction = []
  w_values=[]
  b_values=[]
  loss_values = []

  iterations = 1000
  for i in range(iterations):
    y_pred = prediction(w,b,x)
    w = w_new(y,y_pred,x,w,lr)
    b = b_new(y,y_pred,x,b,lr)
    Loss = loss_function(y,y_pred) 

    y_prediction.append(y_pred)
    w_values.append(w)
    b_values.append(b)
    loss_values.append(Loss)

    print(f'w={w}, b={b}, loss = {loss_function(y,y_pred)}, i = {i}')

if __name__ == '__main__':
  w=b=0
  lr=0.0259
  gradient_descent(y,x,w,b,lr)

Erick Herrera

student•

Hola, agregué algunos comentarios a las líneas de código para guiarme mejor, espero le sirvan a alguien más.

import torch
# para trabajar con arreglos
import numpy as np
# para implementar nuestra regresión lineal (redes neuronales)
import torch.nn as nn
# trae la optimización necesaria para calcular los gradientes y hacer una backpropagation
import torch.optim as optim
# biblioteca de ayuda para graficar algunas cosas
import matplotlib.pyplot as plt

Regresión lineal

car_prices = [5, 6, 7, 8, 9, 10]
unit_sold = [8.5, 8.0, 7.5, 7.0, 6.5, 6.0]

# grafica los dos datos uno vs el otro
plt.scatter(car_prices, unit_sold)

Transformamos a un arreglo numpy desde un arreglo de python

reshape transforma el arreglo en otra orientación para se trabajado

prices_array = np.array(car_prices).reshape(-1, 1)

unit_array = np.array(unit_sold).reshape(-1, 1)
prices_array, unit_array

Transformamos a una tupla desde un arreglo numpy

# requires_grad_ : el guión bajo significa que agrega en el tensor el requires_grad = True
prices = torch.from_numpy(prices_array).float().requires_grad_(True) 
units = torch.from_numpy(unit_array).float()

Creamos el modelo, la función de errores cuadráticos y el descenso del gradiente.

Creamos un modelo lineal, recibe el tamaño o dimensión de la entrada y salida

model = nn.Linear(1, 1)

Creamos la función de error con la Media del Cuadrado de los Errores

loss_function = nn.MSELoss()

# Stocastic gradient Descendt, lr: learning rate
optimizer = optim.SGD(model.parameters(), lr=0.015)

losses = []
iterations = 2000

for i in range(iterations):
  # Forward pass (predicción)
  pred = model(prices)  # Le enviamos al modelo los features
  loss = loss_function(pred, units) # Obtenemos el error entre la predicción dada y el valor real
  losses.append(loss.data) # Guardamos el error en el arreglo losses para después graficarlo

  optimizer.zero_grad() # Reiniciamos el gradiente, porque PyTorch acumula los gradientes, por eso los reiniciamos
  # Backward pass backpropagation
  loss.backward() 
  optimizer.step() # se mueve en dirección de mi mean

print(float(loss))
plt.plot(range(iterations), losses)

Usuario anónimo

user•

Un gran aporte, muchas gracias

Usuario anónimo

user•

import torch
import numpy as np
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# Regresión Lineal

---



car_prices = [5, 6, 7, 8, 9, 10]
units_sold = [8.5, 8, 7.5, 7.0, 6.5, 6.0]
plt.scatter(car_prices, units_sold)

prices_array = np.array(car_prices).reshape(-1,1)
units_array = np.array(units_sold).reshape(-1,1)
prices_array

prices= torch.from_numpy(prices_array).float().requires_grad_(True)
units= torch.from_numpy(units_array).float()
prices, prices.shape

model = nn.Linear(1,1)
loss_function = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.015)
losses = []
iterations = 2000
for i in range(iterations):
  pred = model(prices)
  loss = loss_function(pred, units)
  losses.append(loss.data)

  optimizer.zero_grad()
  loss.backward()
  optimizer.step()
print(float(loss))
plt.plot(range(iterations), losses)



x=torch.Tensor([[11.0]])
p= model(x)
p```

<code> ```

Daniel Alejandro Moreno Astorga

student•

De verdad esta es la forma de hacer un curso??????. No se explica nada bien. Yo entiendo que el tema da para investigar y complementar desde otras fuentes o recursos de información. Pero por lo que veo hay que aprender en un 100% desde otras fuentes. Lamento hacer esta critica pero es lo que se ve.

Julián Andrés Santos Méndez

student•

Este tema es muy amplio, por eso el curso es de Introducción, en otros cursos se va profundizando en diferentes modelos y en las matemáticas que se necesita para la ML.

Rodrigo Urquizo Yepez

student•

Tienes razon, yo tambien pienso lo mismo, su explicacion es muy pobre y solo pasan imagenes, asi nadie aprende nada, peor los que recien estan comenzando en AI.Mientras no hagan nada te recomiendo hacer el curso de Andrew Ng en Coursera, ahi si se entiende todo y valdria la pena pagar por ese curso a pesar de que es gratis.Te dejo el link: https://www.coursera.org/learn/machine-learning/home/welcome Tambien te dejo una fuente muy buena de Google para ML: https://developers.google.com/machine-learning/crash-course/reducing-loss/learning-rate?hl=es-419 En fin hay un millon de fuentes muy buenas, pero esas son las que me ayudaron a entender todo.

losses = []
iterations = 2000

for i in range(iterations):
  pred = model(prices)
  loss = loss_function(pred, units)
  losses.append(loss.data)

  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

import numpy as np
import matplotlib.pyplot as plt
import random

x = np.array([ x+random.uniform(0,1) for x in range(0,10)])
y = np.array([ y+random.uniform(0,1) for y in range(0,10)])

#Compute prediction
def prediction(w,b,x):
  return w*x+b

n = len(y) 

#Compute loss function and gradient's
def loss_function(y,y_p):
  return (1/n)* sum([val**2 for val in (y-y_p)])

def w_slope(y,y_p,x):
  return -(2/n)*sum(x*(y-y_p))

def b_slope(y,y_p,x):
  return -(2/n)*sum(y-y_p)

#Define new Steps to change the values of w & b
def w_new(y,y_p,x,w,lr):
  return w - lr* w_slope(y,y_p,x)
def b_new(y,y_p,x, b,lr):
  return b - lr* b_slope(y,y_p,x)

#Starting values for w & b
def gradient_descent(y,x,w,b, lr):

  y_prediction = []
  w_values=[]
  b_values=[]
  loss_values = []

  iterations = 1000
  for i in range(iterations):
    y_pred = prediction(w,b,x)
    w = w_new(y,y_pred,x,w,lr)
    b = b_new(y,y_pred,x,b,lr)
    Loss = loss_function(y,y_pred) 

    y_prediction.append(y_pred)
    w_values.append(w)
    b_values.append(b)
    loss_values.append(Loss)

    print(f'w={w}, b={b}, loss = {loss_function(y,y_pred)}, i = {i}')

if __name__ == '__main__':
  w=b=0
  lr=0.0259
  gradient_descent(y,x,w,b,lr)

import torch
# para trabajar con arreglos
import numpy as np
# para implementar nuestra regresión lineal (redes neuronales)
import torch.nn as nn
# trae la optimización necesaria para calcular los gradientes y hacer una backpropagation
import torch.optim as optim
# biblioteca de ayuda para graficar algunas cosas
import matplotlib.pyplot as plt 

# requires_grad_ : el guión bajo significa que agrega en el tensor el requires_grad = True
prices = torch.from_numpy(prices_array).float().requires_grad_(True) 
units = torch.from_numpy(unit_array).float()

losses = []
iterations = 2000

for i in range(iterations):
  # Forward pass (predicción)
  pred = model(prices)  # Le enviamos al modelo los features
  loss = loss_function(pred, units) # Obtenemos el error entre la predicción dada y el valor real
  losses.append(loss.data) # Guardamos el error en el arreglo losses para después graficarlo

  optimizer.zero_grad() # Reiniciamos el gradiente, porque PyTorch acumula los gradientes, por eso los reiniciamos
  # Backward pass backpropagation
  loss.backward() 
  optimizer.step() # se mueve en dirección de mi mean

print(float(loss))
plt.plot(range(iterations), losses)

import torch
import numpy as np
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# Regresión Lineal

---



car_prices = [5, 6, 7, 8, 9, 10]
units_sold = [8.5, 8, 7.5, 7.0, 6.5, 6.0]
plt.scatter(car_prices, units_sold)

prices_array = np.array(car_prices).reshape(-1,1)
units_array = np.array(units_sold).reshape(-1,1)
prices_array

prices= torch.from_numpy(prices_array).float().requires_grad_(True)
units= torch.from_numpy(units_array).float()
prices, prices.shape

model = nn.Linear(1,1)
loss_function = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.015)
losses = []
iterations = 2000
for i in range(iterations):
  pred = model(prices)
  loss = loss_function(pred, units)
  losses.append(loss.data)

  optimizer.zero_grad()
  loss.backward()
  optimizer.step()
print(float(loss))
plt.plot(range(iterations), losses)



x=torch.Tensor([[11.0]])
p= model(x)
p```

Implementación de regresión lineal en Pytorch, Regresión logística, Implementación de regresión logística en Pytorch

Conceptos básicos de Machine Learning

Bienvenida Curso de Introducción a Machine Learning

Introducción a la terminología de Machine Learning

Terminología y regresión lineal

Trabajando con Pytorch

Introducción a Pytorch, trabajar con tensores y representar datasets con tensores

Trabajando con tensores

Representando datasets con tensores

Implementaciones de algoritmos de Machine Learning en Pytorch