Docstoc

Modex-Rapport

Document Sample
Modex-Rapport Powered By Docstoc
					Adriana DINU
Joëlle BARRAL



                          MODEX D’ELECTRONIQUE




      CODES CORRECTEURS D’ERREURS

                     Implémentation des turbo-codes

                               _____________


    Enseignants responsables : S. Lasaulce, A. Fromentel, JP. Jacquet et S. Puong
SOMMAIRE

 1. Modélisation……………………………………...........................Page 4
         A. Transmissions numériques……………………………. ………...Page 4

         B. Simplification……………………………………………………Page 5

 2. Les codes correcteurs…………………...........................Page 6
         A. Définitions………………………………………………….........Page 6

                  1.   Codeur linéaire
                  2.   Distance minimale
                  3.   Matrice génératrice
                  4.   Matrice de contrôle
                  5.   Syndrome
                  6.   Canal gaussien
                  7.   Canal de Rayleigh

         B. Le code de Hamming…………………………………................Page 9

         C. Les turbo-codes……………………………….......................... .Page 11

                  1. Codeur convolutif
                  2. Algorithme aller-et-retour
                  3. Décodage itératif

 3. Evaluation………………………………………………................Page 20
         A. La limite de Shannon…………………………..........................Page 20

                  1.   Définitions
                  2.   Théorème de Shannon
                  3.   Cas d’un canal gaussien
                  4.   Performance des codes de longueur finie
                  5.   Synthèse

         B. Mise en œuvre………………………………………………….Page 24

                  1. Implémentation des turbo-codes
                  2. Exploitation

         C. Pour aller plus loin……………………………………………..Page 28


                                                                          2
                   La transmission de l’information

        Dans tout système de communication, on cherche à transmettre l’information
provenant d’une source vers un récepteur, à travers un canal de transmission. Les
perturbations intervenant sur celui-ci induisent des erreurs de transmission que le codage
de canal s’efforce de combattre. L’objectif est alors d’assurer un taux d’erreur minimal.
Comment y parvenir ?
        La solution est basée sur l’insertion parmi les éléments d’information d’éléments
supplémentaires (la redondance) qui suivent une loi connue. Ce phénomène nous est
proche : qui n’a jamais fait répéter un interlocuteur dont les paroles avaient semblé
obscures ?
        Si cette idée première est enfantine, sa mise en œuvre sous une forme plus
évoluée est assez récente : la théorie du codage trouve sa source dans la théorie de
l’information élaborée par Shannon à partir de 1948. Celle-ci assure qu’on peut trouver
une probabilité d’erreur aussi petite que l’on veut, dès lors que le taux d’émission du code
est inférieur à la capacité du canal, si l’on emploie un code approprié. Toute la difficulté
réside dans le choix de ce code : la complexité du décodage associé a longtemps été
prohibitive.
        En 1993, Berrou, Glavieus et Thitimajshima inventent les turbo-codes qui
approchent les limites données par la théorie de l’information et donnent ainsi un souffle
nouveau aux recherches concernant les codes correcteurs.

        Enthousiasmées par des découvertes aussi récentes que prometteuses, nous avons
cherché à comprendre d’où provenait la spécificité des turbo-codes et en quoi ceux-ci
offraient de nouvelles perspectives dans le monde des communications.

       Après avoir extrait d’une chaîne de transmission, les maillons affectés par le
codage/décodage d’erreurs, nous partons de codeurs simples, comme le code de
Hamming, pour introduire les différents concepts liés au problème du codage. Nous nous
efforçons ensuite de bien comprendre le fonctionnement des codeurs convolutifs,
éléments constitutifs des turbo-codeurs. Cette approche nous permet alors de comparer
les performances obtenues pour les turbo-codeurs aussi bien à celles de codeurs plus
classiques, qu’à celles prévues par la théorie de l’information.




                                                                                          3
     1.Modélisation

             A. Transmissions numériques
       Une chaîne d’information peut être schématisée de la façon suivante :




  Source              Codeur Source            Codeur Canal             Modulateur




                                                                                        Canal
                                                                        Bruit




     Récepteur             Décodeur              Egaliseur            Estimateur
                                                                        Canal




                         Fig. 1 : Transmission à travers un canal

        Le signal analogique s(t) fourni par la source passe d’abord par un filtre anti-
repliement qui permet de tronquer en fréquence et d’obtenir une fréquence maximale du
spectre conditionnant l’échantillonnage. Il est ensuite converti en signal numérique,
échantillonné (il s’agit d’une quantification temporelle) et discrétisé en amplitude. Le
codeur de source convertit les paliers obtenus lors de la quantification, en une série de
bits. Le modulateur retire au signal sa composante continue.

        Le codage de canal est le maillon de la chaîne qui nous intéresse tout
particulièrement : c’est en effet lui qui met en place la structure permettant à la réception
de corriger le bruit, à savoir le code correcteur d’erreur. La transmission est modélisée
par un canal gaussien ou par un canal de Rayleigh, suivant les phénomènes que l’on
souhaite mettre en évidence.

       A la réception, l’estimateur de canal élabore la réponse en impulsion du canal et
précède l’égaliseur, chargé de corréler les différents signaux reçus. Enfin le décodeur
permet de retrouver l’information originelle.


                                                                                                4
             B. Simplification
       Pour mettre en évidence les problèmes liés au codage/décodage de l’information,
nous nous devions de simplifier cette modélisation de transmission de données. Nous
avons ainsi considéré le schéma suivant :


                                                          Bruit



      CODEUR                MODULATEUR                                           DECODEUR




 Fig. 2 : Simplification du canal pour mettre en évidence le codage/décodage d’erreurs

         Le codeur est chargé d’ajouter aux bits d’information des bits de redondance qui
permettront de savoir si des erreurs dues au bruit ont affecté l’information et, le cas
échéant, de les corriger. Le bruit ne fait bien sur pas la distinction entre bits d’information
et bits de redondance, sur lesquels des erreurs peuvent donc également intervenir. L’enjeu
est alors de détecter et de corriger toutes les erreurs touchant l’information, sans en
introduire de nouvelles.




                                                                                             5
     2.Les codes correcteurs

           A. Définitions
Définissons tout d’abord quelques notions.

                    1. Codes linéaires

       Dorénavant, nous allons utiliser les notations suivantes :

               k - pour désigner la longueur du mot d’information
               r - pour désigner le nombre de bits de contrôle (redondance)
               n - pour désigner la longueur du mot de code
               Nous avons n=k+r.

        Les codes linéaires sont des codes où les bits du mot de code s’obtiennent à partir
des bits d’information, avec les connecteurs logiques OU EXCLUSIF et ET. Nous avons
ainsi une bijection linéaire entre les mots d’information et les mots de code.

            Exemple:

       mot d’ information: i=(i1,i2,……ik)
       mot de code :      c=(c1,c2,……cn) , où ij, ,cj  B={0,1}

         Nous partons donc de la chaîne i, qui a k éléments et, après avoir ajouté les bits de
redondance, nous obtenons la chaîne c. L’exemple le plus simple est l’ajout d’un bit de
parité :
          i = (1 0)
          c = (1 0 1)
          k=2, n=3
         Le dernier bit de c est calculé comme la somme (modulo 2) des bits de i.

                    2. Distance minimale

       La distance entre deux codes, c1 et c2, se définit comme le nombre de bits égaux à
1 contenus dans la somme c1+c2 (modulo 2). La distance minimale est donc la plus petite
distance que l’on peut trouver entre deux mots quelconques du code.

            Exemple

       c1 = (1 1 0 0 1 0)
       c2 = (0 1 0 1 1 0)
       La distance entre c1 et c2 vaut 2
       (c’est également le nombre de positions j où c1(j)  c2(j) )



                                                                                            6
                   3. Matrice génératrice

         Comme les mots d’information ont une longueur k, on peut avoir 2k mots
différents, qui forment un espace vectoriel de dimension k. Si nous considérons le fait
que les mots de codes sont en bijection linéaire avec les mots d’information, nous
pouvons dire que ces derniers forment un sous-espace vectoriel de dimension k de {0,1}n.
Il suffit alors de trouver une matrice G de dimension (k,n), formée des vecteurs de base
de ce sous-espace vectoriel. Un mot quelconque sera obtenu comme :

                                         c=i*G

On appelle matrice génératrice du code la matrice G.

                   4. Matrice de contrôle

         On appelle code dual de C un code D défini sur le sous-espace orthogonal à
l’ensemble des mots du code C et on note H la matrice génératrice de ce code dual. On a
la relation :

                                       G * Ht=0

       En effet, d’après la définition de H, tous les vecteurs-lignes de G sont
orthogonaux à tous les vecteurs-lignes de H. On appelle matrice de contrôle pour le code
C la matrice H.

                   5. Syndrome

         Avec ces propriétés, pour un mot donné c, le produit H*ct est nul si et seulement
si c est un mot de code. On peut définir ainsi le syndrome :

                                        s = H*ct


qui est un vecteur-colonne de r bits. Si le syndrome s est nul alors le mot c appartient à
l’ensemble des mots du code et sinon, il est égal à la colonne de H correspondant au bit
erroné (pour le cas où l’on est sûr de ne pas avoir plus d’une erreur).




                                                                                        7
                   6. Canal gaussien

        Pour les codes que nous avons implémentés, nous avons toujours supposé que le
canal était affecté par un bruit gaussien blanc. Ce bruit est avant tout un modèle, basé sur
les deux suppositions suivantes :
        -tous les bits ont même probabilité, quelle que soit leur position.
        -les erreurs des différentes positions sont indépendantes.
Le bruit est dit gaussien car il a une densité de probabilité gaussienne.
        Bien que ce modèle paraisse simple, on rencontre en pratique plusieurs difficultés.
En effet, on peut avoir des probabilités variables suivant les positions et, de plus, les
erreurs ont tendance à être liées entre elles, et non indépendantes (par exemple quand la
cause de l'erreur est commune et intervient de façon globale sur le canal). Cependant,
comme au niveau de la modélisation il n’est pas possible d’avoir plus d'informations sur
le bruit, la modélisation considérée parait raisonnable. C’est d’ailleurs une excellente
modélisation du bruit thermique, perturbation universelle s’il en est.

                   7. Canal de Rayleigh

        Un autre modèle que nous avons envisagé consiste en un canal de transmission
affecté par les évanouissements de Rayleigh.
        Dans le cas d’un canal gaussien blanc, nous avions considéré le signal reçu y(t)
suivant :
                                          y(t)=x(t)+b(t)
où x(t) est le signal envoyé et b(t) le bruit (purement additif).
        Le modèle de Rayleigh considère une modification de l’amplitude du signal :
                                       y(t)=h(0)*x(t)+b(t)
où h(0)= α(0)+j*β(0) avec α(0)et β(0) distribuées selon des lois gaussiennes.
La loi de probabilité pour |h(t)| est alors décrite par :
                                              r        r2
                                     fr(r)=       exp( 2 )
                                            sig 2     sig
        .




                                                                                          8
           B. Le code de Hamming
        Voyons comment les différentes notions introduites s’appliquent au cas d’un
codeur linéaire simple. Nous devons d’ores et déjà mentionner le fait que le code de
Hamming ne peut corriger qu’une seule erreur à la fois. Lors d’une transmission, si nous
sommes sûrs de ne pas trouver plus d’une erreur, nous avons n+1 possibilités (pour les
cas où l’erreur affecte l’un des n bits et le cas où il n’y a pas d’erreur). D’autre part,
comme le vecteur syndrome a r lignes, nous ne pouvons pas avoir plus de 2r possibilités.
Pour que nous puissions corriger l’erreur, il faut donc avoir la relation
                                  2r  n+1, soit 2r -1  n
        Les codes de Hamming sont, par définition, les codes qui corrigent une erreur et
où l’on a :
                                                2r -1=n
        Nous avons étudié le code de Hamming pour n=7 et k=4. La matrice de contrôle
est dans ce cas :
                                              0001111
                                          H= 0110011
                                                       
                                              1010101
                                                       
        Les colonnes de H représentent exactement la transcription binaire des nombres
de 1 à 7. Le syndrome va donc donner directement le bit erroné.
        La matrice G, qui se déduit de la matrice H, est :

                                           1110000
                                           1001100
                                        G=        
                                           0101010
                                                  
                                           1101001

        On vérifie alors facilement si un mot c appartient au code ou non, en effectuant le
produit c* Ht, qui nous donne, en cas d’erreur, la transcription binaire du numéro du bit
erroné.
        En réalisant l’histogramme des distances (le nombre des mots de code à distance
fixée), nous pouvons constater que la distance minimale de ce code de Hamming est 3 (cf.
Fig 3).




                                                                                         9
               Fig. 3 : Histogramme des distances d’un code de Hamming

         Bien qu’un codeur-décodeur de Hamming soit relativement facile à implémenter,
il est très limité à cause de son pouvoir de correction : il ne fonctionne que si l’on n’a
qu’une erreur à traiter. Par exemple, comme nous le voyons dans l’exécution du
programme ci-dessous, si on reçoit un mot c= 1110010  affecté par deux erreurs (en
position 3 et en position 5), le syndrome est :
                                         s= 110  ,
On obtient donc comme mot transmis c= 1110000  , qui est un mot de code mais pas le
mot d’où nous sommes partis.




     Comme dans la réalité on peut avoir plus d’une erreur par mot, le code de
Hamming se révèle insuffisant.


                                                                                       10
           C. Les turbo-codes
                    1. Le codeur convolutif

            Le treillis

        Une notion absente des codes linéaires vient s’ajouter, lorsque l’on s’intéresse aux
codeurs convolutifs : il s’agit du treillis associé au codeur.
        En effet, pour représenter le fonctionnement d’un codeur convolutif, on peut
employer un diagramme de transitions d’état, développé en fonction du temps. Ce temps
discrétisé est appelé niveau de noeud. L’état est décrit par la mémoire du codeur : pour un
codeur de mémoire de taille ν, 2ν états sont accessibles (4 dans notre cas, où la mémoire
du codeur est constituée de 2 bits). On inscrit sur chaque branche associée à une
transition possible entre deux états, les bits sortant du codeur quand cette transition a lieu.
        Tout chemin de ce graphe, et seulement tout chemin, représente donc une suite
que peut émettre le codeur.

                         00                 00                       00
              00                                                          11
                            11                     11

                                                                     11
                                              10                               00
             10
                                                                                10

                                                                          01
                                                   01
              01
                                                                  01
                                                                          11

             11

                       Fig. 4 : Treillis du codeur convolutif (Fig. 5)




                                                                                            11
            Deux codeurs en parallèles

        Les champs d’application du codeur convolutif sont extrêmement variés : en effet,
la structure du codeur est particulièrement simple et son implémentation permet de
conserver une information de fiabilité sur chacun des bits reçus.
        Nous avons utilisé des codeurs convolutifs itératifs systématiques. Explicitons ces
différents termes :

       -convolutif : la décision est prise en fonction des probabilités de chacun des bits
       (on conserve une information souple de fiabilité sur chacun des bits).
       -itératif : on exécute plusieurs fois le même algorithme jusqu’à ce que l’on
       obtienne des probabilités satisfaisantes.
       -systématique : le mot d’information initial est récupéré directement dans le mot
       de code reçu.


            u                                                                      v0




                       d(t)        d(t-1)     d(t-2)




                                                                                        v1

                Fig. 5 : Exemple de codeur convolutif itératif systématique

        Le codeur convolutif est aussi caractérisé par sa mémoire, comme nous pouvons
le voir sur la figure 4 (dt-1, dt). Cette mémoire peut être plus grande : ici elle est de taille
deux, ce qui correspond à notre implémentation.




                                                                                             12
       Le codage pour les turbo-codes se fait à l’aide de plusieurs codeurs convolutifs
(dont le nombre donne le nombre de niveaux), mis en parallèle. Nous nous sommes
limitées à deux niveaux, la complexité augmentant très rapidement avec le nombre de
codeurs mis en jeu.


                                           R1                                 v1

    u                                                                      v0=u

                       π                   R2                                 v2


                          Fig. 6 : Codeur pour le turbo-codage

        Les deux codeurs convolutifs travaillent sur la même chaîne de bits, mais ils sont
décorrelés à l’aide d’un entrelaceur.

         Soulignons enfin le fait que dans l’algorithme de codage-décodage nous
accordons beaucoup d’importance à l’état de la mémoire du codeur. En effet, pour
pouvoir faire le décodage, il faut non seulement que la mémoire du codeur parte mais
aussi revienne dans l’état (0,0). Si nous imposons l’état initial, l’état final dépend de la
chaîne que nous donnons à l’entrée du codeur. Nous ne pouvons cependant pas empêcher
l’utilisateur de transmettre n’importe quelle chaîne ! Nous avons donc ajouté deux bits à
la chaîne donnée, en fonction de l’état de la mémoire à laquelle elle conduit, pour forcer
la mémoire à revenir à l’état (0,0).




                                                                                         13
                    2. L’algorithme aller-retour

        C’est ce passage obligé pour parvenir aux turbo-codes qui nous a posé le plus de
problèmes à l’implémentation. En effet, de nombreuses précautions numériques
s’imposent, dès lors que le bruit gaussien qui vient perturber le canal est suffisamment
petit pour être réaliste (typiquement,  compris entre 0.1 et 1).
        Cet algorithme est basé sur le calcul de la probabilité d’apparition d’un bit (1 ou 0)
dans une certaine position. Nous avons à notre disposition une chaîne de longueur T, qui
provient du codage (à l’aide du codeur décrit dans la section précédente) d’un mot
d’information de taille T/2. La méthode consiste à calculer itérativement la probabilité a
posteriori de chaque bit, en fonction d’abord des valeurs des probabilités pour les bits
antérieurs à lui, puis en fonction des bits postérieurs. Pour cette raison, l’algorithme
s’appelle « algorithme aller-retour ». Nous accordons une importance égale aux bits
« d’avant » et aux bits « d’après ».
        Dans ce qui suit on a noté Y la chaîne des bits reçus et t la position du bit dans la
chaîne. De même, nous avons noté Bi(t) l’ensemble de transitions de l’état St-1=l’ à l’état
St=l, dès que l’on a le bit i à l’entrée. Soit M le nombre d’états possibles (dans notre cas
M=4)

       Nous cherchons à calculer la quantité :

                                                      P(u(t )  1 / Y ) 
                                     (u(t ))  ln                      
                                                      P(u(t )  0 / Y ) 

où u désigne la sortie du codeur.

Pour deux états donnés l’ et l, on définit une probabilité conjointe:

                   t (l ' , l )  P( S t 1  l ' , S t  l / Y )  P(u (t )  i, S t  l / Y )

i étant le bit qui envoie l’ en l (t vaut 0 quand il n’y a pas de transition de l’ à l)

Nous avons donc la relation suivante :

                                    P(u(t )  i / Y )          
                                                           ( l ,l ')Bi ( t )
                                                                             t   (l ' , l )


Pour calculer , il faut introduire la densité de probabilité conjointe :

                                 t (l )  P(u (t )  i, S t  l , y (1 : n)),

où nous avons noté y(1 : n) les éléments de 1 à n du vecteur Y.




                                                                                                   14
De même, nous définissons la probabilité conditionnelle :

                                             t (l )  P( y (k  1 : T ) / u (t )  i, S t  l )

A l’aide de la règle de Bayes, on obtient la relation :

                                       P(Y , u (t )  i, St  l ) P( y (1 : t ), y (t  1, T ), u (t )  i, l )
                     t (l ' , l )                              
                                                P(Y )                                P(Y )

                                       P(u (t )  i, l , y (1 : t )) * P( y (t  1 : T ) / u (t )  i, l , y (1 : t ))
                                 
                                                                         P(Y )

Mais, comme les événements après l’instant t ne dépendent pas de la suite reçue jusqu’à
cet instant, l’expression devient :

                                             P(u (t )  i, l , y (1 : t )) * P( y (t  1 : T ) / u (t )  i, l )
                          t (l ' , l ) 
                                                                           P(Y )

Comme, grâce au rapport, on peut omettre le terme P(Y), on obtient :

                                              t (l ' , l )   t (l ) *  t (l ), pour le bit i

                  Calcul de  et 

Nous cherchons à calculer  récursivement. Pour cela, on écrit  comme :

                                              t (l )  P(u (t )  i, l , y (1 : t  1), y (t ))

alors, en faisant la somme pour toutes les transitions possible depuis l’instant t-1 :

                   t (l )            P(u(t )  i, u(t  1)  j, St  l, S (t  1)  l ' , y(1 : t  1)
                                l'     j0,1
pour un bit i.

En appliquant la règle de Bayes, on trouve :

                                                  t (l )            t 1   (l ' ) *  ti (l ' , l )
                                                                
                                                            l ' i 0,1



où  ti (l ' , l )  P (u (t )  i, l , y (t ) / u (t  1)  j , l ' ).




                                                                                                                         15
On trouve donc :

                        t (l ' , l )   t (l ) * t 1 (l ' ) *     
                                                                     
                                                                    i 0,1
                                                                                t 1   (l ' ) *  ti (l ' , l )

Par des calculs similaires, on obtient :

                                   t (l )               t 1   (l ' ) *  ti1 (l ' , l )
                                                l'   
                                                     j 0,1

Comme  caractérise le bruit, qui est gaussien blanc, on peut écrire :

                                                    y(t )  x(t )                 2
                                                                                         
                  (l ' , l )  P(u (t )  i) * exp
                   i                                                                      , si (l,l’)Bi(t)
                   t
                                                     2 * 2                            
                                                                                        
                  0 sinon.

Ici x(t) est la valeur qu’on aurait dû avoir à la sortie du codeur, dès qu’on passe de l’état
l’ à l’état l.

            Résumé

       L’algorithme s’effectue de la façon suivante :

               -on initialise 0(l) et T-1(l) à une valeur indépendante de t
               -on calcule ti(l’,l)
               -on calcule t(l) et t(l) itérativement avec les formules obtenues
               -à la fin, on prend la décision à partir de la valeur de (t) :
                        si >0 on choisit u(t)=1, sinon, u(t)=0.

       Même si les calculs mathématiques semblent clairs, nous avons rencontré
beaucoup de problèmes lors de l’implémentation. Un des plus difficiles a été lié à la
rapide croissance/décroissance de l’exponentielle, qui force Matlab à évaluer son résultat
à 1 ou 0. Or, pour que l’algorithme fonctionne, nous avions besoin de calculs plus précis.
Nous avons déclaré toutes les variables de type « double » mais cela n’a pas apporté
beaucoup d’améliorations, et il a fallu normaliser  et  par la somme sur tous les états
de la mémoire :
                                            (l)        l


        Un autre problème était celui de l’état final. Au début, nous avions implémenté
l’algorithme en négligeant le fait que la mémoire devait revenir à l’état (0,0), comme
nous l’avons expliqué ci-dessus. Après une étude plus attentive, nous avons compris les
conséquences désastreuses de cette omission !
        En effet, si l’on analyse les formules du décodage, nous comprenons l’importance
de cette condition : nous initialisons  et  à 0. Le fait de partir et d’arriver à (0,0) permet
de conserver la validité de cette initialisation. Plus précisément, l’état de début
correspond à 0 et l’état de fin à 0.


                                                                                                                  16
                    3. Le décodage itératif

      Le décodage itératif est basé sur l’utilisation de deux décodeurs convolutifs, qui
échangent de l’information.



                                           Π^-1
                                      1(ext)

                           C1^(-1)         π
    y1                                                                         2(ext)

    y0

                                            π               C2^(-1)
                                                                                 Π^-1
     y2                                                                 2



                            Fig. 7 : Le décodage du turbo-code

        Dorénavant nous notons avec un « - » les variables décorrelées (auxquelles nous
avons appliqué une permutation).
        Nous commençons par lancer l’algorithme aller-retour pour le premier décodeur,
avec des probabilités a priori valant ½, comme nous avions fait pour le décodage simple.
Comme résultat, nous obtenons la fonction lambda :
                                                    P (u (t )  1 / Y ) 
                                  1 (u (t ))  ln  1                    
                                                    P1 (u (t )  0 / Y ) 
qui dépend d’une part de l’information correspondante à l’entrée du codeur (le y0 sur la
figure) et d’autre part de l’information contenue dans les bits de redondance. L’idée de
l’algorithme consiste à séparer les deux types d’information. Nous écrivons donc, 1(u(t))
comme :
                                        P 1 (1) 
                        (u (t ))  ln  t1   2 *  2 y 0 (t )  1 (u (t ))
                                                                            ext

                                        Pt (0) 
                                                

où Pt1 représente la probabilité a priori, y0(t) le signal d’entrée et 1ext(u(t)) une fonction
des bits de redondance introduits par le codeur. Pour cette raison, 1ext(u(t)) s’appelle
aussi «information extrinsèque ».




                                                                                            17
         Comme 1ext(u(t)) est indépendante de l’entrée « 0 » du décodeur C1, on peut
l’utiliser comme probabilité a priori pour le décodeur C2. De cette manière, le décodeur
C2 aura une information de plus sur les données. De plus, l’entrée pour C2 est décorrelée
de celle pour C1 et nous devons faire la même chose pour 1ext(u(t)) avant de l’utiliser.

        Des formules suivantes :
                                                                   Pt 2 (1) 
                                           1   ext
                                                      (u (t ))  ln  2 
                                                                     Pt (0) 
                                                                              
                                                                                                 (*)
                                                 Pt (1)  1  Pt (0)
                                                      2                    2




nous déduisons les probabilités a priori pour le décodeur C2 :
                                                                 
                                                            ext ( 
                                                                       ext
                                                                               (u (t )))
                                        Pt (1) 
                                           2                          1
                                                                      
                                                          1  ext ( 
                                                                               ext
                                                                                     (u (t )))
                                                                           1


                                                                        1
                                        Pt (0) 
                                           2
                                                                      
                                                          1  ext ( 
                                                                               ext
                                                                                     (u (t )))
                                                                           1


        Nous appliquons alors l’algorithme aller-retour pour le deuxième décodeur avec
ces probabilités et nous obtienons 2(t), que nous écrivons aussi comme :
                                           P 2 (1)         
                         2 (u (t ))  ln  t 2   2 *  2 y 0 (t )  ext (u (t ))
                                                                         2
                                           Pt (0) 
                                                   
                                                   

(nous tenons compte du fait que la variable y (t) est décorrelée).0


Puis, en utilisant (*) :
                                                                                   
                           2 (u (t ))   1ext (u (t )) 2 *  2 y 0 (t )  ext (u (t ).
                                                                               2



        D’une manière analogue à celle employée pour 1, nous déduisons les probabilités
a priori pour le décodeur C1 et nous itérons.




                                                                                                       18
            Résumé :

       L’algorithme est le suivant :

              -nous initialisons Pt1(1) et Pt1(0) à ½ et ext (u (t )) à 0.
                                                           2

              -nous calculons 1(u(t)) et 2(u(t)) à l’aide de l’algorithme aller-retour
              avec les probabilités a priori Pt1(1) et Pt1(0) ;
              -nous déduisons les valeurs des quantités extrinsèques :
                                                             
                         1ext (u (t ))  1 (u (t ))   2 ext (u (t )) 2 *  2 y 0 (t )
                                                                                  
                        2 ext (u (t ))  2 (u (t ))   1ext (u (t )) 2 *  2 y 0 (t )

              -nous mettons à jour les probabilités :

                                                   
                                             ext (   (u (t )))
                                                            ext


                               Pt (1) 
                                  j                     j
                                                     
                                           1  ext (   (u (t )))
                                                                 ext

                                                             j



                                                                  1
                                 Pt (0) 
                                      j
                                                            
                                             1  ext (   (u (t )))
                                                                      ext

                                                                  j

              -nous retournons à la deuxième instruction tant que les probabilités
              obtenues sont déclarées irrecevables.
              -nous donnons λ2(t) à l’organe de décision.


        Du point de vue de l’implémentation, nous devons faire attention aux
permutations effectuées : il faut avoir en permanence à l’esprit les variables permutées et
celles qui ne le sont pas, afin de conserver la cohérence globale.




                                                                                              19
   3.Evaluation

             A. La limite de Shannon
        La théorie de l’information définit les frontières du possible en matière de
communication. Aux limites imposées par la capacité et précisées par le théorème de
Shannon, correspondent les limites asymptotiques en termes de longueur de code
        En effet, pour des longueurs de code petites (typiquement notre cas, puisque dans
nos exemples, celle-ci reste inférieure à 100), les limites proposées par la théorie de
l’information ne sont plus pertinentes dans la mesure où les longueurs considérées ne
tendent plus vers l’infini. Il faut donc étudier de nouvelles bornes prenant en compte la
longueur finie du code.

                   1. Définitions

        Soient x et y deux variables aléatoires discrètes de probabilités respectives P(x) et
P(y).

            Information mutuelle : information sur l’événement x fournie par
             l’événement y

                                    P( x / y ) 
                                    P( x)   log( P( x / y))  log( P( x))
                     i( x; y)  log            
                                               


   Incertitude restant sur x après
   observation de y=                                      Information intrinsèque =
    information conditionnelle                            Incertitude a priori sur l’événement x
                                                          (information nécessaire pour résoudre cette
                                                          incertitude)




            Information mutuelle moyenne (moyenne sur l’ensemble des réalisations
             possibles) :

                                                            P ( xi / y j ) 
                        I ( X , Y )   P( xi ; y j ) log 
                                                            P( x )        
                                                                    i      




                                                                                              20
            Capacité

       La capacité d’un canal est définie comme le maximum de l’information mutuelle
moyenne, X et Y étant les variables aléatoires associées respectivement à l’entrée et à la
sortie du canal. La maximisation est effectuée sur l’ensemble des distributions de
probabilité P(x) à l’entrée du canal.

                                        C  max I ( X ; Y )
                                              P( x)



La capacité du canal dépend donc de la probabilité de transition du canal.
        L’information mutuelle est concave, généralement strictement, ce qui garantit
l’existence d’un unique maximum.
        Pour les canaux discrets symétriques le maximum de l’information mutuelle est
atteint pour une distribution équiprobable des symboles d’entrée et on a :

                                                     P( y / x)          
                  C  max  P( x) P( x / y ) log                           (*)
                                                   P( x' ) P( y / x' ) 
                                                                        

      L’emploi du log en base 2 permet alors d’exprimer la capacité en bits par
dimension réelle.

            Taux d’émission : pour un canal de taille de modulation Q et de rendement
             de code correcteur R, Rb= R*log2(Q)

                     2. Théorème de Shannon

        Pour un taux d’émission Rb < C, où C est la capacité du canal en bits/dimension, il
existe un code de longueur N, tel que sa probabilité d’erreur par mot soit arbitrairement
petite lorsque N tend vers l’infini. Cette probabilité d’erreur peut être majorée par une
fonction de la forme :
                                      Pe < 2 –N* E(Rb)

où E(Rb) est l’exposant de Gallager ou exposant de codage linéaire. Cet exposant est
positif pour un taux d’émission Rb inférieur à la capacité C du canal.

       Ce résultat suppose que le codage est à maximum de vraisemblance.

        Pour un taux d’émission Rb, la connaissance de C fournit la valeur maximale de
la variance du bruit, ou de façon équivalente la valeur minimale du rapport signal sur
bruit, pour pouvoir assurer une transmission fiable des données lorsque la longueur du
code tend vers l’infini.




                                                                                        21
                   3. Expression de la capacité dans le cas d’un canal gaussien
                     (AWGN)

        Soient X et Y deux variables aléatoires représentant respectivement l’entrée et la
sortie du canal AWGN. Le bruit, caractérisé par la variable aléatoire Z, est un bruit
additif gaussien de variance No (=σ ²)
         Pour un canal gaussien (entrée et sortie continues), l’information mutuelle
moyenne est maximisée par une distribution gaussienne de la variable aléatoire X. La
capacité du canal vérifie alors :
                                       1                 E
                                  C  log 2 (1  2 * C * b )
                                       2                 No
où Eb est l’énergie moyenne par bit d’information. Pour un canal à entrée discrète, il n’y a
plus de maximisation sur la distribution en entrée du canal mais on appelle capacité
l’information mutuelle obtenue avec cette distribution, par abus de langage.

      Dans le cas d’un canal AGWN avec entrée discrète et sortie continue, si la
modulation en entrée s’écrit avec Q symboles de l’alphabet {x 0,…xQ-1}, et si tous ces
symboles sont équiprobables alors
                                                       yx 2
                                        1                   q 
                       p( y / xq )             * exp  
                                     2 * * N o        2 * No 
                                                               
                                                              

donc avec (*), on peut obtenir l’expression de la capacité.

                   4. Performance des codes de longueur finie

        L’exposant de Gallager ne donne qu’une information peu précise des
performances du code lorsque l’exposant N est fini.
        En 1959, Shannon propose une approche géométrique pour calculer la probabilité
d’erreur optimale- du moins un encadrement de cette probabilité- dans le cas d’un canal
gaussien sphérique (c'est-à-dire lorsque tous les mots du code ont la même puissance).
Deux paramètres interviennent : la longueur N du code et le taux d’émission R.
        Il serait trop long d’exposer dans le détail cette approche (cf. Bibliographie [1]).
Contentons-nous d’en extraire les aboutissants.
        Notons Q(Ω) (de façon équivalente Q(θ)) la probabilité qu’un mot de code situé
sur l’axe d’un cône d’angle solide Ω =Ω(θ) (correspondant à la région de Voronoï du
code) soit déplacé par le bruit à l’extérieur de ce cône. Soit M le nombre de mots du code
(M=2 NR). θ0 est tel que Ω (θ0) = ΩN/N avec ΩN=∑ Ωc où Ωc désigne l’angle solide de la
région de Voronoï d’un mot de code c.
        La probabilité d’erreur par mot vérifie alors l’encadrement suivant :
                                                       
                                                    M 0
                                                    N 
                           Q( 0 )  Pe  Q( 0 )        ( )dQ( )
                                                        0
        Cette formule n’est pas très explicite mais des algorithmes de calcul performants
permettent toutefois de l’évaluer de façon très satisfaisante.


                                                                                         22
                   5. Synthèse

        Le théorème fondamental du codage de canal peut être considéré comme le
résultat le plus important de la théorie de l’information, en lui-même et pour ses
conséquences. C’est un résultat très surprenant : affirmer l’existence d’une transmission
absolument sûre à travers un canal bruyant va à l’encontre du bon sens ! La possibilité
d’accéder à la perfection a conduit à de nombreuses recherches puisque la démonstration
de Shannon, si elle garantit l’existence d’un code aussi bon que voulu, se base sur des
codes aléatoires et n’indique donc aucunement la façon de l’obtenir.




                                                                                      23
             B. Mise en oeuvre
        Observons la façon dont nous avons implémenté l’algorithme des turbo-codes - ce
qui a constitué le cœur de notre travail- et les résultats auxquels nous parvenons.

                    1. Implémentation des turbo-codes.

       Tous les fichiers que nous avons conçus sont présentés dans l’annexe B.
Décortiquons la façon dont nous avons procédé.

            Le codeur convolutif

        Conformément à la modélisation choisie, nous avons commencé par implémenter
le codeur convolutif systématique (cf. Fig. 5). Nous constatons que la sortie présente un
bloc d’information qui est le bloc d’entrée puisque le codeur est systématique, et un bloc
de redondance, calculés bit-à bit par :
    v0=u
    v1=d(t-1)+u
puisque les additions se font dans Z/2Z.
Nous constatons qu’à première vue la taille de la mémoire aurait pu être réduite de 2 à 1
bit puisque d(t-2) n’apparaît pas en sortie du codeur.
        Ce codeur se base sur plusieurs fonctions annexes qui permettent de calculer l’état
de la mémoire ou de la sortie du codeur après réception d’un bit ou d’un bloc de bits.
A la sortie du codeur les bits 1 et 0 sont modulés en -1 et 1.

            Décodage d’un code convolutif à l’aide de MAP

         Nous nous sommes ensuite attachés à effectuer le décodage convolutif à l’aide de
l’algorithme MAP. Comme nous l’avons déjà mentionné, cette partie est de loin la plus
délicate : aux difficultés inhérentes à l’algorithme s’ajoute celles propres à Matlab et qui
sont principalement d’ordre numérique.
         En conservant des notations cohérentes, nous avons ainsi obtenu les fonctions
gamma, alpha, beta, sigma et lambda. L’algorithme se basant sur des maxima de
vraisemblances, nous devons par ailleurs évaluer l’état initial de la mémoire connaissant
les bits reçus. Dans toutes ces fonctions l1 désigne l’état de la mémoire dont on part pour
aboutir grâce au bit d’entrée i à l’état l, sig désigne la variance du bruit, y le vecteur reçu,
à savoir le bit d’information et le bit de redondance associé au bit i, et t le temps, c’est-à-
dire l’indice dans le bloc reçu.

       Les problèmes numériques rencontrés alors imposent de normaliser les fonctions
alpha et beta et de multiplier leur valeur initiale afin de compenser l’exponentielle (les
valeurs sont étonnantes : nous avons typiquement utilisé un facteur multiplicatif de
10^30 !)




                                                                                             24
       Enfin n’oublions pas de forcer la mémoire à retourner à l’état (0 0) : il convient
pour cela d’ajouter des bits à la fin du mot d’entrée (deux bits ajoutés dans le cas d’une
mémoire de taille 2).
       L’utilisation de ce décodage convolutif se fait en comparant l’entrée au mot
décodé, après avoir pris la peine d’introduire un bruit gaussien blanc.

                                                                                      Fonctions Matlab
            Décodage itératif                                                        correspondantes

       C’est ici que se posent de façon cruciale les limitations numériques,          Perm(2)
puisque l’itération modifie les probabilités et conduit rapidement à des              inv_perm(2)
valeurs extrêmes.                                                                     alpha
       L’entrelacement se fait grâce à une matrice de permutation. Celle-ci           beta
et son inverse apparaissent aussi bien dans l’implémentation du codeur                gamma
convolutif global (de rendement 1/3 puisque les deux sont systématiques),             sigma
que dans l’intervention de l’information extrinsèque.                                 lambda
                                                                                      beta_normalise
       En modifiant les probabilités à chaque itération, (ce qui influe sur           alpha_normalise
gamma et donc sur toutes les fonctions qui en dépendent) notre algorithme
permet alors de comparer l’entrée à la sortie après décodage itératif.                verificationTurbo1


       Il ne faut pas se méprendre sur l’apparente simplicité d’une telle structure ! Les
turbo-codes mettent en jeu des interactions complexes et la difficulté ne réside pas
seulement dans la multiplicité des notations employées !

                    2. Exploitation

        Qu’obtenons-nous concrètement ? Dans quelle mesure cet algorithme s’avère-t-il
efficace ? Quelle est sa sensibilité vis-à-vis du bruit affectant le canal ?
        Si les résultats obtenus semblent modestes, ils sont néanmoins fort satisfaisants :
nous avons commencé par tester notre algorithme sur de petits blocs de codage en faisant
un petit nombre d’itérations, pour différents niveaux de bruit. Il convient de noter dès à
présent que l’itération n’est possible que si les probabilités ne deviennent pas trop petites :
il faut donc choisir un bruit de variance σ supérieure à 0.2. Les limitations sont alors
essentiellement liées au temps de calcul.




                                                                                           25
verificationTurbo(0.3,[1 1 0 0])

Itération   Résultat                   Remarques :
0(entrée)   1    1     0   0   0   1
1           1    0     0   0   1   1   2 erreurs
2           1    1     0   0   0   1   correct
                                       Warning: Log of
3           1    1     1   0   0   0   zero.


verificationTurbo(1.5,[1 0 1 0])

Itération   Résultat                   Remarques
0(entrée)    1   0     1   0   1   0
1            1   1     1   1   1   1   3 erreurs
2            1   1     1   1   1   1   3 erreurs
3            1   0     1   1   1   1   2 erreurs



verificationTurbo(1.5,[1 0 1 0])

Itération   Résultat                   Remarques
0(entrée)   1    0     1   0   1   0
1           0    1     0   0   0   1   5 erreurs
2           0    1     1   0   0   0   3 erreurs
3           1    1     1   1   0   0   3 erreurs
4           1    0     1   1   1   0   1 erreur
                                       Probabilités égalées à
5           0    1     1   1   0   0   0
6           0    0     1   0   0   0


verificationTurbo(1.5,[1 1 1 0])

Itération   Résultat                   Remarques
0(entrée)   1    1     1   0   0   0
1           1    1     0   1   0   1   3 erreurs
2           1    1     1   0   0   0   3 erreurs
3           1    1     1   1   0   0   1 erreur




                                                                26
        Pour évaluer les performances des turbo-codes, il faut chercher à déterminer le
taux d’erreur en fonction de la variance σ du bruit introduit ou plus précisément en
fonction de 1/√σ puisque c’est en réalité le rapport signal-sur-bruit qui nous intéresse ici
(dans notre cas la puissance du signal vaut 1 puisque le canal est choisi gaussien). Une
étude statistique s’impose donc.
        L’utilisation de la fonction statistique.m permet de compter le nombre d’erreurs
sur le mot déterminé par le turbo-décodeur en sortie, par rapport à un mot d’entrée de
taille choisie, formés de bits générés aléatoirement, et ce pour un grand nombre de mots
(nous l’avons utilisée avec 50 mots aléatoires). La valeur du bruit est également choisie.
        Voici la forme (laconique !) que prennent les résultats :




        Nous avons typiquement après une itération du turbo-code, 9 erreurs parmi les
50*4 =200 bits d’entrée, soit un taux d’erreur de 4,5 % pour un bruit σ de 0.2.
        Cette première application ne permet bien sûr pas d’obtenir une évaluation des
performances mais elle montre que celle-ci est faisable, à condition de fixer dans
verificationTurbo1 le nombre d’itérations voulues.




                                                                                         27
             C. Pour aller plus loin…
        Notre projet nous a permis de découvrir le vaste monde des codes correcteurs
d’erreurs et nous avons réussi après de nombreuses difficultés à implémenter un
algorithme de turbo-codes qui fonctionne ! Ces difficultés ont d’ailleurs été fructueuses :
ce sont elles qui nous ont permis de rentrer précisément au cœur de l’algorithme.
        Un bémol vient néanmoins modérer notre satisfaction : la lenteur de l’algorithme
ne nous a pas permis d’établir une étude statistique suffisamment poussée pour être
véritablement validée. Comment améliorer notre algorithme ?

        Une solution pourrait être d’en chercher une variante, comme le MAP
logarithmique qui permet de s’affranchir de l’exponentielle de la fonction gamma et donc
d’éviter certains problèmes numériques, ou le max-log-MAP, qui est une approximation
du précédent.

         Il peut également être intéressant de comparer les turbo-codes à d’autres codes
composites (par concaténation, intersection ou produit). Il faudrait pour cela envisager
une nouvelle recomposition des sorties. Malheureusement, le temps nous a fait défaut
pour poursuivre ce type de comparaison : nous ne pouvons que faire confiance à la
littérature assurant la suprématie des turbo-codes, également parmi les codes composites !

      Enfin, on peut imaginer un turbo-code qui serait basé sur la mise en parallèle de N
décodeurs convolutifs : la complexité devient alors telle que cette implémentation parait
impossible à réaliser dès que N est grand. Mais pourquoi ne pas essayer avec N=3, par
exemple ?

       Les possibilités sont donc multiples : si l’on s’approche beaucoup de la limite de
Shannon avec les turbo-codes, celle-ci n’est pas atteinte. Ce mince écart laisse la porte
ouverte aux recherches futures !




                                                                                        28
                                   Conclusion
        Les codes correcteurs d’erreurs englobent des concepts très divers. Des codes
linéaires aux turbo-codes, la mise en avant de différences structurelles permet de mieux
comprendre toutes les difficultés liées au décodage, qui rendent l’approche de la limite de
Shannon à la fois surprenante et inespérée.
        La distribution de distances d’un turbo-code ressemble en effet à celle d’un code
aléatoire. Par ailleurs, la comparaison de ces performances avec celles de code optimaux
de même longueur et de même rendement montre bien toute l’amélioration acquise lors
de la transmission par turbo-code.
        Le rôle majeur d’un code correcteur fiable au sein d’une chaîne de transmission
nous engage à poursuivre les recherches : à peine plus d’un demi-siècle après sa création,
la théorie de l’information nous réserve encore de nombreuses énigmes liées à son
domaine d’origine, les techniques de la communication.




                                                                                        29
ANNEXES

 A.Bibliographie
 B.Programme




                   30
A- BIBLIOGRAPHIE
[1] Thèse de S. VIALLE
 « Construction et analyse de nouvelles structures de codage adaptées au traitement
itératif »

[2] G. BATTAIL
  Théorie de l’information. Application aux techniques de communication

[3] G. COHEN
   J-L. DORNSTETTER
   P. GODLEWSKI
   Codes correcteurs d'erreurs, une introduction au codage algébrique.

[4] R. HAMMING
   Coding and Information theory

[5] B. VUCETIC
    J. YUAN
   Turbo-codes : Principles and Applications

[6] W.E. RYAN
    A Tubo Code Tutorial

[7] P. CSILLAG
    Introduction aux codes correcteurs




                                                                                      31
B- PROGRAMME
         1.     Hamming

hamming.m
distance.m
histo.m


         2.     Codeur/Décodeur convolutif : l’algorithme MAP

codeur.m
convo.mem
convo_sortie.m
convo_sortie_bloc.m
convo_mem.m
alpha.m
beta.m
gamma.m
sigma.m
lambda.m
avant.m
invmod.m
beta_normalise.m
alpha_normalise.m
completeEntree.m
verification

         3.     Décodage itératif : le turbo-code

perm.m
inv_perm.m
perm2.m
inv_perm2.m
alpha.m
beta.m
gamma.m
sigma.m
lambda.m
beta_normalise.m
alpha_normalise.m
verificationTurbo1.m

statistique.m




                                                                32

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:15
posted:6/13/2011
language:French
pages:32