Proseminar Datenkompression Thema : Arithmetische Kodierung 18.03.2002Eric Bodden, Malte Clasen,...

18.03.2002 Eric Bodden, Malte Clasen, Joachim Kneis 1

Proseminar DatenkompressionThema : Arithmetische Kodierung

Arithmetische Kodierung



Motivation

Ziel des Verfahrens:• beliebige Daten verlustfrei komprimieren

Mittel und Weg:• Sequenzen durch Codes ersetzen

Methode:• Symbole durch Codes ersetzen (Huffman)• Sequenzen durch Codes ersetzen (Arithmetische

Kodierung)• Kodierung im Intervall [0,1)



Geschichte

• 1960: Elias, Abramson – Erste Ansätze

• 1976: Pasco, Rissanen – Beweis, das endlich genaue Arithmetik ausreicht

• 1980: Rubin, Guazzo, Rissanen, Langdon - Erster praktikabler Algorithmus• Scaling• FIFO-Prinzip• Erste hardwarenahe Realisierungen



Definition: Alphabet, Symbol, Sequenz

Alphabet:• endliche, nichtleere Menge

z.B. A = {a,b,c,d}

Symbol:• Element des Alphabets

z.B. a A

Sequenz:• Symbolfolge

z.B. S = abaabcda A*



Definition: Modell

Modell:

• Abbildung A [0,1): ai PM(ai)

• PM(ai) ist angenommene Wahrscheinlichkeit

• Nicht zwingend gleich mit P(ai), der korrekten Wahrscheinlichkeit

• Im Folgenden: Annahme eines einfachen Modells



Beispiel: Modell

a 6,51 % h 4,76 % o 2,51 % v 0,67 %

b 1,89 % i 7,55 % p 0,79 % w 1,89 %

c 3,06 % j 0,27 % q 0,02 % x 0,03 %

d 5,08 % k 1,21 % r 7,00 % y 0,04 %

e 17,40 % l 3,44 % s 7,27 % z 1,13 %

f 1,66 % m 2,53 % t 6,15 %

g 3,01 % n 9,78 % u 4,35 %



Definition: Entropie

Entropie H ist Maß für Informationsgehalt einer Sequenz S

Definition:

Beachte: [H] = Bits / Symbol



Definition: Modellabhängige Entropie

Problem: Korrekte Wahrscheinlichkeiten nicht bekannt

Also Differenzierung nötig

Modellabhängige Entropie

Definition:



Beispiel: Entropie (1)

Angepaßte Entropie der Sequenz „abaabcda“ unter dem Modell

a=50%, b=25%, c=12,5%, d=12,5%. (Modell mit korrektem PM)



Beispiel: Entropie (2)

Angepaßte Entropie der Sequenz „abaabcda“ unter dem Modell

a=12,5%, b=12,5%, c=50%, d=25% (Modell mit schlechtem PM)



Definition: Kodierer/Dekodierer

Kodierer:

• Algorithmus, der eine gegebene Sequenz S kodiert

• Ausgabe: Code(S)

Dekodierer:

• Algorithmus, der S wieder aus Code(S) herstellt



Einführung: Kodierung

• Relative Häufigkeiten aller Symbole über Alphabet A ergeben addiert 1

• Einzelne relative Häufigkeiten können als Teilintervalle von [0,1) aufgefasst werden

• Logische Konsequenz: Überschneidungsfreies Verteilen der Teilintervalle über das Gesamtintervall

• Resultat: Partition von [0,1)



Kodierung in R: Grundidee Intervallbildung

Idee: Wahrscheinlichkeiten werden kumuliert

Dies liefert Teilintervall von [0,1) für jedes Symbol des Alphabets

a cb d

0 0,5 0,75 0,875 1



Kodierung in R: Kumulierte Wahrscheinlichkeiten

Intervall aufteilen durch kumulierte Wahrscheinlichkeiten

dazu Definition von K(ak) für ak A:



Intervallschachtelung

• Für das erste Symbol ordnen wir diesem ein Teilintervall zu

• Für das zweite betrachten wir dann dieses Teilintervall und partitionieren dies

• Iterieren bis Sequenzende...

• Ergebnis: Teilintervall von [0,1)



Kodierung in R: Die Grenzen low und high

Bezeichnung der Intervallgrenzen:

•untere Grenze: low

•obere Grenze: high

Grenzen werden im weiteren Verlauf nach dem Lesen jeden Symbols aktualisiert:



Kodierung in R: Baumartige Partitionierung

daraus resultiert: Baumartige Partitionierung von [0,1)

a

b c

d

ab c

d ab c

d ab c

d ab c

d

0 1

. . .. . . . . . . . .

s1

s2

s3...



Kodierung in R: Beispiel (1)

0

1

0,5

d

c

b

a

d

c

b

a

0

0,5

0,25

d

c

b

a

0,25

0,3125

0,375d

c

b

a

0,25

0,28125

0,3125d

c

b

a

0,25

0,265625

0,28125

Eingabe a Eingabe b Eingabe a Eingabe a



Kodierung in R: Beispiel (2)

d

c

b

a

0,25

0,265625

0,28125d

c

b

a

0,265625

0,26953125

0,2734375d

c

b

a

0,271484375

0,2719726563

0,2724609375d

c

b

a

0,2723388672

0,2723999024

0,2724609375

0,2723388672

0,2723693848

0,2723999024

Zie

linte

rva

ll

d

c

b

a

Eingabe b Eingabe c Eingabe d Eingabe a



Kodierung in R: Algorithmus in Pseudocode

low =0;

high=1;

do {

temp = lies_zeichen();

low‘ = Modell-> untere_Grenze(temp,low,high);

high‘ = Modell-> obere_Grenze (temp,low,high);

low = low‘;

high = high‘;

} while ( !ende_der_sequenz() );

return( wert_im_intervall(low,high) );



Abschluß der Codesequenz

Sequenzende muß dem Dekodierer mitgeteilt werden

Möglichkeiten:

• Intervallgrenzen übertragen

• Länge der Sequenz übertragen

• Endsymbol mit minimaler Wahrscheinlichkeit im Modell bereitstellen



Einführung: Dekodierung

• Idee: Schritte des Kodierers nachvollziehen

• Schritte laufen genau parallel zum Kodierungsvorgang

• Eingabe: Code in Form einer Zahl aus dem Zielintervall des Kodierers

• Verfahren: Überprüfen, in welches Teilintervall diese Zahl fällt, Teilintervall neu aufteilen und iterieren bis Sequenzende erreicht



Dekodierung in R: Beispiel (1)

0

1

0,5

d

c

b

a

d

c

b

a

0

0,5

0,25

d

c

b

a

0,25

0,3125

0,375d

c

b

a

0,25

0,28125

0,3125d

c

b

a

0,25

0,265625

0,28125

Ausgabe a Ausgabe b Ausgabe a Ausgabe a



Dekodierung in R: Beispiel (2)

d

c

b

a

0,25

0,265625

0,28125d

c

b

a

0,265625

0,26953125

0,2734375d

c

b

a

0,271484375

0,2719726563

0,2724609375d

c

b

a

0,2723388672

0,2723999024

0,2724609375

0,2723388672

0,2723693848

0,2723999024

Zie

linte

rva

ll

d

c

b

a

Ausgabe b Ausgabe c Ausgabe d Ausgabe a



Dekodierung in R: Algorithmus in Pseudocode

Eingabe: „Zahl“

seq ='';low =0;high =1;do{

low‘ = modell->untere_grenze(Zahl,low,high);high‘ = modell->obere_grenze (Zahl,low,high);low = low‘;high = high‘;seq .= modell->symbol_zu_intervall(low,high);

}while ( !ende_der_sequenz() );return(seq);



Zusammenfassung

Bisher:

• Kodierung über reellen Zahlen

• [0,1) in Teilintervalle aufteilen

• sukzessive Intervalle aufziehen

Problem:

• unendliche Genauigkeit vorausgesetzt



Kodierung mittels Integers (Implementierung)

Warum Integers?• keine unendlichen reellen Zahlen im Rechner• Integer in einfachen CPU schneller als Float• geringer Speicherbedarf

Konsequenz• diskretes Intervall: [0,max_int] , max_int N• max_int: größter darstellbarer Integerwert



Die Wahrscheinlichkeitsgrenzen low_count und high_count

Wahrscheinlichkeitsgrenzen entsprechend anpassen:

low_count = low * total

high_count = high * total

total = Summe der

Häufigkeiten der Symbole

1

0

low

high

total

0

low_count

high_count



Der Kodierer

3 statische Variablen• mLow = untere Grenze (0)• mHigh = obere Grenze (max_int)• mStep = Schrittweite

Interface

void Encoder( unsigned int low_count,

unsigned int high_count,

unsigned int total );



Grenze

0

m Low

m H ighm ax_ in t

0

low _count

h igh_count

tota l

a

b

c

0

m Low

m H igh

m ax_ in t

d



Beispiel: Kodierung

„a“:Encode( 0, 4, 8 ); [Pa=4,Pb=2,Pc=1,Pd=1]

mStep = ( mHigh - mLow + 1 ) / total;= ( 127 - 0 + 1) / 8= 128 / 8 = 16

mHigh = mLow + mStep * high_count - 1;= 0 + 16 * 4 - 1= 64 – 1 = 63

mLow = mLow + mStep * low_count;= 0 + 16 * 0 = 0



Der Dekodierer

Interface:

Wahrscheinlichkeitsintervall bestimmen

uint Decode_Target( unsigned int total );

Encoder nachbilden

void Decode( unsigned int low_count,

unsigned int high_count );



Beispiel: Dekodierung (1)

Decode_Target( 8 ); [Pa=4,Pb=2,Pc=1,Pd=1]

mStep = ( mHigh - mLow + 1 ) / total;= ( 127 - 0 + 1 ) / 8= 128 / 8 = 16

value = ( mBuffer - mLow ) / mStep;= ( 40 - 0 ) / 16= 40 / 16 = 2return value; // 2 [0,4) = „a“



Beispiel: Dekodierung (2)

Decode( 0, 4 ); [Pa=4,Pb=2,Pc=1,Pd=1]

mHigh = mLow + mStep * high_count - 1;= 0 + 16 * 4 - 1= 64 – 1 = 63

mLow = mLow + mStep * low_count;= 0 + 16 * 0 = 0



Problem: Begrenzt genaue Arithmetik

Problem:

• Bei bisherigem Verfahren wird betrachtetes Intervall beliebig klein.

• Folge: total > mHigh – mLow

• also: (mHigh – mLow + 1) / total = 0



Lösung: Skalierung des Intervalls

Aber:• Führende Stellen von mHigh und mLow gleich, also

unveränderlich

Also:• Führende Stellen schon senden/speichern• Intervall entsprechend vergrößern

Mittel dazu:• Skalierungsfunktionen



Definition: E1-Skalierung

while( mHigh < g_Half )

{

SetBit( 0 );

mLow = mLow * 2;

mHigh = mHigh * 2 + 1;

}

* 2 entspricht Shift nach links0

1

0,5

0

0,5

0,25




while( mLow >= g_Half )

{

SetBit( 1 );

mLow = 2*(mLow-g_Half);

mHigh = 2*(mHigh-g_Half)+1;

}

0

1

0,5

0,5

1

0,75



Problem: Was tun bei Intervallmitte?

Problem bei mittig liegendem Intervall:

• führende Stellen von mLow und mHigh bleiben längere Zeit invers zueinander

• Folge: E1/E2-Skalierung nicht anwendbar

• Also: gleiches Problem wie zuvor



Lösung

Bei mittig liegendem Intervall:• Intervall mittig aufziehen• iterieren bis obere bzw. untere Hälfte festliegt

Folge:• E3-Skalierung




while( ( g_1Q <= mLow ) && ( mHigh < g_3Q ) )

{

mScale++;

mLow = 2*(mLow-g_1Q);

mHigh= 2*(mHigh-g_1Q) + 1;

}

0

1

0,5

0,25

0,75

0,5



Beispiel: E3-Skalierung

0

1

0,5

0,25

0,75

0,5

0,375

0,625

0,5

0,375

0,5

0,4375

Schritt 1 Schritt 2 Schritt 3

E3, E3, E1



Beispiel: Gleichheit von E1 E3^n und E2^n E1

0

1

0,5

0

0,5

0,25

0,25

0,5

0,375

0,375

0,5

0,4375

Schritt 1 Schritt 2 Schritt 3

Anwendung von E1, E2, E2 (also 011)



Beweis der Gleichheit (1)

Formalisierung dieser Gleichheit durch Hintereinanderausführung der Abbildungen:



Auflösung E3-Skalierung (1)

Bisher nur E3-Skalierungen mitgezählt.

Nun, wo die Hälfte feststeht, noch entsprechende Bits ausgeben:while( ( mHigh < g_Half ) || ( mLow >= g_Half ) ) {

if( mHigh < g_Half ) // E1{

SetBit( 0 );mLow = mLow * 2;mHigh = mHigh * 2 + 1;for(; mScale > 0; mScale-- )SetBit( 1 ); // 1 == !0

}...}



Auflösung E3-Skalierung (2)

while( ( mHigh < g_Half ) || ( mLow >= g_Half ) ) {

...

else if(mLow >= g_Half ) // E2

{

SetBit( 1 );

mLow = 2 * ( mLow - g_Half );

mHigh = 2 * ( mHigh - g_Half ) + 1;

for(; mScale > 0; mScale-- )

SetBit( 0 ); // 0 == !1

}

}



Dekodierer: Buffer auch skalieren

Im Dekoder muß der Buffer noch nachskaliert werden:

// E1

mBuffer = 2 * mBuffer + GetBit();

// E2

mBuffer = 2 * (mBuffer-g_Half) + GetBit();

// E3

mBuffer = 2 * (mBuffer-g_1Q) + GetBit();



Zusammenfassung Kodierer

Kodierer:

void Encode( unsigned int low_count, unsigned int high_count, unsigned int total );

void EncodeFinish();

EncodeFinish() schließt die Sequenz korrekt ab.



Abschluß der Codesequenz

if( mLow < g_1Q ) // mLow < 1Q < Half <= mHigh{

SetBit( 0 ); // 1 + e3-Skalierung abbauen

for( int i=0; i<mScale+1; i++ ) SetBit( 1 );}else // mLow < Half < 3Q <= mHigh{ SetBit( 1 ); // der Decoder fügt die Nullen automatisch an}



Zusammenfassung Dekodierer

Dekodierer:

void DecodeStart()=

for( int i=0; i<31; i++ )

mBuffer = ( mBuffer << 1 ) | GetBit();

uint DecodeTarget(unsigned int total );

void Decode(unsigned int low_count, unsigned int high_count );



Effizienzbetrachtung (1)

Länge des Codes für jedes Symbol ai A kann wie folgt beschränkt werden:

Im folgenden: Wahrscheinlichkeiten über Sequenzen anstatt

Symbolen betrachten. l(x)




Durchschnittliche Länge >= Entropie

Also durchschnittliche Länge pro Symbol:




Entropie der Sequenz S(m) mit |S(m)|=m ist m-fache Entropie der Symbole x:

Es folgt:



Effizienzbetrachtung – Vergleich Huffman

Für Huffman bekannt:

Für Extended Huffman:



Nachteile gegenüber der Huffman-Kodierung

Nachteil bei sequentieller Kodierung:Wird ein Bit falsch empfangen, so ist der gesamte nachfolgende Code nicht korrekt dekodierbar.

Huffman unter Umständen speicher-effizienter bei:

• großen Alphabeten und kurzen Sequenzen[(0,086+Pmax)* HM(S) ] oder

• Wahrscheinlichkeiten von P(a)=2n

Arithmetische Kodierung i.a. etwas langsamer als Huffman



Vorteile gegenüber der Huffman-Kodierung

• Meist höhere Speichereffizienz,auch in Bezug auf Arbeitsspeicher

• Grund: Vergabe unganzzahliger Bitlängen sowie Nutzung konstant großen Arbeitsspeichers

• Noch effizienter für kleine Alphabete

• Leichtes Aufsetzen verschiedener Modelle möglich

• Adaptive Modelle leichter zu implementieren



Alternative Modelle

• Statische Modelle• Feste angenommene Wahrscheinlichkeitsverteilung

• Adaptive Modelle• Wahrscheinlichkeiten werden beim Lesen jedes

Symbols neu berechnet• Vorteile:

Modell muss nicht übertragen werden Modell passt sich den Daten an



Order-n-Modelle

Betrachtung der Wahrscheinlichkeiten im Kontext der letzten n Symbole

Beispiel:

„u“ an sich: Wahrscheinlichkeit 4,35 %

„u“ nach „q“: Wahrscheinlichkeit 99 %

genauere Vorhersage durch Kontext



PPM

Order „0..n“

• Symbol in Order-n-Kontext: Kodiere Symbol

• Sonst: Wechsel zu n-1-Kontext

• Order -1: Speichere Symbole in Gleichverteilung

Für jeden Kontext eigene Verteilung



PPM (2)

Probleme

• Order-Wechsel für Decoder kennzeichnen

• hoher Speicherbedarf

Vorteile

• praktisch bestmögliche Kompression (neben BWT)

• gut auch bei kleinen Dateien ( < 1 Mb )



Zusammenfassung

Arithmetische Kodierung ist zur Kompression geeignet

Implementierung mit Integers oder Floats möglich

Sequentielles Arbeiten ist möglich und sinnvoll

Dazu Methode des Scaling erforderlich

Verfahren sehr effizient für realistische Quellen

Möglichkeit des modularen Austauschs von Modellen

Sehr gut für adaptive Modelle, Erweiterungen wie PPM



Ausblicke

Range Coder:

• Benutzt ganze Bytes statt Bits für Skaling-Methoden

• Resultat: Bis zu 50% schneller bei nur 0,01% längerem Code

In Zukunft:

• aufgrund schnellerer Float-Operationen (z.B. Itanium)eher Entwicklung in diese Richtung, weg von Integer-Arithmetik



Implementierung

Implementierung in C++

• Einfacher Kodierer / Dekodierer

• Auswahl verschiedener Modelle möglich

• Visualisierung mit Kodierer als DLL

• Download möglich unter:http://ac.bodden.de

Proseminar Datenkompression Thema : Arithmetische Kodierung 18.03.2002Eric Bodden, Malte Clasen,...

Documents

Transcript of Proseminar Datenkompression Thema : Arithmetische Kodierung 18.03.2002Eric Bodden, Malte Clasen,...