Théorie d`information

Report
ELG3575 Introduction aux
systèmes de télécommunication
Théorie d’information
Théorie d’information
• Information est une quantité qu’on peut mésurer.
• On peut déterminer les limites d’information qu’on peut
transmettre sur un lien.
• Théorie d’information est conçu par Claude
Shannon en 1949.
• Encodage Huffmann pour l’encodage efficace de la
sortie d’une source.
• Codes correcteur d’erreurs pour la correction des
erreurs qui arrivent en communication.
Montant d’information d’un message
• Il y a une source qui, à chaque instant de signalisation,
émet un message qui vient d’un ensemble de messages
{m1, m2, …, mN}.
• Supposons que la source n’a pas de memoire, c’est-àdire que l’émission de messages futurs ne depend pas
des messages qui ont été émis dans le passé.
• Chaque message a une probabilité de transmission
{p(m1), p(m2), … p(mN)}.
• Le montant d’information de chaque message dépend
de sa probabilité de transmission.
– Exemple: m1 = il fait beau, m2 = il y a une tornade.
– SI LA PROBABILITÉ D’ÉMISSION EST FAIBLE, LE
MESSAGE CONTIENT BEAUCOUP D’INFORMATION!!!
Montant d’information
• Ici p(m1)>p(m2) mais I(m1)<I(m2).
• Supposons que m3 = m1m2. Si on suppose que la
source n’a pas de memoire, p(m3) = p(m1)p(m2), mais
c’est claire que I(m3) = I(m1)+I(m2).
• Alors I(mi) = logb(1/p(mi)) = -logb(p(mi)).
• b = 2, I(mi) (bits)
• b = 3, I(mi) (symbôles ternaires)
• b = e, I(mi) (nats)
• b =10, I(mi) (Hartleys)
Exemple
• M = {m1, m2, m3, m4} avec P = {0.35, 0.11, 0.45,
0.09}
• I(m1) = 1.51 bits
• I(m2) = 3.18 bits
• I(m3) = 1.15 bits
• I(m4) = 3.47 bits
• La probabilité que la source émet le message m1 suivit
par m2 est 0.35×0.11 = 0.0385. L’information dans
cette séquence de messages est –log2(0.0385) = 4.69
bits = 1.51+3.18.
Entropie de la source
• L’entropie de la source, H(M), est la valeur moyenne
d’information par transmission.
N
H ( M )    p ( m i ) log
i 1
b
p (mi )
Exemple
•
•
•
•
•
•
M = {m1, m2, m3, m4} et P = {0.35, 0.11, 0.45, 0.09}
I(m1) = 1.51 bits
I(m2) = 3.18 bits
I(m3) = 1.15 bits
I(m4) = 3.47 bits
H(M) = 0.35(1.51)+0.11(3.18)+0.45(1.15)+0.09(3.47)
= 1.71 bits/message.
Encodage de source
• Prenons l’exemple precedant.
• H(M) = 1.71 bits/message.
• Encodons les messages: m1 = 00, m2 = 01, m3 = 10 et
m4 = 11, la longueur de chaque message 2 bits. L =
longueur moyenne.
• On peut démontrer que H(M) ≤ L.
• Maintenant utilisons ce code:
• m1 = 01, m2 = 000, m3 = 1 and m4 = 001. L =
0.45(1)+0.35(2)+0.11(3)+0.09(3) = 1.75
bits/message.
• Exemple: 010101000010010010010011 = m1, m1, m1,
m2, m1, m4, m4, m4, m4, m3 : uniquement décodable
Encodage de source
• Prenons ce code:
• m1 = 10, m2 = 100, m3 = 1 and m4 = 010. L =
0.45(1)+0.35(2)+0.11(3)+0.09(3) = 1.75
bits/message.
• Exemple: 1010 = m1, m1, ou m3, m4. ce n’est pas
uniquement décodable.
• Un code à longueur variable est uniquement décodable
s’il est un code à préfixe conditionné.
• Efficacité de l’encodeur est H(M)/L. (dans notre exemple
eff = 1.71/1.75 = 0.977.
Codes Huffmann
• L’algorithme Huffmann permet de concevoir des codes à
préfixe conditionné.
m3
0.45
m1
0.35
0.45
+
m2
0.11
+
m4
0.09
0.20
0.55
m3
m1
0.45
0.45
01
0.35
+
m2
0.11
0.09
0.55
0
001
+
m4
1
000
0.20
00
m3 = 1, m1 = 01, m2 = 001
m4 = 000.
Codes correcteur d’erreurs
• Code bloc
– Linéaire
• Hamming, LDPC
– Non-Linéaire
– Cyclic
• BCH, RS
• Codes Convolutionnelles
• Codes Turbo
Bits de parité
• Supposons qu’on veut transmettre le message
m=[1001001].
• Supposons que le deuxième bit est décodé en erreur, r
= [1101001].
• Le récepteur ne peut pas déterminer que r est en
erreur.
• Supposons, qu’avant la transmission, on ajoute un bit
de parité paire au message mc= [10010011].
• Maintenant, supposons que le deuxième bit est reçu en
erreur, r = [11010011]. Il y a maintenant 5 1’s, ce qui
n’est pas permis. Alors un erreur est détecté et le
récepteur peut demander une nouvelle transmission.
• La détection de cet erreur est possible en ajoutant le bit
de parité.
Codes Blocs
• Les données sont regroupés en groupes de k bits.
• Chaque « bloc » de k bits est encodé. L’encodage
produit un nouveau bloc de n bits où n>k. Encodage
produit de la redondance dans le message à
transmettre.
• Le taux du code est is r = k/n.
m
1011
encodeur
c
1011100
Addition et multiplication binaire
• 0+0 = 0, 0+1 = 1, 1+0 = 1 et 1+1=0 (il n’y a pas de
retenu).
• 0x = 0 où x = 0 ou 1. 1x = x où x = 0 ou 1.
• Exemples 1010 + 1100 = 0110. 0(10010) = (00000).
Codes Blocs Linéaires
• Soit C est un code qui consiste de l’ensemble des
vecteurs {c0, c1, … cM} où M = 2k-1 .
• C est un code linéaire si pour ci et cj en C, ci+cj est
aussi en C.
• Exemple C = {c0 = 0000, c1 = 0110, c2 = 1001, c3 =
1111}.
• c0+cx = cx for x = 0, 1, 2 ou 3.
• cx+cx = c0.
• c1+c2 = c3, c2+c3 = c1, c1+c3 = c2.
• C est linéaire.
• C2 = {c0 = 0001, c1 = 0111, c2 = 1000, c3 = 1110}.
• cx+cx = 0000 qui n’est pas en C2.
• C2 n’est pas linéaire.
Poids Hamming
• Pour un mot de code cx du code C, son poids Hamming
égal le nombre d’elements en cx qui ne sont pas 0.
• C = {0000 0110 1001 1111}
• H.W{0000} = 0
• H.W{0110} = 2
• H.W{1001} = 2
• H.W{1111} = 4
Distance Hamming
• La distance Hamming entre deux mots de codes ci et cj
du code C égal le nombre de position où les deux mots
se diffèrent.
0000
0110 1001 1111
0000
0
2
2
4
0110
2
0
4
2
1001
2
4
0
2
1111
4
2
2
0
• ci+cj = 0 dans les positions où ils sont pareils et ci+cj =
1 dans les positions où ils se diffèrent. Donc HD{ci, cj}
= HW{ci+cj}.
Distance minimum d’un code bloc
linéaire
• Dans l’exemple précédant, dmin = 2.
• Nous avons vu que HD{ci,cj} = HW{ci+cj} = HW{cx}
où, dans le cas des codes blocs linéaires, cx est un autre
mot de code en C excluant le mot de code entièrement
zéro.
– Donc, dmin = poids Hamming minimum du code C en
excluant le mot de code entièrement zéro.
• Dans notre exemple, en excluant 0000, les autres mots
de code sont 0110, 1001 et 1111. Le poids Hamming
minimum de ces trois mots de code est 2. Donc dmin =
2.
Base d’un code bloc
• C est un code bloc linéaire
• Choissisons k mots de codes indépendants, c1, c2, …, ck.
Aucun de ces mots de code peut être exprimé comme une
combinaison linéaire des autres.
• Tous les 2k mots de codes en C peuvent être exprimés comme
une combinaison linéaire de ces k mots de codes.
– On dit que ces k mots de code forment la base du code C.
• cx = a1c1+a2c2+a3c3+…+akck où ai = 0 ou 1
• Pour notre code on peut choisir comme base 0110 et 1111, ou
0110 et 1001 ou 1001 et 1111.
• exemple, prenons c1 = 0110 et c2 = 1111 comme la base du
code.
– 0000 = 0c1+0c2, 0110 = 1c1+0c2, 1001 = 1c1+1c2 et
1111 = 0c1+1c2.
Matrice génératrice
 c1 
 
c2


G 
  
 
c k 
c x  m xG
Exemple
0
G  
1
0

1
1 1
1 1
[0
0 ] G  [0
[0
1] G  [1 1 1 1]
[1
0] G  [0
[1 1]G  [1
0
0
1 1
0
Les dimensions de la matrice G sont k×n.
0
0]
0]
1]
Codes équivalents
• Les codes générés par G1 et G2 sont équivalents
si les matrices génèrent les mêmes mots de codes
(cependant les messages correspondants sont
différents).
• Exemple
0
G1  
1
m 00
01
10
11
1 1
1 1
0000
1111
0110
1001
0

1
G2
1
 
1
0
0
1
1
0000
1111
1001
0110
1

1
Codes systématiques
• Un code est systématique si les bits du message se
retrouvent au début des mots de codes.
• c = [m|p].
• Gsyst = [Ik|P].
• Exemple
m 00
01
10
11
0000
0110
1001
1111
G syst
1

0
0
0
1
1
1

0
Code systématique équivalent
• Pour n’importe quel code, on peut trouver la matrice
génératrice de son code systématique équivalent par
transformation linéaire.
– Exemple au tableau.
Lecture 6
Matrice de vérification de parité
• La matrice de vérification de parité H pour un code a la
propriété cHT = 0, où c est n’importe quel mot de code
du code C.
• On peut écrire cHT = 0 comme mGHT = 0
• Donc GHT = 0.
• On peut trouver H à partir da la matrice Gsyst.
• H= [PT|In-k].
0
H 
1
1
1
0
0
0

1
• Les dimensions de H sont (n-k)×n.
Exemple: Code Hamming (7,4)
1

0

G 
0

0
1
0
0
1
0
1
1
0
1
0
0
1
1
0
1
0
0
1
1
0
1

0

0

1
Trouvez tous ses mots de codes ainsi que dmin, et trouvez H.
Solution au tableau.
Decodage
• Le mot reçu, r = c+e, où e = vecteur d’erreur.
• Par exemple, si c = (1 1 0 0 1 1 0 1) et r = (1 0 0 0 1 1
0 1), donc e = (0 1 0 0 0 0 0 0).
• En supposant que les erreurs de détection arrivent avec
p < 0.5
– Dans le cas où le mot reçu contient des erreurs, le
vecteur d’erreur le plus probable est celui avec le
poids le plus faible.
Exemple
• C = {(00000) (01011) (10110) (11101)}
• r = (11111)
– Si c = (00000), alors e = (11111) qui arrive avec
probabilité p5.
– Si c = (01011), alors e = (10100) qui arrive avec
probabilité p2(1-p)3.
– Si c = (10110), alors e = (01001) qui arrive avec
probabilité p2(1-p)3.
– Si c = (11101), alors e = (00010) qui arrive avec
probabilité p(1-p)4 > p2(1-p)3 > p5.
• Donc le décodeur choisit c = (11101) comme le mot de
code le plus probable et sa sortie est le message qui
corréspond à ce mot de code.
Decodage par tableau standard
• Tableau qui donne la mise en corréspondance entre les
mots reçus et le de code les plus probable.
00000
01011
10110
11101
00001
01010
10111
11100
00010
01001
10100
11111
00100
01111
10010
11001
01000
00011
11110
10101
10000
11011
00110
01101
10001
11010
00111
01100
11000
10011
01110
00101
Comment construire le tableau
standard
• Faites une liste de tous les mots possibles.
• Enlever de la liste les mots de codes et les placer dans
la première rangée avec le mot entièrement zéro à la
gauche.
• Prendre le mot avec le poids le plus faible et mettre
dans la colonne sous le mot entièrement zéro.
Additionner ce vecteur aux autres mots de code et
placer le resultat sous ce mot de code.
– Enlever tous ces résultats de la liste.
• Répeter jusqu’à la fin de la liste de mots.
Decodage par syndrome
• S = rHT.
• r=c+e, therefore S = (c+e)HT = cHT + eHT = eHT.
• Tous les vecteurs dans la même rangée du tableau
standard produit le même syndrome.
• Syndrome indique le vecteur d’erreur le plus probable et
on produit c par c = r+e.
Exemple
• Pour ce code:
1
G  
0
1

H  1

 0
0
1
1
1
0
1
0
1
0
1
0
1
1
0
0
0

1
0

0

1 
Exemple
• Supposons r = (01001), alors
(0
1
0
0
1

0

1)  1

0
0

1
1
0
1
0
0

1

0   0

0
1 
1
0
• Ceci indique que le 4e bit est en erreur: e = (00010)
donc c = (01011).
Capacité de correction ou détection
d’erreur
• t = tous les vecteur d’erreur de poids t ou moins
peuvent être corrigés.
• J = tous les vecteur d’erreur de poids J ou mons
peuvent être détectés.
• t = (dmin-1)/2 (dmin est impaire) or (dmin-2)/2 (dmin est
paire).
• J = dmin -1
• Parfois on crée des codes qui tente de corriger les
erreurs de poids t ou moins mais est capable de
détecter des erreurs de poids supérieur à t: t+J = dmin
-1 où J > t.
– Exemple un code qui corrige 2 erreurs mais détecte
4 erreurs doit avoir dmin = 7 (ou plus).
Performance: Decoder Failure
• Probability of decoder failure = probability that decoder
selects the incorrect codeword = probability that error
pattern is not one of the error patterns that it can
correct
– In our example, the decoder can correct all 5 error
patterns of weight 1 and 2 error patterns of weight
two. The probability that the error pattern IS one of
these is (1-p)5+5p(1-p)4 + 2p2(1-p)3. Therefore
P(E) = 1- (1-p)5-5p(1-p)4 - 2p2(1-p)3
– In many cases, the code has too many codewords to
construct a standard array.
– But we usually know dmin, therefore we know t.
Performance: Decoder Failure
n i
n i
P ( E )  1     p (1  p )
i0  i 
t
Performance: Bit Error Rate
• (1/k)P(E) < Pb < P(E)
Performance: Probability
Undetected Error
• P(U) = probability that an error is undetected =
probability that syndrome = 0 even if error pattern is
not 0 = probability that error pattern is same as a
codeword.
• In our example P(U) = 2p3(1-p)2 + p4(1-p).
• If we don’t know the codewords because code is too
large, then P(U) < probability error pattern has weight
greater than j = 1 – probability that error pattern has
weight j or less
n i
n i
P (U )  1     p (1  p )
i0  i 
j

similar documents