import pandas as pd

#Si vous venez d'exécuter le notebook précédent, vous pouvez simplement récupérer le fichier temporaire créé.
#df = pd.read_csv("houses_features.csv", index_col = 0)

#Vous pouvez aussi récupérer une version du fichier hébergée ici:
df = pd.read_csv("https://raw.githubusercontent.com/titsitits/Python_Data_Science/master/Donn%C3%A9es/houses_features.csv", index_col = 0)
dfbxl = df[df.city == "Bruxelles"]
df

#L'adresse n'a pas d'intérêt (on a déjà extrait la ville, qui est une catégorie intéressante)
dataset = df.drop("address",axis=1)
#dataset = dfbxl.drop("address",axis=1)


#One-hot encoding des variables catégorielles
dataset = pd.get_dummies(dataset, drop_first=True)
dataset

dataset.corr()

from sklearn.linear_model import LinearRegression

#On crée un objet de la classe LinearRegression
regressor = LinearRegression()


trainsize = 6

trainset = dataset.iloc[:trainsize]
testset = dataset.iloc[trainsize:]

features = ["surface","rooms"]
#Pour tester un autre set de features, décommenter la ligne suivante
features = ["surface","rooms","city_Fleurus","city_Namur"]

Xtrain, ytrain, Xtest, ytest = trainset[features], trainset["price"], testset[features], testset["price"]

regressor.fit(Xtrain, ytrain)

trainpred = regressor.predict(Xtrain)
testpred = regressor.predict(Xtest)
print(testpred[0], ytest.values[0])

regressor.coef_

from sklearn.metrics import mean_absolute_error

mae_train = mean_absolute_error(trainpred,ytrain)
mae_test = mean_absolute_error(testpred,ytest)

mae_train, mae_test

trainpred

testpred

ytest

from matplotlib import pyplot as plt

plt.scatter(ytrain,trainpred)
plt.scatter(ytest,testpred)


plt.legend(["train","test"])
plt.xlabel("Labels")
plt.ylabel("Prédictions")

#Des prédictions parfaites devraient se situer sur la droite suivante (erreur de prédiction nulle)
plt.plot([200000,600000],[200000,600000], 'g')

output = df.iloc[trainsize:]
output = output.assign(predictions = testpred)
output["delta"] = output["price"] - output["predictions"]
output

df

from sklearn.preprocessing import StandardScaler

#Scaling
scaler = StandardScaler()
Xtrain_scaled = scaler.fit_transform(Xtrain)
Xtest_scaled = scaler.transform(Xtest)

#Entraînement
regressor.fit(Xtrain_scaled, ytrain)

#Prédictions
trainpred = regressor.predict(Xtrain_scaled)
testpred = regressor.predict(Xtest_scaled)

(features,regressor.coef_)

from sklearn.linear_model import SGDRegressor

#On crée un objet de la classe SGDRegression
regressor = SGDRegressor(loss = "squared_loss", learning_rate = "constant", eta0 = 0.01, max_iter = 300)
regressor.fit(Xtrain_scaled, ytrain)
print(regressor.predict(Xtest_scaled)[0], ytest.values[0])

#Leave-one-out validation
from sklearn.metrics import mean_squared_error
import numpy as np

testpredictions = []

input_features = features


for i in dataset.index:
  
  #trainset: tout sauf i
  trainset = dataset[dataset.index!=i]
  
  #testset: i (une seule observation)
  testset = dataset.loc[i].to_frame().transpose()
  Xtrain, ytrain, Xtest, ytest = trainset[input_features], trainset["price"], testset[input_features], testset["price"]
  
  scaler = StandardScaler()
  Xtrain_scaled = scaler.fit_transform(Xtrain)
  Xtest_scaled = scaler.transform(Xtest)

  regressor.fit(Xtrain_scaled, ytrain)
  
  trainpred = regressor.predict(Xtrain_scaled)
  testpred = regressor.predict(Xtest_scaled)
  
  print(i, " - training mean error:", np.mean(np.abs(trainpred - ytrain)), "\n\t test mean error:", np.mean(np.abs(testpred - ytest)), "\n")
  
  #On ajoute la prédiction pour i à la liste des prédictions de test
  testpredictions.append(testpred[0])
  

testpredictions

mean_absolute_error(dataset["price"],testpredictions)