Commit d3f89a31 authored by Pierre-antoine Comby's avatar Pierre-antoine Comby

début de la refonte de TD 455

parent 231a6c20
\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$$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}
\ No newline at end of file
\documentclass{article}
\input{../../preambule/preambule}
\newcommand{\nom}{TD2 : Random TD}
\renewcommand{\nomentete}{UE455 - \nom}
\begin{document}
\titre{\nom}
\cacededi{Tu vois E.? Il a renversé sa bière sur le Mac Book de B. Alors B. était vénère. Du coup il lui a sucé la bite.}{Cédric Colonna}
\section*{Exercice 3 : Code préfixe pour les entiers}
\begin{enumerate}\setlength{\itemsep}{1cm}
\item Si $\forall k,k \leq m$, alors il faut $\lceil \log_2 k \rceil$ ($\log_2 k$ arrondi au supérieur). Les codes sont ici tous de la même longueur, donc ce codage est préfixe.
\item $\lceil \log_2 k \rceil$ donne la taille du nombre $k$ codé.
\begin{center}
\begin{tabular}{|c|c|c|}
\hline
$k$ & $\lceil \log_2 k \rceil$ & $C(k)$ \\
\hline
0 & 0 & 10 \\
\hline
1 & 0 & 11 \\
\hline
2 & 1 & 0110 \\
\hline
\end{tabular}
\end{center}
\item $ C_1(k)$ est-il préfixe ?
On prend $k_1 \neq k_2$
\begin{itemize}
\item si $\lceil \log_2 k_1 \rceil = \lceil \log_2 k_2 \rceil$, alors la 2e partie du code est différente. Les deux codes font la même longueur mais sont différents, donc c'est préfixe.
\item si $\lceil \log_2 k_1 \rceil < \lceil \log_2 k_2 \rceil$, alors la 1e partie du code est différente, donc c'est préfixe.
\end{itemize}
\item $l_1(k) = \lceil \log_2 k \rceil + 1 + \lceil \log_2 k \rceil = 2\lceil \log_2 k \rceil + 1 = 2 \log_2 k + \mathcal{O}(1)$
\item On code $\lceil \log_2 k \rceil$ avec $C_1$ : $C_2(k) = C_1(\lceil \log_2 k \rceil)x...x$$x...x$ est $k$ en binaire.
On a alors $l_2(k) = 2 \lceil \log_2 ( \lceil \log_2 k \rceil ) \rceil + \lceil\log_2 k \rceil = 2 \log_2 (\log_2 k) + \log_2 k + \mathcal{O}(1)$
\end{enumerate}
\section*{Exercice 5 : Distribution de redondance minimale}
On considère un code préfixe : $C=\{C_1,C_J\}$ dont la longueur de chaque mot de code est $l_i, i = 1 \dots J$.
On considère une source $X$ dont l'alphabet est $A=\{a_1,...a_J\}$ et le vecteur de probabilités $\underline{p}=[p_1, \dots p_J]$.
\newcommand{\p}{\underline{p}}
\begin{enumerate}\setlength{\itemsep}{1cm}
\item Donner l'entropie de la source .
\[H(\p) = - \sum_{i=1}^J p_i \log_2 p_i\]
\item Donner la longueur moyenne du code.
\[l(C,\p) = \sum_{i=1}^J p_i l_i \]
\item Donner la redondance du code
\[ R(C,\p) = l(c,\p) - H(\p) = \sum_{i=1}^J p_i (l_i + \log_2 p_i) \]
On veut chercher $\p$ qui va minimiser $R(c,\p)$
\item Quelles sont les contraintes que doivent satisfaire les composantes de $\p$ ?
\[ \sum_{i=1}^J p_i=1 \quad \et \quad \forall i=1,\dots J, \quad 0 \leq p_i \leq 1\]
\item Un problème d'optimisation sous contraintes. Minimiser $R=\sum_{i=1}^J p_i (l_i + \log_2 p_i)$
\item On utilise le lagrangien :
\[ L(\p,\ld) = \sum_{i=1}^J p_i(l_i+\log_2 p_i) + \ld(\sum_{i=1}^J p_i-1) \]
\item Condition d'optimalité :
\begin{align*}
\acc{\drond{L}{p_i}(\p^*,\ld^*)&=0, \quad \forall i = 1,\dots J}{\drond{L}{\ld}(\p^*,\ld^*)&=0} & \Leftrightarrow \acc{l_i + \log_2p_i^* + \log_2 e + \ld^* & = 0}{\sum_{i=1}^J p_i^*-1 & =0}\\
& \Leftrightarrow \acc{p_i^* & = 2^{-l_i - \ld^* - \log_2 e} }{1 & = \sum_{i=1}^J 2^{-l_i}2^{-\ld^*-\log_2 e}} \\
& \Leftrightarrow \acc{p_i^* & = 2^{-l_i}2^{- \ld^* - \log_2 e} }{2^{-\ld^*-\log_2 e} & = \frac{1}{\sum_{i=1}^J 2^{-l_i}}}
\end{align*}
\[ \boxed{ p_i^*= \frac{2^{-l_i}}{\sum_{i=1}^J 2^{-l_i}}} \]
\end{enumerate}
\end{document}
\ No newline at end of file
\documentclass{article}
\input{../../preambule/preambule}
\newcommand{\nom}{TDx : Choix de la fonction de Lyapunov candidate et Commandabilité et Observabilité}
\renewcommand{\nomentete}{UE455 - \nom}
\begin{document}
\titre{\nom}
\section*{Exercice 9: Comparaison de LZM et de LZ77}
On considère une source $\X$ ayant généré le message suivant:
\[bongbonbongobang\$ \]
ou $\$$ est un symbole particulier marquant la fin du message, mais qui devra être codé comme les autres symboles.\\
\begin{enumerate}
\item Trivial
\item très simple
\item easy
\item On confond fréquence et probabilité estimé:
\begin{tabular}{|c|c|}
\hline
Symboles & Fréquence \\
\hline
\hline
b & $\frac{4}{17}$ \\
\hline
o & $\frac{4}{17}$ \\
\hline
n & $\frac{4}{17}$ \\
\hline
g & $\frac{3}{17}$ \\
\hline
a & $\frac{1}{17}$ \\
\hline
$\$$ & $\frac{1}{17}$ \\
\hline
\end{tabular}
L'entropie est donc de 2.4 bits/symbole.
\item On initialise le dictionnaire avec
On commence par coder la première lettre, puis on rajoute la lettre et la lettre suivante au dictionnaire et ainsi de suite.
Lorsque l'on arrive a $bo$ qui est déjà dans le dictionnaire, on peut directement le coder, puis on le rajoute ainsi que la lettre qui suit c'est à dire $bon$, et ainsi de suite.
Le dictionnaire ainsi généré est:
\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|c|}
\hline
a & b & g & o & n & $\$$ & bo & on & ng &gb & bon & nb & bong & go & ob & ba & an & ng$\$$\\
\hline
0 & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 &9 & 10 & 11 & 12 & 13 & 14 & 15 & 16 & 17\\
\hline
\end{tabular}
La séquence ainsi obtenue est :
\[\text{1 4 3 2 6 3 10 0 4 1 0 8 5}\]
\item Pour décoder, on effectue la même démarche, on décode 1 en d qui est déjà dans le dictionnaire et on ajoute d et la prochaine lettre trouvée et ainsi de suite.
Si on l'effectue correctement on retrouve le même texte avec le même dictionnaire.
\item Il prend 5 symboles à partir de second.
\item Problème d'initialisation, il n'est pas possible de coder un symbole qui n'est jamais apparu.
\item A l'itération i, on a $x_1,...,x_n = [y_i,\omega_i, \xi^{(i)},z_i]$ avec $y_i$ qui est déjà codé, $\omega_i$ la plus longue sous chaine de $y_i$ et $\xi^{(i)}$ le symbole suivant $\omega_i$.\\
Ainsi $[\omega_i , \xi_{(i)}]$ est codé $ <j, k, \xi_{(i)}>$.\\
Si $\omega_i = 0$ on code $ <0, 0, \xi_{(i)}>$.
ET on oublie pas : $c(i,:) = <j, k, \xi_{(i)}>$, c'est à dire: ??!?. Ça traine tout seul dans son coin du tableau.
\item Pour coder la chaîne bongbonbongobang$\$$, on commence par coder les quatre premiers symboles, c'est à dire que l'on a:
\[<0,0<b> <0,0,o> <0,0,n> <0,0,g>\]
Puis on code les quatre suivant ensemble avec $<1,3,b>$ car la sous-chaine composé de $bon$ apparait déjà avant.\\
Puis $ongo$ car la racine $ong$ existe déjà donc on a $<2,3,o>$.\\
Ensuite on code $ba$ qui donne $<1,1,a>$.\\
Et pour finir on code $ng\$$ qui donne $<3,2,\$>$.
\item \begin{lstlisting}
c; //vecteur de triples
x = []; // séquence décodée
for i=1:length(c)
x = [x, x[c(i,1):c(i,1)+c(i,2)], c(i,3)]
end
\end{lstlisting}
\item Pour coder la chaîne bongbonbongobang$\$$, on commence par coder les quatre premiers symboles, c'est à dire que l'on a:
\[<0,0<b> <0,0,o> <0,0,n> <0,0,g>\]
Puis on code les quatre suivant ensemble avec $<1,3,b>$ car la sous-chaine composé de $bon$ apparait déjà avant.\\
Puis $ongo$ car la racine $ong$ existe déjà donc on a $<2,3,o>$.\\
Ensuite on code $ba$ qui donne $<1,1,a>$.\\
Et pour finir on code $ng\$$ qui donne $<3,2,\$>$.
\item On effectue le même travail en décodant cette fois. Si on ne se trompe pas, on retombe sur la même chose.
\item Avec la méthode C, pour coder bongbongbonbongobang$\$$ on obtient:
$<0,0,b> ... <0,0,g> <1,7,b><2,3,o><1,1,a><3,2,\$>$
Ce que l'on retient c'est que pour bongbon on a une répétition sur 7 symbole des 4 premiers, après il suffit d'appliquer bêtement l'énoncé.
\item \begin{lstlisting}
c;
x=[];
for i=1:length(c)
for j = 1:c(i,2)
x = x[x,x[c(i,1+j-1)];
end
end
\end{lstlisting}
LE problème est que ? pas compris ce qu'il a dit.
\item \begin{align*}
0 \leq j \leq s \Rightarrow \lceillog_2 S \rceil \text{ bits} \\
0 \leq k \leq s + t \Rightarrow \lceillog_2 (S+t) \rceil \text{ bits} \\
u \Rightarrow \lceillog_2 u \rceil \text{ bits} \\
\end{align*}
\end{enumerate}
\end{document}
\ No newline at end of file
\documentclass{article}
\input{../../preambule/preambule}
\newcommand{\nom}{TD5 : Codage de sources}
\renewcommand{\nomentete}{UE455 - \nom}
\begin{document}
\titre{\nom}
\cacededi{C'est pratique d'avoir un pantalon troué, je peux me gratter les couilles comme je veux.}{Tom Colinot}
\section*{2. Quantification et codage entropique}
\img{0.5}{1}
\begin{enumerate}\setlength{\itemsep}{5mm}
\item On ne peut pas le dire directement parce que les couples $(R,D)$ n'ont ni $R$, ni $D$ connu pour QSU et QSNU.
\item Sans codeur entropique, on ne se réfère qu'on premier tableau. Pour le même débit, on a toujours $RSB_{QSU} \leq RSB_{SQNU}$, donc la QSNU est meilleure.
\item $D_{min} = \sigma^2 2^{-2R}$
\img{0.5}{2}
\[RSB_{max} = 10\log_{10} \frac{\sigma^2}{D_{min}} = 6.02R\]
\[D(r) - D_{min}(R) = RSB_{max} - RSB(R) = 6R - RSB(R)\]
Avec un codeur entropique parfait, on a $R=H$ et donc :
\begin{center}
\begin{tabular}{c|c|c}
$\log_2 M$ & QSU & QSNU \\
\hline
1 & 1.6 & 1.6 \\
2 & 2.174 & 2.166 \\
3 & 2.296 & 2.33 \\
4 & 2.232 & 2.37 \\
5 & 2.124 & 2.36
\end{tabular}
\end{center}
\item C'est QSU + CE qui est meilleur.
\end{enumerate}
\section*{3. Codage scalable}
\begin{enumerate}\setlength{\itemsep}{5mm}
\item
\begin{enumerate}
\item $M=2^R$ donc $\Delta = \frac{2X_{max}}{M} = \frac{2X_{max}}{2^R} = X_{max}2^{1-R}$
\item $D = \frac{\Delta^2}{12} = \frac{(X_{max}2^{1-R})^2}{12} = X_{max}^2 \frac{1}{3} 2^{-2R} $
\item $R=3 \Rightarrow M=8$
\imgt{3}
\item
\begin{itemize}
\item $X_1 = 0.9X_{max} \Rightarrow 111$
\item $X_2 = -0.1X_{max} \Rightarrow 011$
\item $X_3 = -0.6X_{max} \Rightarrow 001$
\end{itemize}
\end{enumerate}
\item Le train binaire classique est 111 0111 001. Si les six bits de la fin sont perdus, on ne peut que reconstruire $X_1$.
\item
\begin{itemize}
\item Scalable 1 : on code d'abord $X_1X_2X_3$ avec un bit par $X_i$, puis on la quantifiée avec 2 puis 3 bits. Au final, on code donc $X_1X_2X_3$ sur un train de 3+6+9=18 bits. Si on n'a que les 3 premiers 100, on peut reconstituer $X_1 = 0.5X_{max}$, $X_2=X_3=-0.5X_{max}$.
\item Scalable 2 : on envoie les premiers bits de $X_1,X_2$ et $X_3$ à la suite, puis les deuxièmes bits, puis les troisièmes. Le train fait donc 9 bits.
\end{itemize}
\begin{figure}
\centering
\begin{tabular}{c|c|c|c|c}
R & D & Non scalable & Scalable 1 & Scalable 2 \\
\hline
0 & $\sigma^2$ & 0 & 0 & 0\\
1 & $\sigma^2 2^{-2}$ & 1 & 1 & 1 \\
2 & $\sigma^2 2^{-4}$ & 2 & 1+2 & 2 \\
3 & $\sigma^2 2^{-6}$ & 3 & 1+2+3 & 3
\end{tabular}
\caption{Débit}
\end{figure}
\item Codage d'image, codage vidéo. \textit{Because why ? Because fuck you that's why.}
\end{enumerate}
\section*{1. Quantification scalaire uniforme}
\imgt{4}
\begin{enumerate}\setlength{\itemsep}{5mm}
\item \begin{align*}
D & = E[(x-y)^2] \\
& = \int_{-\infty}^{+\infty} p_X(x)(x_Q(x))^2dx \\
& = \sum_{i=1}^N \int_{s_{i-1}}^{s_i} p_X(x)(x-y_i)^2 dx
\end{align*}
\item $N=2$
\img{0.5}{5}
$y_1 = -\frac{\Delta}{2}, \quad y_2 = \frac{\Delta}{2}$
On cherche $\Delta$ qui minimise $D$ :
\begin{align*}
D & = \int_{-\infty}^0 p_X(x)(x+\frac{\Delta}{2})^2 dx + \int_0^{\infty}p_X(x)(x-\frac{\Delta}{2})^2 dx \\
& = \int_{-\infty}^0 p_X(x)(x^2+\frac{\Delta^2}{4}+x\Delta) dx + \int_0^{\infty}p_X(x)(x^2+\frac{\Delta^2}{4}-x\Delta) dx \\
& = \int_{-\infty}^{\infty} p_X(x)(x^2 + \frac{\Delta^2}{4}) dx + \Delta(\int_{-\infty}^0p_X(x)dx - \int_0^{\infty}p_X(x)dx)
\intertext{Or, $\int_{-\infty}^0p_X(x)dx + \int_0^{\infty}p_X(x)dx = 0$ ($X$ de valeur moyenne nulle)}
D & = \int_{-\infty}^{\infty} p_X(x)(x^2 + \frac{\Delta^2}{4}) dx + 2\Delta\int_0^{\infty}p_X(x)dx \\
& = (\int_{-\infty}^{+\infty} p_X(x)dx)\frac{\Delta^2}{4} - (2\int_0^{\infty} xp_X(x)dx)\Delta + \int_{-\infty}^{+\infty} x^2p_X(x)dx \\
& = \frac{\Delta^2}{4} - (2\int_0^{\infty} xp_X(x)dx)\Delta + \int_{-\infty}^{+\infty} x^2p_X(x)dx
\end{align*}
Ainsi, \[ \drond{D}{\Delta} = 0 \Rightarrow \frac{1}{4}2\Delta - 2\int_0^{\infty} xp_X(x)dx = 0 \Rightarrow \Delta = 4\int_0^{\infty} xp_X(x)dx \]
\item On a maintenant $\acc{y_{i+1}-y_i & = \Delta}{y_{N/2} = -\Delta / 2, & y_{N/2+1} = \Delta / 2}$
De plus, $y_{N/2}-y_1 = \Delta(N/2-1)$ donc $y_1 = y_{N/2}-\Delta(N/2-1) = -\Delta(N/2-1/2)$
$y_i = \Delta/2(-N+1)+(i-1)\Delta = (i-N/2-1/2)\Delta$
$S_i=y_i+\Delta/2=\Delta(i-N/2)$
\begin{align*}
D & = \int_{-\infty}^{\Delta(1-N/2)}p_X(x)(x+\Delta(N/2-1/2))dx + \sum_{i=2}^{N-1} \int_{\Delta(i-1-N/2)}^{\Delta(i-N/2)} p_X(x)(x-\Delta(i-\frac{N+1}{2})^2)dx + \int_{\Delta(N/2-1)}^{\Delta(i-N/2)} p_X(x)(x-\Delta(N/2-1/2))dx
\end{align*}
Ensuite, on cherche $\Delta$ tel que $\drond{D}{\Delta}=0$ mais c'est relou donc on va pas le faire.
\item \begin{enumerate}
\item $ \Delta = \frac{2A}{4} = \frac{A}{2}$
\item \img{0.5}{6}
\item $D=\frac{\Delta^2}{12}=\frac{A^2}{3\times^{2R}}$
\end{enumerate}
\end{enumerate}
\section*{4. Codage avec information adjacent au décodeur}
\begin{enumerate}
\item Un exemple de compression d'une sourceX en se servant d'une information adjacente supposée disponible au codeur et au décodeur:\\
En codage vidéo, le codeur dispose de l'image n-1 (compressée et décompressée) pour coder l'image n.\\
Le décodeur dispose également de l'image n-1.\\
\item On fabrique $\tilde{X}$ à partir de X et de Y :
\[\tilde{X} = X-Y\]
Au décodeur, $\tilde{X}$ sera utilisé pour calculer $\hat{X}$ (l'estimé de X).\\
\item On suppose que Y et donc Z suivent une loi normale de moyenne nulle et d'écart-type respectif $\sigma_Y$ et $\sigma_Z$.
\begin{enumerate}
\item \begin{align*}
E(X) &= E(Y+Z) = E(Y) + E(Z) = 0\\
\sigma_X^2 &= E((X-E(X))^2) = E(X^2) =E(Y^2 + Z^2 + 2YZ)\\
&= E(Y^2) + 2E(Y)E(Z) +E(Z^2)\\
&= \sigma_Y^2 + \sigma_Z^2
\end{align*}
\item On ne tient compte de Y ni au codeur, ni au décodeur, $\tilde{X} = X$ et $D_1(R) = \sigma_X^2 2^{-2R}$.\\
\item Si on compresse $\tilde{X} = X-Y = Z$, alors $D_2(R) = \sigma_{\tilde{X}}^2 2^{-2R} = (\sigma_X^2 - \sigma_Y^2) 2^{-2R}$. Donc:
\[D_2(R) \leq D_1(R)\]
\end{enumerate}
\item On n'utilise pas Y au codeur, donc à priori, les performances devraient être moins bonnes.
\img{0.5}{7.png}
Tout d'abord, X est quantifié à l'aide d'un quantificateur scalaire uniforme de pas $\Delta_1$, centré en 0. X appartient à un intervalle de quantification répété par un index $q_1$, cet intervalle est alors découpé en M sous-intervalle, $m \in \{0,1,...,M-1\}$.
\item \[\Delta_1 = M\Delta_2 \Rightarrow \Delta_2 = \frac{\Delta_1}{M} \]
\item Les m(s) sont équiprobables donc:
\[H = \sum_{i=1}^{\Delta_2} \frac{1}{\Delta_2}log_2(\frac{1}{\frac{1}{\Delta_2}} = log_2(\Delta_2) \]
C'est le nombre de bits nécessaire.\\
Première méthode:\\
On quantifie Y au décodeur avec $\Delta_1$:
\img{0.5}{8.png}
\item Il faut:
\[\acc{k\Delta_1 - \frac{\Delta_1}{2} \leq Y \leq k\Delta_1 + \frac{\Delta_1}{2}}{k\Delta_1 - \frac{\Delta_1}{2} \leq X \leq k\Delta_1 + \frac{\Delta_1}{2}} \]
\img{0.5}{9.png}
On suppose que $Y = k \Delta_1$ donc, on a $k\Delta_1 - \frac{\Delta_1}{2} \leq k \Delta_1 + Z \leq k\Delta_1 + \frac{\Delta_1}{2}$. Ce qui implique que :
\[-\frac{\Delta_1}{2} \leq Z \leq \frac{\Delta_1}{2}\]