Commit 41efb086 authored by Pierre-antoine Comby's avatar Pierre-antoine Comby

migrate 455 from drive

parent 641e245f
\documentclass[main.tex]{subfiles}
\begin{document}
\paragraph{Pourquoi a-t-on besoin du codage de source ?}
Un téléviseur HD affiche des images de 1920 x 1080 pixels. Chaque pixel est formé d'une combinaison de 3 couleurs RGB, chacune des couleurs étant codée par un nombre sur 8, 10 ou 12 bits. À raison de 25, 50 ou 60 images par seconde, le débit nécessaire est R= 1920 x 1080 x 3 x 8 x 25 = 1,22 Gbits par seconde. \\
En 4G, le débit maximal est de 100 Mbits par seconde (quand on est seul dans la zone) et en ADSL, il est de 20 Mbits par seconde.
Il faut compresser les données avec un facteur 100 au minimum.\\
\emph{"Le taux minimum c'est 25 images par seconde, pour pas avoir l'impression de regarder un dessin animé japonais."}
\emph{"Des émissions mettent volontairement moins pour qu'on ait l'impression d'avoir trop bu en regardant la télé."}\\
\paragraph{Comment faire de la compression?} Quelles propriétés du signal vidéo peut-on utiliser pour réaliser de la compression?
On utilise la redondance statistique. Par exemple, pour la vision (ou tech 3D) on utilise les petites différences pour obtenir la profondeur. De la même façon, en stéréo on a deux micros pour l'enregistrement. C'est la ressemblance entre les deux signaux qui nous intéresse ici pour effectuer la compression.\\
La compression est possible à cause de plusieurs propriétés:
\begin{itemize}
\item La corrélation temporelle (ressemblance entre deux image successives d'une vidéo ou échantillons audio successifs).
\item La corrélation spatiale (le fait que certaines zones présentes sont relativement uniforme, ressemblance entre deux pixels voisins).
\item La corrélation spectrale (ressemblance entre les composantes R, G et B d'une image).
\item Les propriétés statistiques du signal (un texte contient plus de "e" que de "z" en général).
\end{itemize}
\paragraph{Exemple d'une chaîne de compression vidéo}
On considère une vidéo mono-vue (pas en 3D) codée en niveaux de gris.\\
\underline{Transformation}: On applique une transformation à l'image, c'est à dire que l'on cherche à exprimer les blocs de l'image dans une base autre que la base canonique, pour permettre une compression plus facile.\\
Par exemple :
$\begin{pmatrix}1&1\\1&1\end{pmatrix}$ permet de décrire les zones constantes
$\begin{pmatrix}1&1\\-1&-1\end{pmatrix}$ pour décrire les variations verticales, et
$\begin{pmatrix}1&-1\\1&-1\end{pmatrix}$ pour une variation horizontale.\\
\underline{Quantification}: Elle permet de représenter les pixels transformés sur un nombre limité de bits (et d'en mettre plein à 0). Cette opération est irréversible.\\
\underline{Codeur entropique}: Il exploite la redondance statistique des coefficients quantifiés (il prend les successions et les compresse). On ne peut pas encore envoyer les données sur le réseaux, il faut appliquer un standard de compression.\\
\underline{Standard de compression}: Détermine la manière dont les bits en sortie sont organisés. (constitue les paquets, les numérote etc.)\\
On peut alors transmettre l'image. Une fois récupérée, on applique un décodage entropique, puis un désindexation et enfin une transformation inverse.\\
La désindexation permet d'obtenir à partir d'un coefficient quantifié, un nombre qui a la même dynamique qu'un coefficient transformé.(exemple: permet de retrouver un nombre à la bonne échelle, même si ce nombre n'est pas exactement le même).
\begin{figure}[H]
\centering
\begin{tikzpicture}
\sbEntree{E}
\sbBlocL{t}{Transformée}{E}
\sbBlocL{q}{Quantificateur}{t}
\sbBlocL{c}{Codeur entropique}{q}
\sbSortie{S}{c}
\end{tikzpicture}
\begin{figure}[H]
\centering
\caption{utilisation d'un décodeur local}
\end{figure}
\caption{Chaine de compression}
\end{figure}
\begin{figure}[H]
\centering
\begin{tikzpicture}
\sbEntree{E}
\sbBlocL{d}{decodeur entropique}{E}
\sbBlocL{D}{Désindexeur}{d}
\sbBlocL{t}{Transformée inverse}{D}
\sbSortie{S}{t}
\end{tikzpicture}
\caption{Chaine de décompression}
\end{figure}
\paragraph{Comment transmettre une vidéo?} appliquer ce shcéma (JPEG) à chaque image et transmettre? non, trop lourd.
On peut comparer l'image 2 à l'image précédente non pas 1 mais $\hat{1}$ l'estimée de l'image reçue par le récepteur, et l'on envoie la différence. Puis pour envoyer l'image 3, on estime la différence précédente, on y ajoute l'image estimée de la première image et on calcule la différence, que l'on envoie au travers des différentes transformations. Et ainsi de suite.\\
De ce fait, au niveau du récepteur on mémorise l'image précédente à laquelle on ajoute les différences.\\
Cette structure de codeur était celle des premiers codeurs vidéo (H261, MPEPZ). H265 encore utilisé a aussi cette structure.\\
\noindent Notations :\\
$I_n$: image numéro n\\
$\hat{I_n}$ : image numéro n au décodeur\\
$f(\hat{I_n}) = \tilde{I_{n+1}}$: image n+1 prédite\\
On va étudier deux cas :
\begin{enumerate}
\item pas de décodeur au niveau du codeur mais on a un prédicteur.
\begin{align*}
\tilde{I_{n+1}} &= T^{-1}(Q^{-1}(Q(T(I_{n+1} - f(I_n))))) + \tilde{I_{n+1}}\\
&= I_{n+1} - f(I_n) + E_{n+1} + \tilde{I_{n+1}} \text{ avec, E le bruit}
\end{align*}
$f(I_n)$ et $\tilde{I_{n+1}}$ ne se compensent pas totalement.
\bigbreak
\item On fait la prédiction a partir des images codées précédemment.
\begin{align*}
\tilde{I_{n+1}} &= T^{-1}(Q^{-1}(Q(T(I_{n+1} - f(\hat{I_n}))))) + f(\hat{I_n}\\
&= I_{n+1} - f(\hat{I_n}) + E_n +f(\hat{I_n})\\
&= I_{n+1} + E_n
\end{align*}
L'utilisation d'un décodeur au niveau du codeur (décodeur local) permet d'éviter une accumulation des erreurs au niveau des images décodées.
\end{enumerate}
\begin{figure}[H]
\centering
\begin{tikzpicture}[thick,scale=0.9, every node/.style={scale=0.9}]
\sbEntree{E}
\node[above] at (E) {...$I_2,I_1$};
\sbComp{a}{E}
\sbRelier{E}{a}
\sbBlocL[6]{c}{Transformée}{a}
\sbBlocL[6]{d}{Quantification}{c}
\sbBlocL[5]{e}{
\begin{tabular}{c}
Codeur\\ entropique
\end{tabular}}{d}
\sbSortie{s}{e}
\sbRelier{e}{s}
\sbDecaleNoeudy[10]{d-e}{Ret}
\sbBlocr{D}{Désindéxation}{Ret}
\sbBlocrL{T}{
\begin{tabular}{c}
Transformée\\inverse
\end{tabular}}{D}
\sbRelieryx{d-e}{D}
\sbCompSum[-6]{C1}{T}{+}{ }{ }{+}
\sbRelier{T}{C1}
\sbBlocrL{m}{Mémoire}{C1}
\sbRelierxy{m}{a}
\sbDecaleNoeudx[5]{m-a}{int}
\node[left] (is) at (m-a){};
\node[left=0.5em] at (m-a) {$\hat{I_1}$};
\node[right] (ie) at (int){};
\draw[-] (is) to[spst] (ie);
\sbRelierxy{int}{C1}
\end{tikzpicture}
\caption{Utilisation d'un décodeur local}
\end{figure}
\begin{figure}[H]
\centering
\begin{tikzpicture}
\sbEntree{E}
\sbBlocL{d}{\begin{tabular}{c}
decodeur \\entropique
\end{tabular}}{E}
\sbBlocL{D}{Désindexeur}{d}
\sbBlocL{t}{\begin{tabular}{c}
Transformée\\inverse
\end{tabular}}{D}
\sbCompSum[8]{c}{t}{ }{+}{+}{ }
\sbRelier{t}{c}
\node[below=4em,rectangle,draw](m) at (c) {Mémoire};
\sbRelier{m}{c}
\sbSortie{S}{c}
\sbRelier[$\hat{I_2}\hat{I_1}$]{c}{S}
\end{tikzpicture}
\caption{Décodeur à mémoire}
\end{figure}
\end{document}
\documentclass[main.tex]{subfile}
\lstset{language=Matlab}
\begin{document}
\section{Rappels mathématiques pour le codage de source}
\paragraph{Signaux et variables aléatoires}
Les signaux qu'on cherche à compresser (texte, échantillons de voix, musique, images, vidéo...) sont décrits comme des réalisations de suites de variables aléatoires.\\
Une variable aléatoire $X$ est décrite par son domaine $\X$, c'est-à-dire l'ensemble des valeurs que $X$ peut prendre (aussi appelé alphabet).
$\X$ peut être à valeurs discrètes (par exemple singletons $\in\{0,1\}, \quad \{0,\dots 255\}$, ou triplets $\{(0,0,0)...(255,255,255)\}$ dans le cas de couleurs), ou à valeurs continues ($\in \R$, un intervalle $[a,b]\subset\R$)
\section{Variables aléatoires discrètes}
$X$ est en plus caractérisée par sa \emph{probability mass function} (loi de probabilité) $p_i = Pr(X=i), \quad i \in \X$
Les $p_i$ sont tels que :
\begin{itemize}
\item $p_i \geq 0, \quad \forall i \in \X$
\item $\sum_{i \in \X}p_i = 1$
\end{itemize}
\medskip
\paragraph{Moyenne de $X$} (ou espérance) : $E(X)=\sum_{i \in \X} i p_i$
\begin{exemple}
$\X=\{1,2,3\}$ avec $p=1 = 0.5, p_2=0.25, p_3=0.25$.
On a $E(X) = 1\times0.5 + 2\times0.25 + 3\times0.25 = 1.75$
\end{exemple}
\paragraph{Variance de X} : $V(x)=E[(X-E(X))^2] = \sum_{i\in\X} (i-E(x))^2p_i$
\begin{exemple}[(suite)]
$\X=\{1,2,3\}$ avec $p=1 = 0.5, p_2=0.25, p_3=0.25$.
On a $V(x) = (1-1.75)^2\times0.5 + (2-1.75)^2\times0.25 + (3-1.75)^2\times0.25=0.69$
\end{exemple}
\paragraph{Écart-type de X} $ \sigma(X) = \sqrt{V(X)}$
\medskip
\begin{exemple}[Générer des réalisations de VA]
Génération d'une suite de réalisations d'une VA $X$ tel que $\X=\{0,1\}$ avec $p_0=0.9,\quad p_1=0.1$
\begin{lstlisting}
x=rand(1,10)>0.9
% rand : générateur de loi uniforme
% randn : générateur de loi gaussienne
\end{lstlisting}
\noindent Pour générer une suite de réalisations correspondant aux exemples précédents
\begin{lstlisting}
x=rand(1,10)
y= (x<0.5) + 2*(x<0.75 & x>0.5) + 3*(x>0.75)
\end{lstlisting}
\end{exemple}
\medskip
On considère deux variables aléatoires $X_1$ et $X_2$ d'alphabet $\X$.
\paragraph{Indépendance}
$X_1$ et $X_2$ sont indépendantes si et seulement si \[Pr(X_1=i,X_2=j)=Pr(X_1=i).Pr(X_2=j)\]
Ainsi $E(X_1X_2)=E(X_1).E(X_2)$\\
Dans le cas général,
\[Pr(X_1=i,X_2=j)=Pr(X_1=i / X_2=j).Pr(X_2=j)=Pr(X_2=j / X_1 =i).Pr(X_1=i)\]
Si $X_1$ et $X_2$ sont indépendants $Pr(X_1=i/X_2=j)=Pr(X_1=i)$ pour tous $i,j$
$\sum_{j\in\X}Pr(X_2=j/X_1=i)=1$ mais $\sum_{i\in\X} Pr(X_2=j/X_1=i)= ?$
\paragraph{Marginalisation}
On suppose connaître $Pr(X_2=j/X_1=i)$ et $Pr(X_1=i)$.
D'après la règle du produit,
\[Pr(X_2=j)=\sum_{i\in\X} Pr(X_2=j,X_1=i) = \sum_{i\in\X} Pr(X_2=j/X_i=i).Pr(X_1=i)\]
\end{document}
\documentclass[main.tex]{subfiles}
% Corrigé jusqu'à II.2 inclus. A 03/03/15
% Corrigé en entier. A 22/04/15
\begin{document}
\newcommand{\X}{\mathcal{X}}
\section{Modèles de sources}
On s'intéresse à la compression sans perte d'un message constitué de symboles appartenant à un alphabet fini $\X$.\\
Ces symboles sont:
\begin{itemize}
\item les caractères d'un texte
\item la sortie du quantificateur d'un codeur vidéo.
\item ...
\end{itemize}
\bigbreak
On fait l'hypothèse que le message est une réalisation d'une suite de variables aléatoires $X_1$,...,$X_n$.\\
\subsection{Modèle stationnaire sans mémoire}
C'est le modèle le plus simple, on suppose que:
\begin{itemize}
\item les VA $x_i$ sont distribuées de la même manière, quelque soit $n$ (stationnarité).
\item les VA sont indépendantes entre elles.
\end{itemize}
\smallbreak
C'est un mauvais modèle, mais il est simple.
Pour décrire ce modèle, il suffit de disposer de $p_i = Pr(X_n=i), \quad \forall i \in \X$.\\
\begin{exemple}
On considère une source binaire $X$, à valeurs dans $\X = \{0,1\}$, et
\[p_0 = Pr(X=0),\quad p_1 = Pr(X=1) = 1 - p_0\]
\end{exemple}
\begin{defin}[Information]
L'information associée à chaque symbole de la VA X est \[I(i) = -log_2 p_i \text{ (en bits/symbole)} \]
\end{defin}
\begin{rem}
C'est une fonction décroissante sur ]0,1] qui s'annule en 1. En effet, l'information associée à quelque chose de certain ($p_i=1$) est nulle, alors que celle associée à quelque chose de peu probable ($p_i\rightarrow 0$) est très grande $(\rightarrow \infty)$.
\end{rem}
\begin{defin}[Entropie]
L'information moyenne associé aux symboles de $X$ ou à $X$ est appelée entropie de la source $X$.
\[H(X) = -\sum_{i\in\X}p_i log_2(p_i) = \sum_{i\in\X}p_i log_2(\frac{1}{p_i})\]
\end{defin}
On rappelle que $log_2(2^n)=n$.
\begin{exemple}
Pour la source binaire:
si $p_0 = 0.5$ et $p_1 = 0.5$ alors $H(X) = 1$ bit/symbole.
si $p_0 = 0.01$ et $p_1 = 0.99$ alors $H(X) = 0.08$ bit/symbole.
\end{exemple}
\begin{prop}
Propriété de l'entropie\\
On considère deux VA $X_1$ et $X_2$ indépendantes et identiquement distribuées (iid).
\begin{align*}
H(X_1,X_2) &= - \sum_{i\in \X, j \in \X} Pr(X_1=i,X_2=j)log_2(Pr(X_1=i,X_2=j))\\
&= H(X_1)+H(X_2)\\
&= 2H(X_1)
\end{align*}
Plus généralement, si on a N VA iid alors $H(X_1,...,X_N) = N(H(X_1))$.\\
Et on a $\boxed{H(X) \leq log_2|\X|}$ (nombre d'élément de $\X$).
\end{prop}
\subsection{Modèle de Markov d'ordre 1}
\noindent Dans ce modèle, la probabilité d'apparition du symbole $n$ ne dépend que de la réalisation du symbole $n-1$. \\
Les probabilités de transition vérifient donc :
\[Pr(X_n=a_n|X_{n-1} = a_{n-1},X_{n-2} = a_{n-2},...,X_{1} = a_{1}) = Pr(X_n = a_n |X_{n-1} = a_{n-1})\]
On considère des sources de Markov d'ordre 1 stationnaires, donc:
\[Pr(X_n=a_n|X_{n-1} = a_{n-1}) = Pr(X_{n-1} = a_n | X_{n-2} = a_{n-1}), \forall n\]
Pour décrire une source de Markov d'ordre 1 stationnaire, il suffit de décrire ses probabilités de transition :
\[Pr(X_{n}=i|X_{n-1}=j) = p_{i|j},\quad \forall i \in \X, \forall j \in \X\]
\begin{exemple}
Comment estimer les probabilités de transition ?
on a la séquence : a a b b a c a b b a\\
\paragraph{Modèle sans mémoire} on estime $\hat{p_a} = \frac{5}{10}$, $\hat{p_b} = \frac{4}{10}$ et $\hat{p_c} = \frac{1}{10}$\\
\paragraph{Modèle de Markov d'ordre 1}
\begin{align*}
Pr(X_{n}=i,X_{n-1}=j) &= Pr(X_{n}=i|X_{n-2}=j)Pr(X_{n-1}=j)\\
&= \frac{Pr(X_{n}=i,X_{n-2}=j)}{Pr(X_{n-1}=j)}
\end{align*}
Avec $j=a$, si $i=a$ alors \[Pr(X_n=a|X_{n-1}=a) = \frac{\text{nombre de paires aa}}{\text{nombre de paires débutant par a}}=\frac{1}{4}\]
si $i = b$ alors \[Pr(X_n=b|X_{n-1}=a) = \frac{\text{nombre de paires ab}}{\text{nombre de paires débutant par a}}=\frac{2}{4}\]
\end{exemple}
On range ces probabilités de transition dans une matrice :
\[\underline{\underline{P}} = (p_{a_j|a_i})_{(i,j)} = \begin{pmatrix}
p_{a_1|a_1} & p_{a_2|a_1} & \dots & p_{a_j|a_1}\\
p_{a_1|a_2} & p_{a_2|a_2} & \dots & p_{a_j|a_2}\\
\vdots & & & \\
p_{a_1|a_J} & p_{a_2|a_j} & \dots & p_{a_J|a_J}\\
\end{pmatrix} \quad \text{avec $J = |\X|$ nombre d'éléments de $\X$}\]
\begin{exemple}
On considère une source de Markov binaire:
\[p_{0|0} = 0.9, \quad p_{1|0} = 0.1, \quad p_{0|1} = 0.3, \quad p_{1|1} = 0.7\]
On a donc :
\[\underline{\underline{P}} = \begin{pmatrix}
0.9&0.1\\0.3&0.7
\end{pmatrix}\]
\end{exemple}
Pour cette source de Markov, on peut être intéressé par les probabilités stationnaires $Pr(x_n=i)$ et on note :
\begin{align*}
\underline{\Pi} &= (Pr(X_n=a_1), \dots, Pr(X_n = a_J))\\
&= (p_{a_1},...,p_{a_J})
\end{align*}
On peut montrer que $\underline{\Pi}$ satisfait :
\[\boxed{\underline{\Pi} = \underline{\Pi}\underline{\underline{P}}}\]
\begin{rem}
On peut aussi voir ce résultat sous la forme plus courante $\underline{\Pi}^T = \underline{\underline{P}}^T \underline{\Pi}^T$. Ceci permet notamment de calculer $\underline{\Pi}$ s'il n'est pas donné, en cherchant un vecteur propre de $\underline{\underline{P}}^T$.
\end{rem}
\paragraph{Entropie d'une source de Markov d'ordre 1}
\begin{align*}
H(X) &= -\sum_{i \in \X}p_i\sum_{j \in \X}p_{i|j}log_2(p_{i|j})\\
&= -\sum_{i \in \X}\sum_{j \in \X}p_{i,j}log_2(p_{i|j})
\end{align*}
$p_{i,j} = Pr(X_n = i, X_{n-1} = j)$\\
\underline{Remarque}: Avec un modèle de Markov, si on essaie de "créer" des mots lettre par lettre, plus on monte dans les ordres, plus la structure de la langue commence à apparaître. À partir de l'ordre 3, il apparaît des mots qui seraient potentiellement de la langue considérée. Ce modèle peut être adapté, comme par exemple pour le correcteur orthographique des téléphones.\\
L'idée générale de la compression d'une source de Markov est d'effectuer des prédictions pour avoir accès aux informations, de sorte qu'il ne reste à transmettre que ce que l'on ne peut pas prédire.\\
\newpage
\section{Codes}
\subsection{Définitions et propriétés}
On considère une source $X$ à valeurs dans $\X = \{a_1,..a_J\}$.
\begin{defin}[Code]
Un code est un ensemble binaire de $\{0,1\}^*$ (union de tous les ensembles $\{0,1\}^2 = \{00,11,01,10\}$ , $\{0,1\}^3 = ...$ ...). Un code est donc un sous-ensemble de $\{0,1\}^*$.\\
\end{defin}
\begin{defin}[Fonction de codage]
Une fonction de codage $c : \X \rightarrow C$ associe à chaque élément de $\X$, un élément de C.\\
\end{defin}
\begin{defin}[Longueur d'un mot de code]
La longueur d'un mot de code associé à $x \in \X$ est notée \[l(x) = l(c(x)) = \text{ nombre de bits de } c(x)\]
Pour une source sans mémoire avec $p_j = Pr(X=a_j)$. La longueur moyenne du code C associé à $\X$ est:
\[\overline{l} = \sum_{j=1}^J p_jl(a_j)\]
\end{defin}
L'objectif du codage sans perte est de minimiser $\overline{l}$ tout en étant capable de décoder le code sans ambiguïté.
\begin{defin}
Un code $C$ (et sa fonction de codage associée $c$) est dit non singulier si:
\[x_1 \neq x_2 \Rightarrow c(x_1) \neq c(x_2) \]
\end{defin}
\begin{defin}
L'extension $C^*$ d'un code $C$ est l'ensemble de toutes les suites, finies et infinies, de mots provenant du code $C$.
\begin{exemple}
Si C $=\{0,10\}$ alors $\{C^*=\{0,10,00,010,100,000,1010,...\}$
\end{exemple}
\end{defin}
\begin{prop}
Un code C est décodable de façon unique si son extension $C^*$ est non singulière.\\
Si on prend deux successions de symboles dans $\X$:
\[x_1x_2...x_N \neq x_1'x_2'...x_{N'} \Rightarrow c(x_1,...x_N)=c(x_1)c(x_2)...c(x_N) \neq c(x_1')...c(x_N')\]
\end{prop}
\begin{defin}
Un code C est un code préfixe si aucun mot de code n'est le début d'un autre mot de code.\\
\begin{exemple}
$\X = \{1,2,3,4\}$\\
\begin{center}
\begin{tabular}{|c||c|c|c|c|}
\hline
X & Singulier & Non singulier & Décodable de manière unique & Préfixe \\
\hline
\hline
1 & 0 & 0 & 10 & 0 \\
\hline
2 & 0 & 010 & 00 & 10 \\
\hline
3 & 0 & 01 & 11 & 110 \\
\hline
4 & 0 & 10 & 110 & 111 \\
\hline
\end{tabular}
\end{center}
\end{exemple}
\end{defin}
\begin{rem}
"Décodable de manière unique" implique "Non singulier".
\end{rem}
\subsection{Inégalités}
\paragraph{Inégalité de Kraft}
Un code binaire préfixe peut exister à condition que ses longueurs de mot de code $l_1,...l_J$ satisfassent:
\[\sum_{j=1}^J2^{-l_j} \leq 1 \]
\begin{proof} Condition nécessaire : \\
Soit $l_{max}$ la plus grande des longueurs.
Le nombre de feuilles à la profondeur $l_{max}$ que peut porter un arbre dont la racine est à la profondeur $l_j$ est $2^{l_{max}-l_j}$.\\
Le nombre maximum de feuilles d'un arbre de profondeur $l_{max}$ est $2^{l_{max}}$.\\
On a $\sum_{j=1}^J2^{l_{max}-l_j} \leq 2^{l_{max}}$ d'où le résultat.\\
Condition suffisante : ?
\end{proof}
\paragraph{Inégalité de Kraft-McMillan}
Un code binaire décodable de manière unique peut exister à condition que ses longueurs de mot de code $l_1,...l_J$ satisfassent:
\[\sum_{j=1}^J2^{-l_j} \leq 1 \]
\begin{rem}
Attention, ce sont des théorèmes d'existence : ils ne peuvent pas servir à vérifier qu'un code est préfixe ou décodable de manière unique.
\begin{exemple}
Le code $\{1,00,10\}$ n'est pas préfixe, pourtant on a $\sum 2^{-l_i} = 2^{-1} + 2^{-2} + 2^{-2} = 1$. On sait seulement qu'il existe un code préfixe dont les mots de code ont ces longueurs.
\end{exemple}
\end{rem}
\begin{rem}
On sait que "préfixe" implique "décodable de manière unique". En revanche, si un code est décodable de manière unique, on peut seulement dire qu'il existe un code préfixe équivalent, sans qu'il soit le même.
\end{rem}
\paragraph{Corollaire} Pour qu'un code binaire soit préfixe (ou décodable de manière uniquer), \emph{il faut} que ses longueurs de mot de code $l_1,...l_J$ satisfassent:
\[\sum_{j=1}^J2^{-l_j} \leq 1 \]
\newpage
\subsection{Code de longueur minimale}
On considère une source $X$ sans mémoire d'alphabet $\X = \{a_1,...,a_J\}$ et de probabilités $p_j = Pr(X=a_j)$.
On souhaite construire un code préfixe de longueur moyenne minimale associé à $X$.\\
Si on note $l_1,...,l_J$ les longueurs des mots de codes associés à $a_1,...a_J$ la longueur moyenne sera:
\[\overline{l}=\sum_{j=1}^Jp_jl_j\]
On cherche à minimiser $\overline{l}$ en s'assurant que le code reste préfixe, c'est à dire que:
\[\sum_{j=1}^J2^{-l_j} \leq 1 \text{ ou } \sum_{j=1}^J2^{-l_j} - 1 \leq 0\]
C'est un problème d'optimisation sans contrainte que l'on résout en introduisant le Lagrangien:
\[L(l_1,...l_J,\mu) = \sum_{j=1}^Jp_jl_j + \mu\times (\sum_{j=1}^J2^{-l_j} - 1) \text{ avec $\mu$ le multiplicateur de Lagrange}\]
Une condition nécessaire d'optimisation est que:
\[\left\{ \begin{matrix}
\frac{\partial L}{\partial l_j}=0 & \forall j=1,...,J\\
\frac{\partial L}{\partial \mu} = 0
\end{matrix}\right.\]
On a donc:
\[
\begin{cases}
\frac{\partial L}{\partial \mu} & = \sum_{j=1}^J2^{-l_j} - 1 = 0 \\
\frac{\partial L}{\partial l_j} & = p_j-\mu. 2^{-l_j}.\ln2 = 0 \text{ , }\forall j=1,...,J
\end{cases}
\]
En sommant ces égalités et en injectant l'égalité précédente de Kraft, on obtient:
\[\mu = \frac{1}{ln2}\]
En remplaçant dans $p_j-\mu. \ln2. 2^{-l_j} = 0$, et en passant au log en base 2:
\[\boxed{l_j = -log_2p_j}\]
\bigbreak
\bigbreak
Pour ce choix de longueurs de mots de code, on obtient:
\[ \boxed{ \overline{l} = \sum_{j=1}^J p_j(-log_2p_j) = H(x)}\]
Le meilleur code préfixe a une longueur moyenne au minimum égale à l'entropie de la source.\\
\begin{rem}
L'entropie (avec une source sans mémoire) donne une borne supérieure de la quantité d'information réelle contenue dans un message. Dans le cas d'un texte, l'entropie au sens d'une source de Makorv diminue quand on augmente l'ordre, jusqu'à se stabiliser au bout d'un certain ordre.
\end{rem}
\newpage
\subsection{Codage de Huffmann}
On considère une source $X$ à valeurs dans $\X$, de probabilités associées $p_i=Pr(X=a_i)$, pour $a_i\in\X$.
\paragraph{Code préfixe à longueur minimale}
Pour qu'un code à longueur variable préfixe $C$ de longueurs de mots de code $l_1,...,l_j$ soit un code de Huffmann, il faut que :
\begin{itemize}
\item $p_i \leq p_j \Rightarrow l_i \geq l_j, \forall i,j$
\item les deux mots de codes associés aux symboles les moins probables aient la même longueur
\item parmi tous les mots de code de longueur maximale, deux d'entre eux ne diffèrent que par le dernier bit.
\end{itemize}
\paragraph{Principe d'un code de Huffmann}
À partir de ces propriétés, on peut fabriquer un code de Huffmann.
Initialement, on considère une source $X^{(0)}$ à $J$ symboles $\X=\{a_1,\dots a_J\}$
\begin{enumerate}
\item On identifie les deux symboles $a_i^{(0)}$ et $a_j^{(0)}$ les moins probables, avec les probabilités associées $p_i^{(0)}$ et $p_j^{(0)}$
\item On fabrique une source fictive $X^{(1)}$ émettant tous les symboles de $\X$ sauf $a_i^{(0)}$ et $a_j^{(0)}$, remplacé par le symbole fictif $a_{ij}^{(0)}$ de probabilité $p_i^{(0)}+p_j^{(0)}$.
$\X^{(1)}$ comporte $J-1$ éléments.
\item On répète 1 et 2 jusqu'à ce qu'il n'y ait plus que deux symboles.
\end{enumerate}
Au bout de $J-2$ itérations, il reste deux symboles $\X^{(J-2)} = \{a_1^{(J-2)},a_2^{(J-1)}\}$. Le premier est identifié avec un 0, le second avec un 1.\\
Si $a_1^{(J-2)}$ est un symbole fictif résultant du regroupement de deux symboles $a_1^{(J-3)}$ et $a_2^{(J-3)}$ alors le code associé à ces deux symboles est obtenu en rajoutant 0 ou 1 au code associé à $a_1^{(J-2)}$.\\
Plus généralement, si $\underline{C}$ est le code associé au symbole fictif $a_i^{k)}$ résultant du regroupement de $a_i^{(k-1)}$ et $a_j^{(k-1)}$, alors le code de $a_i^{(k-1)}$ sera $\underline{C} 0$ et le code de $a_j^{(k-1)}$ sera $\underline{C} 1$.\\
\paragraph{Propriétés}
On peut montrer que la longueur moyenne $\overline{l}$ d'un code de Huffmann associé à une source satisfait \[ H(x) \leq \overline{l} \leq H(X) +1 \]
On peut obtenir des codes plus performants en codant des paires de symboles, des triplets... des N-uplets de symboles. Avec ce type de technique, la longueur moyenne $\overline{l}$ par symbole de la source initiale satisfait : \[H(X) \leq \overline{l} \leq H(X)+1 \]
L'inconvénient est la taille de la table de Huffmann à gérer.
\newpage
\subsection{Codage arithmétique}
On considère une source binaire $X$ avec $p_0=Pr(X=0)$ et $p_i=Pr(X=i)$.
Cette source génère un message $x_{1:N}$ de longueur $N$.
On va associer un code $\underline{c}(x_{1:N})$ à $x_{1:N}$ qui sera un nombre dans l'intervalle $[0,1[$.
On essaie de représenter $\c(x_{1:N})$ avec peu de bits si $x_{1:N}$ est très probable et avec plus de bits si $x_{1:N}$ est moins probable.
\subsubsection{Algorithme de codage arithmétique (codage d'Elias)}
\paragraph{Initialisation} $l_0=0, \quad h_1 = 1,\quad n=1$
\paragraph{Étapes}
\begin{enumerate}
\item Si $x_n=0$ alors $l_n=l_{n-1}$ et $h_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$
\item Si $x_n=1$ alors $l_n=l_{n-1}+(h_{n-1}-l_{n-1})p_0$ et $h_n=h_{n-1}$
\item $n = n+1$
\item Si $n\leq N$, aller en 1.
\item On a $h_N-l_N=p(x_{1:N})$
\end{enumerate}
On pose $\mu(x_{1:N}) = \frac{l_N+h_N}{2} \text{ et } \lambda(x_{1:N}) = \lceil - \log_2(p(x_{1:N})) \rceil + 1$
\[ \overline{c}(x_{1:N}) = \lfloor \mu(x_{1:N}) \rfloor _{\lambda(x_{1:N})} \]
$\lfloor a \rfloor _{\lambda}$ est la représentation binaire de $a$ tronquée à $\lambda$ bits. (Exemple : $\lfloor 0,1011 \rfloor _2 = 0,10$)\\
Il faut montrer que $c(x_{1:N}) \in [l_N,h_N[$ (et qu'alors on pourra décoder), et que cette procédure de codage est efficace. \\
\begin{itemize}
\item On sait que $c(x_{1:N}) \leq \mu(x_{1:N})$ et on veut montrer que $\mu(x_{1:N})-c(x_{1:N}) \leq \frac{h_N-l_N}{2}$.\\
Avec par exemple
$\mu(x_{1:N}) = 0,101xxx$ et $c(x_{1:N})=0,101$, alors
\[ \mu(x_{1:N}) - c(x_{1:N}) = 0,000xxx \leq \sum_{i=4}^6 2^{-i} \]
Ainsi dans le cas général,
\[ \mu(x_{1:N}) - c(x_{1:N}) \leq \sum_{i=\lambda(x_{1:N})+1}^{+\infty} 2 ^{-i} = 2^{-\lambda(x_{1:N})} \]
Or, on a $\lambda(x_{1:N}) = -\lceil \log_2(p(x_{1:N})) \rceil