début de la refonte de TD 455
This commit is contained in:
Pierre-antoine Comby
parent
231a6c2033
commit
d3f89a3148
24 changed files with 0 additions and 1072 deletions
|
|
@ -1,241 +0,0 @@
|
|||
\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}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 40 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 48 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 74 KiB |
|
|
@ -1,91 +0,0 @@
|
|||
\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$ où $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}
|
||||
|
|
@ -1,133 +0,0 @@
|
|||
\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}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 25 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 19 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
|
|
@ -1,239 +0,0 @@
|
|||
\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}\]
|
||||
|
||||
\item Lorsque Y est très proche de la limite de l'intervalle, on a une distorsion de l'ordre de $\Delta_1^2$, même lorsque $Z << Y$.
|
||||
|
||||
\item Deuxième méthode: On découpe l'intervalle de largeur $\Delta_1$ en 0, en M sous-intervalle, et on sélectionne le milieu 0' du sous-intervalle indexé par m.
|
||||
Ensuite, Y est quantifié avec $\Delta_1$ mais centré en 0'.\\
|
||||
|
||||
\img{0.5}{10.png}
|
||||
|
||||
Première étape: on reconstruit $\hat{\omega}$ à partir de m et $-\frac{\Delta_1}{2} \leq \tilde{\omega} \leq \frac{\Delta_1}{2}$.\\
|
||||
Seconde étape: $Y \rightarrow \hat{Y}$\\
|
||||
\begin{align*}
|
||||
\hat{X} = \hat{Y + \hat{\omega}} \text{ et,} X = Y + Z\\
|
||||
\text{donc, } (\hat{X}-X) = (\hat{Y} - Y) + (\hat{\omega} - Z)\\
|
||||
(\hat{Y}-Y)^2 \leq \frac{\Delta_1^2}{4}
|
||||
\end{align*}
|
||||
|
||||
Si $Z \in [-\frac{\Delta_1}{2}; \frac{\Delta_1}{2}]$ alors, $ (Z-\hat{\omega})^2 \leq \Delta_1^2$, sinon $(z-\hat{\omega})^2$ peut être large.
|
||||
|
||||
\item $\Delta_1$ assez grand pour que $|Z| \leq \frac{\Delta_1}{2}$.\\
|
||||
D(R) augmente aussi et $(\hat{m}-m)$ augmente.
|
||||
|
||||
\item Montrons que $Pr(|Z|> \frac{\Delta_1}{2}) = \sqrt{\frac{2}{\pi \sigma_Z^2}} \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_z^2}) dz$, dont la distribution de probabilité est:
|
||||
\img{0.5}{11.png}
|
||||
On peut aussi montrer que:
|
||||
\begin{align*}
|
||||
Pr(|Z|>\frac{\Delta_1}{2}) &= 2 Pr(Z > \frac{\Delta_1}{2})\\
|
||||
&= 2 \sqrt{\frac{1}{2\pi \sigma_Z^2}} \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_z^2}) dz
|
||||
\end{align*}
|
||||
|
||||
On suppose que $ \Delta_2 << \Delta_1$, et $\Delta_2 << \sigma_Z$.\\
|
||||
On peut montrer que $|Z| \leq \frac{\Delta_2}{2} \Rightarrow D_1 = \frac{\Delta_2^2}{12}$ et que $|Z| > \frac{\Delta_2}{2} \Rightarrow D_2 = \Delta_2^2$.\\
|
||||
|
||||
\begin{align*}
|
||||
D &= D_1 Pr(|Z| \leq \frac{\Delta_1}{2}) + D_2 Pr(|Z| > \frac{\Delta_1}{2})\\
|
||||
&= \frac{\Delta_2^2}{12} \int_{-\frac{\Delta_1}{2}}^{\frac{\Delta_1}{2}} \frac{1}{\sqrt{2\pi \sigma_Z^2}} exp(-\frac{z^2}{2\sigma_Z^2})dz + \Delta_1^2 \sqrt{\frac{2}{\pi \sigma_Z^2}} \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_Z^2})dz\\
|
||||
&= \sqrt{\frac{2}{pi \sigma_z^2}} \left(\frac{\Delta_2^2}{12} \int_{0}^{\frac{\Delta_1}{2}} exp(-\frac{z^2}{2\sigma_Z^2})dz + \Delta_1^2 \int_{\frac{\Delta_1}{2}}^{+\infty} exp(-\frac{z^2}{2\sigma_Z^2})dz\right)
|
||||
\end{align*}
|
||||
|
||||
\item R est fixé donc M est fixé, et $\Delta_2 = \frac{\Delta_1}{M}$.
|
||||
|
||||
On calcul $\frac{\partial D}{\partial \Delta_1}$ et par magie on trouve 0.
|
||||
|
||||
\end{enumerate}
|
||||
\end{document}
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 32 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 64 KiB |
|
|
@ -1,212 +0,0 @@
|
|||
\documentclass{article}
|
||||
\input{../../preambule/preambule}
|
||||
|
||||
\newcommand{\nom}{TD6 : Allocation optimale de bits}
|
||||
\renewcommand{\nomentete}{UE455 - \nom}
|
||||
|
||||
|
||||
|
||||
\begin{document}
|
||||
|
||||
\titre{\nom}
|
||||
|
||||
\cacededi{C'est bizarre, il a dit "reconnaissance de formes" et on l'a pas entendu jouir derrière.}{Tom Colinot}
|
||||
|
||||
\section{Transformation unitaires, gain de codage}
|
||||
|
||||
\subsection{Quantification sans transformation}
|
||||
|
||||
\newcommand{\y}{\underline{y}}
|
||||
|
||||
On considère une source $X$ dont les réalisations sont groupées en $N$ composantes considérées comme générées par une source vectorielle $Y$.
|
||||
|
||||
\begin{center}
|
||||
\begin{tabular}{c|cc}
|
||||
$X_i$ & $x_1\dots x_N$ & $x_{N+1} \dots x_{2N}$ \\
|
||||
\hline
|
||||
$Y_i$ & $\y_1$ & $\y_2$
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
|
||||
\begin{enumerate}\setlength{\itemsep}{5mm}
|
||||
\item On dispose de $NR$ bits par vecteur de $N$ composantes, donc on utilise $R$ bits par composante.
|
||||
|
||||
\item $D_Y = \frac{1}{N} E(||\y_k-\tilde{\y_k}||^2) = D_X$.
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Quantification après transformation}
|
||||
|
||||
\newcommand{\tv}{\underline{t}}
|
||||
\newcommand{\Uu}{\underline{\underline{U}}}
|
||||
\newcommand{\Id}{\underline{\underline{I}}}
|
||||
|
||||
\begin{enumerate}\setlength{\itemsep}{5mm}\setcounter{enumi}{2}
|
||||
\item On fait une transformation sur $\y_k$ :
|
||||
\[ \tv_k = \Uu^T \y_k \avec \Uu.\Uu^T = \Id_N\]
|
||||
|
||||
\imgt{1}
|
||||
|
||||
\begin{align*}
|
||||
D_T & = \frac{1}{N}E(||\tv_k - \tilde{\tv_k}||^2 ) \\
|
||||
& = \frac{1}{N} E(||\Uu^T \y_k - \Uu^T \tilde{\y_k}||^2) \\
|
||||
& = \frac{1}{N} E((\Uu^T(\y_k-\tilde{\y_k}))^T.(\Uu^T(\y_k-\tilde{\y_k}))) \\
|
||||
& = \frac{1}{N}E((\y_k - \tilde{y_k})^T \Uu.\Uu^T(\y_k - \tilde{y_k})) \\
|
||||
& = \frac{1}{N}E(||\y_k - \tilde{\y_k}||^2) \\
|
||||
& = D_Y
|
||||
\end{align*}
|
||||
|
||||
\item \[NR = \sum_{l=1}^N R_l\]
|
||||
|
||||
\item \[D_T = \frac{1}{N} \sum_{l=1}^N D_{t,l}(R_l) = \frac{1}{N} \sum_{i=1}^N \epsilon_{t,l}\sigma^1_{t,l} 2^{-2R_l} \]
|
||||
|
||||
\item On peut jouer sur $R_i, \forall i= 1, \dots N$ pour minimiser $D_T$ sous la contrainte $\sum R_l = NR$.\\
|
||||
|
||||
$D_T$ est une fonction convexe, donc la condition d'extremum est une condition de minimum.\\
|
||||
|
||||
On utilise le lagrangien :
|
||||
\[ J(R_1, \dots, R_N, \ld) = \frac{1}{N} \sum_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2 2^{-2R_l} + \ld(\sum_{l=1}^N R_l - NR) \]
|
||||
|
||||
\item Les conditions nécessaires pour minimiser $J(R_1, \dots, R_N, \ld)$ sont donc :
|
||||
\[ \acc{ \drond{J}{R_l} & = 0, \quad \forall l = 1, \dots, N }{ \drond{J}{\ld} & = 0, \quad \forall \ld \in \{\ld\} \quad \text{Lolilonche}} \]
|
||||
|
||||
\item \begin{align*}
|
||||
\drond{J}{R_l} = 0 & \Leftrightarrow \frac{1}{N} \epsilon_{t,l} \sigma_{t,l}^2 (-2\ln2)2^{-2R_l} + \ld = 0 \\
|
||||
& \Leftrightarrow 2^{-2R_l} = \frac{N\ld}{\epsilon_{t,l} \sigma_{t,l}^2 (2\ln2)}, \quad \forall l = 1, \dots, N\\
|
||||
\drond{J}{\ld} = 0 & \Leftrightarrow \sum_{l=1}^N R_l = NR
|
||||
\intertext{On en déduit donc que}
|
||||
2^{-2\sum R_l} & = \prod_{l=1}^N \frac{N\ld}{\epsilon_{t,l} \sigma_{t,l}^2 (2\ln2)} \\
|
||||
2^{-2NR} & = \prod_{l=1}^N \frac{(N\ld/(2\ln2))}{\epsilon_{t,l} \sigma_{t,l}^2} \\
|
||||
2^{-2NR} & = \frac{(N\ld/(2\ln2))^N}{\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2} \\
|
||||
(N\ld/(2\ln2)) & = 2^{-2R} (\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N} \\
|
||||
\ld & = \frac{2\ln2}{N}2^{-2R} (\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}
|
||||
\intertext{ Ainsi, en reprenant l'expression trouvée pour $2^{-2R_l}$}
|
||||
R_l & = -\frac{1}{2} \log_2 \frac{(N\ld/(2\ln2))}{\epsilon_{t,l} \sigma_{t,l}^2} \\
|
||||
& = \frac{1}{2} \log_2 \frac{\epsilon_{t,l} \sigma_{t,l}^2}{2^{-2R}(\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}} \\
|
||||
R_l & = R + \frac{1}{2} \log_2 \frac{\epsilon_{t,l} \sigma_{t,l}^2}{2^{-2R}(\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}}
|
||||
\end{align*}
|
||||
|
||||
\item \begin{align*}
|
||||
D_{t,l}(R_l) & = \epsilon_{t,l} \sigma_{t,l}^2 2^{-2R_l} \\
|
||||
& = \epsilon_{t,l} \sigma_{t,l}^2 \frac{N\ld}{\epsilon_{t,l} \sigma_{t,l}^2 (2\ln2)} \\
|
||||
D_{t,l}(R_l)& = \frac{N\ld }{2\ln2} \quad \text{constante}
|
||||
\end{align*}
|
||||
|
||||
\item \begin{align*}
|
||||
D_T^* & = \frac{1}{N} \sum_{l=1}^N D_{t,l}(Rl) \\
|
||||
& = \frac{1}{N} N \frac{N\ld}{2\ln2} \\
|
||||
& = \frac{N\ld}{2\ln2} \\
|
||||
D_T^* & = 2^{-2R} (\prod_{l=1}^N\epsilon_{t,l} \sigma_{t,l}^2)^{1/N}
|
||||
\end{align*}
|
||||
|
||||
\item \[ D = \frac{1}{N} \sum_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2 2^{-2R} \]
|
||||
|
||||
\item \[G_T = \frac{\frac{1}{N}\sum_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2}{(\prod_{l=1}^N \epsilon_{t,l} \sigma_{t,l}^2)^{1/N}} \]
|
||||
\end{enumerate}
|
||||
|
||||
\begin{flushright}
|
||||
Si tu n'as pas encore vomi c'est le moment, je te laisse un bout de page blanche.
|
||||
\end{flushright}
|
||||
|
||||
\vspace{8cm}
|
||||
|
||||
\subsection{Applications numériques}
|
||||
Le chinois a \emph{rage quit}.
|
||||
|
||||
\newpage
|
||||
\section{Techniques de codage d'images}
|
||||
|
||||
\subsection{Codage sans pertes}
|
||||
|
||||
\begin{enumerate}\setlength{\itemsep}{5mm}
|
||||
\item On estime d'abord les probabilités d'apparition :
|
||||
|
||||
\begin{center}
|
||||
\begin{tabular}{c|c|c}
|
||||
Symbole & Nombre d’occurrences & Probabilité estimée \\
|
||||
\hline
|
||||
4 & 1 & 1/16 \\
|
||||
6 & 3 & 3/16 \\
|
||||
8 & 7 & 7/16 \\
|
||||
10 & 5 & 5/16
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
|
||||
L'estimation de l'entropie est donc :
|
||||
\[ \hat{H} = -\sum_i p_i \log_2 p_i \approx 1.749 \text{bpp} \]
|
||||
|
||||
\item Il n'est pas possible d'obtenir un débit de 0.5 bpp $< \hat{H}$.
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Codage avec pertes - Quantification}
|
||||
|
||||
\begin{enumerate}\setlength{\itemsep}{5mm}\setcounter{enumi}{2}
|
||||
\item $E(X) = 4\frac{1}{16} + 6\frac{3}{16} + 8\frac{7}{16} + 10\frac{5}{16} = 8$
|
||||
|
||||
$Var(X) = E((X-E(X))^2) = \dots = 3$
|
||||
|
||||
\item $D(R) = \sigma_X^2 2^{-2R}$
|
||||
\img{0.5}{2}
|
||||
|
||||
\item $RSB_{dB} \approx 6R$ donc $R=1 \text{bpp} \Rightarrow RSB_{dB} = 6dB$. Pour $R=0.5\text{bpp}$, on aurait $RSB_{dB}=3dB$.
|
||||
|
||||
\item On choisit le quantificateur suivant :
|
||||
\img{0.5}{3}
|
||||
|
||||
\[ \hat{X} = \acc{ \mu + \Delta & \si X \geq \mu }{ \mu - \Delta & \sinon} \]
|
||||
|
||||
\begin{align*}
|
||||
D & = \int_{-\infty}^{+\infty} ( X-\hat{X})^2 f_X(x) dx \\
|
||||
& = 2 \int_{\mu}^{+\infty} (X-\mu-\Delta)^2 f_X(x) dx
|
||||
\intertext{Changement de variables $z=x-\mu$}
|
||||
D & = 2\int_0^{+\infty} (z-\Delta)^2 f_Z(z) dz \quad \avec f_Z(z) = \frac{1}{\sqrt{2\pi\sigma_X^2}}\exp(-\frac{z)^2}{2\sigma_X^2}) \\
|
||||
D & = 2\int_0^{\infty} z^2 f_Z(z) dz + 2\Delta^2 \int_0^{\infty} f_Z(z)dz - 4 \Delta\int_0^{\infty} zf_Z(z)dz \\
|
||||
& = \sigma_X^2 + \Delta^2 - 4 \Delta\int_0^{\infty} zf_Z(z)dz
|
||||
\intertext{Or,}
|
||||
\int_0^{\infty} zf_Z(z)dz & = \int_0^{+\infty} \frac{1}{\sqrt{2\pi\sigma_X^2}}\exp(-\frac{z)^2}{2\sigma_X^2}) dz \\
|
||||
& = \frac{1}{2} \int_0^{\infty} \frac{1}{\sqrt{2\pi\sigma_X^2}}\exp(\frac{-y}{2\sigma_X^2}) dy \quad \avec y=z^2\\
|
||||
& = \frac{1}{2} \frac{2\sigma_X^2}{\sqrt{2\pi\sigma_X^2}} = \frac{1}{2} \sqrt{\frac{2\sigma_X^2}{\pi}}
|
||||
\intertext{Donc}
|
||||
D(\Delta) = \Delta^2 - 2\sqrt{\frac{2\sigma_X^2}{\pi}} \Delta + \sigma_X^2
|
||||
\end{align*}
|
||||
|
||||
Ainsi,
|
||||
\begin{align*}
|
||||
\drond{D}{\Delta} = 0 & \Rightarrow \Delta^* = \sqrt{\frac{2\sigma_X^2}{\pi}} \approx 1.4 \\
|
||||
& \Rightarrow D^* = \frac{2\sigma_X^2}{\pi} - 2\frac{2\sigma_X^2}{\pi} + \sigma_X^2 = \sigma_X^2(1-\frac{2}{\pi})\\
|
||||
& \Rightarrow RSB^* = \frac{\sigma_X^2}{D^*} = \frac{1}{1-\frac{2}{\pi}} \approx 2.75
|
||||
& \Rightarrow RSB_{dB}^* = 10\log_{10}2.75 \approx 4.396 \text{dB} < 6 \text{dB}
|
||||
\end{align*}
|
||||
|
||||
\item Pour avoir $R=0.5$ bpp on doit utiliser un quantificateur vectoriel.
|
||||
\end{enumerate}
|
||||
|
||||
\subsection{Codage avec perte - DPCM}
|
||||
|
||||
\newcommand{\Aa}{\underline{\underline{A}}}
|
||||
\newcommand{\A}{\underline{A}}
|
||||
|
||||
\begin{enumerate}\setlength{\itemsep}{5mm}\setcounter{enumi}{7}
|
||||
\item \begin{align*}
|
||||
\Aa & = [ \A_1 \A_2 \A_3 \A_4 ] \\
|
||||
\A_l & = [\A_1^T \A_2^T \A_3^T \A_4^T] \\
|
||||
& = [6,4,6,8,6,8,10,8,8,10,10,8,10,8,10]
|
||||
\end{align*}
|
||||
|
||||
\item Soit $E(y) = 0, \y=[y_1,\dots y_N]$
|
||||
|
||||
$\hat{y_{i+1}} = \alpha y_i, \quad \alpha^* = \frac{\gamma_Y(1)}{\gamma_Y(0)}$
|
||||
|
||||
$\underline{B}_L = \A_l - 8[ 1, 1, \dots 1 ] = [-2, -4, -2, \dots]$
|
||||
|
||||
$\gamma_X(0) = \sigma_X^2 = 3$
|
||||
|
||||
$\gamma_X(1) = \frac{1}{N} \sum_{i=1}^{N-1} B_l(i+1) B_L(i) = 5/4$
|
||||
|
||||
$\alpha \approx 0.4$
|
||||
|
||||
$\y(i) = \alpha B_L(i-1) + 8$
|
||||
|
||||
La variance diminue un peu.
|
||||
\end{enumerate}
|
||||
|
||||
\end{document}
|
||||
|
|
@ -1,156 +0,0 @@
|
|||
\documentclass{article}
|
||||
\input{../../preambule/preambule}
|
||||
|
||||
\newcommand{\nom}{TD7}
|
||||
\renewcommand{\nomentete}{UE455 - \nom}
|
||||
|
||||
|
||||
|
||||
\begin{document}
|
||||
|
||||
\titre{\nom}
|
||||
\section*{Exercice I-TD3: Entropie différentielle d'une source Gaussienne}
|
||||
|
||||
\begin{enumerate}
|
||||
\item
|
||||
\begin{align*}
|
||||
f_X(x) = \frac{1}{\sqrt{2 \pi \sigma^2}} exp(-\frac{(x-\mu)^2}{2\sigma^2}
|
||||
\intertext{Montrons que $h(x) = \frac{1}{2} log_2(2\pi e \sigma^2)$}
|
||||
h(x) = - \int_{-\infty}^{\infty} f_x(x) log_2(f_x(x)) dx\\
|
||||
\end{align*}
|
||||
Tout réside dans le log de exp, la définition de la variance et de la densité de probabilité. Trivial donc.
|
||||
|
||||
\item \begin{align*}
|
||||
\int_{-\infty}^{+\infty} f_Y(x) log_2(\frac{f_X(x)}{f_Y(x)}) dx = h(Y) - \int_{-\infty}^{+\infty} f_Y(x) log_2(f_X(x)) dx
|
||||
=h(Y) - h(X) \leq 0
|
||||
\end{align*}
|
||||
D'où le résultat.
|
||||
\end{enumerate}
|
||||
|
||||
|
||||
\section*{Exercice III-TD3: Schéma de compression binaire avec pertes}
|
||||
|
||||
\begin{align*}
|
||||
\underline{X} = x_1x_2...x_mX_{m+1}x_{2m}\\
|
||||
\underline{Y} = y_1 y_2
|
||||
\end{align*}
|
||||
On suppose que $n_j = \sum_{i=0}^M x_{(j-1)M+i}$. $n_j$ est le nombre de '1' dans $x_{(j-1)M+i} ... x_{jM}$.
|
||||
|
||||
\begin{align*}
|
||||
y_j &= \acc{0 \text{ si, } M-n_j > \frac{M}{2}}{1 \text{sinon, ie } n_j \geq \frac{M}{2}}\\
|
||||
\text{Pour $M = 3$, alors } x_1 &= 001\text{ }000\text{ }100\text{ }110\\
|
||||
\text{On a donc: } y_1 = 0 0 0 1
|
||||
\end{align*}
|
||||
|
||||
|
||||
\begin{enumerate}
|
||||
\item \begin{align*}
|
||||
y_2 = (0100) \Rightarrow \hat{x_2} = 000\text{ }111\text{ }000\text{ }000
|
||||
\end{align*}
|
||||
|
||||
\item On a $P(X=0) = 0.8$. Et $R = \frac{j}{Mj} = \frac{1}{M} $ bits/symbole.\\
|
||||
Pour M=2, y=0 si $n<\frac{M}{2}$ et 0 sinon, d'où:\\
|
||||
\begin{tabular}{|c|c|c|c|c|c|}
|
||||
\hline
|
||||
$\underline{X}$ & p & n & y & $\hat{\underline{x}}$ & d \\
|
||||
\hline
|
||||
\hline
|
||||
00 & $0.8^2$ & 0 & 0 & 00 & 0 \\
|
||||
\hline
|
||||
01 & $0.8\times 0.2$ & 1 & 1 & 11 & 1 \\
|
||||
\hline
|
||||
10 & $0.2 \times 0.8$ & 1 & 1 & 11 & 1 \\
|
||||
\hline
|
||||
11 & $0.2^2$ & 2 & 1 & 11 & 0 \\
|
||||
\hline
|
||||
\end{tabular}
|
||||
|
||||
\begin{align*}
|
||||
d(x,\hat{x}) &= \sum x_i \oplus \hat{x_i}\\
|
||||
D_2 &= \frac{1}{2}(0*0.8^2+1*0.8*0.2+1*0.8*0.2+0)\\
|
||||
\end{align*}
|
||||
Pour $M=1$ on a $D_1 = 0$ et $R_1 = 1$ bits/symbole.\\
|
||||
Et l'autre qui demande à aller beaucoup plus vite...
|
||||
|
||||
|
||||
n=0,...,M
|
||||
$p_n = C_M^n*0.2^n * 0.8^{m-n}$
|
||||
Si $n<\frac{M}{2}$ $\hat{x}$ contient M 0 et x N 1, donc $d_n = n$
|
||||
Si $n\geq \frac{M}{2} $ $\hat{x}$ contient M bits de 1 et X M-n bits de 0 donc $d_n = M-n$
|
||||
|
||||
$D_n = \sum_{n=0}^{\lceil\frac{M}{2}\rceil - 1} C_M^n 0.2^n 0.8^{M-n} + \sum_{n = \lceil\frac{M}{2}}^{M} C_M^n 0.2^n 0.8^{M-N} (M-n) = \frac{1}{M}$
|
||||
|
||||
\item
|
||||
\begin{align*}
|
||||
x \longrightarrow y \longrightarrow Codeur \\
|
||||
1 \longrightarrow \frac{1}{M} \longrightarrow \frac{1}{M} H(Y) = R\\
|
||||
P(Y=0) = \sum_{n=0}^{\lceil\frac{M}{2}\rceil - 1} C_M^n 0.8^{M-n} 0.2^n\\
|
||||
P(Y=1) = 1-P(Y=0)\\
|
||||
H(Y) = -P(Y=0)log_2(P(Y=0)) - P(Y=1) log_2(P(Y=1))
|
||||
\end{align*}
|
||||
\end{enumerate}
|
||||
|
||||
|
||||
\section*{Exercice I-TD4: Codage prédictif d'une image}
|
||||
|
||||
\begin{align*}
|
||||
\underline{\underline{X}} = [\underline{\underline{X}}(:,1),\underline{\underline{X}}(:,2),...,\underline{\underline{X}}(:,256)]\\
|
||||
\underline{X_1} = \begin{pmatrix}
|
||||
\underline{\underline{X}}(:,1)\\
|
||||
\underline{\underline{X}}(:,2)\\
|
||||
\vdots\\
|
||||
\underline{\underline{X}}(:,256)
|
||||
\end{pmatrix}
|
||||
\end{align*}
|
||||
|
||||
\begin{enumerate}
|
||||
\item L'hypothèse gaussienne est fausse, mais permet d'obtenir de bon ordre de grandeurs, $D(R) \leq D_g(R)$\\
|
||||
|
||||
\item On a $D(R) = \sigma_x^2 * 2^{-2R}$ pour une source gaussienne.\\
|
||||
$RSAB_{db} = 10 log_10 \frac{\sigma_x^2}{\sigma_x^2 2^{-2R}} \approx 6R$\\
|
||||
$RSAB_{db} \geq 30 dB \Rightarrow R \geq 5$ bits/pixel.
|
||||
|
||||
\item \begin{align*}
|
||||
\hat{x}(n) = [a_1
|
||||
r = E(x(n)x_p(n) = \begin{pmatrix}
|
||||
\mu_x(1)\\
|
||||
\vdots
|
||||
\mu_x(p)
|
||||
\end{pmatrix}\\
|
||||
R = \begin{pmatrix}
|
||||
\mu_x(0) & &\\
|
||||
\vdots & \mu_x(|i-j|) & \\
|
||||
\mu_x(p) & &
|
||||
\end{pmatrix}
|
||||
\end{align*}
|
||||
|
||||
Des résultats random :\\
|
||||
Par définition : \\
|
||||
$\sigma_e^2 = (e^2(n))= E((x(n)-\hat{x(n)})^2)$
|
||||
Par minimisation de $\sigma_e^2$ donc en dérivant:
|
||||
$a_p = R^{-1} r$ puisque R est inversible.\\
|
||||
\begin{align*}
|
||||
\sigma_e^2 = \mu_x(0) - 2(R^{-1}r)^Tr + (R^{-1}r)^TR(R^{-1}r)\\
|
||||
=\mu_x(0) - r^TR^{-1}r
|
||||
\end{align*}
|
||||
|
||||
\item L'écart entre deux pics est 256. Les ressemblances des pixels d'une même ligne qui sont séparés de 256 pixels dans $\hat{x}$. Les maximums décroissent.
|
||||
|
||||
\item Pour p=1 r vaut $\mu_x(1)$ et $R = \mu_x(0)$, ainsi $a_p = 0.95$.
|
||||
Et $\sigma_e^2 = 255.95$.
|
||||
|
||||
\item $D_e = \sigma_e^2 2^{-2R}$
|
||||
$RSBA_{db} = 10 log_{10} \frac{\sigma_x^2}{D_e} \approx10.4 + 6R = 30.$
|
||||
Donc R = 33 bits/symbole
|
||||
|
||||
\item Gain de codage:
|
||||
$RSAB^{(p)} - RSAB = 10.4 db$
|
||||
|
||||
|
||||
|
||||
\end{enumerate}
|
||||
|
||||
|
||||
|
||||
|
||||
\end{document}
|
||||
Loading…
Reference in a new issue