codage_convolutif

Codage de canal et turbo-codes

13/10/2000

1/12

Les codes convolutifs Table des matières Table des matières .................................................................... .................................................................................. 1 Table des figures ..................................................................................... .................................................................... 1 1. Introduction Introduc tion .................................................................................... .................................................................... 1 2. Structure Structur e des codes convolutifs......................... convolutif s......................... .......................................................................................... ....... 2 2.1. Code convolutif de rendement 1/n ................................................................... .......................................... 2 2.2. Code convolutif de rendement k/n ................................................................... .......................................... 3 2.3. Représentation Représen tation polynômiale .......................................................... ............................................................. 3 2.4. Codes convolutif s récursifs récursif s systématiques systématiq ues ........................................................................... ..................... 4 3. Représentations Représent ations graphiques graphiqu es des codes convolutifs..... convolutif s............................................................................................ ....................................................................................... 5 4. Transformations Transfo rmations des codes convolutifs................................... convolutif s................................... ........................................................................... 7 4.1. Perforation Perfora tion .............................................................................. .................................................................... 7 4.2. Fermeture du treillis : transformation transfor mation en code en bloc.................................................. bloc .................................................. ............................ 8 5. Algorithmes de décodage ...................................................................... ............................................................. 8 5.1. L’algorithme L’algorit hme de Viterbi........................................................................................... Viterbi.... ....................................................................................... ................................... 8 5.1.1. Description de l’algorithme de Viterbi : ................................................................ ............................ 9 5.1.2. Exemple de décodage à décision dures .......................................................... ................................... 9 5.2. L’algorithme L’algorit hme de Viterbi à sortie souple (SOVA) .................................................................................... 10

Table des figures Figure 1 : Code convolutif de rendement r=1/n.................................................................................... r=1/n. ................................................................................... ..................... 2 Figure 2 : Code convolutif de rendement 2/3 et de longueur de contrainte L=2 ............ ................... ............. ............. ............. ............. .............. ......... .. 3 Figure 3 : Code convolutif NRNSC (7,5) ............................................................................................ ...................... 4 Figure 4 : Code convolutif RSC (1,5/7) ............................................................................. ........................................ 5 Figure 5 : Arbre du code convolutif NRNSC (7,5).................................................................................................... (7,5)..... ............................................................................................... 6 Figure 6 : Treillis du code convolutif NRNSC (7,5) ............................................................................ ..................... 7 Figure 7 : Etat de la fenêtre à l’instant 1 ............................................................................ ...................................... 10 Figure 8 : Etat de la fenêtre à l’instant 2 ............................................................................ ...................................... 10 Figure 9 : Etat de la fenêtre à l’instant 3 ............................................................................ ...................................... 10 Figure 10 : Etat de la fenêtre à l’instant 9 .......................................................................... ...................................... 10 Figure 11 : Etat de la fenêtre à l’instant 10 ........................................................................ ...................................... 10 Figure 12 : Exemple d’un treillis décodé par le SOVA.................................................... ....................................... 12

1. Introduction Nous avons présenté, dans les cours précédents, l’amélioration des performances d’une communication numérique sur des canaux sans mémoire (canal binaire symétrique ou additif blanc gaussien) grâce à l’enploi du codage par bloc. Les codes convolutifs, introduits en 1955 par Elias, peuvent être considérés comme un cas particulier des codes en bloc linéaires, mais un point de vue plus large nous fera découvrir que la structure convolutive additionnelle munit le code linéaire de propriétés favorables qui facilitent à la fois son codage et amélioent ses performances. Les codes convolutifs forment une classe extrêmement souple et efficace de codes correcteurs d’erreurs. Ce sont les codes les plus utilisés dans les systèmes de télécommunications fixes et mobiles. Théoriquement, ils ont les mêmes caractéristiques que les codes en blocs sauf pour la valeur de leur dimension et leur longueur. Les codes convolutifs s’appliquent sur des séquences infinies de symboles d’information et génèrent des séquences infinies de symboles codés. Dans un premier temps, nous présenterons les codes convolutifs comme un cas particulier des codes en bloc linéaires, avant d’exploiter dans un deuxième temps leur structure spécifique pour aboutir à un procédé de décodage à maximum de vraisemblance de faible complexité.

Cours 5 : Les codes convolutifs

O. Pothier


13/10/2000

2/12

2. Structure des codes convolutifs 2.1. Code convolutif de rendement 1/ n Considérons le code en bloc linéaire binaire spécifié par la matrice génératrice suivante :

 g0    G=    

g1

g2



g L−1

g0

g1

g2



g L −1

g0

g1

g2



g L−1



  g0

g1

g2

 

        g L−1 

(1)

Chaque élément g l 0≤l ≤ L-1, de la matrice est un vecteur ligne binaire à n composantes de la forme : g l = g l 1 , g l 2 , g l n

Les zones laissées vides en bas à gauche et en haut à droite correspondent à des éléments tous nuls. Chaque ligne s’obtient en décalant la précédente de n colonnes vers la droite. Cette matrice, de taille B×(nB+L-1) décrit donc un code linéaire en bloc dont les mots de code pourraient être engendrés par le dispositif de la Figure 1. Généralement, les mots de codes sont très longs, c’est à dire B>> L et nous pouvons même considérer cette matrice comme infinie. Ce code linéaire ne possède donc plus à proprement parler de dimension ni de longueur. Le rendement ne peut alors être défini comme pour les codes en blocs. Cependant en négligeant la fermeture du code (le vidage des registres), nous remarquons qu’il existe un rapport 1/n entre le nombre de bits d’information et le nombre de bits du mot de code. Le rendement de ce code est donc : r =1/n

g 01

g 11

g 21

g L-1,1

g 02

g 12

g 22

g L-1,2

g 0n

g 1n

g 2n

g L-1,n

Figure 1 : Code convolutif de rendement r=1/n La quantité L est appelée longueur de contrainte du code convolutif. Le terme « convolutif » s’applique à cette classe de codes parce que la suite de bits codés s peut s’exprimer comme le résultat de la convolution de la suite de bits d’information e par les coefficients g . En effet, puisque le code est linéaire, nous avons : s = e . G. En observant la forme particulière de G, les n bits en sortie du codeur à l’instant t , correspondant à une entrée, s’écrivent : s t =

t

∑e

k g u −k u = max (1,t − L +1)

La complexité du codeur est indépendante de la longueur de la séquence de bits d’information émise et ne dépend que de la longueur de contrainte du code. Exercice 1 : Donner le rendement, la longueur de contrainte, construire la matrice et le schéma de codage d’un code convolutif de coefficients : g0=(1,1), g1=(1,0), g2=(1,1).


O. Pothier


13/10/2000

3/12

2.2. Code convolutif de rendement k / n Pour obtenir un rendement égal à un nombre rationnel quelconque inférieur à 1, il nous faut généraliser la forme (1) de la matrice génératrice et le schéma à la Figure 1 du codeur. Nous supposons maintenant que k bits d’information sont introduits en parallèle à un instant donné dans le codeur ou qu’un décalage temporel du vecteur e des bits d’information se fait par bloc de k bits. Cela revient à remplacer la ligne [ g0 g1 … gL-1] de taille 1× L.n par une sous matrice binaire de taille k × L.n. dont les éléments constituant gl sont de taille k ×n. La construction générale par décalage de la matrice reste la même : n  k  g 0   G=    

g1



g L −1

g0

g1



g L−1



 g0

g1



g L−1

        

Exemple 1 : Soit le code convolutif de rendement 2/3 et de longueur de contrainte L=2 défini par les coefficients suivants : 1 1 1 1 0 1  g0 =  g1 =    0 1 0 1 1 0 Son codeur possède la structure suivante :

Figure 2 : Code convolutif de rendement 2/3 et de longueur de contrainte L=2 La sortie d’un codeur convolutif à l’instant t dépend de ses entrées à l’instant t et de l’état des registres du codeur à cet instant. En posant ν= L-1, tout code convolutif de rendement k /n et de longueur de contrainte L possède k ν registres, qui peuvent donc prendre 2 k ν états différents. Comme l’entrée est constituée de k bits différents, il existe 2 k transitions possible à partir d’un état du codeur à un instant donné.

2.3. Représentation polynômiale Soit un code convolutif de rendement k /n et de longueur de contrainte L. Son entrée peut être vue comme la donnée de k séquences infinies de bits, que nous représentons par des séries en x : ei ( x ) =

+∞

∑= e x , 

i

i = 1,, k

 0

où l’inconue x symbolise un retard d’une période. Le coefficient ei est le bit présent à la i-ème entrée du codeur à l’instant  . De la même manière, les n sorties du codeur peuvent être indexées par j et s’écrivent : s j ( x ) =

+∞

∑= s x , 

j

j = 1,, n

 0

La relation introduite par le code convolutif entre les entrées et les sorties peut s’écrire de façon élégante avec ses notations, en introduisant les polynômes générateurs. Le polynôme générateur qui lie la i-ème entrée à la jième sortie est noté g ij ( x ) , et est de degré inférieur ou égal à L-1. Le coefficient de degré r de ce polynôme vaut 1 si une connexion existe entre la sortie j et le bit présent dans le r -ième registre correspondant à l’entrée i. La notation octale est couramment utilisée pour représenter ces polynômes. Ainsi, g ( x ) = 1 + x + x 3 sera représenté par le nombre 15.


O. Pothier


13/10/2000

4/12

Les sorties se calculent en fonction des entrées à l’aide des polynômes générateurs : s j ( x ) =

k

∑= g ( x )e ( x ), ij

i

j

= 1,, n

i 1

puisque la convolution temporelle correspond à la multiplication polynômiale. Exercice 2 : Expliciter et donner la représentation octale des polynômes générateurs des codes introduits à l’exercice 1 et l’exemple 1. Une représentation matricielle compacte de la formule précédente se déduit de l’écriture sous forme vectorielle des entrées et sorties : E = [e1 ( x ) e2 ( x )  ek ( x )] S = [ s1 ( x ) s 2 ( x )  s n ( x )] S = GE

où

 g 11 ( x )  g ( x ) 21 G=    ( )  g k 1 x

g 12 ( x )  g 1n ( x )

g 22 ( x )  g 2 n ( x )

   g k 2 ( x )  g kn ( x ) 



2.4. Codes convolutifs récursifs systématiques Un code convolutif est dit récursif lorsque ses polynômes générateurs sont remplacés par les quotients de deux polynômes. Une partie de la sortie est alors réintroduite dans le registre à décalage selon les connexions définies par les polynômes situés aux dénominateurs. Un code convolutif est dit systématique lorsque une partie de ses sorties est exactement égale à ses entrées. Cela revient à dire que ( g 11(x)=1, g 21(x)=0, … , g k1(x)=0), ( g 12(x)=0, g 22(x)=1, … , g k2(x)=0), …, et ( g 1k (x)=0, g 2k (x)=0,… , g kk (x)=1). Un cas particulièrement intéressant est celui de la transformation d’un code convolutif non récursif non systématique (NRNSC) de rendement k /(k +1) en un code récursif systématique (RSC). Prenons l’exemple d’un code NRNSC de rendement ½. Il est défini par la donnée de ses deux polynômes générateurs g 11(x)= g 1(x) et g 12(x)= g 2(x), qui forment la matrice : G = [ g 1 ( x ) g 2 ( x ) ] La transformation en code RSC correspond à considérer le code défini par la matrice génératrice suivante : G

 = 1 

g 2 ( x )  g 1 ( x )

 

Exemple 2 : Soit le code convolutif NRNSC de rendement ½, de longueur de contrainte L=3 et de polunômes générateurs (7,5). Ses polynômes s’écrivent : g 1(x)=1+x+x2 et g 2(x)=1+x2. Son codeur possède la structure suivante :

Figure 3 : Code convolutif NRNSC (7,5) Ses deux sorties s1(x) et s2(x) s’expriment en fonction de l’entrée e(x) de la manière suivante :


O. Pothier


13/10/2000

5/12

s1(x)=(1+x+x2)e(x) et s1(x)=(1+x2)e(x) Sa transformation en code RSC correspond aux relations suivantes : s1(x)=e(x) et s 2 ( x ) =

1 + x 2 1 + x + x 2

e( x )

La deuxième relation s’écrit encore :

(1 + x + x s) ( x ) = (1 + x )e( x ) 2

2

2

soit, en repassant en notation temporelle, à l’instant k : s 2

k

= e k + e k −2 + s 2 k −1 + s2 k − 2

La structure du code RSC est la suivante :

Figure 4 : Code convolutif RSC (1,5/7) Exercice 3 : Prouver, en dérivant les équations des sorties en fonction de l’entrée à partir du schéma ci-dessus, qu’il s’agit bien du code (1,5/7). Donner une autre r eprésentation correspondant à un filtrage ARMA. Exercice 4 : Donner les conditions sur les polynômes générateurs pour qu’un code NRNSC de rendement k /n puisse être transformé en un code RSC.

3. Représentations graphiques des codes convolutifs L’idée d’une représentation graphique d’un code convolutif provient des caractéristiques markoviennes de la sortie du codeur. En effet, la sortie du codeur dépend de son entrée et de ses états. Les graphes équivalents à la représentation polynômiale sont souvent plus faciles à manipuler et permettent de dériver des résultats plus puissants. Tout code convolutif est représenté par trois graphes équivalents mais différents : l’arbre du code, le treillis du code et le diagramme d’états.

•

• •

L’arbre est un graphe de hauteur et de largeur infinies. Un sommet dans l’arbre représente un état possible du codeur. Une arrête symbolise une transition d’un état à l’autre. Classiquement l’arbre commence à son sommet par l’état 0 (le registre à décalage est initialisé à 0). Tout chemin dans l’arbre du code est une séquence possible (un mot de code) à la sortie du codeur convolutif. Le treillis est obtenu en repliant l’arbre sur sa largeur, par fusion des sommets représentant le même état au même instant. Le diagramme d’états est à son tour construit en repliant le treillis sur sa longueur, par fusion des sommets représentant aussi le même état, à des instant différents.

Incontestablement, le treillis est l’outil graphique le plus performant pour caractériser un code et concevoir des algorithmes de décodage. Nous illustrons ci-dessous l’arbre, le treillis et le diagramme des deux codes, l’un NRNSC (7,5) et l’autre RSC (1,5/7) à 4 états. Cas du code NRNSC R=1/2, g 1=7 g2=5 : notons : • a=00 • b=01 • c=10 • d=11 les 4 états possibles du codeur convolutif. Les deux bits constituant l’indice de l’état ne sont autres que les deux bits contenus dans le registre à décalage de la Figure 3.


O. Pothier


•

• • •

13/10/2000

6/12

Supposons que le codeur est dans l’état a à l’instant t=0. Deux transitions, correspondant aux valeurs possibles du bit à l’entrée du codeur partent de l’état a : • la première a → a correspond à une entrée e=0 et une sortie s=00. • la seconde a → c correspond à une entrée e=1 et une sortie s=11. Ces deux transitions restent valables à n’importe quel instant t dans le treillis. Supposons maintenant le codeur dans l’état b. Les deux transitions partant de l’état b sont les suivantes : • b → c correspond à une entrée e=1 et une sortie s=00. • b → a correspond à une entrée e=0 et une sortie s=11. Les deux transitions qui partent de l’état c sont les suivantes : • c → b correspond à une entrée e=0 et une sortie s=10. • c → d correspond à une entrée e=1 et une sortie s=01. Les deux transitions partant de l’état d sont : • d → d correspond à une entrée e=1 et une sortie s=10. • d → b correspond à une entrée e=0 et une sortie s=01.

Ceci permet d’illustrer les faits suivants : • Le code convolutif possède 2k ( L-1)=2k ν=4 états • Il y a 2 k =2 transitions par états • Et donc 2kL=8 transitions possible entre deux instants consécutifs. La Figure 5 représente l’arbre de ce code. a 00 a 11 00 c a

11 10 00 c 01

0

d a

a 1 11 11 00 10 c

c

01 01 d 10 d

Figure 5 : Arbre du code convolutif NRNSC (7,5)


O. Pothier


13/10/2000

7/12

Le treillis est obtenu en repliant l’arbre sur sa hauteur. Il est représenté à la Figure 6. Les deux premiers bits sur chaque transition représentent la sortie, et le dernier l’entrée correspondante. Notons que le treillis devient périodique à partir de la 3 ème étape où l’on retrouve les 8 transitions entre les 4 états. En général, le treillis d’un code convolutif devient stationnaire après L= ν+1 étapes. Etats 00/0

a=00 11/1

00/0

00/0 11/1

00/0 11/1

11/1

11/0

00/1

00/1

10/0

11/1

11/0

11/0

=01

10/0

00/0

00/1

10/0

10/0

c=10

01/1

01/1

01/1

01/1

01/0

01/0

01/0

d=11 10/1

10/1

10/1

Figure 6 : Treillis du code convolutif NRNSC (7,5) Les mots du code (7,5) sont tous les chemins possibles dans le treillis. Il est facile de vérifier que le code est linéaire, i.e. le chemin 00...0 appartient au treillis et la somme binaire modulo 2 des bits codés présents sur les branches de deux chemins correspond aux bits présents sur les branches d’un troisième chemin dans le treillis. D’autre part, le treillis permet de trouver facilement la distance minimale du code. Il s’agit du poids de Hamming minimal entre deux mots de codes, donc deux chemins. En comparant tous les chemins au chemin tout à zéro, dans notre cas, un chemin divergeant à n’importe quel instant du chemin tout à zéro, en suivant a →c→ b→a pour converger à nouveau vers le chemin tout à zéro possède le poids de sortie minimal W Hmin=5. Nous en déduisons que la distance minimale d Hmin (aussi appelée distance libre d free) du code convolutif (7,5) est égale à 5. Ce chemin correspond à un poids en entrée de 1. Exercice 5 : Construire le diagramme d’état du code convolutif NRNSC (7,5). Il s’agit d’un graphe dont les sommets représentent les états, mais où la notion temporelle n’apparaît pas. On l’obtient par fusion dans le treillis de tous les états identiques à des instants différents. Cas du code RSC R=1/2, g 1=1 g2=5/7 : les 4 états a, b, c, d sont notés de manière similaire à ceux du code NRNSC. La structure du treillis est parfaitement identique : deux branches arrivent et partent de chaque état. Le treillis devient périodique à la L=3 ème étape, lorsque toutes les transitions sont présentes. La différence entre le code récursif et non récursif réside dans l’étiquetage binaire des branches. En effet, sachant que le code RSC est er systématique, le 1 bit de sortie est égal à l’entrée. Ainsi les deux bits associés à une branche du treillis représentent toujours les deux bits de sortie et la valeur de l’entrée est contenue dans le 1 er bit Exercice 6 : Construire le treillis du code RSC (1,7/5) dont le codeur est représenté à la Figure 4. Remarquons que la distance minimale de ce code RSC est elle aussi égale à 5 et se déduit du même chemin a→c→ b→a. Une entrée non nulle permet de quitter l’état 0 dans les deux cas récursifs et non récursifs. En revanche, une entrée nulle n’est pas suffisante pour revenir à l’état 0 dans le cas du code RSC. En effet, le retour b→a est généré par e=0 pour le code NRNSC, et par e=1 pour le code RSC. Ainsi, le poids d’entrée du chemin à distance minimale du code RSC est égal à 2.

4. Transformations des codes convolutifs 4.1. Perforation Considérons un code convolutif binaire récursif ou non de rendement R=k /n et de mémoire quelconque. Durant u étapes dans le treillis, le codeur reçoit k ×u bits d’information et délivre n×u bits codés. Parmi ces bits codés, v sont supprimés et n×u-v sont émis sur le canal. Cette opération, appelée perforation du code convolutif, transforme le rendement R=k /n en un rendement R’ =(k ×u)/(n×u-v). Par exemple, un code convolutif de


O. Pothier


13/10/2000

8/12

rendement ½ est facilement converti par perforation en un code de rendement 2/3 (u=2 v=1) ou un rendement ¾ (u=3,v=2). Le choix des bits codés non transmis (on dit perforés) se fait généralement suivant un motif périodique décrit par une matrice binaire, dite de perforation, de taille n×u qui comporte v zéro.

4.2. Fermeture du treillis : transformation en code en bloc Tout code convolutif est convertible en un code en bloc. Il suffit de stopper l’avance dans le treillis après un nombre de branches fixé par la longueur du code en blocs recherché. Une méthode triviale consiste à couper le treillis sans spécifier l’état final (troncature). La bonne méthode transforme le code convolutif en un code en bloc en forçant le retour à l’état 0 par une terminaison du treillis. Inversement, il est possible de construire un treillis représentant tout code en bloc.

5. Algorithmes de décodage Nous décrivons dans ce paragraphe deux algorithmes de décodage applicables aux codes convolutifs. Ils effectuent leurs opérations sur un treillis, qui représente, dans le cas du décodage des codes convolutifs, la structure du code. Ils sont cependant applicables plus généralement à le recherche du chemin dans un treillis qui minimise un critère de distance additive. Ils sont donc aussi applicables au décodage des codes en bloc (par l’intermédiaire de leur représentation en treillis), à celui des modulations codées en treillis, où à la detection au maximum de vraisemblance sur un canal introduisant de l’interférence entre symboles, problème qui correspond à l’estimation des symboles d’un modèle de chaîne de Markov cachée, représentable lui aussi par un treillis. Le premier algorithme décrit ci-dessous est celui de Viterbi (VA). Il s’agit d’un algorithme de décodage à entrée ferme ou souple mais à sortie ferme (des décisions sont prises sur chaque transition du chemin choisi dans le treillis) qui calcule le chemin dont la vraisemblance est maximale (ML : Maximum Likelihood). Il s’agit donc d’un algorithme de décodage ML par séquence (chemin). Le deuxième algorithme est un Viterbi modifié afin de fournir une sortie souple (SOVA : Soft-Output Viterbi Algorithm) : à chacun des symboles associés aux transitions du chemin choisi, il fait correspondre une information de fiabilité sous optimale. Un troisième algorithme, le Forward-Backward , fait l’objet d’un document séparé. Il calcule de manière exacte la probabilité a posteriori des symboles présents sur les branches. Il s’agit donc aussi d’un algorithme à entrée et sortie souples (SISO : Soft-Input Soft-Output) à décision MAP (Maximum A Posteriori) qui peut tenir compte d’une information probabiliste a priori disponible sur les symboles émis. Contrairement aux algorithme de Viterbi, il s’agit d’une maximisation symbole par symbole. Les algorithmes de Viterbi, le SOVA et le Forward-Backward sont couramment utilisés dans les systèmes de transmission mobile et fixe à codage simple ou concaténé.

5.1. L’algorithme de Viterbi La description de l’algorithme de Viterbi est faite dans le cadre du décodage à maximum de vraisemblance (à entrée ferme ou souple) des codes convolutifs. La description reste similaire pour les autres applications du VA, à condition de modifier la définition de la métrique de manière idoine. Soit C un code convolutif binaire de rendement R=k /n et de longueur de contrainte L. Le nombre de bits à l’entrée du codeur (respectivement en sortie) est égal à k (respectivement à n). L’algorithme de Viterbi est le moyen le plus répandu pour le décodage ML lorsque C possède un treillis de taille raisonnable, i.e. un nombre d’états inférieur ou égal à 256. L’algorithme de Viterbi est de faible complexité et est simple à implanter. Le décodage à maximum de vraisemblance correspond à chercher dans le treillis du code C le chemin le plus proche (le plus vraisemblable) de la séquence reçue (i.e. l’observation). La distance employée dans l’algorithme est soit la distance euclidienne dans le cas d’entrées souples, soit la distance de Hamming dans le cas d’entrées fermes. k ( L-1)

Rappelons que le nombre d’états dans le treillis du code C est égal à 2 et que le nombre de transitions par k k état est 2 . Chaque sommet dans le treillis est connecté de part et d’autre par 2 branches vers les sommets antérieurs et postérieurs. Le nombre total de branches entre deux étapes dans le treillis est 2


k(L-1)

×2k = 2 kL. La

O. Pothier


13/10/2000

9/12

séquence à décoder étant théoriquement de longueur infinie, on se limite en pratique à la recherche du chemin le plus proche sur une fenêtre de largeur W. Les chemins manipulés dans le treillis du code sont donc de longueur W branches. Si l’on essaie d’appliquer une méthode de décodage par recherche exhaustive et même si nous supposons connus les états initiaux et finaux (cas d’un code convolutif dont on a fermé le treillis), nous nous kL W- L) trouvons confrontés à la recherche du meilleur chemin parmi (2 )( possibilités. La complexité d’un tel procédé est prohibitive puisqu’elle est exponentielle en fonction de W. L’algorithme de Viterbi décrit ci-dessous apporte une grande réduction de la complexité de la recherche, qui devient linéaire en W.

5.1.1. Description de l’algorithme de Viterbi : Le temps est noté par l’indice t . Un état dans le treillis est noté par st à l’instant t , où 0 ≤ s t < S = 2 k ( L −1) . T ( st -1 ,st ) représente la branche à l’instant t dans le treillis associée à la transition de l'état st -1 à l'état st . La somme des carrés des distances associées aux branches entre le chemin du treillis arrivant à l’état st à l’instant t le plus proche de l’observation, et toute l’observation jusqu’au même instant est appelée métrique cumulée du sommet st et est notée λ(t , st ).

• •

Initialisation : λ(0,0)=0.0 et λ(0, s)=+∞ pour s≠0. En effet, nous savons que le codeur par de l’état 0. A l’étape t , pour chaque état st : On choisit la branche T ( st -1, st ) telle que la distance cumulée λ(t , st ) entre le chemin sélectionné et l’observation jusqu’au temps t soit minimale λ

(t , st ) = min s −

t 1

[λ (t − 1, s − ) + d {T ( s − , s ), observation}] 2

t 1

t 1

t

L’état st -1 qui correspond à ce minimum est appelé smin. On stocke ensuite le chemin survivant : survivant(t , s t ) = survivant(t − 1, s min ) + T ( s min , st )

•

Résultat du décodage ML (avec un délai W) : on fournit la branche T (t -W, s, s’) appartenant au survivant(t , st ) ayant la plus petite métrique cumulée λ(t , st ) entre tous les survivants. kL

métriques à chaque étape t , d’où une complexité de W×2 , linéaire en W. Cependant, la complexité reste exponentielle en k et L, ce qui limite l’utilisation aux codes de petite taille (kL de 7 à 10 maximum). La largeur W de la fenêtre de décodage est prise dans la pratique à 5 L environ. Cette valeur garantie (de manière empirique) que les survivants convergent vers un chemin unique k ( L-1) à l’intérieur de la fenêtre de décodage. L’algorithme de Viterbi nécessite donc le stockage de 2 métriques k ( L-1) cumulées et 2 survivants de longueur 5kL bits. L’algorithme de Viterbi nécessite donc le calcul de 2 kL

5.1.2. Exemple de décodage à décision dures Nous illustrons l’algorithme de Viterbi décrit au paragraphe précédent par une simple application au décodage à décisions dures du code convolutif (7,5) à 4 états et de rendement ½. Notez que la distance minimale de ce code est dHmin=5. Le treillis de ce code est représenté à la Figure 6. 2

La métrique d’une branche d {T ( st -1, st ),observation} est égale à la distance de Hamming d H[T ( st -1 ,st ),2 bits reçus] entre les deux bits de la branche considérée et les deux bits reçus à l’instant t . Supposons que le codeur a émis le chemin : c=00 00 00 00 00 00 00 00 00 00 00 et que le décodeur a reçu l’observation : r=10 00 00 00 00 10 00 00 00 00 00 Les figures suivantes illustrent l’état de la fenêtre de décodage pour t=1..10. Les métriques cumulées sont affichées sur le côté droit de la fenêtre. Les chemins survivants sont dessinés en lignes continues.


O. Pothier


13/10/2000

10/12

0

1

+∞

+∞

+∞

1

+∞

+∞

Figure 7 : Etat de la fenêtre à l’instant 1 1 2 3 2

Figure 8 : Etat de la fenêtre à l’instant 2

1 3 2 3



Figure 11 : Etat de la fenêtre à l’instant 10

5.2. L’algorithme de Viterbi à sortie souple (SOVA) L’algorithme de Viterbi peut être modifié afin de fournir à sa sortie une valeur de confiance ou de fiabilité (approximant une probabilité a posteriori) associée à chaque bit décodé. La valeur des bits décodés est toujours donnée par le chemin ayant la métrique cumulée minimale fourni par l’algorithme classique. Les valeurs de confiance produites par le VA modifié peuvent être par exemple utilisées par le décodage à entrées souples d’un code externe. Malgré sa sous-optimalité, le SOVA présente des performances proches de l’algorithme Forward-Backward qui calcule de manière exacte les probabilités a posteriori des bits décodés. Pour simplifier la description du SOVA, plaçons nous dans le cas d’un code convolutif binaire de rendement 1/n. Nous avons ainsi deux transitions partant de et arrivant à chaque état dans le treillis. Le nombre d’états du treillis ν est noté S=2 où ν= L-1 est la mémoire du code. ν Supposons que le VA classique prenne des décisions avec un délai W suffisamment grand pour que les 2 survivants convergent vers le même chemin avec une très grande probabilité. A l’instant t, l’algorithme de


O. Pothier


13/10/2000

11/12

Viterbi doit choisir un survivant pour l’état 0 ≤ sl < S . Ceci est illustré par la Figure 12. Le VA sélectionne le chemin ayant la plus petite métrique cumulée. Dans le cas où le canal est un canal gaussien (AWGN) à sortie souple, les métriques cumulées s’expriment sous la forme : M m

=

r − x ( m )

2

=

2 N 0

t

E s

n

∑ ∑ (r − x ) =− =

( m) 2 ij

ij

N 0

m = 1,2

j t W i 1

(m)

où xij est le i-ème bit codé à l’instant j parmi les n bits associés à une branche du chemin d’indice m arrivant à l’état st . L’échantillon r ij est l’observation en sortie du canal correspondant au bit numéro i à l’instant j. Nous supposons que les symboles (confondus avec les bits) appartiennent à une modulation BPSK, i.e. xij

=±

2 E s où E s est l’énergie moyenne par symbole codé sur fréquence porteuse. En mettant en facteur

2 E s , nous écrivons les symboles sous la forme xij

= ±1 d’où le rapport Es/N0.

Avec les notations définies ci-dessus, la probabilité que le chemin m soit émis sachant que l’observation est proportionnelle à la probabilité conditionnelle de l’observation sachant le chemin m émis : P (chemin m observation ) α e − M m Nous indexons arbitrairement le chemin ayant la métrique cumulée minimale par m=1. Ainsi nous avons

M 1

≤ M 2 et le VA choisit le chemin survivant d’indice 1. Après normalisation par la somme des probabilités

des deux cas possibles, la probabilité de choisir le mauvais chemin survivant, à l’instant t et pour l’état st , est égale à : p st avec

=

e − M 2 e

− M 1

+e

− M 2

=

1 1+ e

=

M 2 − M 1

∆ = M 2 − M 1 ≥ 0 . Cette probabilité approche 0.5 si M 2≈M1

1 1 + e∆

et tend vers 0 si M 2>>M1. L’algorithme de

Viterbi commettra des erreurs avec une probabilité p st sur les e positions où les chemins 1 et 2 ont des bits (1)

(2)

d’information différents u j ≠u j pour les positions j= j1, j2,…, je. . Notons que e=2 dans la Figure 12. Les (1) (2) positions où u j =u j ne sont pas affectées par la sélection du survivant. Notons W m la largeur de la fenêtre dans le treillis où les chemins 1 et 2 arrivant à l’état st ne sont pas confondus (voir Figure 12). Ainsi, nous avons e bits d’information différents et W m -e bits d’information identiques. (1)

Notons pˆ j la probabilité que le bit u j

associé au chemin 1 de l’état st soit erroné. Supposons que les valeurs de

pˆ j sont stockées en mémoire pour les instants j=l-Wm,…,t-1. Prenons comme valeur initiale pˆ l = 0 (le bit décodé reste parfaitement fiable tant que les deux chemins indiquent la même valeur). Sachant que l’algorithme de Viterbi a sélectionné le chemin 1, nous pouvons mettre à jours les probabilités d’erreurs des bits différents selon la formule : pˆ j ← pˆ j (1 − p sl ) + (1 − pˆ j ) p sl pour j = j1, j2,…, je Cette équation nous fournit une approximation de la probabilité d’erreur pour le bit d’information u j. Même si le SOVA est incapable de fournir l’APP exacte du bit u j, une valeur de confiance µ j est facilement obtenue à partir de pˆ j : µ j

= log

1 − pˆ j

0 ≤ µ j

pˆ j

< +∞

En combinant les équations ci-dessus, nous obtenons une formule de mise à jour des valeurs de confiance : µ j

← f ( µ j , ∆ ) =

1 α

log

1+ e e∆

αµ j + ∆

+ eαµ

j

Rappelons que la mise à jour est effectuée sur les positions j= j1, j2,…, je. Le facteur α introduit dans la fonction f() permet d’éviter les débordements de la valeur de confiance à fort rapport signal-à-bruit. Asymptotiquement, E nous pouvons normaliser la moyenne de à 1.0 en choississant α = 4d H min s où d H min est la distance minimale N 0 du code convolutif. Une approximation simple et pratique de la fonction f() est f ( µ j , ∆ ) ≈ min( µ j , ∆ / α )


O. Pothier


13/10/2000

12/12

Cette dernière formule permet une mise à jour très rapide de la valeur de confiance sans même connaître la valeur du rapport Es/N0. Nous pouvons maintenant décrire de manière générale les étapes de l’algorithme SOVA : Stockage : • L’indice t du temps, modulo W+1 • Les suites des bits décodés par décisions dures u( st )={ ul-W( st ),…, ul( st )}, u j( st )∈±1 pour 0 ≤ st < S .

•

Les suites de valeurs de confiance µ( st )={µl-W( st ),…,µl( st )} avec 0 ≤ µ j ( s t ) < +∞ pour 0 ≤ s t < S .

•

Les valeurs des métriques cumulées λ(t , st ) pour 0 ≤ st < S .

Mise à jour : • Etape VA classique: Pour chaque état st , calculer λ(t , st ). Stocker la métrique cumulée, le survivant et le bit décidé ut ( st ). • Etape de décision à sortie souple: Pour chaque état st , stocker la différence des deux métriques

∆ = max[λ (t − 1, st −1 ) + d 2 (T ( st −1 , st ), observation )] − max 2[λ (t − 1, st −1 ) + d 2 (T ( st −1 , st ), observation )] Initialiser µt( st )=+∞. (1) (2) Pour j=t-ν en arrière jusqu’à t-Wm, comparer les deux chemins convergents en st et si u j ( st )≠u j ( st ) mettre à jour les fiabilités par la formule µ j( st )=f(µ j( st ),∆).

Sorties ferme et souple : • L’algorithme fournit une sortie ferme : le bit décodé ut -W associé au meilleur survivant de métrique minimale λ(t , st ) parmi tous les états st . 1 − pˆ t −W • L’algorithme fournit une sortie souple : la valeur souple u t-W× µt-W où µ t −W = log est la valeur de pˆ t −W confiance à l’instant t -W du meilleur survivant.

+1 +1

+1

-1

-1

+1

S états

m=1 sl m=2 -1 l-W

l-Wm

+1 -1

l

Figure 12 : Exemple d’un treillis décodé par le SOVA.


O. Pothier

codage_convolutif

Recommend Documents