Le codage adaptatif d’Huffman

 Technique basée sur le codage de Huffman .

 Permet de construire un code au fur et à mesure de la transmission

des symboles, sans connaissance initiale de la distribution de la source

 Permet un codage en un seul passage et une adaptation aux

conditions changeantes des données.

 Avantage:
la source peut être encodée en temps réel, bien qu'elle devienne
plus sensible aux erreurs de transmission, car une seule perte fausse
tout le code.
 Le codage adaptatif d’Huffman
Règles:
Soit un alphabet de n éléments A={a1 ,…, an}. Exemple: n=26 pour la langue française
ou anglaise. Un arbre contient 2n-1 nœuds (racines + feuilles). Pour n=26, on a 51 nœuds.

Les attributs d’un nœuds sont:

symboles, code gauche=0, droit=1, parent, frères (a et b), poids=3, symbole a, id.=49

Nœud interne
3
1
0 51

Nœud externe a 1 2 b
ou feuille 49 50
1. Point de départ: arbre avec un seul élément (feuille sans racine): poids=0,
symbole=NYT (Not Yet Transmitted).
NYT 0
2. Si un symbole est rencontré pour la 1ère fois, envoyer le code de NYT suivi
d’un code fixé
3. Si un symbole est déjà rencontré, transmettre seulement le code de ce symbole
 Le codage adaptatif d’Huffman
Règles (suite):

4. Le poids d’un fils doit être toujours inférieur à celui de ses parents. Sinon
procéder à un réarrangement (shuffling)

5. A un même niveau de nœuds, Le poids gauche doit être toujours inférieur

au poids de droite. Sinon procéder à un réarrangement (shuffling):
intervertir l’ordre, en plaçant le nœud sur le chemin le plus éloigné.

1 2
 Construction de l’arbre de Huffman
Exemple pour coder le message [a a r d v a r k]
[a a r]
[a] [a a]
NYT 0 1 2
0 51 1 0 51 1
51
Poids NYT =2*n-1
=2*26-1 = 51 a NYT 0 2 a
NYT 0 1
49 50 49 50
[a a r d v ] 5 [a a r d v] [a a r d]
0 51 4 3
0 51 1 0 51 1
3 2 a
2 2 a a
0 49 50 1 2
0 49 1 50 0 49 1 50
intervertir r
2 1
0 47 1 48 1 1 r NYT 0 r
1
0 47 1 48 47 48
1 1 d
0 47 1 48 NYT 0 1 d
NYT 45 46
0 1 v
 [a a r d v ] [a a r d v ] 5 [a a r d v a]
5
0 51 1 0 51 1
6
a a 2 0 51 1
3 2 3
0 49 50 49 0 50 1
1 a 3 3
intervertir
r
49 0 50 1
r 1 2 1 2
47 0 48 1 47 0 48 1
r 1 2
d 47 48 1
1 1 1 1 d 0
0 45 1 0 45 1
46 46
1 1 d
v 0 45
NYT 0 1 v NYT 0 1 1 46
43 44
43 44 NYT 0 v
1
43 44

0
 [a a r d v a r k] [a a r d v a r k]
[a a r d v a r] 8
7 8 51 1
0 51 1 0
0 51 1
a 3 5
a a 3 0
3 4 5 49 50 1
49 50 1 49 0 50 1
0
r 2 3
r 2 2 r 2 3 47 0 48 1
47 0 48 1 47
0 48 1
intervertir d 1
d d 45 2
1 1 2 1 46 1
0 45 1 0 45 1 46 0
46
v 1 1 v
NYT 0 1 v 1 1 43 1
0 43 1 0 44
43 44 44

NYT 0 1 k
NYT 0 1 k
41 42
 Algorithme de Codage adaptatif de source
Soit l’alphabet A={a1 ,…, an}
1. Fixer un code initial pour l’alphabet.
2. Arbre formée d’une seule feuille NYT(Not Yet Transmitted).
3. Parcourir les éléments de la source.
A. Si l’élément NYT
i. Envoyer NYT (code NYT + code fixe)
ii. Mise à jour de l’arbre
B. Sinon
i. Envoyer le mot code de l’élément
ii. Mise à jour de l’arbre
4. Condition d’arrêt: parcours de toute la source.
Note 1: Code dépend de la fréquence des éléments.
Note 2: Encodeur et décodeur doivent être synchrone.
 Détermination des codes
1. Le code NYT s’obtient en partant de la racine de l’arbre jusqu’à la feuille NYT.
NYT doit être toujours à gauche de l’arbre et doit avoir un poids=0

2. Le code fixe s’obtient à l’aide de 2 paramètres: e et r définis tels que

a. n= 2e + r
b. Dans le cas de l’alphabet de l’anglais, on écrit 26= 24 +10. D’où e=4, r=10

Soit K la position (index) du symbole aK dans l’alphabet. (e.g aK = [a] pour K=1)

• Si 1≤ K ≤ 2r ---> alors aK est encodé avec (e+1) bits représentant

l’indice K-1
• Si K > 2r ---> alors aK est encodé avec (e) bits représentant
l’indice K-r-1
 Exemple: On veut coder le message:
[a a r d v a r k]
[a] lu comme 1er symbole et 1ère apparition. Son index
est K=1. Pas encore de code NYT. 1≤ K ≤ 2r =20
Lire symbole
d’entrée
 (K-1) Codé sur (e+1)=5 bits.  envoi de 00000 pour
[a]
1ère
[a] lu. 2ème apparition.
oui non
apparition Envoyer son code (voir arbre)  [a] codé sur 1
?
[r] lu. 1ère apparition. Index K=18 <20. Code NYT= 0 (voir
arbre). 17 sera codé sur 5 bits et ajouté à NYT=0
 envoi de 010001 pour [r]

Envoyer code
[d] lu. 1ère apparition. Index K=4<20. Code NYT= 00 (voir
Code NYT
symbol arbre). 3 sera codé sur 5 bits et ajouté à NYT=00
+code fixe
 Envoi de 0000011 pour [d]

[v] lu. 1ère apparition. Index K=22 >20. Code NYT= 000
Mettre à jour l’arbre
d’Huffman (voir arbre). (K-r-1)=11 sera codé sur 4 bits et ajouté à
NYT=000
 [v] codé 0001011
[a a r d v a r] [a] lu. 3ème apparition.
7
0 51 1 Envoyer son code (voir arbre)  [a] codé sur 0

a 3 [r] lu. 2ère apparition.

4 Envoyer son code (voir arbre)  [r] codé sur 10
49 0 50 1
[k] lu. 1ère apparition. Index K=11 <20. Code NYT= 1100
r 2 2 (voir arbre). (K-1)=10 sera codé sur 5 bits et ajouté à
47 0 48 1
NYT=1100
 [k] codé 110001010
1 1 d
0 45 1
46
NYT 0 1 v
43 44

D’où le code du message sur 39 bits au lieu de 64 bits (ascii):

a a r d v a r k

00000 1 010001 0000011 0001011 0 10 110001010

On veut décoder le code binaire précédent:
00000 1 010001 0000011 0001011 0 10 110001010
Code  Au début on a toujours NYT
oui non
NYT
? NYT 0
51
Donc on lit e bits (e=4): 0000 (0 < r = 10)
Donc lire un bit de plus: 00000 (p=0)
Lire e bits Décode élément Décoder p+1=1 ----> [a]
après NYT mise à jour de l’arbre:
Arbre mis à jour 1 Maintenant le code de NYT est 0 et
oui Valeur p
non 0 51 1 celui de [a] est 1
de e <r
a
? NYT 0 1 Le prochain bit est 1 (non NYT)
Donc c’est de nouveau le code de
Lire un bit de pp+r 2 l’élément [a] dont le poids devient 2
plus 0 51 1
a Le prochain bit est 0 (NYT)
NYT 0 2 Les e=4 bits suivants  p=8<10
Décoder p+1
Les 5 bits donnent p=17
On décode donc 18 qui donne [r]
Arbre mis à jour
On met à jour l’arbre (page suivante)
 3 00000 1 010001 0000011 0001011 0 10 11001010
0 51 1

1 2 a Prochains bits 00  NYT:

0 49 1 50 Les e=4 bits suivants  0001  p=1<10
Les 5 bits donnent 00011 soit p=3
NYT 0 1 r On décode donc 4 qui donne [d]
47 48 On met à jour l’arbre (ci-dessous)

4
0 51 1 Prochains bits 000  NYT:
Les e=4 bits suivants 1011, soit p=11 >10
2 2 a On calcule p  p+r, soit p=21
0 49 1 50 On décode donc 22 qui donne [v]

1 1 r
0 47 1 48 On met à jour l’arbre et on inter-change les nœuds
NYT
0 1 d
45 46 On obtient l’arbre (page suivante)
 5
0 51 1 00000 1 010001 0000011 0001011 0 10 110001010
a 2 3
49 0 50 1
a
r 1 2
47 0 48 1

1 1 d
0 45 1
46
NYT 0 1 v
43 44
Prochain bit 0 (non NYT).
6 On décode donc le symbole [a]
0 51 1 On met à jour l’arbre
a 3 3
49 0 50 1
a
r 1 2
47 1
 7 Prochains bits 10 (non NYT).
0 51 1 On décode donc le symbole [r]
On met à jour l’arbre (ci-contre)
a 3 4
49 0 50 1 Prochains bits 1100  NYT:
Les e=4 bits suivants 0101 p=5 < 10
r 2 2 Les 5 bits donnent 01010 soit p=10
47 0 48 1 On décode donc 11 qui donne [k]
On met à jour l’arbre
1 1 d
0 45 1
46
NYT 0 1 v
43 44
 8
51 1
0

3 5
49 0 50 1

r 2 3
47 0 48 1

d 1
45 2
46 1
0

1 1 v
0 43 1 44

NYT 0 1 k
41 42