241 lines
8.5 KiB
TeX
241 lines
8.5 KiB
TeX
|
\documentclass{article}
|
||
|
|
\input{../../preambule/preambule}
|
||
|
|
|
||
|
|
\newcommand{\nom}{TD1 : Codage de Sources}
|
||
|
|
\renewcommand{\nomentete}{UE455 - \nom}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
\begin{document}
|
||
|
|
|
||
|
|
\titre{\nom}
|
||
|
|
|
||
|
|
\begin{center}
|
||
|
|
TD et TP : remi.azouit@ens-cachan.fr
|
||
|
|
\end{center}
|
||
|
|
|
||
|
|
\section*{Point de cours sur le codage de Huffman}
|
||
|
|
|
||
|
|
Il s'agit d'un codage préfixe construit de façon récursive. Avec un codage préfixe, on n'a pas besoin de recevoir tout pour décoder. On peut décoder au fur et à mesure de la réception. Dans un code préfixe, chaque code ne peut pas être le début d'un autre code.
|
||
|
|
|
||
|
|
\begin{exemple}
|
||
|
|
|
||
|
|
On considère une source $X$ à valeurs dans $\X=\{A,B,...G\}$.
|
||
|
|
|
||
|
|
On a $p_A=3/8,\quad p_B=3/16, \quad p_C=3/16, \quad p_D=1/8,\quad p_E=1/16,\quad p_F=1/32,\quad p_G=1/32$.\\
|
||
|
|
|
||
|
|
Pour construire le codage, on range les symboles par probabilité d'apparition décroissante et on construit un arbre en associant à chaque fois les deux probabilités les plus faibles. Ainsi, les symboles les plus probables ont les codes les plus courts. Si on a deux probabilités qui sont égales, on peut choisir de façon équivalente l'une des deux : le codage sera différent mais tout aussi efficace.
|
||
|
|
|
||
|
|
\begin{figure}[h!]
|
||
|
|
\centering
|
||
|
|
\includegraphics[scale=0.5]{arbre1.png}
|
||
|
|
\end{figure}
|
||
|
|
|
||
|
|
\begin{center}
|
||
|
|
\begin{tabular}{|c|c|c|c|c|c|c|c|}
|
||
|
|
\hline
|
||
|
|
$X$ & A & B & C & D & E & F & G \\
|
||
|
|
\hline
|
||
|
|
Code & 1 & 011 & 010 & 001 & 0001 & 00001 & 00000 \\
|
||
|
|
\hline
|
||
|
|
\end{tabular}
|
||
|
|
\end{center}
|
||
|
|
|
||
|
|
\begin{rmq}
|
||
|
|
Pour coder un texte, on peut soit utiliser des probabilités et donc des codes "généraux", ou alors les recalculer à chaque fois.
|
||
|
|
\end{rmq}
|
||
|
|
\end{exemple}
|
||
|
|
|
||
|
|
\newpage
|
||
|
|
\section*{Exercice 1 : Codage de Huffman}
|
||
|
|
|
||
|
|
\begin{enumerate}
|
||
|
|
\item Construction de l'arbre puis codage
|
||
|
|
|
||
|
|
\begin{figure}[h!]
|
||
|
|
\centering
|
||
|
|
\includegraphics[scale=0.5]{arbre2.png}
|
||
|
|
\end{figure}
|
||
|
|
|
||
|
|
\begin{center}
|
||
|
|
\begin{tabular}{|c|c|c|c|c|c|c|c|c|}
|
||
|
|
\hline
|
||
|
|
X & D & B & A & F & E & C & G & H \\
|
||
|
|
\hline
|
||
|
|
Code & 00 & 10 & 010 & 110 & 111 & 0110 & 01110 & 01111 \\
|
||
|
|
\hline
|
||
|
|
\end{tabular}
|
||
|
|
\end{center}
|
||
|
|
|
||
|
|
\item $R = \sum_{x\in\X}p_x \times l_x$ où $l_x$ est la longueur du code associé à $x$
|
||
|
|
|
||
|
|
Ainsi, $R=2.83$ bits/symbole.
|
||
|
|
|
||
|
|
\item L'entropie est le nombre minimal de bits par symbole nécessaire pour représenter la source:
|
||
|
|
|
||
|
|
$H=-\sum_{x\in\X} p_x \log_2 p_x$
|
||
|
|
|
||
|
|
Ainsi $H=2.7978$ bits/symbole.\\
|
||
|
|
|
||
|
|
On a bien $H \leq R$. Notre codage n'est pas le codage optimal.
|
||
|
|
|
||
|
|
\begin{rmq}
|
||
|
|
On obtiendrait $R=H$ dans le cas où toutes les probabilités étaient des puissances de 2.
|
||
|
|
\end{rmq}
|
||
|
|
|
||
|
|
\item Le code correspondant à $ABAADE$ est :
|
||
|
|
$010|10|010|010|00|111$
|
||
|
|
\end{enumerate}
|
||
|
|
|
||
|
|
\newpage
|
||
|
|
\section*{Exercice 2 : Codage d'une source de Markov}
|
||
|
|
|
||
|
|
\begin{enumerate}
|
||
|
|
\item Le nombre minimal de bits par symbole est déterminé par l'entropie. Le code le plus efficace aurait donc un nombre moyen de bits par symbole égal à l'entropie $H=\sum p_i \log(\frac{1}{p_i}) = 1.19$ bits/symbole.
|
||
|
|
|
||
|
|
\item Construction de l'arbre puis du codage
|
||
|
|
|
||
|
|
\begin{figure}[h!]
|
||
|
|
\centering
|
||
|
|
\includegraphics[scale=0.5]{arbre3.png}
|
||
|
|
\end{figure}
|
||
|
|
|
||
|
|
\begin{center}
|
||
|
|
\begin{tabular}{|c|c|c|c|c|}
|
||
|
|
\hline
|
||
|
|
X & ADD & STO & SUB & MPY \\
|
||
|
|
\hline
|
||
|
|
\hline
|
||
|
|
CODE & 0 & 10 & 110 & 111 \\
|
||
|
|
\hline
|
||
|
|
\end{tabular}
|
||
|
|
\bigbreak
|
||
|
|
\end{center}
|
||
|
|
On calcule alors le débit moyen R = $\sum_{x \in \X} pr(x).Nbbit(X)$ = 1.375 bit/symbole\\
|
||
|
|
|
||
|
|
On a une valeur supérieure à l'entropie mais inférieure à la valeur initiale. Cool! Notre codage n'est pas optimal mais est meilleur que le premier proposé.\\
|
||
|
|
|
||
|
|
|
||
|
|
On considère maintenant le modèle de Markov d'ordre 1 pour modéliser la succession d'instructions constituany un programme. La matrice de transmission de ce modèle est donnée par:
|
||
|
|
\[P_{j|i} = \begin{pmatrix}
|
||
|
|
\frac{13}{16}&\frac{1}{16}&\frac{1}{16}&\frac{1}{16}\\
|
||
|
|
0&0&0&1\\
|
||
|
|
\frac{1}{4}&\frac{1}{4}&\frac{1}{4}&\frac{1}{4}&\\
|
||
|
|
1&0&0&0
|
||
|
|
\end{pmatrix}\]
|
||
|
|
\begin{enumerate}
|
||
|
|
\item Montrer que $p = \left(\frac{3}{4}\frac{1}{16},\frac{1}{16}, \frac{1}{8} \right)$ représente bien la distribution de probabilité stationnaire de la source de Markov d'ordre 1.\\
|
||
|
|
Il s'agit de vérifier que $p\times P_{j|i} = p$.\\
|
||
|
|
|
||
|
|
\underline{Remarque}: On peut aussi voir ce résultat sous la forme plus courante $p^T = P_{j|i}^T p^T$. Ceci permet notamment de calculer $p$ s'il n'est pas donné, en cherchant un vecteur propre de $P_{j|i}^T$.\\
|
||
|
|
|
||
|
|
\item Calculer les probabilités moyennes d'avoir une succession des deux instructions suivantes :\\
|
||
|
|
|
||
|
|
\underline{Remarque}: ne pas confondre les lignes et les colonnes dans $P_{j|i}$:
|
||
|
|
\[P_{j|i} = \begin{pmatrix}
|
||
|
|
p_{ADD|ADD} & p_{SUB|ADD} & p_{MPY|ADD} & p_{STO|ADD}\\
|
||
|
|
p_{ADD|SUB} & p_{SUB|SUB} & p_{MPY|SUB} & \vdots \\
|
||
|
|
\vdots & \dots & \dots & \vdots\\
|
||
|
|
p_{ADD|STO} & \dots & \dots & p_{STO|STO}
|
||
|
|
\end{pmatrix}\]
|
||
|
|
On a donc avec la règle de Bayes :
|
||
|
|
\begin{align*}
|
||
|
|
p(STO - ADD) &= p(ADD_j | STO_{j-1}).p(STO_{j-1})\\
|
||
|
|
&= 1 \times \frac{1}{8}\\
|
||
|
|
&= \frac{1}{8}\\
|
||
|
|
p(ADD - ADD) &= \frac{13}{16}\times \frac{3}{4}\\
|
||
|
|
&= \frac{39}{64}\\
|
||
|
|
p(SUB-MPY) &= 0 \times \frac{1}{16}\\
|
||
|
|
&= 0
|
||
|
|
\end{align*}
|
||
|
|
On peut calculer les autres probabilités cumulées de la même façon à partir des probabilités conditionnelles en les piochant dans le tableau.(Elles seront toutes données à la question 4.)\\
|
||
|
|
|
||
|
|
\item En utilisant le modèle de Markov d'ordre 1, dans quelles proportions est-il possible de réduire le nombre moyen de bits utilisés pour coder une instruction?\\
|
||
|
|
|
||
|
|
On calcule donc l'entropie $H=0.87$bit/symbole. On a une entropie inférieur à l'entropie initiale. Ceci vient du fait que l'on a un couplage des symboles, donc plus d'informations pour un même nombre de bits transmis.\\
|
||
|
|
\end{enumerate}
|
||
|
|
|
||
|
|
\item
|
||
|
|
On commence par rappeler toutes les probabilités cumulées ordonnées:\\
|
||
|
|
\begin{center}
|
||
|
|
\begin{tabular}{|c|c|c|c|c|c|}
|
||
|
|
\hline
|
||
|
|
X & ADD-ADD & STO-ADD & SUB-STO & ADD-SUB & ADD-MPY \\
|
||
|
|
\hline
|
||
|
|
Pr(X) & $\frac{39}{64}$ & $\frac{8}{64}$ & $\frac{4}{64}$ & $\frac{3}{64}$ & $\frac{3}{64}$ \\
|
||
|
|
\hline
|
||
|
|
\hline
|
||
|
|
X & ADD-STO & MPY-ADD & MPY-SUB & MPY-MPY & MPY-STO \\
|
||
|
|
\hline
|
||
|
|
Pr(X) & $\frac{3}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ & $\frac{1}{64}$ \\
|
||
|
|
\hline
|
||
|
|
\end{tabular}
|
||
|
|
\end{center}
|
||
|
|
\bigbreak
|
||
|
|
On a alors $R = \frac{1.98}{2}$ bit/instruction. (On divise par 2 car on a 2 instructions codées à chaque fois)
|
||
|
|
\end{enumerate}
|
||
|
|
|
||
|
|
\newpage
|
||
|
|
\section*{Exercice 14 : Codage de source distribué}
|
||
|
|
|
||
|
|
\begin{enumerate}
|
||
|
|
|
||
|
|
\item On a 8 possibilités et toutes équiprobables donc :
|
||
|
|
\begin{align*}
|
||
|
|
H(X) &= -\sum p_i log_2 p_i\\
|
||
|
|
&= -8 (\frac{1}{8} log_2 \frac{1}{8})\\
|
||
|
|
H(X) &= 3 bit/symbole = H(Y)
|
||
|
|
\end{align*}
|
||
|
|
|
||
|
|
\item On a $d_H(x_k,y_k) \leq 1$ ce qui impose certaines combinaisons. Pour un x donné, il y a 4 possibilités de y. On a donc $8\times 4 =32$ possibilités toutes équiprobables.\\
|
||
|
|
Ainsi, $H(x_k,y_k) = 5$ bit/symbole.\\
|
||
|
|
|
||
|
|
\item On a par propriété : $H(X,Y) = H(X|Y) + H(Y)$, or si X et Y sont indépendants alors $H(X|Y) = H(X)$ donc on a $H(X|Y) = H(X) + H(Y)$.\\
|
||
|
|
Comme on n'a pas cette égalité, c'est que X et Y sont corrélés.\\
|
||
|
|
|
||
|
|
\item Il faut 3 bits pour coder $x_k$\\
|
||
|
|
%Trou du cul!!!
|
||
|
|
\item $H(X,Y) = H(X|Y) + H(Y)$ donc on a clairement $H(X|Y)=2$.\\
|
||
|
|
|
||
|
|
Comme $d_H(x_k,y_k) \leq 1$, on a qu'un seul bite de différent. Il suffit donc de coder la position du bite différent, 00 si identique, 01 pour le premier etc.\\
|
||
|
|
|
||
|
|
\item Pour coder le couple, il ne faut plus que 5 bits.\\
|
||
|
|
|
||
|
|
\item Dans ce cas, s'ils ne communiquent pas, on va devoir coder avec 6 bits.\\
|
||
|
|
|
||
|
|
\item 4 ensembles, donc on n'a besoin que de deux bits.\\
|
||
|
|
|
||
|
|
\item On a donc besoin que de 5 bits.\\
|
||
|
|
|
||
|
|
\item On connaît x et l'index de y, et x a un bit de différent avec l'une des deux possibilités de l'ensemble correspondant à l'index donné par y. Ces 2 possibilités sont distantes de 3, donc x ne peut être distant de 1 qu'avec l'un des deux. On peut donc retrouver (seulement car $d_H(x,y)\leq 1$) y à partir de x.\\
|
||
|
|
|
||
|
|
\item On alors R=H !!! \huge youuuupiiiiiiiiii \small
|
||
|
|
\end{enumerate}
|
||
|
|
|
||
|
|
\newpage
|
||
|
|
\section*{Exercice 13 : Codage par plages de zéros}
|
||
|
|
\begin{enumerate}
|
||
|
|
\item On calcule l'entropie de cette source: $H(X) = -(p log(p) + (1-p)log(1-p))$\\
|
||
|
|
|
||
|
|
\item Huffman serait inefficace (inutile) car il y a seulement 2 symboles à coder.\\
|
||
|
|
|
||
|
|
\item On a $y \in [0;+\infty [$.\\
|
||
|
|
|
||
|
|
\item On a $P_0 = p$, $P_1 = p(1-p)$, $P_2 = p(1-p)^2$ et $P_k = p(1-p)^k$.\\
|
||
|
|
|
||
|
|
\item On a $H(Y) = -\sum_{k=0}^{\infty} P_k logP_k$.\\
|
||
|
|
|
||
|
|
\item \begin{align*}
|
||
|
|
H(Y) &= - \sum_{k=0}^{\infty}p(1-p)^klog(p(1-p)^k)\\
|
||
|
|
&= - \sum_{k=0}^{\infty}p(1-p)^k(log(p)+klog(1-p))\\
|
||
|
|
&= -log(p) - \frac{1-p}{p} log(1-p)
|
||
|
|
\end{align*}
|
||
|
|
|
||
|
|
\item On part de $-log(p_k) \leq \lceil-log(p_k) \rceil \leq -log(p_k) + 1$ en multipliant par $p_k$ et n sommant sur l'infini, on identifie l'entropie et on obtient:
|
||
|
|
\[H(Y) \leq l(Y) \leq H(Y) +1 \]
|
||
|
|
|
||
|
|
\item k pour Y représente k+1 bits pour X.
|
||
|
|
\end{enumerate}
|
||
|
|
|
||
|
|
|
||
|
|
\end{document}
|