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

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

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[‘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)

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 “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)) "

A mi me sale un error en el color=‘R’, y lo reemplacé por color =‘Red’

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

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 “SuperCaras” 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[‘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’)