Code
# On importe les librairies dont on aura besoin pour ce tp
import numpy as np
import pandas as pd
import [Link] as plt
# On charge le dataset
house_data = pd.read_csv('[Link]')
# On affiche le nuage de points dont on dispose
[Link](house_data['surface'], house_data['loyer'], 'ro', markersize=4)
[Link]()
# On décompose le dataset et on le transforme en matrices pour pouvoir effectuer notre
calcul
X = [Link]([[Link](house_data.shape[0]), house_data['surface'].values]).T
y = [Link](house_data['loyer']).T
# On effectue le calcul exact du paramètre theta
theta = [Link]([Link](X)).dot(X.T).dot(y)
print(theta)
[Link]('Surface')
[Link]('Loyer')
[Link](house_data['surface'], house_data['loyer'], 'ro', markersize=4)
# On affiche la droite entre 0 et 250
[Link]([0,250], [[Link](0),[Link](0) + 250 * [Link](1)], linestyle='--',
c='#000000')
[Link]()
# Méthode avec scikit-learn : régression linéaire déjà implémentée
from sklearn import linear_model
regr = linear_model.LinearRegression()
[Link](X, y)
[Link](<des données de test>)
# Effectuer un sampling
sample = [Link](data_size, size=int(data_size*0.1) )
sampled_data = [Link][sample]
# Définition de la proportion du dataset
from sklearn.model_selection import train_test_split
xtrain, xtest, ytrain, ytest = train_test_split(X, y, train_size=0.8)
# Appel du dataset MNIST
from [Link] import fetch_openml
mnist = fetch_openml('mnist_784', version=1)
# Le dataset principal qui contient toutes les images
print ([Link])
# Le vecteur d'annotations associé au dataset (nombre entre 0 et 9)
print ([Link])
# Effectuer un sampling de 5000 données
import numpy as np
sample = [Link](70000, size=5000)
data = [Link][sample]
target = [Link][sample]
# Séparer le jeu de données en training set et testing set
from sklearn.model_selection import train_test_split
# Les images d'exemple "X" et les annotations cibles "y"
xtrain, xtest, ytrain, ytest = train_test_split(data, target, train_size=0.8)
# Créer un premier classifieur 3-NN
from sklearn import neighbors
knn = [Link](n_neighbors=3)
[Link](xtrain, ytrain)
# Tester l’erreur de notre classifieur
error = 1 - [Link](xtest, ytest)
print('Erreur: %f' % error)
# Tester le modèle pour tous les k de 2 à 15, mesurer l’erreur test et afficher la performance
en fonction de k pour trouver le k optimal
errors = []
for k in range(2,15):
knn = [Link](k)
[Link](100*(1 - [Link](xtrain, ytrain).score(xtest, ytest)))
[Link](range(2,15), errors, 'o-')
[Link]()
# On récupère le classifieur le plus performant
knn = [Link](4)
[Link](xtrain, ytrain)
# On récupère les prédictions sur les données test
predicted = [Link](xtest)
# On redimensionne les données sous forme d'images
images = [Link]((-1, 28, 28))
# On sélectionne un echantillon de 12 images au hasard
select = [Link]([Link][0], size=12)
# On affiche les images avec la prédiction associée
fig,ax = [Link](3,4)
for index, value in enumerate(select):
[Link](3,4,index+1)
[Link]('off')
[Link](images[value],cmap=[Link].gray_r,interpolation="nearest")
[Link]('Predicted: {}'.format( predicted[value]) )
[Link]()
# On récupère les données mal prédites
misclass = (ytest != predicted)
misclass_images = images[misclass,:,:]
misclass_predicted = predicted[misclass]
# On sélectionne un échantillon de ces images
select = [Link](misclass_images.shape[0], size=12)
# On affiche les images et les prédictions (erronées) associées à ces images
for index, value in enumerate(select):
[Link](3,4,index+1)
[Link]('off')
[Link](misclass_images[value],cmap=[Link].gray_r,interpolation="nearest")
[Link]('Predicted: {}'.format(misclass_predicted[value]) )
[Link]()
• une séparation en training / testing set ;
• deux propositions d'amélioration du modèle qui obtiennent de meilleures
performances que la "baseline" (la régression linéaire avec une
seule feature) ;
• une sélection d'un modèle final à partir des performances.
