Python se ha convertido en uno de los lenguaje de programación más populares dentro de la industria del Machine Learning y otras ramas de la ingeniería. Es increíble la cantidad de cosas que se pueden hacer con el y un poco de imaginación. En este articulo haremos uso de Python para predecir costo casa Python , utilizado como alimentación de nuestro algoritmo un dataset enorme de casas con sus características y costo de cada una de ellas.
Instalaciones requeridas
Partiremos en el punto de que todos tenemos Python instalado en nuestros ordenadores, o estamos utilizando un editor en linea como Jupyter para poder continuar.
Dependencias:
$ pip install pandas $ pip install numpy $ pip install seaborn $ pip install matplotlib $ pip install sklearn
Parecieran muchas, más sin embargo son bastantes útiles estas herramientas.
Comencemos
Primero necesitamos importar cada una de las librerías a utilizar en nuestro archivo
import pandas as pd import numpy as np import seaborn as sns import matplotlib.pyplot as plt from sklearn.linear_model import Ridge from sklearn.preprocessing import StandardScaler from sklearn.preprocessing import PolynomialFeatures from sklearn.pipeline import Pipeline from sklearn.model_selection import train_test_split
El siguiente paso es importar nuestro dataset, en este caso en formato csv con la información para entrenar nuestro modelo:
df = pd.read_csv('home_data.csv')
Este es el formato de nuestro dataset, el cual cuenta con 21,614 registros:
| id | date | price | bedrooms | bathrooms | sqft_living | sqft_lot | floors | waterfront | view | condition | grade | sqft_above | sqft_basement | yr_built | yr_renovated | zipcode | lat | long | sqft_living15 | sqft_lot15 |
| 7129300520 | 20141013T000000 | 221900 | 3 | 1 | 1180 | 5650 | 1 | 0 | 0 | 3 | 7 | 1180 | 0 | 1955 | 0 | 98178 | 47.5112 | -122.257 | 1340 | 5650 |
| 6414100192 | 20141209T000000 | 538000 | 3 | 2.25 | 2570 | 7242 | 2 | 0 | 0 | 3 | 7 | 2170 | 400 | 1951 | 1991 | 98125 | 47.721 | -122.319 | 1690 | 7639 |
| 5631500400 | 20150225T000000 | 180000 | 2 | 1 | 770 | 10000 | 1 | 0 | 0 | 3 | 6 | 770 | 0 | 1933 | 0 | 98028 | 47.7379 | -122.233 | 2720 | 8062 |
| 2487200875 | 20141209T000000 | 604000 | 4 | 3 | 1960 | 5000 | 1 | 0 | 0 | 5 | 7 | 1050 | 910 | 1965 | 0 | 98136 | 47.5208 | -122.393 | 1360 | 5000 |
Ahora vamos a analizar los datos y encontrar una relación entre nuestra salida esperada en este caso es el precio y cada una de nuestras columnas, para ello nos apoyamos de una matriz de correlación grafica:
corr = df.corr() sns.heatmap(corr, xticklabels=corr.columns, yticklabels=corr.columns) plt.show()
Analizando la grafica nos damos cuenta que información influye más en el costo de una vivienda y podemos pulir de alguna forma nuestra dataset para eliminar nuestro sesgo de información.
Entre mas fuerte sea el cuadro que intercepta al precio y cada columna, menos relacion tiene en cuento al mismo, entonces en base a esto podemos deducir lo siguiente, los campos:
- ‘id’
- ‘date’
- ‘zipcode’
- ‘condition’
no influyen en nuestra salida esperada, entonces procedemos a quitarlas de nuestro dataset:
x = np.asanyarray(df.drop(columns=['id','date','price','zipcode', 'condition'])) y = np.asanyarray(df[['price']])
en nuestra x tendremos nuestros datos para entrenar a nuestro modelo (eliminando price ya que le estaríamos dando las respuestas al modelo y habría un sobre entrenamiento) y en el caso de nuestra y solo incluiríamos el price ya que será lo que esperamos de salida.
Ahora viene el momento de separar la información 80 -20, normalmente es lo utilizado para entrenar modelos, separar de manera aleatoria los datos 80% para entrenar y 20% para testing.
xtrain, xtest, ytrain, ytest = train_test_split(x,y)
Casi por ultimo viene el entrenamiento de nuestro modelo y el pipeline para ello, el modelo que en este caso utilizamos fue el de Ridge Regressor.
model = Pipeline([
('poly', PolynomialFeatures(degree=2, include_bias=False)),
('scaler', StandardScaler()),
('lin_reg', Ridge(alpha=0.0001)),
])
model.fit(xtrain,ytrain)
print('Train: ', model.score(xtrain,ytrain))
print('Test: ', model.score(xtest,ytest))
Nuestro pipeline en pocas palabras hace:
- Agrega característica polinomial lo que aumenta la complejidad de nuestro modelo, en este caso a grado 2.
- Estandarización de datos
- Ridge Regressor
- Entrena el modelo
Con esto tendremos nuestros scores para valorar lo certero que será nuestro modelo, los valores Train y Test, nos otorgan nuestro porcentaje de eficiencia. Entre más se acerquen a 1 y entre ambos valores tengan una diferencia no mayor a 3, nuestro modelo funcionara correctamente, con un bajo porcentaje de error.
Train: 0.8060546359311568 Test: 0.8108612763406902
Ahora es turno de realizar una prueba aleatoria con nuestro mismo dataset, para eso usamos el siguiente codigo:
r = np.random.randint(0, 21613)
x_test = np.asanyarray(df[r:r+1].drop(columns=['id','date','price','zipcode', 'condition']))
print("Predict price: ", int(model.predict(x_test)))
print("Real price: ", df.at[r,'price'])
Obtenemos un registro aleatorio dentro de nuestro dataset y hacemos una predicción con nuestro modelo entrenado y lo comparamos con nuestro precio real.
Predict price: 643438 Real price: 552500 Predict price: 338676 Real price: 315000 Este articulo puede interesarte Configuración de HTTPS de manera fácil y gratuita Predict price: 321347 Real price: 355000
