Entrenando un modelo de regresión lineal con scikit-learn
Contenido del curso
Cómo funciona la regresión lineal
Regresión lineal multivariable
Proyecto práctico
Pasos siguientes
Entrenando un modelo de regresión lineal con scikit-learn
Contenido del curso
Entrenando un modelo de regresión lineal con scikit-learn
Thomas Gonzalez Rodrigues
Estudiante
Jeinfferson Bernal G
Estudiante
Mauricio Gonzalo Aliendre Pérez
EstudianteJeinfferson Bernal G
Estudiante
Pedro Alvarado Garcia
Estudiante
Jonatan David Acevedo Lopez
Estudiante
Endy Bermúdez R
Estudiante
Rafael Rivera
Estudiante
Julián Cárdenas
Estudiante
Tomas Dale
Estudiante
Luis Fernando Laris Pardo
Estudiante
Pedro Navarrete
Estudiante
Fabian Villada
Estudiante
Marcelo Bengolea
Estudiante
Harry Salvador
EstudianteTomas Dale
Estudiante
Carlos Mazzaroli
Estudiante
Dick Saide Suárez Blanco
Estudiante
Martín Alexis Farrera Lara
Estudiante
Dionicio Perez
Estudiante
Marco Carmona
EstudianteLuis Fernando Laris Pardo
Estudiante
Natalia Caro Barrios
Estudiante
Axel Yaguana
Team PlatziNatalia Caro Barrios
Estudiante
Cristian Enrique Cuevas Mercado
Estudiante
Jeison Mesa Diez
Estudiante000791.d35f7069a76c4bbfbfa52e7
Estudiante
Matías Collado
EstudianteDick Saide Suárez Blanco
Estudiante
Jaime Joaquín Gonzalez Bosch
Estudiante
Mario Alexander Vargas Celis
Estudiante
Adriana Villalobos
Estudianteuna representation grafica de lo que hace .reshape(-1,1)
arr:
[2 3 4 5 6 7 8]
la forma es (7,) lo que es solo una dimension
arr.reshape(-1,1)
[[2] [3] [4] [5] [6] [7] [8]]
su forma es de (7,1) por lo que se le agrega una dimension
Gracias. Todo mas claro! 😉
Quizas sirva de aclaracion para alguien, con el -1 en reshape(-1,1) le decimos a numpy que 'decifre' la nueva dimension basado en la longitud de la dimension previa, es decir si teniamos una dimension de (4,) ahora tendremos una dimension igual a (4,1), si hubieramos puesto reshape(1,-1) tendríamos una dimensión igual a (1,4) | Fuente: https://stackoverflow.com/questions/18691084/what-does-1-mean-in-numpy-reshape
Muy interesante!
Están chidos estos cursos en los que comienzan con práctica y luego se pasa a la teoría.
Me parece bastante espectacular lo que se ha visto en tan solo tres clases. Ha usado un montón de conceptos que se han aprendido a lo largo de muchos cursos de una manera muy simple y fácil de comprender, esto me llena de mucha expectativas respecto a este curso. Estoy muy emocionado!!!
Un fragmento para predecir el precio de las viviendas con diferentes número de habitaciones:
n_rooms = 6 n_rooms_std = sc_x.transform(np.array([n_rooms]).reshape(-1, 1)) std_prediction = slr.predict(n_rooms_std) price = float(sc_y.inverse_transform(std_prediction))*1000 print(f'El precio estimado de una vivienda de {n_rooms} habitaciones en boston es de US${round(price, 2)}')
output>>> El precio estimado de una vivienda de 6 habitaciones en Boston es de US$19942.03
Excelente aporte Endy, gracias por compartir
Gracias compañero, buen aporte!
Tiene error el anteriro, este esta bien
from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LinearRegression
#Promedio de casas, y mediada de precios #reshape para eliminar problema de #Expected 2D array , got 1D array X=df['RM'].values.reshape(-1,1) y=df['MEDV'].values.reshape(-1,1)
sc_x = StandardScaler() sc_y = StandardScaler()
#standarizacion de los datos X_std = sc_x.fit_transform(X) y_std = sc_y.fit_transform(y)
slr= LinearRegression() slr.fit(X_std, y_std)
#GRAFICAR plt.ylabel('Mediana Precio casas en miles MDEV') plt.xlabel('Promedio habitaciones RM')
#scatter plt.scatter(X_std,y_std);
#linea roja de predicción de modelo entrenado slr plt.plot(X_std, slr.predict(X_std),color='R')
import numpy as np
num_habitaciones = 5
num_habitaciones_std = sc_x.transform(np.array([num_habitaciones]).reshape(-1,1)) precio = sc_y.inverse_transform(slr.predict(num_habitaciones_std))
print("El precio de una casa con 5 habitaciones en Boston es de ", precio)
:thinking: Es cierto, luego pueden pasar errores en ciertos puntos, en ciertos casos lo mejor es aplicar el reshape de numpy como bien mencionas. Gracias por este comentario!
A mi me sale un error en el color='R', y lo reemplacé por color ='Red'
tal cual, me sucedio lo mismo
Otra forma de corregirlo es con "r" minúscula.
Este curso esta increible!!!!
from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LinearRegression
#Promedio de casas, y mediada de precios #reshape para eliminar problema de #Expected 2D array , got 1D array X=df['RM'].values.reshape(-1,1) y=df['MEDV'].values.reshape(-1,1)
sc_x = StandardScaler() sc_y = StandardScaler()
#standarizacion de los datos X_std = sc_x.fit_transform(X) y_std = sc_x.fit_transform(y)
slr= LinearRegression() slr.fit(X_std, y_std)
plt.ylabel('Mediana Precio casas en miles MDEV') plt.xlabel('Promedio habitaciones RM')
#scatter plt.scatter(X_std,y_std);
#linea roja de predicción de modelo entrenado slr plt.plot(X_std, slr.predict(X_std),color='R')
pregunto, no es confuso poner x_std para referirnos a la normalización? lo primero que se me vino a la mente era la desviación estándar con el sufijo std
------>Regresion lineal / Scikit-learn<-------- (minutos 7:24 a 13:34) Parte 2
σ Objetivo principal es graficar, se tienen dos variables, se tiene que graficar. 1. " plt.scatter(X_std,y_std) " +Esto nos ayuda a mostrar los datos de los que se esta haciendo la prediccion. +En donde la variable X = estandarizado de las casas. Y = la mediana de los precios. 6. Utilizar un plot para ver como esta haciendo las predicciones. Utilizando "plt.plot(X_std,slr.predict(X_std), color='R') " + Basicamente diciendole al modelo, ya creaste una linea recta, ahora utiliza los valores que conoces de x para crear predicciones +Y no solo eso sino, que lo ponga la linea en un color Rojo. ----------->Antes de continuar, Luis quiere aplicar una etiqueta a las X and Y axis en la grafica, para ello usa : " plt.ylabel("Mediana del precio de las casas en miles [MEDV]") " " plt.xlabel("Promedio de habitaciones [RM]")" +Para nombrar el valor de las X como "Promedio de habitaciones" +Para nombrar el valor de las Y como "Promedio de habitaciones" -----------> Con el modelo ya generado se pueden hacer predicciones. En este ejemplo imaginemos cuales es la mediana del precio de una casa de 5 habitanciones. 7. " num_habitaciones = 5 " + Solo establecemos el numero de de la variable. (luego estableceremos la varible en si). 8. " num_habitaciones_std= sc_x.transform(np.array([num_habitaciones]).reshape(-1,1)) " ----------> UFF muchas cosas estan ocurriendo aqui. + El objetivo ahora es especificar a la computadora lo que se va a hacer con " num_habitaciones " + Lo primero que hace es "estandarizar el numero" a traves de poner un " _std " + Continua con un "sc_x.transform ( " + Pero tambien tiene que especificar que es un "arreglo de numpy" (el cual lo abrevio como np) entonces se pone nombre de la variabla.array OR " (np.array( " + Interesante, Luis escribe " [num_habitaciones] ", lo cual ya sabemos que es la varible con la que quiere trabajar. Mas esta en formato de " lista " OR " [ ] ", y esto es para que se vea mejor. +" .reshape(-1,1)) " Esto segun Google, es para que no tener que especificar las dimensiones of the axis. 😮 ----------> Una vez teniendo el valor estandarizado que se quiere predecir. 9. Ahora solo queda presentar los graficos con titulo que le de sentido. " print("El precio de una casa con 5 habitaciones en Boston es de ",sc_y.inverse_transform(slr.predict(num_habitaciones_std))). ----------> Oh yeah baby 😎 estas lineas de codigo son las buenas. +Empezando con algo facil, "print (" blah blah... " eso ya sabemos es un string. + Sin embargo, es portante saber que la grafica se entienda mejor, debera primero aplicarse la inversa del y-axis. Es to se hace con un ",sc_y.inverse_transform", de lo que se quiere predecir. +Que en este caso lo que se quiere predecir es el numero de habitaciones el cual es " (slr.predict(num_habitaciones_std)) "
¿Cuándo aplico StandardScaler() a los datos los escala a 0? He seguido los pasos tal cual lo explica el maestro. Aun no lo resuelvo, alguien que sepa que esta pasando?
Este el link de la documentación oficial de la libreria Sklearn, el proceso de escalamiento estandar es el siguente
z = (x - u) / s Esto es, a un valor de x se le resta el promedio y el resultado se divide entre la varianza. Entonces, no escala los datos a cero, sino normaliza, centra y estandariza los datos.
¿Por qué en este ejemplo no se separar el dataset en datos de entrenamiento y datos de testeo?
Porque en este ejercicio solo se quería mostrar cómo funciona la regresión lineal sin entrar tanto a detalle en puntos técnicos de cómo hacer aprendizaje supervisado en ML, en el caso práctico sí se utilizan datos de entrenamiento y de prueba :D
Para que es estandarizan las variables? Podríamos hacer la regresión con las variables sin estandarizar:
x = data['RM'].values.reshape(-1, 1) y = data['MEDV'].values.reshape(-1, 1)
slr = LinearRegression() slr.fit(x, y)
¡Hola, Natalia!
La estandarización se usa por varios motivos. Entre ellos cuando las variables tienen diferentes unidades. Por ejemplo, si quisiéramos analizar el peso y estatura de individuos, tendríamos variables muy distintas. Una persona puede medir 182 cm y pesar 72 kg. De 72 a 182 hay una diferencia de 110. Entonces, al estandarizar, se pretende minimizar ese efecto.
Para machine learning, previo a la creación de los modelos, hay un paso que se llama feature engineering que trata sobre todos estos procedimientos de estandarización y normalización.
@axl_yaguana, Muchas gracias por tu explicación, me quedo claro.
Le falto algo en el print(). "El precio PROMEDIO de una casa con 5 habitaciones en boston es de" El pronostico en regresion se basa en la media, donde ese sera el valor medio pronosticado en la variable explicada para un valor dado de X (variable explicativa)
Hola @Cristian, hay que tener cuidado en realidad cuando es un modelo de regresión lineal no es pronóstico es predicción (solo podemos predecir en el espacio parametrico de nuestros valores observados) . Cuando se habla de pronóstico, es utilizando algún modelo de series de tiempo. Y efectivamente tienes razón la predicción en este caso sería -El valor esperado de la median del precio.
Que pasa cuando hay más de una variable de correlación?
Según la clase de estadistica descriptiva: Primero que todo, la correlación nos dirá el grado de relación lineal entre dos variables. Si la correlación es muy alta, cada una representa muy bien el comportamiento de la otra. Posteriormente, podemos usar el PCA, que es una técnica que nos permite reducir variables que aportan la misma información deducida de su alta correlación. Gracias a esto, reducimos la dimensionalidad.
------>Regresion lineal / Scikit-learn<-------- (minutos 0:16 a 7:24 ) Parte 1
σ Luis explica que un Modelo de regresion Lineal utiliza puntos reales los cuales ajusta una linea recta para asi poder hacer una predccion sobre estos. σ Scikit - learn es una Machine Learning de Python que ayuda a graficar datos. 1. Lo primero es importar la libreria de Scikit - learn. Para ello Luis Utiliza " from sklearn.preprocessing import StandardScaler" + " from "( continua ) " import ", esto es importante porque nos muestra otra manera de declarar a la computadora el lugar de donde queremos importar las cosas. Y asu vez a donde llevarlas. + " StandardScaler ". Nos permite hacer un escalamiento de los datos, lo que permite que el modelo se ajuste bien a ellos. 2.Importar la informacion que se va a ocupar para el modelo. Para ello se utiliza " from sklearn.linear_model import LinearRegression. NOTA: Ya con estas dos lineas de codigo, se puede empezar hacer un modelo de regresion lineal. 3.Pero primero debemos de definir la variable "X" y "Y", con la que vamos a trabajar. Justo usando estas dos lineas de codigo.: " X = df['RM'].values.reshape(-1, 1) " " y = df['MEDV'].values.reshape(-1, 1) " ------------> +Notas rapidas: ambos valores ya se establecieron la clase pasada. (Era segun la columna or Valor dependiente e independiente segun sea el caso). Segun el caso " X " sera el promedio de las casas. e " Y " sera la mediana de los precios. +Algo interesante es ver que debemos se escribe un " .values " despues de la definicion, obvio ya sabemos que eso es para declarar que solo queremos los valores. + Asi mismo, despues de ".values" hay un ".reshape. (-1, 1) " and the reason for this is that without them , the information would move one move to the left. 4. Crear el modelo de StandarScaler poniendo " sc_x = StandardScaler() " " sc_y = StandardScaler() " +Esto es solo como para programar que vamos a usar el StandarScaler con estos datos, pero nada mas, ya que despues si se va a poner los datos y valores. 5. Ahora si los datos para el StandardScaler de ambas variables, para ello usamos. " X_std = sc_x.fit_transform(X) " " y_std = sc_y.fit_transform(Y) " +originalmente no era " X_std " y " Y_std " , sino que eso de " std " se le agrego, para aclarar que la variable que se escibria es la estandarizacion. (y no la version regular). + la segunda parte de este es " scvariable.fit_transform() ", y al final esta llega a ser la manera en la que se especifica que los resultados de esta estandarizacion se deben de mostrar en la grafica de una manera ajustada. (que como ya sabemos, nos ayuda a hacer una prediccion mas acertada.) + Al ultimo de la linea ponemos nuevamente la variable, solo para aclarar. 6. Ya con todos los datos, podemos crear un modelo de regresion lineal " slr = LinearRegression() " " slr.fit(X_std, y_std) " + " slr " = standard linear regression. Notese que esta estableciendo un la abreviacion de slr. + " nombre de la variable.fit(x_std, y_std) " crear un feed o linea recta que mejor se ajuste a los datos. Y que lo haga con los valores estandarizados de X e Y.
La función StandardScaler() de la biblioteca sklearn.preprocessing se utiliza para estandarizar características, es decir, restar la media y escalar a la varianza de cada variable. Esto es importante en regresiones lineales, ya que ayuda a que los algoritmos converjan más rápido y mejora la precisión.
Si aplicas StandardScaler() a la variable Y (dependiente) y a las variables X (independientes) por separado, mantienes la integridad de la relación entre ellas. Usar la misma transformación en ambas no sería correcto, ya que Y es afectada por X y su escala puede ser diferente.
Entrenar un modelo de regresión lineal con Scikit-learn es sencillo. A continuación te muestro un ejemplo completo, paso a paso, con explicaciones:
✅ 1. Importar las librerías necesarias
import numpy as np import pandas as pd from sklearn.linear_model import LinearRegression from sklearn.model_selection import train_test_split from sklearn.metrics import mean_squared_error, r2_score
✅ 2. Crear o cargar los datos
Aquí vamos a crear datos sintéticos como ejemplo:
# Datos de ejemplo (relación lineal con algo de ruido) np.random.seed(0) X = 2 * np.random.rand(100, 1) y = 4 + 3 * X + np.random.randn(100, 1)
✅ 3. Dividir en entrenamiento y prueba
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
✅ 4. Entrenar el modelo
model = LinearRegression() model.fit(X_train, y_train)
✅ 5. Ver los coeficientes del modelo
print(f"Intercepto: {model.intercept_}") print(f"Coeficientes: {model.coef_}")
✅ 6. Realizar predicciones
y_pred = model.predict(X_test)
✅ 7. Evaluar el modelo
print(f"Error cuadrático medio (MSE): {mean_squared_error(y_test, y_pred):.2f}") print(f"Coeficiente de determinación (R²): {r2_score(y_test, y_pred):.2f}")
✅ 8. (Opcional) Visualizar resultados
import matplotlib.pyplot as plt
plt.scatter(X_test, y_test, color='blue', label='Datos reales') plt.plot(X_test, y_pred, color='red', linewidth=2, label='Regresión lineal') plt.xlabel('X') plt.ylabel('y') plt.legend() plt.title('Modelo de Regresión Lineal') plt.show()
El método inverse_transform se utiliza para revertir una transformación aplicada a los datos, como la normalización o estandarización, permitiendo que los resultados se interpreten en su escala original. Esto es crucial al evaluar modelos de regresión lineal, ya que queremos entender las predicciones en el contexto de los datos originales. Por el contrario, transform aplica la transformación sin revertirla. En resumen, se usa inverse_transform para obtener valores que tengan sentido en la escala original de los datos.