TCC

Timisoara 18-20 mars 2003
Turbo codes
(convolutifs)
Timisoara
18-20 mars, 2003
Michel Jézéquel,
Claude Berrou et Catherine Douillard ENST Bretagne
Michel.Jezequel@enst-bretagne.fr
Plan
1. Les codes correcteurs d’erreurs 4. Turbo codes
1. Généralités • La philosophie
2. Limites Théoriques • Les différents schémas
2. Les codes convolutifs • Turbo décodage
1. Les codes classiques 5. Permutation
2. Les codes RSC
• Régulière
3. Poinçonnage et terminaison
• Aléatoire
3. Les algorithmes SISO • Pseudo-aléatoire
1. SOVA
6. Turbo codes duo-binaires
2. MAP
• Principe et avantages
3. SUB-MAP
• Performance
7. Conclusions et perspectives
ENST Bretagne 1
Chapitre 1
Les codes correcteurs d’erreurs
Une chaîne de transmission

Canal de transmission
Source Di Modulation et
numérique Codage filtrage
Milieu
de
transmission
Destinataire Di Décodage Filtrage et

démodulation
ENST Bretagne 2
Codes correcteur d’erreurs Généralités
Différentes familles de codage
Codage de source : réduire le débit d’information

Codage de canal : ajouter de la redondance
Sécurité, cryptographie
Authentification, watermarking
CDMA
...

Séquence d’information à transmettre : [d1 d2 ... di ... dk]
Addition d’une redondance linéaire : [r1 r2 ... rj ... rn-k]
(le code est dit systématique)
rj = ∑ pi, j d i mod 2 (pi,j = 0 ou 1)

i =1...k
p1,1 p1,n-k
Forme matricielle
[r1 r2 ... rj ... rn-k] = [d1 d2 ... di ... dk] pk,1 pk,n-k
ENST Bretagne 3
[d1 d2 ... di ... dk][r1 r2 ... rj ... rn-k] : mot de code
Rendement de codage : R =k/n
Code (n , k , dmin)
de distance minimale dmin
Le code étant linéaire, la séquence « tout zéro »

peut être prise comme référence
La distance dmin est le nombre minimum de « 1 »

des mots de code [d1 d2 ... di ... dk] [r1 r2 ... rj ... rn-k]
si [d1 d2 ... di ... dk] ≠ « tout zéro »
Un bon code est un code avec une grande distance dmin

mais ce n’est pas tout :
• il doit pouvoir être décodé !
(contre-exemple : les codes aléatoires)
• il doit exister un décodeur permettant d’utiliser
la capacité de correction du code
Exemple :
ENST Bretagne 4
MDP4, canal gaussien, taux d’erreurs cible : 10-8

TEB
5
10-1 1 E
5
non codé erfc ( b )
2 N0
10-2 avec
5 ∞
2
10-3
mauvaise
erfc( x) = ∫ exp(−t 2 )dt
π t=x
5
convergence, gain
10-4 asymptotique élevé
5
10-5
5
10-6
Bonne
5
convergence, faible
10-7 gain asymptotique
5
Eb/N0 (dB)
10-8
0 1 2 3 4 5 6 7 8 9 10 11 12
Ga = 10 log (R.dmin)
Limite théorique
(R=1/2, 188 octets) dmin > 25
distinction traditionnelle mais inappropriée entre
Les codes en « bloc » : Hamming, Golay, BCH, Reed-Solomon, ...
Les codes « convolutifs »
Une distinction plus naturelle prendrait en compte l’algorithme

de décodage, en particulier :
• hard – dur (algébrique)
• soft – souple (probabiliste)
Exemple :
ENST Bretagne 5

Comment transformer un code de Hamming parfait (8,4,4)
Etat
000
X=0, Y=0 001
X=0, Y=1 010
X=1, Y=0
011
Xi 100
X=1, Y=1 101
110
111
di
(donnée) s1 s2 s3
Yi
di Hamming Yi di Hamming Yi
étendu étendu
0000 0000 0000 1111 1111 1111
0001 0111 1011 1110 1000 0100
0010 1101 0111 1101 0010 1000
0011 1010 1100 1100 0101 0011
0100 1110 1110 1011 0001 0001
0101 1001 0101 1010 0110 1010
0110 0011 1001 1001 1100 0110
0111 0100 0010 1000 1011 1101
(autre exemple : le code de Golay étendu (24, 12, 8) peut être représenté par un treillis circulaire 16 états)

Code aléatoire (Shannon)
Information Redondance
1 .... i ... k 1 .... j ... n- k
10000000 ... 00000000000000 0010010111...0110000100
01000000 ... 00000000000000 1001110100...0011101001
00100000 ... 000000000000001111010001...0001111011
.............
00000000 ... 00000000000001 1010101110...1010111101
Σ
10010110 ... 100011000101010011101011...1110010100
dmin ≈ (n-k)/4 = k.(1-R)/4R où R = k/n
ENST Bretagne 6
dmin ≈ (n-k)/4 = k.(1-R)/4R où R = k/n
Exemple : k = 1504 (MPEG), R = 1/2

dmin ≈ 375 !!
(un code convolutif 64 états

a une distance dmin = 10 pour R = 1/2 !!)
Mais non décodable en pratique ...

(sur la base d’un code aléatoire)
Limite (Eb/N0, dB) (k infini) [Shannon, Proakis]

3
2
canal
à entrée
binaire
canal
continu
0 R=5/6 R=4/5 R=3/4 R=2/3 R=1/2

extension
0 1 2 3
de la bande (dB)
ENST Bretagne 7
∆ Eb/N0 (dB) (taux d’erreurs paquets = 10-4)
100 101 102 103 104 105 Taille du bloc (k)
Correction à prendre en compte pour des bocks de taille k :

[S. Dolinar, D. Divsalar and F. Pollara, "Code performance as a
function of block size", TMO progress report 42-133, JPL, NASA].
Calcul des limites

Un outil de calcul des limites théoriques a
été développé par un étudiant en thèse il est
disponible à l’adresse :
http://www-elec.enst-bretagne.fr/~emaury/Capa_UI.html
ENST Bretagne 8
Chapitre 2
Codes convolutifs
Plan
• Codes convolutifs classiques
– Représentations
– Propriétés
• Codes convolutifs systématiques
• Codes convolutifs récursifs systématiques
• Rendement de codage et poinçonnage
• Fermeture de treillis
ENST Bretagne 9
Codes convolutifs
Registre à décalage (mb étages)
b bits b b
d’information
1 2 3 K=m+1
mot de code
fonctions linéaires n symboles
K= longueur de contrainte
R=b/n (rendement de codage)
Code convolutif classique
di di-1 di-2
D D Elias, 1954
Mémoire du code : ν = 2
yi Longueur de contrainte :
K=ν+1=3
xi
R = 1/2
di di-1 di-2
D D Forney, 1970
yi
ENST Bretagne 10
Exemple
xi
• K=3
di di-1 di-2 • b=1
D D
• n=2
yi •R=b/n=1/2
xi
Exemple
di di-1 di-2
D D
yi
di
state 0 0 2 1 0 0 2 3 1 0 0 0 0 0
xi
yi
ENST Bretagne 11
Générateurs
2
xi =∑g1jdi− j
j =0
di di-1 di-2
D D
2
yi =∑g 2j di− j
j =0
g1=[g01,g11,g12]=[1,0,1] G1(D)=g01+ g11D+ g12D2
g 2=[g02,g12,g22]=[1,1,1] G2(D)=g02+ g12D+ g22D2
Générateurs sous la forme octale : (5,7)
Représentation des codes

convolutifs
Trois formes :
• arbre
• machine d’état
• treillis
ENST Bretagne 12
xi
arbre
di di-1 di-2
D D
xi yi
yi
00
00
00 11
0 01
11
10
11
01
1 11 00
10
10
01
Machine xi
d’états di D di-1 D di-2
xi yi
di =0
xi yi yi
di =1
10
11 10
00 01
00 01 00 11
11 10
01
ENST Bretagne 13
xi
Treillis
di di-1 di-2
xi yi D D
di =0
xi yi yi
di =1
00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
10 10 10 10
01 01 01
11
Treillis xi yi
di =0
xi yi
di =1
xi
00
di di-1 di-2 00
D D 11 11
01 00
yi 01
10 10
10
01
11
ENST Bretagne 14
Distance
(K=3) (5,7) -> distance libre = dlibre=5
00 00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
Poids=P=1 10 10 10 10
01 01 01
11
Distance de
Hamming 0 + 2 + 1 + 2 + 0 + 0 =5
Distance
00 00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
Poids =P=2 10 10 10 10
01 01 01
11
Distance de
Hamming 0 + 2 + 1 + 1 + 2 + 0 =6
ENST Bretagne 15
Distance
00 00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
Poids =P=2
=P=2+2=4 10 10 10 10
01 01 01
11
Distance de
Hamming 0 + 2 + 1 + 0 + 1 + 2 =6
Distance
• Longueur de contrainte : K = 3
• Générateurs (5,7)
– Distance libre minimale = 5
– Spectre des distances:
• Distance = 5 (1 cas), P=1
• ….
ENST Bretagne 16
Codes systématiques
xi xi=di
di di D D
D D
yi yi
NSC SC
(Non Systematic Convolutional) (Systematic Convolutional)
Exemple : K=3, b=1, n=2, R=b/n=1/2
(machine
x
d’états)
i xi=di
di D D di D D
NSC yi SC yi
10 10 10 10
11 01 11 11
00 00
00 00 11 00 10 11
01 01
11 10 01 00
01 xi yi 01
di =0
xi yi
di =1
ENST Bretagne 17
Codes systématiques (treillis)

xi xi=di
di D D di D D
NSC yi SC yi
00 00
00 00
11 11 11 01
01 00 01 10
01 01
10 10 xi yi 10 00
di =0
10 10
01 xi yi 01
11 di =1 11
Codes systématiques(distance)
00 00
00
00 11 01 00
01
01 11 11
01
01
10
00
Poids=P=1
Poids=P=1+2=3 10
11
Distance NSC 0 + 2 + 1 + 2 + 0 =5
libre
minimale SC 0 + 2 + 1 + 1 + 0 =4
0 + 2 + 1 + 0 + 1 =4
ENST Bretagne 18
Spectre des distances

n P SC n P NSC
d=4 2 3 0 0 n = nombre de cas
d=5 0 0 1 1 P = poids
d=6 5 15 2 4
d=7 0 0 4 12
d=8 13 58 8 32
d=9 0 0 16 80
d=10 34 201 32 192
d=11 0 0 64 448
d=12 89 655 128 1024
d=13 0 0 256 2304
d=14 233 2052 512 5120
(Taux d’Erreurs Binaire)
TEB
1,E+00
1,E-01
1,E-02
1,E-03
Non codé
1,E-04 SC
NSC
1,E-05
1,E-06
1,E-07
1,E-08 Eb/N0
0 2 4 6 8 10 12
ENST Bretagne 19
Interprétation des résultats
Codes convolutifs
Existe-t-il un code convolutif combinant :
• les distances minimales des codes non systématiques

• le bon comportement à faible rapport signal/bruit
????
La réponse est : OUI
ENST Bretagne 20
Codes récursifs systématiques

xi
xi
di di D D
D D
[1,(1+D+D2)/(1+D2)] yi
NSC yi
[(1+D2),(1+D+D2)]
xi
di
Exemple: D D
K=3,
b=1, n=2,
R=b/n=1/2 [1,(1+D2)/(1+D+D2)] yi

(treillis)
xi xi
di
di D D D D
RSC yi
NSC yi
00 00
00 00
11 11 11 11
01 01 00
00
01 01
10 10 xi yi 10 10
di =0
10 10
01 xi yi 01
11 di =1 11
ENST Bretagne 21
Codes Récursifs systématiques

(machine
x
d’états)
i xi
di di
D D D D
yi yi
NSC RSC
10 10 10 10
11 01 11 01
00 00
00 00 11 00 00 11
01 01
11 10 11 10
01 xi yi 01
di =0
xi yi
di =1
Codes récursifs systématiques(distance)

00 00 00 00 00
00
11 11 11 11 11 11
01 00 00
01 01 01
10 01 01
Poids=P=2 10 10 10
11 10 10
Distance
libre
minimale RSC 0 + 2 + 1 + 2 + 0 =5
ENST Bretagne 22
Spectre des distances

n P NSC n P RSC
d=5 1 1 1 2
d=6 2 4 2 6
d=7 4 12 4 14
d=8 8 32 8 32 n = nombre de cas
d=9 16 80 16 72 P = poids
d=10 32 192 32 160
d=11 64 448 64 352
d=12 128 1024 128 768
d=13 256 2304 256 1664
d=14 512 5120 512 3584
d=15 1024 11264 1024 7680

(Taux d’Erreurs Binaires)
TEB
1,E+00
1,E-01
1,E-02
1,E-03 Non codé
SC
1,E-04
NSC
1,E-05 RSC
1,E-06
1,E-07
1,E-08 Eb/N0
0 2 4 6 8 10 12
ENST Bretagne 23
Rendement de codage et poinçonnage

xi
Multiplexage &
di Sortie
Poinçonnage
D D
yi
R=1/2 xi yi xi+1 yi+1 xi+2 yi+2 xi+3 yi+3 xi+4 yi+4
R=2/3 xi xi+1 yi+1 xi+2 xi+3 yi+3 xi+4 xi+5 yi+5 xi+6
R=3/4 xi xi+1 xi+2 yi+2 xi+3 xi+4 xi+5 yi+5 xi+6 xi+7
R=3/5 xi xi+1 yi+1 xi+2 yi+2 xi+3 xi+4 yi+4 xi+5 yi+5
Codes poinçonnés
(Taux d’Erreurs Binaire)
TEB Rendement de codage =3/4
1,E+00
1,E-01
1,E-02
1,E-03
Non codé
1,E-04 NSC
RSC
1,E-05
1,E-06
1,E-07
1,E-08 Eb/N0
0 2 4 6 8 10 12
ENST Bretagne 24
d X
Plus le registre Générateur

pseudo
est grand, 1 2 ν aléatoire
meilleur est le
code convolutif Y
0.09 0.07 0.07 0.06
0.08 0.06 0.06 0.05
0.07 0.05 0.05 0.04
0.06 0.04 0.04 0.03
0.05 0.03 0.02

0.03
TEB
0.04 0.02
E b/N 0
0.02 0.01
-0.2 0.2 0.6 0.8 1.2 1.6 1.2 1.6 2.0 1.6 2.0 2.4
R = 1/2 R = 2/3 R = 3/4 R = 4/5
0.06 0.06 0.05
ν =2 ν =4
0.05 0.05 0.04
ν =6 ν =8
0.04 0.04 0.03
0.03 0.03 0.02

Limite de Shannon
(canal gaussien
0.02 0.02 0.01
entrée binaire)
0.01 0.01 0.00

1.6 2.0 2.4 1.8 2.2 2.6 2.2 2.6 3.0
R = 5/6 R = 6/7 R = 7/8
Fermeture de treillis
xi 00
di =0
di 01
D 0 D 0 di =1
10
Initialisation yi
11
00
01
10
11
0 1 2 3 n-1 n
Bloc de k bits, 2k bits transmis → R=1/2
ENST Bretagne 25
xi 00
di =0
di 01
D 0 D 0 di =1
10
Initialisation yi
11
00
01 Transmission
de l’état final
10 (K-1 bits)
11
0 1 2 3 n-1 n
Bloc de k bits, 2k+K-1 bits transmis → R=k/(2k+K-1)
xi xi
di 0
di D 0 D 0 D D Insertion
de
tail bits
Initialisation yi yi
00 00
01
10
11
0 1 2 3 n-1 n
Bloc de k bits, 2k+2(K-1) bits transmis → R=k/2(k+K-1)
ENST Bretagne 26
Codes convolutifs circulaires
di
D D D
yi
000
001
010
011
100
101
110
111
0 1 1 0 1 1 0 1
di
D D D
yi
000
001
010
011
100
101
110
111
ENST Bretagne 27
Calcul de l’état circulation
A s1 s2 s3
B
S i = G.S i −1 + X i −1 Mod 2 (1)
 s1,i   Ai + Bi  1 0 1
 
Si =  s2,i  ; Xi =  Bi  ; G = 1 0 0
   
 s3,i   Bi  0 1 0
La période L du générateur est telle que G L = I (Identité)
En partant de (1), nous pouvons en déduire :

S i = G.S i −1 + X i −1
S i −1 = G.S i − 2 + X i − 2
S1 = G.S 0 + X 0
Après codage d’une séquence de longueur k :
S k = G k .S 0 + ∑ G k − p X p −1 (2)
p =1...k
Si I + G k est inversible, il existe un Sc tel que S c = S k = S0 .

Sc est appelé état de circulation.
−1
Sc = I + G k . ∑ G k-p X p −1 (3)
p =1...k
ENST Bretagne 28
En pratique :
Le codeur est initialisé à S0 = 0 ; la séquence de longueur k est codée donnant, d’après (2) :
Sk 0 = ∑ G k − p X p −1
p =1...k
(3) devient :
−1
Sc = I + G k . Sk 0 (4)
La correspondance entre S et S k 0est mémorisée dans une petite fonction combinatoire

(3 bits en entrée, 3 bits en sortie).

- Initialisation à l’état tout zéro
• Pré-codage : - Codage de la séquence d’information
- Détermination de l’état de circulation
• Initialisation à l’état de circulation
• Codage
000
001
010
011
100
101
110
111 0 1 1 0 1 1 0 1
ENST Bretagne 29

(comment décoder ?)
Prologue
• “tail bits”
rendement de codage
☺ facile à implémenter
• codes circulaires (“tail biting” NSC)
pré-codage
☺ rendement de codage
ENST Bretagne 30
Chapitre 3
Algorithmes de décodage à
entrée et sortie pondérées ou
SISO (Soft-In Soft-Out)
Codes convolutifs algorithmes SISO
Le turbo-décodage utilise des décodeurs élémentaires à entrées

et sorties pondérées.
Deux familles d’algorithmes de décodage SISO pour

les codes convolutifs :
• Les algorithmes basés sur l’algorithme de
Viterbi
• L’algorithme MAP (Maximum A Posteriori)
et ses approximations
ENST Bretagne 31
Illustration avec le code suivant :

00 (0) 00 (0)
Xi
01 (1) 01 (1)
10 (2) 10 (2)
di D D
11 (3) 11 (3)
i-1 i
di = 0
Yi
di = 1

Modèle de la chaîne de transmission
c1k r1k
source {X 1,L, X k } {x1,L, xk }
destinataire
Codeur Canal decodeur
{d1,L, d k }
convolutif gaussien SISO
{dˆ1,L, dˆk }
{Y1 ,L, Yk } {y1,L, yk }
Les symboles transmis Xi et Yi, i = 1…k prennent leurs

valeurs dans {-1,+1}
c1k : séquence codée et modulée (MDP2)
c1k = {c1, L , ck } avec ci = ( X i , Yi )
r1k : séquence bruitée reçue

r1k = {r1 , L , rk } avec ri = ( xi , yi ), xi = X i + nix , yi = Yi + niy
ENST Bretagne 32
Codes convolutifs algorithmes SISO : SOVA
Application de l’algorithme de Viterbi
• L’algorithme de Viterbi est utilisé pour chercher le chemin à

vraisemblance maximale dans le diagramme en treillis.
• Critère de décodage : maximiser Pr{R1k|C1k }
k
Pr{R1k |C1k } = ∏ Pr{Ri |Ci }
i =1
k 1 
2  ( xi − X i )2   ( yi − Yi )2 
= ∏   exp −  exp− 
i =1 2πσ 
 2 σ 2   2 σ 2 
   
k k
• Maximiser Pr{R1 |C1 }
k
[ 2
minimiser ∑ ( xi − X i ) + ( yi − Yi )
i =1
2
]
• A chaque instant i, calcul de la métrique de branche Lxi

associée à chaque chemin x dans le treillis, c-a-d de la
distance euclidienne entre le symbole reçu ri et le symbole
codé ci associé au chemin x.
Lxi = ( xi − X i ) 2 + ( yi − Yi ) 2
• Calcul (récursif) de la métrique de chemin M ix associée au

chemin x. i
M ix = ∑ Lxj = M ix−1 + Lxi
j =1
ENST Bretagne 33

(Xi, Yi)
Exemple 0 x (-1,-1) 0 Lxi = L0i ,0 = ( x i +1) 2 + ( y i +1) 2
(1,1)
(1,1) M ix = M i0,0 = ( x i +1) 2 + ( y i +1) 2 + M ix−1
1 1
(-1,-1)
(1,-1)
x Lxi = L2i ,1 = ( x i −1) 2 + ( y i +1) 2
2 2
M ix = M i2,1 = ( x i −1) 2 + ( y i +1) 2 + M ix−1
(-1,1) (-1,1)
3 3
(1,-1)
i-1 i
di = 0
di = 1

• Pour chaque nœud s, recherche du chemin à métrique minimale
(le survivant) et mémorisation de la métrique associée M is (s )
avec la valeur de di.
(Xi, Yi)
M i0,0
0 (-1,-1) 0 ⇒ M is (0)
(1,1) M i1,0
(1,1)
M i3,1 s
1
(-1,-1)
1 M i2,1 ⇒ M i (1)
(1,-1) M i1, 2 ⇒ M s (2)
2 2 i
M i0, 2
(-1,1) (-1,1)
M i2, 3
3 3 ⇒ M is (3)
(1,-1) M i3, 3
i-1 i
ENST Bretagne 34

• A l’instant i, sélection du nœud à métrique minimale,
• Remontée le long du chemin survivant (pour profiter du
futur).
• A l’instant i-L, la décision dˆi − L est la valeur binaire stockée
dans le nœud appartenant au chemin survivant.
0
chemin survivant
2
dˆi − L M is (2) = min ( M is (s))
s = 0,..., 3
3
i−L i − L −1 i − L − 2 i−2 i −1 i
• L’algorithme de Viterbi ne peut pas être utilisé pour le

décodage itératif !
Il produit des décisions binaires
Il doit être modifié pour produire des décisions pondérées
=> SOVA (Soft-Output Viterbi Algorithm)
ENST Bretagne 35
• Une première estimation de la fiabilité ou du poids de la

décision peut être donnée par la différence entre les
métriques du chemin survivant et de l’autre chemin ( le
chemin concurrent):
wi = ∆M i (s) = M ic (s) − M is (s) ≥ 0
• Mais cette estimation doit être affinée!
=> algorithmes de révision des poids
0
Si ∆M i −1 (1) >> 0
1
et ∆M i (2) = 0
2
=> le poids à l’instant i-1
3 doit être revu à la baisse
i−L i − L −1 i − L − 2 i−2 i −1 i
survivant concurrent
Codes convolutifs algorithmes SISO : MAP
L’algorithme MAP (Maximum A Posteriori)
• Encore appelé algorithme BCJR (Bahl, Cocke, Jelinek,

Raviv), algorithme APP (A Posteriori Probability), ou
algorithme Aller-Retour (Backward-Forward)
• But de l’algorithme : calcul du Logarithme de Rapport de
Vraisemblance (LRV) relative à la donnée di
Pr{d i = 1 r1k } signe ⇒ décision binaire

Λ (d i ) = ln
Pr{d i = 0 r1k } valeur absolue ⇒ fiabilité
r1k désigne la séquence bruitée reçue

r1k = {r1 , L , rk } avec ri = ( xi , yi )
ENST Bretagne 36
• Chaque APP (A Posteriori Probability) Pr{d i = j r1k } est

estimée par le biais des probabilités conjointes
Pr{S i −1 = s′, S i = s, r1k }
S i : état du codeur à l’instant i
∑ Pr{Si −1 = s′, Si = s, r1k }
(s′,s )∈Ti j
Pr{di = j r1k } = j = 0,1
Pr{r1k }
Ti j : ensemble des transitions du treillis 0 0
associées à di = j
1 1
∑ Pr{Si −1 = s′, Si = s, r1k }

2 2
(s′,s )∈Ti1
=> Λ (d i ) = ln
∑ Pr0 {Si −1 = s′, Si = s, r1k } 3 3
(s′,s )∈Ti i-1 i
• Principe de l’algorithme MAP : traiter séparément les

données relatives aux instants compris entre 1 et i et celles
relatives aux instants compris entre i +1 et k.
=> Introduction des probabilités « aller » (forward)
α i (s), i = 1L k et « retour » (backward) βi (s), i = 1L k
relatives aux états du treillis
α i (s) = Pr{S i = s, r1i }

βi (s) = Pr{rik+1 S i = s}
=> et des probabilités relatives aux transitions du treillis
γ i (s′, s) = Pr{S i = s, ri S i −1 = s′}
ENST Bretagne 37
• On peut montrer que
Pr{S i −1 = s′, S i = s, r1k } = α i −1 (s′) γ i (s′, s)βi (s)
∑ α1i −1 (s′) γ i (s′, s)βi (s)

(s′,s )∈Ti
=> Λ (di ) = ln
∑ α i −1 (s′) γ i (s′, s)βi (s)
(s′,s )∈Ti0
Exemple 0 0
k 1 1
* Pr{Si −1 = 1, Si = 2, r1 } = αi −1 (1) γ i (1,2)βi (2)
k 2 2
* Pr{Si −1 = 0, Si = 2, r1 } = α i −1 (0) γ i (0,2)βi (2)
3 3
i-1 i
di = 0
di = 1
α i −1 (1) γ i (1,0)βi (0) + α i −1 (2) γ i (2,1)βi (1)
Λ (d i ) = ln L
α i −1 (0) γ i (0,0)βi (0) + α i −1 (3) γ i (3,1)βi (1)
+ α i −1 (0) γ i (0,2)βi (2) + α i −1 (3) γ i (3,3)βi (3)
L
+ α i −1 (1) γ i (1,2)βi (2) + α i −1 ( 2) γ i (2,3)βi (3)
ENST Bretagne 38
• Récursion aller : calcul de α i (s)
2ν −1
α i (s) = ∑ αi −1 (s′) γ i (s′, s) (ν = mémoire du code)
s′= 0
Initialisation: si s0 est l’état initial du α 0 (s 0 ) = 1

codeur α 0 (s) = 0 ∀s ≠ s 0
NB: pour éviter les problèmes de précision, α i (s ) peut être

normalisé à chaque étape de calcul (Λ ( d i ) est un rapport)
α i (s)
α′i (s) = ν
2 −1
∑ αi (s' )
s '= 0

α i (0)
Exemple: 0
α i −1 (0)
0
(sans normalisation) α i (1)
1 1
α i −1 (1)
2 2
α i −1 (2) α i +1 (2)
3 3
α i −1 (3)
i −1 i i +1
di ou di +1 = 0
di ou di +1 = 1
* α i (0) = α i −1 (0) γ i (0,0) + α i −1 (1) γ i (1,0)
* α i (1) = α i −1 (3) γ i (3,1) + α i −1 (2) γ i ( 2,1)

α i +1 ( 2) = α i (1) γ i +1 (1,2) + α i (0) γ i +1 (0,2)
*
ENST Bretagne 39
• Récursion retour : calcul de βi (s′)

2ν −1
βi (s′) = ∑ βi +1(s) γ i +1(s′, s)
s =0
Initialisation : si sk est l’état final du codeur
β k (s k ) = 1, β k (s) = 0 ∀s ≠ s k
Si l’état final est inconnu :
1
β k (s) = ∀s
2ν
βi (s)
Normalisation: β′i (s) = ν
2 −1
∑ βi (s' )
s′= 0

βi (0) βi +1 (0)
Exemple: 0 0
(sans normalisation) βi −1 (1) βi +1 (1)
1 1
β i ( 2) βi +1 (2)
2 2
βi +1 (3)
3 3
i −1 i i +1
di ou d i +1 = 0
di ou d i +1 = 1
* βi (0) = βi +1 (0) γ i +1 (0,0) + βi +1 (2) γ i +1 (0,2)

* βi (2) = βi +1 (3) γ i +1 (2,3) + βi +1 (1) γ i +1 (2,1)
* βi −1 (1) = βi (2) γ i (1,2) + βi (0) γ i (1,0)
ENST Bretagne 40

• Calcul des probabilités de branches γ i (s′, s)
S’il n’y a pas de transition entre s' et s dans le treillis.

γ i (s′, s) = 0
sinon
γ i (s′, s) = Pr{d i = j} Pr{ri ci }
si di = j est le bit d’information et ci le symbole codé et modulé

correspondant à la transition s' → s du treillis et ri est le
symbole reçu, à l’instant i .
Pour une transmission sur canal gaussien :
1  ri − ci 2  σ2 : variance du bruit
Pr{ri ci } = exp −  sur le canal
2πσ 2  2σ 2

 

• Calcul des probabilités de branches γ i (s′, s)
1
Si ci = ( X i , Yi ), ri = ( xi , yi ) et Pr{di = 0} = Pr{di = 1} =
2
 2  2
γ i (s′, s) =
1
exp − ( xi − X i )  exp − ( yi − Yi ) 
4πσ2  2σ 2   2σ 2 
 
x  y 
γ i (s′, s) = K exp i2  exp 2i  ( X i = −1, Yi = −1)
σ  σ 
x   y 
γ i (s′, s) = K exp i2  exp − 2i  ( X i = −1, Yi = +1)
σ   σ 
 x  y 
γ i (s′, s) = K exp − i2  exp 2i  ( X i = +1, Yi = −1)
 σ  σ 
 x   y 
γ i (s′, s) = K exp − i2  exp − 2i  ( X i = +1, Yi = +1)
 σ   σ 
Ν. Β. Λ(di) étant un rapport, K peut être omis dans les expressions de αi(s) et βi(s).
ENST Bretagne 41
Codes convolutifs algorithmes SISO : Log-MAP

et Sub-MAP
L’algorithme MAP dans le domaine logarithmique (Log-MAP)
Multiplications => additions

Les exponentielles dans les probas de branches s’éliminent
Additions => ?
Solution 1: Log-MAP
− a −b
ln(e a + eb ) = max(a, b) + ln(1 + e )
Le terme ln(1 + e − a −b ) est pré-calculé et stocké dans une table
☺ Performance MAP
Connaissance de σ requise
Codes convolutifs algorithmes SISO : Sub-MAP
L’algorithme MAP dans le domaine logarithmique (Sub-MAP)
Solution 2: Sub-MAP (Max-Log-MAP)
ln(e a + eb ) ≈ max(a, b)
⇒ Algorithme « Dual Viterbi »
Performance < MAP (qqes dixièmes de dB)

☺ Estimation de σ inutile
ENST Bretagne 42

• Reformulation de Λ(di)
Λ ( d i ) = ln ∑ α i −1 (s′) γ i (s′, s )βi (s) − ln ∑ α i −1 (s′) γ i (s′, s) βi (s)
(s′,s )∈Ti1 (s′,s )∈Ti0
Λ(di ) ≈ max {ln(αi −1 (s′) γ i (s′, s) βi (s) )}

(s′,s )∈Ti1
− max {ln(α i −1 (s′) γ i (s′, s) βi (s) )}
(s′,s )∈Ti0
Métriques de nœuds et de branches :

∆
M iF (s) =− σ 2 ln α i (s) Métrique de nœud aller (forward)
∆
M iB (s) =− σ 2 ln βi (s) Métrique de nœud retour (backward)
∆
mi (s′, s) =− σ 2 ln γ i (s′, s) Métrique de branche

∆ σ2
L’algorithme Sub-MAP calcule Λ ′( d i ) = Λ (di ) :
2
Λ′(d i ) ≈
1
 {
min M iF−1 (s′) + mi (s′, s) + M iB (s)
2 (s′,s )∈Ti0
}
( 
− min M iF−1 (s′) + mi (s′, s) + M iB (s) 
(s′,s )∈Ti1
)

1
Λ′(d i ) ≈  min {M iF−1 (s′) + xi ± yi + M iB (s)}
2 (s′,s )∈Ti0

− min {M iF−1 (s′) − xi ± yi + M iB (s)}
(s′,s )∈Ti1 
ENST Bretagne 43
Exemple:
1
Λ′( d i ) = [min(M iF−1 (0) + mi (0,0) + M iB (0), M iF−1 (3) + mi (3,1) + M iB (1),
2
M iF−1 (1) + mi (1,2) + M iB (2), M iF−1 (2) + mi (2,3) + M iB (3) )
− (
min M iF−1 (1) + mi (1,0) + M iB (0), M iF−1 (2) + mi ( 2,1) + M iB (1),
M iF−1 (0) + mi (0,2) + M iB (2), M iF−1 (3) + mi (3,3) + M iB (3) )]
0 0
1 1
2 2
3 3
i-1 i
M iF (s) et M iB (s) sont calculés récursivement :
M iF (s) ≈ min {M iF−1 (s′) + mi (s′, s)}

s′ = 0L2ν −1
M iF (s) ≈ min {M iF−1 (s′) ± xi ± yi }

s′ = 0L2ν −1
M iB (s′) ≈ min {M iB+1 (s) + mi +1 (s′, s)}

s = 0L2ν −1
M iB (s′) ≈ min {M iB+1 (s) ± xi +1 ± yi +1}

s = 0L2ν −1
ENST Bretagne 44

M iF (0)
Exemple 0 0
M iF−1 (0)
M iF (1)
1 1
M iF−1 (1)
2 2
M iF−1 (2) M iF+1 (2)
3 3
M iF−1 (3)
i −1 i i +1
di ou di +1 = 0
di ou di +1 = 1
* (
Μ iF (0) = min Μ iF−1 (0) + mi (0,0), Μ iF−1 (1) + mi (1,0) )
* Μ iF (1) = min (Μ iF−1 (3) + mi (3,1), Μ iF−1 (2) + mi (2,1) )
* Μ iF+1 (2) = min (Μ iF (1) + mi +1 (1,2), Μ iF (0) + mi +1 (0,2) )
Exemple M iB (0) M iB+1 (0)

0 0
M iB−1 (1) Μ iB+1 (1)
1 1
M iB (2) M iB+1 (2)
2 2
M iB+1 (3)
3 3
i −1 i i +1
di ou di +1 = 0
di ou di +1 = 1
* (
Μ iΒ (0) = min Μ iΒ+1 (0) + mi +1 (0,0), Μ iΒ+1 (2) + mi +1 (0,2) )
* (
Μ iΒ (2) = min Μ iΒ+1 (1) + mi +1 (2,1), Μ iΒ+1 (3) + mi +1 (2,3) )
* (
Μ iΒ−1 (1) = min Μ iΒ (0) + mi (1,0), Μ iΒ (2) + mi (1,2) )
ENST Bretagne 45
• Obtention de l’information extrinsèque pour le décodage itératif :
1 F B
Λ′( di ) ≈  min 0{M i −1 (s′) + xi ± yi + M i (s)}
2 (s′,s )∈Ti

− min {M iF−1 (s′) − xi ± yi + M iB (s)}
(s′,s )∈Ti1 
Λ ′( d i ) peut s’écrire :
Λ′( di ) ≈ xi + Z i
Z i est l’information extrinsèque produite par le décodeur
Codes convolutifs algorithmes SISO : Biblio

[1] G. Battail, “Pondération des symboles décodés par l’algorithme de Viterbi”, Ann.
Télécomm., vol. 42, N°1-2, pp. 31-38, Jan. 1987.
[2] J. Hagenauer and P. Hoeher, “A Viterbi algorithm with soft-decision outputs and its
applications”, in Proc. IEEE Globecom’89, Dallas, Texas, Nov. 1989, pp. 4711-
4717.
[3] C. Berrou, P. Adde, E. angui, and S. Faudeil, “A low complexity soft-output Viterbi
decoder architecture”, in Proc. IEEE Int’l Conf. on Comm., Geneva, Switzerland,
1993, pp.737-740.
[4] L.R. Bahl, J. Cocke, F. Jelinek, and J. Raviv, “Optimal decoding of linear codes for
minimizing symbol error rate”, IEEE Trans. Inform. Theory, vol. IT-20, pp. 284-
287, 1974.
[5] P. Robertson, E. Villebrun, and P. Hoeher, “ A comparison of optimal and sub-
optimal MAP decoding algorithms operating in the log domain”, in Proc. IEEE Int’l
Conf. on Comm., Seattle, WA, 1995, pp.1009-1013.
[6] A. J. Viterbi, “An intuitive justification and a simplified implementation of the
MAP decoder for convolutional codes”, IEEE Journal on Selected Areas in Comm.,
Vol. 16, N°2, Feb. 1998.
[7] B. Vucetic, J. Yuan, Turbo Codes, Principles and Applications, Kluwer Academic
Publishers, 2000.
ENST Bretagne 46
Chapitre 4
Turbo codes
Plan
• Mots croisés
• “turbo codes historique”
• Pourquoi de si bons résultats ?
• Différents schémas
– Turbo Codes en bloc
– Turbo Codes convolutifs
ENST Bretagne 47
1 2 3 4 5
Mots croisés I D E G A T ☺
II G A M M A ☺
Horizontal III D I N E R ☺
I. Dommage IV U S R N T
II. Lettre V D A R I G
III. Repas
IV. Minent
V. Enchâssement 1 2 3 4 5
I D E G A T ☺
Vertical
1. Gras II O M E G A ☺
2. Envoyée III D I N E R ☺
3. Indisposer IV U S E N T ☺
4. Intermédiaire
5. Gâteau V S E R T E ☺
☺ ☺ ☺ ☺ ☺
Turbo Codes
Inventés* en 1990, les Turbo Codes est une mise en oeuvre
de la déclaration de Claude Shannon (1953) :
A scheme of coding and decoding can be found allowing

correction of all transmission errors, if the information rate
is inferior or equal to the channel capacity.
* première publication à ICC’93 – Genève - Suisses
Travaux précédents : Tanner, Gallager, Battail, Hagenauer & Hoegher, …
ENST Bretagne 48
Codeur Turbo Codes

Un Turbo codeur est constitué d’au moins deux codeurs élémentaires
de codes convolutifs systématiques (RSC) codes séparés par un
entrelaceur
xi
Données
Code 1
di y1i
Redondance
y2i
π Code 2 Rendement
naturel :1/3
Concaténation parallèle de 2 codes RSC
Codeur Turbo Codes

Un Turbo codeur est constitué d’au moins deux codeurs élémentaires
de codes convolutifs systématiques (RSC) codes séparés par un
entrelaceur
xi
Données y1i
Code 1
di
yi
y2i Redondance
π Code 2
Poinçonnage
Concaténation parallèle de 2 codes RSC

(R=1/2)
ENST Bretagne 49
xi
Données
Code 1
di y1i
Redondance
y2i
π Code 2
Xi
Y1i
Décodeur 1
π Décodeur 2
π
-1 ^
di
Y2i
Xi = (2xi-1) + ni (xi=di)
Y1i = (2y1i-1) + n1i
Y2i = (2y2i-1) + n2i
Turbo Codes
Décodeur
Construit sur la base de décodeurs élémentaires à entrées et sorties
pondérées (Soft Input Soft Output SISO)
Processus itératif (effet turbo)
π
-1
Xi
Y1i
Décodeur 1
(SISO)
π Décodeur 2
(SISO) π
-1 ^
di
Y2i
Xi = (2xi-1) + ni (xi=di)
Y1i = (2y1i-1) + n1i
Y2i = (2y2i-1) + n2i
ENST Bretagne 50
Turbo Codes
Décodeur
Construit sur la base de décodeurs élémentaires à entrées et sorties
pondérées (Soft Input Soft Output SISO)
Processus itératif (effet turbo)
première itération
Xi
π π
Décodeur 1 Décodeur 2 -1
Z1i
Y1i (SISO) (SISO)
Y2i
Xi = (2di-1) + ni
Y1i = (2xi-1) + n1i Z1i : information extrinsèque
Y2i = (2yi-1) + n2i
Turbo Codes
Décodeur
Itération p
Zp-1 i
Xi Décodeur 1
(SISO)
π Décodeur 2
(SISO)
π
-1
Zp i
Y1i
^
π
-1 di
Y2i
Zp i : information extrinsèque associée à la donnée di

Zp i et Xi sont altérées par des bruits non corrélés (effet de la diversité)
ENST Bretagne 51
Comment faire pour que les deux décodeurs travaillent

conjointement, c’est à dire que le décodeur 1 profite de Y2
et que le décodeur 2 profite de Y1 ?
Xi
Données
xi
Y1,i
Décodeur 1
π
Code 1
di y1,i
π
y2,i
π
Décodeur 2 -1
π Code 2
Y2,i
« Message passing »
« turbo »
Turbo décodage Information extrinsèque

• Critère de décodage : les deux décodeurs doivent converger vers la
même solution (décision et probabilité associée)
Z2
π
-1
X1
X Décodeur 1 O1 =X1+Z1
Y1 (SISO)
Y2
Décodeur 2 O2 =X2+Z2
π X2 (SISO)
Z1
ENST Bretagne 52
Turbo décodage Information extrinsèque

• Critère de décodage : les deux décodeurs doivent converger vers la
même solution (décision et probabilité associée)
Z2
π
-1
X1+Z2
X Décodeur 1 O1 =(X1+Z2)+Z'1
Y1 (SISO)
Y2
Décodeur 2 O2 =(X2+Z1)+Z'2
π
X2+Z1 (SISO)
Z1
Turbo décodage Le principe turbo
Itérations et convergence d’un turbo décodeur
Canal
Eb/N0
Décodeur 1
SNRZ1in SNRZ1out
G1
SNRZ2out Décodeur 2 SNRZ2in

G2
L’information Extrinsèque est approximée à une variable

Gaussienne de moyenne λ et de variance σλ2
∆
SNR = λ2 / σ λ2
Chaque décodeur est considéré au travers d’une fonction de
transfert non-linéaire de rapport signal à bruit (SNR)
SNRZ1out=G1 (SNRZ1in , Eb/N0)
SNRZ2out=G2 (SNRZ2in , Eb/N0)
ENST Bretagne 53
Turbo décodage Le principe turbo
Itérations et convergence d’un turbo décodeur

SNRout
G1
G2-1
l 3ème itération
ne
tun
dépend 2ème itération
de Eb/N0 1ère itération
SNRin
D. Divsalar, S. Dolinar, F. Pollara, "Low Complexity Turbo-like Codes", Proc. 2nd International
Symposium on Turbo Codes and Related Topics, Brest, France sept. 2000, pp. 73-80
Turbo codeur Turbo décodeur :

une structure à contre-réaction
x
Π
C1
d X1
décodeur
(données)
Z1
SISO
Y1 8 états LLR 1(d)
y1 X x β x β sortie
permutation Y2
Π C2 décodeur LLR (d) décodée
2
Z2 SISO
Π 8 états
d^
X
2
y2 Π−1
Adaptée pour un circuit analogique,

mais pas pour un circuit numérique !!
⇒ Processus itératif
ENST Bretagne 54
Turbo codeur Turbo décodeur
Information extrinsèque
x
Π
C1
d X1
décodeur
(données)
Z1
SISO
Y1 8 états LLR 1(d)
y1 X x β x β sortie
permutation Y2
Π C2 décodeur LLR (d) décodée
2
Z2 SISO
Π 8 états
d^
X
2
y2 Π−1
Réglage du Décodeurs à
gain de boucle entrées et sorties
pondérées
Pourquoi de si bons résultats ?
ENST Bretagne 55
Turbo codes :
similaires à des RSC de grande longueur
Il peut être comparé à un code convolutif ayant une
grande longueur de contrainte,
qu’il est possible de décoder.
Xi
xi Décodeur 1
Données Y1i
Code 1
di y1i
π
y2i Décodeur 2
π
-1
π Code 2
Y2i
d X
Plus le registre Générateur

pseudo
est grand, 1 2 ν aléatoire
meilleur est le
code convolutif Y
0.09 0.07 0.07 0.06
0.08 0.06 0.06 0.05
0.07 0.05 0.05 0.04
0.06 0.04 0.04 0.03
0.05 0.03 0.02

0.03
TEB
0.04 0.02
E b/N 0
0.02 0.01
-0.2 0.2 0.6 0.8 1.2 1.6 1.2 1.6 2.0 1.6 2.0 2.4
R = 1/2 R = 2/3 R = 3/4 R = 4/5
0.06 0.06 0.05
ν =2 ν =4
0.05 0.05 0.04
ν =6 ν =8
0.04 0.04 0.03
0.03 0.03 0.02

Limite de Shannon
(canal gaussien
0.02 0.02 0.01
entrée binaire)
0.01 0.01 0.00

1.6 2.0 2.4 1.8 2.2 2.6 2.2 2.6 3.0
R = 5/6 R = 6/7 R = 7/8
ENST Bretagne 56
Turbo codes :
similaires à des RSC de grande longueur
xi
Données
Code 1 Code simple
di Y1,i
Mémoire ν
Y2,i
π Code 2
ν ≤ mémoire ≤ k +2ν
k bits
À prouver !
Pourquoi de si bons résultats ?

Lorsqu’un paquet d’erreurs affecte “code 1”, les erreurs
sont disséminées pour le “code 2” et vice versa.
Xi
xi Décodeur 1
Données Y1i
Code 1
di y1i
π
y2i Décodeur 2
π
-1
π Code 2
Y2i
ENST Bretagne 57
Turbo codes :
une approche du codage aléatoire
Partie
systématique
Y1,0 Concaténation
Y1,k/N-1
k-1 0
parallèle de N codes
k données
binaires permutation
Π
CRSC
Treillis CRSC:
1 circulaire
(identity)
Y1,i M Codage
o
Y2,0 quasi-aléatoire
t
permutation
Π
CRSC Y2,k/N-1
k-1 0 (pour N ≥ 4)
2 d
Treillis
Tirés de
Y2,i
e circulaire Et c’est décodable !!
manière
c
aléatoire
o
d YN,0
e YN,k/N-1 Heureusement, N = 2
k-1 0
permutation
Π
CRSC
Treillis
est suffisant:
N
circulaire
YN,i
turbo codes
Le rôle fondamental de π :
minimiser la probabilité que les 2 décodeurs défaillent
(un problème très complexe combinant algèbre, géométrie, ...)
xi Xi Decodeur 1
Data
Code 1 Y1,i
di y1,i
π Code 2
y2,i π Decodeur 2
Y2,i
Xi = (2xi-1) + ni (xi = di)

Y1,i = (2y1i-1) + n1i
Y2,i = (2y2i-1) + n2i
ENST Bretagne 58
Différents schémas de
turbo codes
Turbo code en bloc

Données
M1 Code 1 C1
(k , n) π M2 Code 2
(k , n)
C2
k colonnes
Mot de code 1
Redondance 1
k lignes
n lignes
code
Mot de
Mot de code 2
Redondance 2
n colonnes
concaténation série de deux codes en bloc
ENST Bretagne 59
Turbo code en bloc

Données
M1 Code 1 C1
(k , n) π M2 Code 2
(k , n)
C2
Propriétés (sans poinçonnage) :

• n = n1.n2
• k = k1.k2
• R = R1.R2
• dmin = dmin1.dmin2
Turbo codes convolutifs

auto-concaténés
xi xi
Données Données
Code 1 Code 1
di y1i di yi
y2i
π Code 2 π
ENST Bretagne 60
Principe de décodage
Information extrinsèque (z)
1 k
Données Données entrelacées
Quelques schémas Turbo codes convolutifs

classique Auto-concaténé
xi xi
données données
Code 1 Code 1
di y1i di yi
y2i
π Code 2 π
xi
données données
Code 1 Code 1
ai,bi y1i di y1i
y2i y2i
π Code 2 π Code 2
duo-binaire série Et plein d’autres ...
ENST Bretagne 61
Chapitre 5
La permutation
Permutation
(Permutation ≡ entrelacement)
données A
Le comportement à faible C1 Y1
TEB (<10-5) est fonction
de la façon dont Π est
conçu Π
C2 Y2
Le rôle fondamental de la permutation : si une séquence directe est RTZ, il faut

minimiser la probabilité que la séquence permutée soit aussi RTZ (et vice-versa).
ENST Bretagne 62
Séquences RTZ
Illustration avec le code suivant : xi yi

di =0
xi yi
di =1
xi
00 00
di 11 11
D D
01 00
yi 01
10 10
10
11 01
Séquences RTZ
00 00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
10 10 10 10
11 01 01 01
Distance de
Hamming 0 + 2 + 1 + 2 + 0 + 0 =5
ENST Bretagne 63
Séquences RTZ
00 00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
10 10 10 10
11 01 01 01
Distance de
Hamming 0 + 2 + 1 + 0 + 1 + 2 =6
Séquences RTZ
00 00 00 00 00 00
00
11 11 11 11 11 11 11 11
01 00 00 00
01 01 01 01
10 10 10 10
10 10 10 10
11 01 01 01
Distance de
Hamming 0 + 2 + 1 + 0 + 1 + 0
ENST Bretagne 64
Séquences RTZ
xi
xi yi
di =0
di
D D xi yi
di =1
yi
10 10
00 11 01
00 01 00 11
11 10
01
Permutation Régulière
Ordre naturel : M colonnes

adresse 0
0010110010...0110001
Écriture ...................................
en 0100100100...1001010 N lignes
ligne 0011110100...1011011
0101000110...0101001
Lecture en Ordre naturel :

colonne adresse k-1
Condition : k = M.N
ENST Bretagne 65
k-1 0
Adresse naturelle : i
0 ≤ i ≤ k-1
Adresse permutée : j
0 ≤ j ≤ k-1
j = P.i mod. k
(P et k premiers entre eux)
La permutation régulière est adaptée aux poids 2
M colonnes
0100000010...0000000
période : 7 ...................................
0000000000...0000000 N lignes
0000000000...0000000
période : 7 0000000000...0000000
k → ∞ ⇒ d(w=2) → ∞
ENST Bretagne 66
xi xi yi
di =0
xi yi
D D D di =1
yi
di 00
110 111 11
100 01
00
11 11
00
000 10 10 011
00
11 11 01
001 01 101
01 010 10
La permutation régulière est adaptée aux poids 3
M colonnes
0110100000...0000000
période : 7 ...................................
0000000000...0000000 N lignes
0000000000...0000000
période : 7 0000000000...0000000
k → ∞ ⇒ d(w=3) → ∞
ENST Bretagne 67
La permutation régulière n’est pas adaptée aux poids 4
M colonnes
0100000010...0000000
0000000000...0000000
0000000000...0000000
période : 7 0000000000...0000000
0000000000...0000000 N lignes
0000000000...0000000
0000000000...0000000
période : 7
0100000010...0000000
.....................................
k → ∞ ⇒ d(w=4) est limité
La permutation régulière n’est pas adaptée pour différents poids
M colonnes
0110100000...0000000
0110100000...0000000
0000000000...0000000
période : 7 0110100000...0000000
0000000000...0000000 N lignes
0000000000...0000000
0000000000...0000000
période : 7
0000000000...0000000
.....................................
ENST Bretagne 68
Il faut donc introduire du désordre,

mais pas de n’importe quelle manière !!
Une bonne permutation doit assurer :

(1) Un maximum de dispersion des données
(2) Un maximum de désordre dans la séquence permutée
(ces deux conditions sont contradictoires)
Permutation Aléatoire
ENST Bretagne 69
Permutation aléatoire selon S. Benedetto et G. Montorsi
Tous les entrelaceurs sont considérés, de manière statistique,
en y incluant les pires
Quels sont les pires ?
0100000010...0000000
...................................
0000000000...0000000
0000000000...0000000
ce couple a une 0000000000...0000000
probabilité de 1/k
de rester inchangé
après permutation
Permutation aléatoire selon S. Benedetto et G. Montorsi
Cette approche conduit naturellement
à une borne qui a l’allure suivante :
1  R.Eb .d min 
0100000010...0000000
Pe ≈ .erfc 

k  N0 
...................................
0000000000...0000000 Donnant une évaluation très pessimiste !
0000000000...0000000
0000000000...0000000
ENST Bretagne 70
Permutation pseudo-aléatoire (= désordre contrôlé)

Chacun a ses recettes
Par exemple, l’entrelacement

du Consultative Committee for
Space Data Systems (CCSDS)
CCSDS 101.0-B-4: Telemetry Channel Coding.

Blue Book. Issue 4. May 1999.
voir http://ftp.ccsds.org/all_books.html#telemetry
Permutation CCSDS
non-uniformité de degré 8
m = s − 1 mod 2
0110101000...010000011001001110100
s-1
i = 4 1110110101...001001100010001101001
k 1010001100...100010011101100101110
s-1 ik 1100101000...110011000010101001011
j= −
2 8 0111101000...010000111001111010101
t = 19i + 1 mod 4 0100010101...001001100010101101001
q = t mod 8 + 1 1010001100...100010001101100111110
k 1100101000...110011000000101001001
c = pq j + 21m mod .....................................
8
0100101011...110011010011001001010
Π ( s ) = 2(t + 4c + 1) − m
1110101010...010110011001011010110
p1 = 31; p2 = 37; p3 = 43; p4 = 47; 0100010101...001001100010101101001
p5 = 53; p6 = 59; p7 = 61; p8 = 67;
ENST Bretagne 71
Permutation
En conclusion :
•Pas de permutation idéale pour le moment (existe-t-elle ?)

•Il n’est pas nécessaire de l’avoir
ENST Bretagne 72
Chapitre 6
turbo codes duo-binaires
Turbo codes duo-binaires
binaire duo-binaire
données (bits) données (couples) A
X
B
C1 Y1 C1 Y1
Π Π
C2 Y2 C2 Y2
R = 1/3 (1/2 //1/2) R = 1/2 (2/3 //2/3)
ENST Bretagne 73
Rappel MDP4, canal gaussien, taux d’erreurs cible : 10-8

TEB
5
10-1 1 E
5
non codé erfc ( b )
2 N0
10-2 avec
5 ∞
2
10-3
mauvaise
erfc( x) = ∫ exp(−t 2 )dt
π t=x
5
convergence, gain
10-4 asymptotique élevé
5
10-5
5
10-6
Bonne
5
convergence, faible
10-7 gain asymptotique
5
Eb/N0 (dB)
10-8
0 1 2 3 4 5 6 7 8 9 10 11 12
Ga = 10 log (R.dmin)
Limite théorique
(R=1/2, 188 octets) dmin > 25

Contribution des codes duo-binaires sur la convergence
k
chemin
erroné
motifs de
verrouillage
C1 duo-binaire : C1
Diminue la corrélation
binaire
Π Durant le décodage Π
k
k /2
C2 C2
k k /2
ENST Bretagne 74

Contribution des codes duo-binaires sur les distances minimales
Le rôle fondamental de la permutation : si une séquence directe est RTZ,
Rappel : il faut minimiser la probabilité que la séquence permutée soit aussi RTZ
(et vice-versa).
données (bit) données (couple) A

X
B
C1 Y1 C1 Y1
Π Π
C2 Y2 C2 Y2
Π : permutation inter-symbole Π : permutation inter-symbole

+ intra-symbole

X AB
000 000
001 001
010 010
Treillis 011 Treillis 011

binaire 100 Duo-binaire 100
(partiel)
101 101
110 110
111 111
exemples de k
k /2 3 1
motifs à 10000001
0 0
201 13
00
0 0
0 0
faibles distances 0
0
0
0
0 0
0 0
00
00 0 2
k 0 0 k/2 0
avec une 0
0
0
0
0 0
0 0
00
00
0 0 00 00 : 0
permutation 10000001 201 13
01 : 1
régulière 10 : 2
11 : 3
X A
B Périodicités du
Code duo-binaire
(a) Y (b) Y
ENST Bretagne 75

Permutation intra-symbole
(sans introduction de désordre aléatoire !)
1 3 1 3
2 0 1
0 0 0 0
0 0
0 0 0 0
0 0
0 0 0 0
0 0 0 0
0 0 0 0
(A,B) devient (B,A) 0 0 0 0 0 0
0 0
avant le codage vertical, 0 0 0 0 3 0 0 0 0 0 0 3
0 0
2 0 1 1 3 0 0
une fois de temps en temps 0 0 0 0
3 0 0 0 0 0 0 3 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
2 0 0 0 0 0 0 2 3 0 0 0 0 0 0 3 0 0
1 3
Ces motifs ne sont plus

Motifs d’erreurs possibles
possibles si les couples sont
avec une grande distance
Inversés périodiquement
Grâce à cette technique, les distances minimales sont généralement

plus grandes que celles des concaténations séries (codes produits) !!!!

Autres avantages des codes duo-binaires
• Latence divisée par 2 (codage et décodage)

• Débit de traitement des données doublé (parallélisme intrisèque)
• Plus faible dégradation MAP → SUB-MAP
• Meilleur mapping pour constellations à grand nombre d’états
ENST Bretagne 76

Standard DBV-RCS (+RCT)
M
partie systématique partie systématique
A o
T
B
1
A s1 s2 s3 d
B permutation e
(k/2)
k/2 couples Y2 Y1 c
Π 2
de données poinçon- o
Y2 Y1 nage
d
redondance
redondance e
Complexité
≈ 20.000 portes Π
par bit.itération SUB-MAP
@ horloge système 8 états Z1 1 1
+ mémoire LLR1 4 chemins Y1, Y2
couple A, B
décodé SUB-MAP 2 2
LLR2 Y1, Y2
8 états Z2
4 chemins
Π
−1
Π

Standard DVB-RCS (+RCT)
Permutation générique Π
Niveau 1 (intra-couple)
if j=0 mod 2 (A,B)=(B,A) [inversion du couple]
Niveau 2 (inter-couple)
if j=0 mod 4 P=0
if j=1 mod 4 P=P1+ N/2
if j=2 mod 4 P=P2
if j=3 mod 4 P=P3 + N/2
i=π(j)=P0.j + P + 1 mod N
P0, P1, P2 et P3 sont des entiers,

pour chaque N (nombre de couples).
ENST Bretagne 77

Taille des blocs : 12, 16, 53, 55, 57, 106, 107,
108, 110, 188, 212, 214, 216 octets
Rendements : 1/3, 1/2, 2/3, 3/4, 4/5, 6/7

Exemple de performance : TC1000 (TurboConcept)
(Mesures, 53 octets, SUB-MAP, 4 bits de quantification, 8 itérations)
1
Non codé
53 octets 1/2 8 it.
0.1
53 octets 2/3 8 it.
53 octets 3/4 8 it.
0.01 53 octets 4/5 8 it.
53 octets 6/7 8 it.
0.001
Taux d’erreurs paquets
0.0001
1e-05
1e-06
1e-07
1e-08
1e-09
0 1 2 3 4 5 6 7 8 9 10
Eb/N0
ENST Bretagne 78

Exemple de performances : TC1000 (TurboConcept)
(Mesures, 188 octets, SUB-MAP, 4 bits de quantification, 8 itérations)
1
Non codé
188 octets 1/3 8 it.
0.1
0.01 188 octets 2/3 8 it.
0.001
0.0001
1e-05
1e-06
1e-07
1e-08
1e-09
0 1 2 3 4 5 6 7 8 9 10
Eb/N0
Duo-binaire turbo codes

Exemple de performances : mini-slots
(simulation, SUB-MAP, 4 bits de quantification, 6 itérations)
10 -1
10 -2
10-3
R = 1/2 R = 2/3
5
R = 1/2 R = 4/5
10 -4
5 12 oct.
14 oct. 4 oct. 4 oct.
16 oct. 12 oct.
10-5
12 oct. 14 oct.
5 12 oct.
14 oct. 16 oct.
10-6 14 oct.
5 16 oct. 16 oct.
R = 4/5
10-7
R = 1/3
5
10-8
3 4 5 Eb/N0 (dB) 6 7 8
ENST Bretagne 79
Chapitre 7
Conclusions et perspectives
Conclusions et perspectives Codage
1
Non codé
0.1
0.01 188 octets 2/3 8 it.
0.001
0.0001
1e-05
1e-06
perte @ PER = 10-4

1e-07
≈ 1.2 dB
1e-08
1e-09
0 1 2 3 4 5 6 7 8 9 10
Limites théoriques Eb/N0
0.3 dB (turbo + it.) + 0.3 dB (SUB-MAP) + 0.15 dB (quantification) + 0.05 dB (matériel)

+ 0.4 dB (?)
ENST Bretagne 80
Conclusions et perspectives Codage

Génération suivante (2002)
1 dB gain @ TEP = 10-7
pour une complexité double
1
Non codé
0.1
0.01 188 octets 2/3 8 it.
0.001 188 octets 4/5 8 it.

0.0001
1e-05
1e-06
1e-07
1e-08
1e-09
0 1 2 3 4 5 6 7 8 9 10
Eb/N0
Standards actuels
Application turbo code terminaison polynômes rendements
CCSDS binaire, tail bits 23, 33, 25, 37 1/6, 1/4, 1/3,
16 états 1/2
IMT-2000 binaire, tail bits 15, 13, 17 1/4, 1/3, 1/2

8 états
DVB-RCS duo-binaire, circulaire 15, 13 de 1/3 à 6/7

8 états
DVB-RCT duo-binaire, circulaire 15, 13 1/2, 3/4

8 états
Inmarsat (mini binaire, no 23, 35 1/2

M) 16 états
Skyplex duo-binaire, circulaire 15, 13 4/5, 6/7

8 états
ENST Bretagne 81
Conclusions et perspectives turbo-X

• Turbo (dé)modulation
• Turbo égalisation
• Turbo détection (CDMA)
• Turbo synchronisation
• Turbo (dé)codage de source
modèle général d’un turbo processeur
information
information extrinsèque
1
intrinsèque
locale
4
2
processeur
probabiliste
3
information
intrinsèque
partagée
Applications
turbo-égalisation,
turbo-synchro, Disques durs ?
turbo-crypto, CD-ROM ?
...
DVB-S ?
DSL ?
CCSDS UMTS
CDMA2000
DVB-RCS
patents M4 DVB-RCT
invention publication HiperAccess
1990 1995 2000
ENST Bretagne 82
Information générale à propos des Turbo codes
- C. Heegard, S. B. Wicker, Turbo Coding, Kluwer Academic Publishers, 1999

- Branka Vucetic, Jinhong Yuan, Turbo Codes, Principles and Applications, Kluwer Academic Publishers,
2000
- C. Schlegel, Trellis coding, IEEE Press, 1997
- B.J. Frey, Graphical Models for Machine Learning and Digital Communication, MIT Press, 1998
- R. Johannesson , K. Sh. Zignagirov, Fundamentals of Convolutional Coding, IEEE Press, 1999
- Hanzo, Lajos, Adaptative wireless transceivers, John Wiley & sons, 2002
- Hanzo, Lajos, Turbo coding, turbo equalisation and space-time coding for transmission over fading
channels, John Wiley & sons, 2002
- sites WEB : http://www-turbo.enst-bretagne.fr/2emesymposium/presenta/turbosit.htm

est un bon point de départ
- base de données IEEE Xplore : mot clé : turbo, 1974 réponses le 13 mars, 2003
Signature
numérique de
Michel Michel Jezequel

ID : cn=Michel
Jezequel,
o=ENST
La signature
n'a pas été
vérifiée.
Jezequel Bretagne, c=FR
Date :
2003.03.31
11:16:10 +02'00'
ENST Bretagne 83

TCC

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TCC

Transféré par

Droits d'auteur :

Formats disponibles

Timisoara 18-20 mars 2003

Les codes correcteurs d’erreurs

Une chaîne de transmission

Destinataire Di Décodage Filtrage et

Codes correcteur d’erreurs Généralités

Différentes familles de codage

Codage de source : réduire le débit d’information

Codes correcteur d’erreurs Généralités

rj = ∑ pi, j d i mod 2 (pi,j = 0 ou 1)

Codes correcteur d’erreurs Généralités

[d1 d2 ... di ... dk][r1 r2 ... rj ... rn-k] : mot de code

Rendement de codage : R =k/n

Le code étant linéaire, la séquence « tout zéro »

La distance dmin est le nombre minimum de « 1 »

Codes correcteur d’erreurs Généralités

Un bon code est un code avec une grande distance dmin

MDP4, canal gaussien, taux d’erreurs cible : 10-8

Codes correcteur d’erreurs Généralités

distinction traditionnelle mais inappropriée entre

Les codes en « bloc » : Hamming, Golay, BCH, Reed-Solomon, ...

Les codes « convolutifs »

Une distinction plus naturelle prendrait en compte l’algorithme

Codes correcteur d’erreurs Généralités

Codes correcteur d’erreurs Généralités

dmin ≈ (n-k)/4 = k.(1-R)/4R où R = k/n

Codes correcteur d’erreurs Généralités

dmin ≈ (n-k)/4 = k.(1-R)/4R où R = k/n

Exemple : k = 1504 (MPEG), R = 1/2

(un code convolutif 64 états

Mais non décodable en pratique ...

Codes correcteur d’erreurs Généralités

Limite (Eb/N0, dB) (k infini) [Shannon, Proakis]

0 R=5/6 R=4/5 R=3/4 R=2/3 R=1/2

Codes correcteur d’erreurs Généralités

∆ Eb/N0 (dB) (taux d’erreurs paquets = 10-4)

100 101 102 103 104 105 Taille du bloc (k)

Correction à prendre en compte pour des bocks de taille k :

Calcul des limites

Code convolutif classique

g1=[g01,g11,g12]=[1,0,1] G1(D)=g01+ g11D+ g12D2

g 2=[g02,g12,g22]=[1,1,1] G2(D)=g02+ g12D+ g22D2

Générateurs sous la forme octale : (5,7)

Représentation des codes

Exemple : K=3, b=1, n=2, R=b/n=1/2

Codes systématiques (treillis)

Spectre des distances

Interprétation des résultats

Existe-t-il un code convolutif combinant :

• les distances minimales des codes non systématiques

La réponse est : OUI

Codes récursifs systématiques

Codes récursifs systématiques

Codes Récursifs systématiques

Codes récursifs systématiques(distance)

Spectre des distances

Codes récursifs systématiques

Rendement de codage et poinçonnage

R=1/2 xi yi xi+1 yi+1 xi+2 yi+2 xi+3 yi+3 xi+4 yi+4

Plus le registre Générateur

est grand, 1 2 ν aléatoire

0.09 0.07 0.07 0.06

0.08 0.06 0.06 0.05

0.07 0.05 0.05 0.04