Implementación de regresión logística en Pytorch

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

Resumen

En esta clase implementaremos en PyTorch la regresión logística. Empezaremos generando unos datos, separarlos y construir el modelo para ver cómo nos queda nuestra predicción

Usuario anónimo

user•

Tenemos dos entradas (valores de los puntos en X y valores de los puntos en Y). Como tenemos un modelo lineal, este va a veparar la entradas con una línea (de color verde), que se describe con la ecuación de la recta:

AX + BY + C = 0

donde -> A: pesos para las entradas en el eje X B: pesos para las entradas en el eje Y C: Umbral de activación del modelo

A = w0[0][0], B = w0[0][1], C = w[1]

despejando Y de la ecuación de la recta, nos queda:

Y = -(AX + C)/ B

y reemplazando A, B y C, nos queda:

Y = -(X * w0[0][0] + w[1]) / w[0][1]

Axel Jiménez

student•

Perfecto, gracias.

Usuario anónimo

user•

Gracias, son cosas que parecen obvias, pero si no las explican, entonces va a ser dificil entender de donde salen algunas ecuaciones, lo que no entiendo aun es como el programa entiende que para model(x,y) = 0,5 la x y la y serán la solucicón a la ecuación AX + BY+C = 0

Eugenio Borzone

student•

Por que no usan ejemplos como la gente?? hay miles de dataset gratis y usan basuras de 6 datos 100% lineal en la regresion lineal y ahora con datos random.. Alto bando, encima no explica nada

Marvin Castillo Félix

student•

Angel Armando Martínez Blanco

student•

Juan Nuñez

student•

Espero que si alguien tuvo alguna duda con esto también le pueda ayudar.

data[:h, :] es una notación usada en numpy para manipular los arreglos sin tener que separarlos.

El arreglo tiene la forma siguiente donde los puntos en X están alojados en el las posiciones [n][0] y los puntos Y están en [n][1]

[ [x1, y1], [x2, y2], [x3, y3] ........ [xn, yn] ]

dado que se necesitan 2 nubes separadas entonces hay que asignar una separación del primer punto a la mitad, entonces data[ : h, : ] es la notación para decir: ve de inicio a h en la coordenada n y ve de inicio a fin en la coordenada m. esto hace que por cada punto X,Y se le asigne la operación de multiplicar por 3 en el caso de este ejercicio y para la siguiente mitad: data[h : , : ] es la notación para decir: ve de la mitad h al final en la coordenada n y ve de inicio a fin en la coordenada m

cuando se hace el plt.scatter() hay que darle un arreglo en x y un arreglo en y por lo que data[ : , 0] dice: ve de inicio a fin en la coordenada n tomando solo el primer elemento de la coordenada m, haciendo lo mismo para Y data[ : , 1] dice: ve de inicio a fin en la coordenada n tomando solo el segundo elemento de la coordenada m,

Leonardo Rodrigo Guardamagna

student•

Excelente y clara la explicación estimado Juan, gracias!

Luis Fernando Pedroza Taborda

student•

Genial explicacion, Juan con este entendi para donde vamos.

- -

student•

Es un desastre esta clase, saca las cosas de la absoluta nada y no explica de donde salen, y espera que nosotros entendamos.

Oyarzabal Ivan

student•

Yo opino un poco igual, pero pensa que es solo buscar que hacen las funciones que el no explica o poner un print y ver que carajos hace. Al final de la clase quedate con la idea de que esto es lo mismo que el agrupamiento sin clasificar jajaja tambien es la base del aprendisaje supervisado por como lo veo

Daniel Montes

student•

Bastante normal en Platzi...

Usuario anónimo

user•

La ecuación que se grafíca aquí es el ajuste lineal de los datos, y = w*x+b. NO la función sigmoide. Ademas, el dato w0[0][1],que no se explica en el video, es el valor de ajuste respecto a el eje Y de entrada, y w0[0][0] la pendiente del eje X de entrada. tensor([x,y][x,y]... )

Erick Herrera

student•

Buenísima, me aclaraste muchas dudas, por eso no me calzaba nada. Gracias

Juan Manuel Cabanillas Lopez

student•

tome su like buen hombre

Engels Prado

student•

tuve que repetir el video como 5 veces jajaja

Helard Flores

student•

jajajaja no eres el unico, yo todo el curso :v

Edwar Cedeño

student•

hasta este punto he tenido que hacer lo mismo, sobre todo en las practicas los ejemplos no son para nada intuitivo y esperan que esto sirva de base.

Jose Oliva Rivera

student•

Implementación de regresión logística:

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


def _get_data(pares_de_datos):
    mitad_de_pares = pares_de_datos//2
    dimen = 2
    return np.random.randn(pares_de_datos, dimen)*3, mitad_de_pares, dimen


def _grafics(labelx, labely, color, s, alpha):
    if plt.scatter(labelx, labely, c=color, s=s, alpha=alpha):
        print('Grafics [OK]')
    else:
        print('Grafics [FAIL]')

def _grafics_with_plot(labelx, labely):
    if plt.plot(labelx, labely):
        print('Grafics [OK]')
    else:
        print('Grafics [FAIL]')


def training_losses(inpt, outpt, model, loss_function, optimizer, losses, iterations):
    for i in range(iterations):
        result = model(inpt)
        loss = loss_function(result, outpt)
        losses.append(loss.data)

        optimizer.zero_grad()
        loss.backward()                                                                  # Back Propagation
        optimizer.step()
    print('last loss: {}.'.format(float(loss)))
    _grafics_with_plot(range(iterations), losses)
    return model



def create_model(inpt, outpt):
    model = nn.Sequential(nn.Linear(2,1), nn.Sigmoid())
    loss_function = nn.BCELoss() # BCE es el Binary cross entropy
    optimizer = optim.SGD(model.parameters(), lr=0.015)
    model = training_losses(inpt, outpt, model, loss_function, optimizer, losses=[], iterations=2000)
    return model


def main(data, mitad_de_pares, pares_de_datos, colors):
    target = np.array([0]*mitad_de_pares + [1]*mitad_de_pares).reshape(pares_de_datos,1)
    inpt = torch.from_numpy(data).float().requires_grad_()
    outpt = torch.from_numpy(target).float()
    model = create_model(inpt, outpt)
    input_data = torch.Tensor([[-5, -6]])
    prediction = model(input_data).data[0][0] > 0.5
    print('La probabilidad sera de: {}, por lo tanto la es de color: {}.'.format(prediction.data, colors[prediction]))

if __name__ == '__main__':
    pares_de_datos = 100
    data, mitad_de_pares, dimen = _get_data(pares_de_datos)
    colors = ['blue', 'red']
    color = np.array([colors[0]]*mitad_de_pares + [colors[1]]*mitad_de_pares).reshape(pares_de_datos)
    _grafics(data[:,0], data[:,1], color, s=75, alpha=0.6)
    data[:mitad_de_pares, :] -= 3*np.ones((mitad_de_pares, dimen))
    data[mitad_de_pares:, :] += 3*np.ones((mitad_de_pares, dimen))
    _grafics(data[:,0], data[:,1], color, s=75, alpha=0.6)
    main(data, mitad_de_pares, pares_de_datos, colors)

Karel Muñiz Perdomo

student•

Hola Jose Muchas gracias por compartir tu codigo. Lo tienes ademas en algun repositorio de git. me siento mas comodo almacenando mi codigo en Github que en cuadernos. Los estudiantes que quieran compartir un repositorio podriamos colaborar Gracias

Usuario anónimo

user•

Comparto el código de las actividades de esta sesión de clase. Importación de librerías necesarias:

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

import matplotlib.pyplot as plt

Generación de los datos aleatoriamente y presentación de los datos obtenidos:

n = 100
h = n//2
dimen = 2

data = np.random.randn(n, dimen)*3
data

Gratificación de los datos tabulados anteriormente:

plt.scatter(data[:,0], data[:,1])

Seperación y marcación de datos en colores para distinguir las regiones de probabilidad con graficación de las regiones:

data[:h, :]= data[:h, :] - 3*np.ones((h, dimen))
data[h:, :]= data[h:, :] + 3*np.ones((h, dimen))
colors = ['blue','red']

color = np.array([colors[0]]*h + [colors[1]]*h).reshape(n)
plt.scatter(data[:,0], data[:,1], c=color, s=75, alpha=0.6)

Calulo del target y los datos de las entradas para el modelo:

target = np.array([0]*h + [1]*h).reshape(n, 1)

x = torch.from_numpy(data).float().requires_grad_(True)

y = torch.from_numpy(target).float()

x.shape, y.shape

Construcción del modelo neuronal, entrenamiento y gráfica de este:

model = nn.Sequential(
          nn.Linear(2,1),
          nn.Sigmoid()
      )
loss_function = nn.BCELoss()

optimizer = optim.SGD(model.parameters(), lr=0.01)

losses = []

iterations = 2000

for i in range(iterations):
  result = model(x)
  
  loss = loss_function(result, y)
  losses.append(loss.data)
  
  optimizer.zero_grad()
  loss.backward()
  
  optimizer.step()

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

Pruebas del modelo con puntos en ambas regiones de probabilidad

blue = torch.Tensor([[-5, -6]])
prediction = model(blue).data[0][0] &gt; 0.5
print(colors[prediction])
red = torch.Tensor([[8, 6]])
prediction = model(red).data[0][0] &gt; 0.5
print(colors[prediction])

Gráfica de la línea de separación de ambas regiones de probabilidad con el calculo en una escala de pesos (w):

w = list(model.parameters())
w0 = w[0].data.numpy()
w1 = w[1].data.numpy()

plt.scatter(data[:,0], data[:,1], c=color, s=75, alpha=0.6)

x_axis = np.linspace(-10, 10, n)
y_axis = -(w1[0] + x_axis*w0[0][0]) / w0[0][1]
plt.plot(x_axis, y_axis,'g--')

Alex John Chamba Macas

student•

Gracias por compartir y comentar el código.

Moises Diaz

student•

Uff gracias!!

Jaime Ramos

student•

no queda claro de donde saca y_axis, dice que de la ecuación del sigmoide pero la ecuación del sigmoide no es así... a lo mejor debe ser algo implícito que debió mencionar...

Arnulfo Rojas Jimenez

student•

Supongo que la salida corresponde a la ecuación de la recta, y=mx + b donde m y b son la salida de la regresión (w). Lo que no entiendo es porque w(0) tiene 2 valores, ni tampoco porque realiza la división.

y_axis = -(w1[0] + x_axis*w0[0][0]) / w0[0][1]

Usuario anónimo

user•

Revisando los comentarios encontré esta respuesta, la cual me parece la mas acertada, espero te sirva.

AX + BY + C = 0

donde -> A: pesos para las entradas en el eje X B: pesos para las entradas en el eje Y C: Umbral de activación del modelo

A = w0[0][0], B = w0[0][1], C = w[1]

despejando Y de la ecuación de la recta, nos queda:

Y = -(AX + C)/ B

y reemplazando A, B y C, nos queda:

Y = -(X * w0[0][0] + w[1]) / w[0][1]

Usuario anónimo

user•

Esta bien complejo todo el tema de entender los porque de las cosas

Jhon Freddy Puentes Nuñez

student•

Tomado de: https://towardsdatascience.com/building-a-logistic-regression-in-python-301d27367c24

Usuario anónimo

user•

Temas que tienen su complejidad

Usuario anónimo

user•

Bastante .-.

Victor Macas

student•

me hablaron chino, necesito un pre del pre curso de introducción :/

Andrés Enrique Sanabria Flores

student•

Puedes hacer los cursos de matemáticas como estadística, cálculo, algebra lineal y de programación python. 🔥

Christian Mahonry Colorado Bulbarela

student•

Información complementaria si alguien se perdio como yo, cuando busca en print(colors[prediction])

(https://stackoverflow.com/questions/17742744/python-list-true-false-first-two-elements)

Geraldine León

student•

Excelente info bro

Juan Cepeda

student•

Muy util, gracias!

Usuario anónimo

user•

Quedan muchas cosas en el aire, sobre todo de fundamentos.

Matias Alexander Ibarra Trujillo

student•

deberias ver los siguientes cursos: https://platzi.com/clases/algebra-ml/ https://platzi.com/clases/matematicas-ai/ https://platzi.com/clases/algebra-lineal/ https://platzi.com/clases/calculo-multivariable/

Recomiendo el libro "calculo de varias variables"-stewart

Con esto puedes profundizar aun mas en los fundamentos matematicos. Igual podrias consultar sobre los tipos de algoritmos que existen

Alexander Mayor

student•

Por si alguien quiere jalar datos desde Google Drive a través de URL:

#Jalamos todas las librerias necesarias

import torch import numpy as np import torch.nn as nn import torch.optim as optim import matplotlib.pyplot as plt import pandas as pd import gspread as gs import gspread_dataframe

#En este caso, hacemos esto para importar los datos de Google Drive, vamos a jalar el auth

from gspread_dataframe import get_as_dataframe, set_with_dataframe from google.colab import auth auth.authenticate_user() from oauth2client.client import GoogleCredentials gc = gs.authorize(GoogleCredentials.get_application_default())

#ahora vamos a leer el archivo por URL

spreadsheet = gc.open_by_url('TU_URL') sheet = spreadsheet.get_worksheet(5) dataframe = pd.DataFrame(sheet.get_all_records()) dataframe

Usuario anónimo

user•

Equation de una LINEA RECTA: Ax+By+C=0. Luego:

A = parameters[0][0] B = parameters[0][1] C = parameters[1]

Usuario anónimo

user•

De verdad que estoy sorprendido con su forma de explicar, hay pequeñas cosas que no entiende uno pero es por los nombres de las funciones que aun no sabemos que se pueden usar y que hacen, pero de resto me siento muy bien. Su tono de voz y la velocidad son perfectas. Gracias.

Arturo Baduna

student•

yo tambien no entiendo 'pequeñas cosas' pero siento q estoy haciendo las cosas mecanicas y no me gusta. yo supongo que cuando me peguen por hacer eso casa vez q necesite hacer algo de esto voy a tener este archivo como modelo,pero no me sierra

Gian franco baltazar mamani

student•

mmm, haber si entendi: Entonces esa vaina es para aplicar la clasificacion binaria a partir de la funcion Sigmoideal, conservando la naturaleza de un Modelo Lineal para buscar reducir el gradiante, pero ahora tomando el cuenta el BCE (log loss). Por lo demas, sigue los mismos pasos del Modelo Lineal: 1. Prediccion 2. Back Propagacion 3. Optimizacion La diferencia es que ahora se utiliza las variables pesos para diferenciar binariamente los puntos graficados y formar dos grupos (Cluster) por los cuales se pueden analizar y aprender para que la maquina pueda predecir el color de cierta coordenada que le demos a continuacion, usando, como se menciono antes, la clasificacion binaria (una muy sencilla). ¿Estará bien eso?

Eday Alix González Manjarrés

student•

No entiendo por qué lo multiplicó por 3...

Alguién ?

juan cabrera

student•

para separar cada nube osea los separo pa que se viera mas la separacion sino se verian muy ensimados

Eugenio Borzone

student•

Hola Eday, estaba construyendo el dataset, al principio creo numeros aleatorios entre 0 y 1 (100). Luego los ordeno y dividio en 2 (50 y 50) y a una mitad la multiplico por 3 y a la otra por -3. para que los puntos suban y bajen respectivamente. Asi poder separarlos. Al profesor le parecio mas pertinente confundir a todos y cear un dataset y algoritmo que no sirve para nada que buscar algun dataset real en iternet y ser mas didactico.

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

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

Regresión logística

Implementación de regresión logística en Pytorch

Redes Neurales y reconocimiento de imágenes

Cómo funciona el reconocimiento facial

Neuronas y función de activación, Usando un modelo pre entrenado para reconocimiento de imágenes, Trabajando un dataset

Usando un modelo pre entrenado para reconocimiento de imágenes

Trabajando un dataset

Reconocimiento de imágenes

Construyendo un modelo, Implementando un clasificador totalmente conectado, Mejoras, limitaciones y conclusiones

Training and Loss: entrenando y ajustando nuestro modelo

Implementando un clasificador totalmente conectado

Mejoras, limitaciones y conclusiones

Collab con Scikit

Aprende a usar Collab con scikit

Demo con Scikit: división de datos

Demo con Scikit: validación de datos

Algoritmos más usados en Machine Learning

Los algoritmos más usados en Machine Learning

Algoritmos supervisados en Machine Learning

Algoritmos no supervisados en Machine Learning

Bonus: Redes neuronales y herramientas

Qué es lo que está detrás de una red neuronal

Cómo funciona una red convolucional intuitivamente y porque son tan buenas con imágenes

Redes generativas

Cierre

Conclusiones y siguientes pasos