304 lines
14 KiB
TeX
304 lines
14 KiB
TeX
\documentclass[main.tex]{subfiles}
|
|
|
|
\begin{document}
|
|
\newcommand{\Y}{\mathcal{Y}}
|
|
\newcommand{\X}{\mathcal{X}}
|
|
\section{Introduction}
|
|
L'objectif de la quantification est de représenter les réalisations d'une source à valeurs dans un "grand" alphabet $\X$ , par exemple $\mathbb{R}$, à l'aide d'éléments d'un alphabet plus "petit" $\Y \in\N $.\\
|
|
|
|
Le quantificateur est donc défini par $q: \X \to \Y$. L'opération de quantification inverse, appelée aussi désindexation, est la fonction $q^{-1}: \Y \rightarrow \X$.\\
|
|
|
|
Remarque: l'opération de quantification n'est pas réversible donc $q^{-1}$ n'a pas de réalité, par contre, par abus de langage on note : $Q(x) = q^{-1}(q(x))$.\\
|
|
|
|
\begin{figure}[H]
|
|
\centering
|
|
\begin{tikzpicture}
|
|
\begin{axis}
|
|
[axis lines=middle,
|
|
xtick={-2,-1,1,2},
|
|
ytick={-1.5,0.5,1.5},
|
|
xlabel =$x$,ylabel=$Q(x)$,
|
|
ymin=-2,ymax=2
|
|
]
|
|
\addplot+[no marks,color=black] plot coordinates {(-2,-1.5) (-1,-1.5) (-1,-0.5) (0,-0.5) (0,0.5) (1,0.5) (1,1.5)(2,1.5)};
|
|
\end{axis}
|
|
\end{tikzpicture}
|
|
\caption{Exemple de quantificateur}
|
|
\end{figure}
|
|
Un quantificateur est défini par des intervalles de quantification $b_0 < b_1 < ... < b_n$ et par des valeurs de reconstitution $y_1,...,y_n$ : si on a $x \in[b_{i-1} ; b_i[$ alors $Q(x) = y_i$.\\
|
|
|
|
Dans la suite, on va voir comment régler de façon efficace les $b_i$ et les $y_i$.
|
|
|
|
\newpage
|
|
\section{Mesure de distorsion et distorsion}
|
|
|
|
On introduit une mesure de distorsion pour les performances d'un quantificateur. Les principales mesures considérées sont:
|
|
\begin{itemize}
|
|
\item la mesure de distorsion en valeur absolue, $d(x,y) = |x-y|$
|
|
\item la mesure de distorsion quadratique, $d(x,y) = (x-y)^2$
|
|
\end{itemize}
|
|
\bigbreak
|
|
|
|
Pour une source $X$ décrite par une distribution de probabilité $f_X(x)$, la distorsion introduite par un quantificateur $Q(x)$, est la moyenne de la mesure de la distorsion:
|
|
\[D = \int_{-\infty}^{\infty} d(x,Q(x))f_X(x) dx \]
|
|
Pour la mesure de distorsion quadratique, on a:
|
|
\[D = \int_{-\infty}^{\infty} (x-Q(x))^2f_X(x) dx \]
|
|
|
|
\section{Quantification uniforme d'une source uniforme}
|
|
|
|
On considère une source $X$ uniformément distribuée sur $[-X_{max} ; X_{max}]$. On considère aussi un quantificateur uniforme, c'est à dire que les intervalles de quantification sont tous de même taille, à M niveaux de sortie, situés au milieux des intervalles de quantification.
|
|
Prenons par exemple, un quantificateur à 4 niveaux de quantification:
|
|
%\img{0.5}{2/1/2.png}
|
|
|
|
On note $\Delta$ l'intervalle de quantification, dans ce cas, $\Delta = \frac{2 X_{max}}{M}$.\\
|
|
|
|
Pour déterminer la distorsion qui va être introduite par le quantificateur, on calcule simplement:
|
|
\begin{align*}
|
|
D &= \int_{-X_{max}}^{X_{max}}\frac{1}{2X_{max}}(x-Q(x))^2 dx
|
|
\intertext{Comme $Q(x)$ est connu et constant sur un intervalle de quantification, on découpe simplement l'intervalle en sous-intervalles de quantification:}
|
|
D &= \sum_{i=-M/2}^{(M-1)/2} \int_{i\Delta}^{(i+1)\Delta} \frac{1}{2X_{max}}(x-(i+\frac{1}{2})\Delta)^2 dx
|
|
\intertext{On calcule}
|
|
I & = \int_{i\Delta}^{(i+1)\Delta} (x-(i+\frac{1}{2})\Delta)^2 \frac{1}{2X_{max}} dx \\
|
|
& = \int_{-\Delta/2}^{\Delta/2} \frac{u^2}{2X_{max}} du \\
|
|
I & = \frac{\Delta^3}{24X_{max}} = \frac{X_{max}^2}{3M^3}
|
|
\end{align*}
|
|
Dans $D$, on a $M$ intégrales égales à $I$ donc \[ D = \frac{X_{max}^2}{3M^2}\]
|
|
|
|
L'énergie de la source est mesurée par sa variance
|
|
\begin{align*}
|
|
\sigma^2 & = \int_{-\infty}^{+\infty} x^2 f(x) dx \\
|
|
& = \int_{-X_{max}}^{X_{max}} \frac{x^2}{2X_{max}} dx \\
|
|
\sigma^2 & = \frac{X_{max}^2}{3}
|
|
\end{align*}
|
|
|
|
On obtient donc $D = \frac{\sigma^2}{M^2}$. Sans codage entropique, le nombre de bits nécessaires pour représenter un niveau de reconstruction est $R = \lceil \log_2 M \rceil $, d'où
|
|
\[ \boxed{ D = \sigma^2 2^{-2R} } \]
|
|
|
|
La distorsion maximale est égale à l'énergie de la source, et diminue très rapidement quand on augmente le nombre de bits du quantificateur.
|
|
|
|
\begin{rem}
|
|
Dans certains cas (source non uniforme), un codage entropique peut permettre de réduire le débit.
|
|
\end{rem}
|
|
|
|
Rapport signal à bruit :
|
|
\begin{align*}
|
|
RSB & = \frac{\sigma^2}{D} = 2^{2R} \\
|
|
RSB_{dB} & = 10\log_{10}(2^{2R}) = 6.02R \text{decibel}
|
|
\end{align*}
|
|
|
|
Le $RSB$ est utilisé comme mesure de qualité en audio, image...
|
|
|
|
\newpage
|
|
\section{Quantification uniforme d'une source quelconque}
|
|
|
|
On considère une source $X$ décrite par sa ddp $f_X(x)$, quantifiée par un quantificateur uniforme à $M$ niveaux de pas $\Delta$.
|
|
|
|
%\img{0.5}{2/1/3}
|
|
|
|
Pour une source quelconque, il faut régler $\Delta$ de manière à équilibrer distorsion de granularité et distorsion de surcharge.
|
|
|
|
\newpage
|
|
\section{Quantification non-uniforme d'une source quelconque - Algorithme de Lloyd-Max}
|
|
|
|
On considère une source $X$ discrète décrite par une ddp $f_X(x)$. On cherche le quantificateur non-uniforme à $M$ niveaux de sortie qui minimise la distorsion de quantification pour une norme de distorsion quadratique.\\
|
|
|
|
Un tel quantificateur est caractérisé par
|
|
\begin{itemize}
|
|
\item $b_0 < b_1 < \dots < b_n$ les bornes des intervalles de quantification
|
|
\item $y_1 < y_2 < \dots < y_n$ les valeurs de reconstruction
|
|
\end{itemize}
|
|
|
|
Ainsi, si $x \in [b_{i-1},b_i], Q(x) = y_i$.\\
|
|
|
|
On cherche à minimiser la distorsion
|
|
\[ D = \int_{-\infty}^{+\infty} (x-Q(x))^2f_X(x)dx = \sum_{i=1}^M \int_{b_{i-1}}^{b_i} (x-y_i)^2f_X(x)dx \]
|
|
|
|
Les conditions nécessaires pour avoir $D$ minimale sont :
|
|
\begin{itemize}
|
|
\item $\derivp[D]{y_i} = 0, \forall i=1\dots M$
|
|
\item $\derivp[D]{b_i} = 0, \forall i = 0\dots M$
|
|
\end{itemize}
|
|
|
|
\begin{align*}
|
|
\intertext{1ère condition d'optimalité}
|
|
\derivp[D]{y_i} & = \derivp{}{y_i} \int_{b_{i-1}}^{b_i} (x-y_i)^2 f_X(x) dx \\
|
|
& = - 2 \int_{b_{i-1}}^{b_i} (x-y_i) f_X(x) dx
|
|
\intertext{Ainsi,}
|
|
\derivp[D]{y_i} = 0 & \Leftrightarrow \int_{b_{i-1}}^{b_i} xf_X(x)dx = y_i \int_{b_{i-1}}^{b_i} f_X(x)dx \\
|
|
& \Rightarrow y_i = \frac{\int_{b_{i-1}}^{b_i} xf_X(x)dx}{\int_{b_{i-1}}^{b_i} f_X(x)dx}, \quad i = 1 \dots M
|
|
\intertext{2ème condition d'optimalité}
|
|
\derivp[D]{b_i} & = \derivp{}{b_i} \int_{b_i}^{b_{i+1}} (x-y_{i+1})^2f_X(x)dx + \derivp{}{b_i}\int_{b_{i-1}}^{b_i} (x-y_i)^2 f_X(x)dx \\
|
|
& = -(b_i-y_{i+1})^2 f_X(b_i) + (b_i-y_i)^2 f_X(b_i)
|
|
\intertext{Ainsi, }
|
|
\derivp[D]{b_i} = 0 & \Leftrightarrow -(b_i-y_{i+1})^2 + (b_i-y_i)^2 = 0 \\
|
|
& \Leftrightarrow (y_{i+1}-y_i)(b_i-y_{i+1}+b_i-y_i) = 0 \\
|
|
& \Leftrightarrow b_i = \frac{y_i+y_{i+1}}{2}, \quad i=1 \dots M-1
|
|
\end{align*}
|
|
|
|
\newpage
|
|
\subsection*{Algorithme de Lloyd -Max}
|
|
\begin{enumerate}
|
|
\item Initialisation : $b_0^{(0)} < b_1^{(0)} < \dots < b_n^{(0)}$ choisis arbitrairement, $k=1$.
|
|
\item $y_i^{(k)}$ obtenus à partir des $b_i^{(k-1)}, i=0 \dots M$ en utilisant la 1ère condition d'optimalité
|
|
\item $b_i^{(k)}$ obtenus à partir des $y_i^{(k)},i=1 \dots M$ en utilisant la 2ème condition d'optimalité
|
|
\item $k=k+1$
|
|
\item tant qu'il y a des variations des $y_i$ ou des $b_i$, aller en 2.
|
|
\end{enumerate}
|
|
|
|
\begin{rem}
|
|
Essayer d'implémenter l'algorithme de Lloyd-Max à l'aide de Matlab, C ou Python pour les fétichistes. Pour Matlab, utiliser la fonction \texttt{quad} afin de calculer les intégrales. Prendre une ddp gaussienne.
|
|
|
|
Essayer de retrouver ceci pour $M=4$ et $\sigma = 1$
|
|
\begin{center}
|
|
\begin{tabular}{ccc}
|
|
$i$ & $b_i$ & $y_i$ \\ \hline
|
|
1 & -0.98 & -1.51 \\
|
|
2 & 0 & -0.45 \\
|
|
3 & 0.98 & 0.45 \\
|
|
4 & $+\infty$ & 1.51 \\
|
|
\end{tabular}
|
|
\end{center}
|
|
|
|
Prendre l'infini égal à 10.
|
|
\end{rem}
|
|
|
|
\begin{rem}
|
|
On ne quantifie jamais sur le domaine des pixels, car les ddp y sont immondes. On effectue des transformées, et ensuite les ddp sont sympa (gaussiennes, laplaciennes), ce qui permet d'avoir des algorithmes efficaces.
|
|
|
|
La plupart du temps, les quantifications sont uniformes (JPEG, JPEG200, H264...). On n'utilise des quantifications non uniformes que dans le cas d'applications très précises, où le gain de 2 ou 3 dB sur le $RSB$ est vraiment nécessaire.
|
|
\end{rem}
|
|
|
|
\newpage
|
|
\section{Comportement asymptotique}
|
|
Pour étudier le comportement asymptotique d'un quantificateur, on suppose $M$ grand (les intervalles de quantification seront petits), $f_X(x) \approx f_X(y_i)$ sur $[b_{i-1},b_i]$. On note $\Delta_i = b_i - b_{i-1}$.\\
|
|
|
|
On a \[P_i = Pr(X\in[b_{i-1},b_i]) \approx f_X(y_i)\Delta_i\]
|
|
|
|
\begin{align*}
|
|
D & = \sum_{i=1}^M \int_{b_{i-1}}^{b_i} (x-y_i)^2 f_X(x) dx \\
|
|
D & = \sum_{i=1}^M f_X(y_i) \int_{b_{i-1}}^{b_i} (x-y_i)^2dx
|
|
\intertext{On suppose que $y_i$ est au milieu de l'intervalle $[b_{i-1},b_i]$}
|
|
\int_{b_{i-1}}^{b_i} (x-y_i)^2 dx & = \int_{-\Delta_i/2}^{\Delta_i/2} u^2 du = [\frac{u^3}{3}]_{-\Delta_i/2}^{\Delta_i/2} = \frac{2}{3} \frac{\Delta_i^2}{8} = \frac{\Delta_i^3}{12}
|
|
\intertext{En réinjectant dans $D$, on a}
|
|
D & = \sum_{i=1}^M f_X(y_i) \frac{\Delta_i^3}{12}
|
|
\intertext{On pose $\alpha_i^3 = f_X(y_i)\Delta_i^3$}
|
|
D & = \frac{1}{12} \sum_{i=1}^M \alpha_i^3
|
|
\intertext{Si on calcule}
|
|
\sum_{i=1}^M \alpha_i & = \sum_{i=1}^M (f_X(y_i))^{1/3} \Delta_i \approx \int_{-\infty}^{+\infty} (f_X(x))^{1/3} dx = cste
|
|
\intertext{On doit trouver les $\Delta_i$ et les $\alpha_i$ qui minimisent $D$ sous la contrainte $\sum_{i=1}^M \alpha_i = C$. On introduit donc le Lagrangien du problème :}
|
|
L(\alpha_1,\dots\alpha_M,\lambda) & = \frac{1}{12}\sum_{i=1}^M\alpha_i^3 + \lambda (\sum_{i=1}^M \alpha_i - C)
|
|
\intertext{Condition d'optimalité :}
|
|
\derivp[L]{\alpha_i} = 0 & \Rightarrow \frac{1}{4}\alpha_i^2 + \lambda = 0, \quad i = 1 \dots M \\
|
|
& \Rightarrow \alpha_i^2 = -4\lambda
|
|
\intertext{Les $\alpha_i$ sont donc tous égaux, d'où}
|
|
\alpha_i & = \frac{1}{M} \int_{-\infty}^{+\infty} (f_X(x))^{1/3} dx
|
|
\end{align*}
|
|
\newpage
|
|
On avait $\alpha_i^3 = f_X(y_i) \Delta_i^3$. Ainsi, si $f_X(y_i)$ est grand, $\Delta_i$ est petit, et inversement.
|
|
|
|
%\img{0.5}{2/2/1}
|
|
|
|
On peut donc calculer la distorsion :
|
|
\begin{align*}
|
|
D & = \frac{1}{12} \sum_{i=1}^M \frac{1}{M^3}(\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3 \\
|
|
& = \frac{1}{12} (\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3.\frac{1}{M^2}
|
|
\intertext{Or, $M=2^R$ d'où}
|
|
D & = \frac{1}{12}(\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3.2^{-2R}
|
|
\end{align*}
|
|
|
|
\begin{rem}
|
|
Comme pour la quantification uniforme, on a une décroissance en $2^{-2R}$ de la distorsion en fonction du débit. Ici, il y a un facteur multiplicatif qui dépend de la ddp de la source.
|
|
|
|
Pour une source quelconque, le comportement débit / distorsion sera :
|
|
\[ \boxed{ D(R) = \epsilon_X \sigma_X^2 2^{-2R} \text{ avec } \epsilon_X = \frac{1}{12\sigma_X^2}(\int_{-\infty}^{+\infty} (f_X(x))^{1/3}dx)^3 } \]
|
|
\end{rem}
|
|
|
|
\section{Quantification vectorielle - Algorithme de Linde-Buzo-Gray}
|
|
|
|
Avec une quantification vectorielle on considère des vecteurs de $N$ échantillons de la source que l'on va représenter à l'aide d'un index de quantification.
|
|
|
|
%\img{0.5}{2/2/2}
|
|
|
|
Pour un couple (poids, taille), on peut :
|
|
\begin{itemize}
|
|
\item quantifier indépendamment le poids et la taille avec deux quantificateurs scalaires
|
|
\item les quantifier simultanément avec une quantification vectorielle
|
|
\end{itemize}
|
|
|
|
\subsection*{Algorithme de Linde-Buzo-Gray}
|
|
|
|
\newcommand{\x}{\underline{x}}
|
|
Cet algorithme permet de fabriquer une quantification vectorielle optimale (optimum local) pour un ensemble de $K$ points de $\R^N$ : $\x_1 \dots \x_K$ et quantifiés sur $M$ niveaux.
|
|
|
|
\newcommand{\y}{\underline{y}}
|
|
Pour cela, on introduit la mesure de distorsion $d(\x,\y) = \frac{1}{N}||\x-\y||^2$.
|
|
|
|
Le quantificateur va minimiser la distorsion.\\
|
|
|
|
Initialisation :
|
|
\begin{itemize}
|
|
\item On sélectionne $M$ points $\y_1^{(0)},\dots,y_M^{(0)}$ parmi les $\x_1,\dots,\x_K$ au hasard.
|
|
\item $l=0, D_l = + \infty$
|
|
\end{itemize}
|
|
|
|
\begin{enumerate}
|
|
\item On réalise une quantification de $\x_1,\dots,\x_K$ en se servant de $\y_1^{(l)},\dots,\y_M^{(l)}$.
|
|
\[ q(\x_i) = \y_j \text{ ssi } ||\x_i-\y_j^{(l)}||^2 \leq ||\x_i-\y_k^{(l)}||^2, \quad \forall k\neq j\]
|
|
|
|
\newcommand{\Cc}{\mathcal{C}}
|
|
|
|
On obtient une partition de l'espace en cellules de quantification $\Cc_j^{(l)},j=1,\dots,M$ appelées cellules de Voronoï.
|
|
|
|
%\img{0.5}{2/3/1}
|
|
|
|
\item On calcule la distorsion :
|
|
\[ D^{(l+1)} = \frac{1}{K} \sum_{i=1}^K ||\x_i-q(\x_i)||^2 \]
|
|
|
|
\item Actualisation des valeurs de reconstruction. On considère l'ensemble des points appartenant à \[\Cc_j^{(l)} = \{ \x_1^{(l)},\dots, \x_{K_l}^{(l)} \}, \quad j = 1,\dots,M\]
|
|
|
|
On calcule le barycentre des points de $\Cc_j^{(l)}$ qui constitue la nouvelle valeur de reconstruction.
|
|
|
|
\[\y_j^{(l+1)} = \frac{1}{K_l} \sum_{i=1}^{K_l} \x_i^{(l)} \]
|
|
|
|
\item $l=l+1$
|
|
|
|
\item Aller en 1 tant que $D^{l-1} - D^l > \epsilon$
|
|
|
|
\end{enumerate}
|
|
|
|
L'algorithme LBG converge vers une minimum local de la distorsion.
|
|
|
|
\newcommand{\Cc}{\mathcal{C}}
|
|
En pratique :
|
|
\begin{itemize}
|
|
\item on transmet pour chaque $\x_i$ l'index $j$ de la cellule de Voronoi $\Cc_j$ auquel il appartient.
|
|
\item il faut transmettre au récepteur l'ensemble des points de reconstruction $\y_1^{(\overline{l})},\dots,\y_M^{(\overline{l})}$ où $\overline{l}$ est l'index final des itérations.
|
|
\item la phase de réglage du quantificateur peut se faire sur seulement $L<<K$ points si on a beaucoup de points.
|
|
\end{itemize}
|
|
|
|
\newpage
|
|
\section{Quantification scalable}
|
|
|
|
L'objectif est de permettre une flexibilité en terme de compression débit-distorsion. Une possibilité est d'avoir recours à un quantificateur scalable.\\
|
|
|
|
On considère une source uniforme sur $[-X_{max};X_{max}]$ quantifiée sur 8 niveaux.
|
|
|
|
%\img{0.5}{2/3/2}
|
|
|
|
Si on a $K$ échantillons à quantifier, on obtient $3K$ bits.\\
|
|
|
|
Les $K$ bits de poids fort sont placés dans un premier paquet.
|
|
|
|
Les $K$ bits de poids intermédiaire sont placés dans un second paquet.
|
|
|
|
Les $K$ bits de poids faible sont placés dans un troisième paquet.\\
|
|
|
|
Des utilisateurs disposant d'un mauvais canal recevront le premier paquet : la distorsion sera élevée.
|
|
|
|
Des utilisateurs disposant d'un excellent canal recevront les 3 paquets et auront une distorsion faible.\\
|
|
|
|
\begin{rem}
|
|
Cette méthode permet de réaliser une quantification sans avoir à connaître l'état du canal.
|
|
\end{rem}
|
|
|
|
\end{document}
|