.. _classificationmultiplerst:

=======================
Classification multiple
=======================


.. only:: html

    **Links:** :download:`notebook <classification_multiple.ipynb>`, :downloadlink:`html <classification_multiple2html.html>`, :download:`PDF <classification_multiple.pdf>`, :download:`python <classification_multiple.py>`, :downloadlink:`slides <classification_multiple.slides.html>`, :githublink:`GitHub|_doc/notebooks/dsgarden/classification_multiple.ipynb|*`


Explorations autour d’un problème de classification multiple.

.. code:: ipython3

    from jyquickhelper import add_notebook_menu
    add_notebook_menu()






.. contents::
    :local:





Début de l’histoire
-------------------

:math:`\mathbf{1\!\!1}_{y_i}`

Confusions
~~~~~~~~~~

Un des premiers réflexes après avoir appris une classification
multi-classe est de regarder la `matrice de
confusion <https://fr.wikipedia.org/wiki/Matrice_de_confusion>`__.
Certaines classes sont difficiles à classer, d’autres non. Je me
demandais s’il existait un moyen de déterminer cela sans apprendre un
classifieur. On souhaite apprendre la classification des points
:math:`(X_i, y_i)`, :math:`X_i` est un vecteur, :math:`y_i` la classe
attendue. Si :math:`\hat{y_i}` est la classe prédite, l’erreur de
classification est :

.. math:: E=\sum_i \mathbf{1\!\!1}_{y_i \neq \hat{y_i}}

On note :math:`c_{ij} = \mathbf{1\!\!1}_{y_i = j}` et
:math:`\hat{c_{ij}} = \mathbf{1\!\!1}_{\hat{y_i} = j}`. On note le vecteur
:math:`C_j=(c_{ij})_i` et :math:`\hat{C_j}=(\hat{c_{ij}})_i`. On peut
réécrire l’erreur comme :

.. math:: E=\sum_{ij} \mathbf{1\!\!1}_{y_i = j} \mathbf{1\!\!1}_{\hat{y_i} \neq j} =\sum_{ij} \mathbf{1\!\!1}_{y_i = j} (1-\mathbf{1\!\!1}_{\hat{y_i} = j})  =\sum_{ij} c_{ij} (1-\hat{c_{ij}})= \sum_j < C_j , 1-\hat{C_j}>

C’est aussi égal à :

.. math:: E = \sum_{k \neq j} <C_j , \hat{C_k}>

Et :math:`<C_j,\hat{C_k}>` correspond au nombre d’erreurs de confusion :
le nombre d’éléments de la classe :math:`j` classés dans la classe
:math:`k`. :math:`<C_j,\hat{C_k}>` est le nombre d’éléments correctement
classés dans la classe :math:`j`. On peut montrer que

.. math:: \sum_{k, j} <C_j , \hat{C_k}> = N

\ où :math:`N` est le nombre d’observations.

Clustering
~~~~~~~~~~

Et si nous introduisions un clustering intermédiaire. On construit
:math:`Q` cluster, :math:`q_i` est le cluster du point :math:`X_i` et on
note :math:`d_{il} = \mathbf{1\!\!1}_{q_i = l}` et le vecteur
:math:`D_l=(d_{il})_i`.

.. math:: E = \sum_{k \neq j} <C_j , \hat{C_k}>

On note :math:`X.Y` le produit terme à terme de deux vecteurs.

.. math:: E = \sum_{k \neq j, l } <C_j.D_l , \hat{C_k}> = \sum_{k \neq j, l } <C_j.D_l , \hat{C_k}.D_l>

Le nombre d’erreurs est la somme des erreurs faites sur chaque cluster.
Supposons maintenant qu’un classifieur retourne une réponse constante
sur chacun des clusters, on choisit la classe plus représentée. Ca
ressemble beaucoup à un `classifieur
bayésien <http://scikit-learn.org/stable/modules/naive_bayes.html>`__.
On note :math:`f(l)` cette classe la plus représentée. Elle vérifie :

.. math:: f(l) = \arg \max_j <C_j,D_l>

Cela signifie que
:math:`\hat{c_{ij}} = \sum_l \mathbf{1\!\!1}_{j = f(l)} d_{il}`. Si on note
:math:`l(i)` le cluster associé à :math:`i`. On continue :
:math:`\hat{c_{ij}} = \mathbf{1\!\!1}_{j = f(l(i))}`. On définit l’erreur
:math:`e(l)` l’erreur de classification faite sur chaque cluster
:math:`l` :

.. math:: e(l) = \sum_i d_{il}\sum_j c_{ij} (1-\mathbf{1\!\!1}_{j = f(l)}) = \sum_i d_{il}\left(\sum_j c_{ij} -\sum_j c_{ij}\mathbf{1\!\!1}_{j = f(l)}\right) = \sum_i d_{il}\left(1 -c_{i,f(l)}\right)= \sum_i d_{il} -\sum_i d_{il}c_{i,f(l)}

Pour résumer, l’erreur est le nombre d’éléments moins le nombre
d’éléments dans la classe majoritaire du cluster. Si le nombre de
clusters :math:`Q` devient supérieur ou égal au nombre d’observations,
cette erreur devient nulle.

Mise en pratique
----------------

L’idée est de voir comment évolue cette erreur de classification naïve
en fonction du nombre de clusters. La différence par rapport à un
classifieur est qu’on sait comment sont fabriqués les clusters et qu’on
peut imaginer les classes comme un assemblage de clusters d’une forme
connue.