VI-ME-RÉ-BAR sur vos propres données!

Instructions:

  • Vous effacerez les instructions au fur et à mesure que vous les aurez suivies. Commencez par effacer celle-ci!

  • Mettez ici une description de votre jeu de données: lequel avez vous choisi, quel est le défi? Intuitivement quels critères pourraient permettre de distinguer les deux classes d’images?

VOTRE RÉPONSE ICI

# Load general libraries
import os, re
from glob import glob as ls
import numpy as np                    # Matrix algebra library
import pandas as pd                   # Data table (DataFrame) library
import seaborn as sns; sns.set()      # Graphs and visualization library
from PIL import Image                 # Image processing library
import matplotlib.pyplot as plt       # Library to make graphs 
# Command to insert the graphs in line in the notebook:
%matplotlib inline

# Reload code when changes are made
%load_ext autoreload
%autoreload 2

# Import utilities
from utilities import *

Étape 1: prétraitement et [VI]sualisation

Le jeu de données consiste en les images suivantes:

Instruction : Chargez votre jeu de données comme dans la feuille 3_jeux_de_donnees.md de la semaine dernière, en stockant les images dans la variables images et en les affichant.

# YOUR CODE HERE
raise NotImplementedError()
assert isinstance(images, pd.Series)
assert len(images) == 20

Prétraitement

Les données sont très souvent prétraitées c’est-à-dire résumées selon différentes caractéristiques : chaque élément du jeu de données est décrit par un ensemble d’attributs – propriétés ou caractéristiques mesurables de cet élément ; pour un animal, cela peut être sa taille, sa température corporelle, etc.

C’est également le cas dans notre jeu de données : une image est décrite par le couleur de chacun de ses pixels. Cependant les pixels sont trop nombreux pour nos besoins. Nous voulons comme la semaine dernière les remplacer par quelques attributs mesurant quelques propriétés essentielles de l’image, comme sa couleur ou sa forme moyenne: ce sont les données prétraitées.

La semaine dernière, les données prétraitées vous ont été fournies pour les pommes et les bananes. Cette semaine, grâce aux trois feuilles précédentes, vous avez les outils et connaissances nécessaires pour effectuer le prétraitement directement vous-même:

Pour commencer, la table prétraitée contient les attributs redness et elongation – tels que vous les avez défini dans la feuille extraction d’attributs – appliqués à votre jeu de données »:

# YOUR CODE HERE
raise NotImplementedError()

Exercice :

  1. Implémentez dans utilities.py de nouveaux attributs adaptés à votre jeu de données. Si vous en avez besoin, vous pouvez utiliser les cellules ci-dessous voire en créer de nouvelles; sinon simplement videz les.

Indications: vous pouvez par exemple vous inspirer

  • des attributes existants comme redness;

  • des exemples donnés dans le cours: matched filter, analyse en composantes principales (PCA).

# YOUR CODE HERE
raise NotImplementedError()
# YOUR CODE HERE
raise NotImplementedError()
  1. Comment les avez-vous choisis?

    VOTRE RÉPONSE ICI

  1. Ajoutez une colonne par attribut dans la table df, en conservant les précédents

# YOUR CODE HERE
raise NotImplementedError()

Vérifications:

  • la table d’origine est préservée:

assert len(df[df['class'] ==  1]) == 10
assert len(df[df['class'] == -1]) == 10
assert 'redness' in df.columns
assert 'elongation' in df.columns
  • Nouveaux attributs:

assert len(df.columns) > 3, "Ajoutez au moins un attribut!"
assert df.notna().all(axis=None), "Valeurs manquantes!"
for attribute in df.columns[3:]:
    assert pd.api.types.is_numeric_dtype(df[attribute]), \
        f"L'attribut {attribute} n'est pas numérique"
assert len(df.columns) > 4, "Gagnez un point en ajoutant un autre attribut"

Exercice : Standardisez les colonnes à l’exception de la colonne class, afin de calculer les corrélations entre colonnes

# YOUR CODE HERE
raise NotImplementedError()
dfstd

Vérifions :

dfstd.describe()
assert dfstd.shape == df.shape
assert dfstd.index.equals(df.index)
assert dfstd.columns.equals(df.columns)
assert (abs(dfstd.mean()) < 0.01).all()
assert (abs(dfstd.std() - 1) < 0.1).all()

Le prétraitement est terminé!

Visualisation

Exercice : Extrayons quelques statistiques de base:

# YOUR CODE HERE
raise NotImplementedError()

Exercice :

  • Visualisez le tableau de données sous forme de carte de chaleur (heat map):

# YOUR CODE HERE
raise NotImplementedError()
  • sa matrice de corrélation:

# YOUR CODE HERE
raise NotImplementedError()
  • ainsi que le nuage de points (scatter plot):

# YOUR CODE HERE
raise NotImplementedError()

Observations

Exercice : Décrivez ici vos observations: corrélations apparentes ou pas, interprétation de ces corrélations à partir du nuage de points, etc. Est-ce que les attributs choisis semblent suffisants? Quel attribut semble le plus discriminant? Est-ce qu’un seul d’entre eux suffirait?

VOTRE RÉPONSE ICI

Étape 2: [ME]sure de performance ([ME]tric)

Pour mesurer les performances de ce problème de classification, nous utiliserons la même métrique par taux d’erreur que dans le TP3:

show_source(error_rate)

Partition (split) du jeu de données en ensemble d’entraînement et ensemble de test

Extraire, depuis dfstd, les deux attributs choisis dans X et la vérité terrain dans Y:

# YOUR CODE HERE
raise NotImplementedError()

Ajouter un autotest que les attributs ne sont pas redness/elongation : un nouvel attribut ; deux nouveaux attributs

assert isinstance(X, pd.DataFrame), "X n'est pas une table Pandas"
assert X.shape == (20,2), "X n'est pas de la bonne taille"
assert set(X.columns) != {'redness', 'elongation'}
assert 'redness' not in X.columns and 'elongation' not in X.columns, \
   "Pour un point de plus: ne réutiliser ni la rougeur, ni l'élongation"

Exercice : Maintenant partitionnez l’index des images en ensemble d’entraînement (train_index) et ensemble de test (test_index). Récupérez les attributs et classes de vos images selon l’ensemble d’entraînement (Xtrain, Ytrain) et celui de test (Xtest, Ytest).

# YOUR CODE HERE
raise NotImplementedError()
assert train_index.shape == test_index.shape
assert list(sorted(np.concatenate([train_index, test_index]))) == list(range(20))

assert Xtest.shape == Xtrain.shape
assert pd.concat([Xtest, Xtrain]).sort_index().equals(X.sort_index())

assert Ytest.shape == Ytrain.shape
assert pd.concat([Ytest, Ytrain]).sort_index().equals(Y.sort_index())
assert Ytest.value_counts().sort_index().equals(Ytrain.value_counts().sort_index())

Exercice : Affichez les images qui serviront à entraîner notre modèle de prédiction (predictive model):

# YOUR CODE HERE
raise NotImplementedError()

Exercice : Affichez celles qui permettent de le tester et d’évaluer sa performance:

# YOUR CODE HERE
raise NotImplementedError()

Exercice : Représentez les images sous forme de nuage de points en fonction de leurs attributs:

# YOUR CODE HERE
raise NotImplementedError()

Taux d’erreur

Comme la semaine dernière, nous utiliserons le taux d’erreur comme métrique, d’une part sur l’ensemble d’entraînement, d’autre part sur l’ensemble de test. Implémentez la fonction error_rate dans votre utilities.py. Pour vérifier que c’est correctement fait, nous affichons son code ci-dessous:

show_source(error_rate)

Étape 3: [RE]férence (base line)

Classificateur

  • En Semaine 4: faites la suite de cette feuille avec l’algorithme du plus proche voisin, comme en Semaine 3.

  • En Semaine 5: faites la feuille sur les classificateurs puis faites la suite de cette feuille avec votre propre classificateur, en notant au préalable votre choix de classificateur ici:

    VOTRE RÉPONSE ICI

Exercice : Ci-dessous, définissez puis entraînez votre classificateur sur l’ensemble d’entraînement.

Indication : Si vous avez besoin de code supplémentaire pour cela, mettez-le dans utilities.py.

# YOUR CODE HERE
raise NotImplementedError()

Exercice : Calculez les prédictions sur l’ensemble d’entraînement et l’ensemble de test, ainsi que les taux d’erreur dans les deux cas:

# YOUR CODE HERE
raise NotImplementedError()
print("Training error:", e_tr)
print("Test error:", e_te)
assert Ytrain_predicted.shape == Ytrain.shape
assert Ytest_predicted.shape == Ytest.shape
assert 0 <= e_tr and e_tr <= 1
assert 0 <= e_te and e_te <= 1

Visualisons les prédictions obtenues:

# The training examples are shown as white circles and the test examples are black squares.
# The predictions made are shown as letters in the black squares.
make_scatter_plot(X, images.apply(transparent_background_filter),
                  train_index, test_index, 
                  predicted_labels=Ytest_predicted, axis='square')

Interprétation

Exercice : Donnez ici votre interprétation des résultats. La performance des prédictions paraît elle satisfaisante? Avez vous une première intuition de comment l’améliorer?

VOTRE RÉPONSE ICI

Étape 4: [BAR]res d’erreur (error bar)

Barre d’erreur 1-sigma

Exercice : Comme première estimation de la barre d’erreur, calculez la barre d’erreur 1-sigma pour le taux d’erreur e_te:

# YOUR CODE HERE
raise NotImplementedError()
print("TEST SET ERROR RATE: {0:.2f}".format(e_te))
print("TEST SET STANDARD ERROR: {0:.2f}".format(sigma))

Barre d’erreur par validation croisée (Cross-Validation)

Nous calculons maintenant une autre estimation de la barre d’erreur en répétant l’évaluation de performance pour de multiples partitions entre ensemble d’entraînement et ensemble de test :

n_te = 10
SSS = StratifiedShuffleSplit(n_splits=n_te, test_size=0.5, random_state=5)
E = np.zeros([n_te, 1])
k = 0
for train_index, test_index in SSS.split(X, Y):
    print("TRAIN:", train_index, "TEST:", test_index)
    Xtrain, Xtest = X.iloc[train_index], X.iloc[test_index]
    Ytrain, Ytest = Y.iloc[train_index], Y.iloc[test_index]
    neigh.fit(Xtrain, Ytrain.ravel()) 
    Ytrain_predicted = neigh.predict(Xtrain)
    Ytest_predicted = neigh.predict(Xtest)
    e_tr = error_rate(Ytrain, Ytrain_predicted)
    e_te = error_rate(Ytest, Ytest_predicted)
    print("TRAIN ERROR RATE:", e_tr)
    print("TEST ERROR RATE:", e_te)
    E[k] = e_te
    k = k+1
    
e_te_ave = np.mean(E)
# It is bad practice to show too many decimal digits:
print("\n\nCV ERROR RATE: {0:.2f}".format(e_te_ave))
print("CV STANDARD DEVIATION: {0:.2f}".format(np.std(E)))

sigma = np.sqrt(e_te_ave * (1-e_te_ave) / n_te)
print("TEST SET STANDARD ERROR (for comparison): {0:.2f}".format(sigma))

Conclusion

Exercice : Résumez ici les performances obtenues, tout d’abord avec votre référence, puis avec les variantes que vous aurez explorées en changeant d’attributs et de classificateur. Puis vous commenterez sur la difficulté du problème ainsi que les pistes possibles pour obtenir de meilleures performances, ou pour généraliser le problème.

VOTRE RÉPONSE ICI

Exercice : Complétez votre rapport (Semaine 4/Semaine5)