Crea una cuenta o inicia sesi贸n

隆Contin煤a aprendiendo sin ning煤n costo! 脷nete y comienza a potenciar tu carrera

Entrenando un modelo de regresi贸n lineal con scikit-learn

3/18
Recursos

Aportes 20

Preguntas 7

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

una 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

Quizas sirva de aclaracion para alguien, con el -1 en reshape(-1,1) le decimos a numpy que 鈥榙ecifre鈥 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

Est谩n chidos estos cursos en los que comienzan con pr谩ctica y luego se pasa a la teor铆a.

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[鈥楻M鈥橾.values.reshape(-1,1)
y=df[鈥楳EDV鈥橾.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(鈥楳ediana Precio casas en miles MDEV鈥)
plt.xlabel(鈥楶romedio 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=鈥楻鈥)

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)

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

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!!!

Este curso esta increible!!!

------>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 鈥減lt.plot(X_std,slr.predict(X_std), color=鈥楻鈥) 鈥
+ 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(鈥淢ediana del precio de las casas en miles [MEDV]鈥) 鈥
鈥 plt.xlabel(鈥淧romedio de habitaciones [RM]鈥)鈥
+Para nombrar el valor de las X como 鈥淧romedio de habitaciones鈥
+Para nombrar el valor de las Y como 鈥淧romedio 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 鈥渆standarizar el numero鈥 a traves de poner un " _std "
+ Continua con un "sc_x.transform ( "
+ Pero tambien tiene que especificar que es un 鈥渁rreglo 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, 鈥減rint (鈥 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)) "

Que pasa cuando hay m谩s de una variable de correlaci贸n?

A mi me sale un error en el color=鈥楻鈥, y lo reemplac茅 por color =鈥楻ed鈥

------>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 鈥淴鈥 y 鈥淵鈥, con la que vamos a trabajar. Justo usando estas dos lineas de codigo.:
鈥 X = df[鈥楻M鈥橾.values.reshape(-1, 1) 鈥
鈥 y = df[鈥楳EDV鈥橾.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 " sc
variable.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.

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

Unico detalle, es que los valores que nos da la regresion no estan directamente en condiciones para ser usados por ninguna otra libreria de visualizacion que no sea matplolib, aqui la solucion para ser usados:

fig1 = px.scatter(
    x = X_std[:,0],
    y = y_std[:,0],
    opacity=0.5,
)

fig1.update_traces(marker_size=12)

fig2 = px.line(
    x = X_std[:,0],
    y = slr.predict(X_std)[:,0], 
    color_discrete_sequence=["#FA0087"]
)

fig5 = go.Figure(data=fig1.data + fig2.data)

fig5.show()

y otra manera de calcular lo mismo:

import scipy.stats

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)

regress_x_y = scipy.stats.linregress(x=X_std[:,0], y=y_std[:,0])
regress_y_x = scipy.stats.linregress(x=y_std[:,0], y=X_std[:,0])

print(regress_x_y, regress_y_x, sep="\n\n")

df_x_y_x1 = np.array([X_std.min(), X_std.max()])
df_x_y_y1 = regress_x_y.intercept + regress_x_y.slope * df_x_y_x1

df_y_x_x1 = np.array([y_std.min(), y_std.max()])
df_y_x_y1 = regress_y_x.intercept + regress_y_x.slope * df_y_x_x1

fig1 = px.scatter(
    x = X_std[:,0],
    y = y_std[:,0],
    opacity=0.5,
)

fig1.update_traces(marker_size=12)

fig2 = px.line(
    x=df_x_y_x1, y=df_x_y_y1, color_discrete_sequence=["#FA0087"]
)

fig5 = go.Figure(data=fig1.data + fig2.data)

fig5.show()

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)

Les comparto mi soluci贸n con un poco menos de c贸digo


Tenia la duda de : **驴porque la mediana en vez de la media? **y google dice :

La media se utiliza para distribuciones normales de n煤meros, con una cantidad baja de valores at铆picos.

La mediana se utiliza generalmente para devolver la tendencia central en el caso de distribuciones num茅ricas sesgadas.

Ejemplo: distribuci贸n sesgada
2, 2, 3, 3, 5, 7, 8, 130
(2+2+3+3+5+7+8+130)/8= 20
MEDIA = 20

(3+5)/2=4
MED = 4

Tiene sentido por los outliers que nos encontramos en la visualizacion primaria las casas 鈥淪uperCaras鈥 pueden sesgar el numero si sacamos la tendencia central incorrecta.

Al escalar los datos lo que estamos haciendo es cambiar el rango de nuestros datos:

Solo esta comenzando y es de los mejores cursos que he tomado en la plataforma de platzi,

estan flipantes estos cursos ^鈥揯

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[鈥楻M鈥橾.values.reshape(-1,1)
y=df[鈥楳EDV鈥橾.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(鈥楳ediana Precio casas en miles MDEV鈥)
plt.xlabel(鈥楶romedio 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=鈥楻鈥)