WORKSHOP SISTEM KOMUNIKASI MULTIMEDIA

LAPORAN : Resmi
JUDUL : Pengenalan Teknik Kompresi Pada Teks
PERCOBAAN :4
NAMA : Muhammad Dicky Athalla
KELAS : 3D3TA
NRP : 1203191017
DOSEN : Hendy Briantoro S.ST., MT.
TANGGAL : 5 November 2021
 TUJUAN
• Mahasiswa mampu memahami teknik-teknik kompresi pada teks
• Mahasiswa mampu menggunakan kompresi teks untuk sistem komunikasi multimedia
DASAR TEORI
Definisi Kompresi Data
Kompresi data adalah sebuah teknik pada ilmu komputer untuk mengecilkan ukuran
data. Banyak orang juga menyebut hal ini dengan memampatkan data. Jadi , data yang ada
dimampatkan menjadi lebih kecil dari ukuran sebenarnya dengan tujuan menghemat ruang
penyimpanan. Apabila kompresi data dilakukan, otomatis Anda hanya membutuhkan
ruang penyimpanan yang lebih kecil. Selain dinilai lebih efisien, kompresi data juga
mempercepat waktu pertukaran data.
Jika Anda masih bingung dengan penjelasan diatas coba simak contoh berikut ini.
Contoh yang paling sering dijumpai adalah menyingkat kata-kata umum yang sering
digunakan seperti “yang” menjadi “yg”. Kompresi data dianggap satu hal yang penting
karena selain mempercepat proses pertukaran data juga mengecilkan kebutuhan
bandwidth. Kompresi data bahkan tidak hanya berlaku untuk teks saja, melainkan gambar
(JPEG, PNG, TIFF), audio (MP3, AAC, RMA, WMA) dan juga video (MPEG, H261,
H263).
Ada beberapa hal yang harus Anda perhatikan agar kompresi data ini dapat berjalan
dengan lancar. Pengiriman data hasil kompresi hanya dapat dilakukan apabila pengirim
dan penerima mempunyai aturan yang sama dalam kompresi data. Selain itu pengirim juga
harus menggunakan algoritma kompresi data yang baku dan pihak penerima pun memakai
teknik dekompresi data yang sama dengan pengirim agar data dapat terbaca.

Jenis-jenis Kompresi Data

Setelah mengetahui dan memahami arti dari kompresi data, Anda juga harus tahu jenis-
jenis dari kompresi data. Terdapat dua jenis kompresi data yaitu Loseless Data
Compression dan Lossy Data Compression. Berikut uraiannya :
1) Loseless Data Compression
Loseless Data Compression adalah teknik kompresi data dimana data kompresi dapat
didekompres kembali. Selain itu hasil kompresi data yang dihasilkan sama persis seperti
data asli sebelum dilakukan kompresi. Contoh dari Loseless Data Compression adalah
ZIP, RAR dan 7-ZIP. Pemakaian Loseless Data Compression biasanya untuk akurasi
data yang sangat penting seperti data teks, data program dan Image (PNG, GIF).

2) Lossy Data Compression

Lossy Data Compression adalah teknik pemampatan data yang hasilnya tidak sama
dengan data aslinya, namun tidak menjadikannya masalah. Teknik Lossy Data
 Compression ini contohnya adalah MP3, Streaming Media, JPEG, MPEG dan WMA.
Penggunaan teknik Lossy Data Compression data ini dinilai lebih efisien dibandingkan
dengan Loseless Data Compression. Alasannya yaitu teknik Lossy Data Compression
hanya membuang bagian-bagian data yang kurang penting. Oleh sebab itu data yang
dihasilkan masih bisa digunakan meskipun beberapa bagian dari data aslinya ada yang
dihilangkan.

Metode Pengkrompesian Data Pada Teks

1) RUN-LENGTH ENCODING (RLE)

Run-Length Encoding (RLE) merupakan metode kompresi data lossless yang
sangat sederhana. Teknik kompresi dengan RLE ini berguna untuk data yang banyak
memiliki kesamaan (homogen) dan data tersebut berdekatan. Pada RLE urutan data
dimana data yang sama terjadi di banyak elemen data berurutan akan disimpan sebagai
nilai dan penghitungan data tunggal, bukan seperti proses asli.
RLE sangat efisien digunakan untuk data yang mengandung banyak proses seperti
itu, seperti gambar grafik sederhana misalnya icon, gambar garis, dan animasi. Untuk
file yang tidak mempunyai kesamaan data yang berdekatan, maka RLE justru akan
membuat ukuran data tersebut menjadi semakin besar.

2) STATIC HUFFMAN CODING (SHC)

● Berbasis pada perhitungan statistik
● Menggunakan bantuan pohon biner
● Data yang frekuensi munculnya paling banyak di kode dengan jumlah bit terkecil
● Data yang frekuensi munculnya paling sedikit dikode dengan jumlah bit terbesar

Algoritma :

- Frekuensi karakter dari string yang akan dikompres dianalisa terlebih dahulu.
Selanjutnya dibuat pohon huffman yang merupakan pohon biner dengan root awal
yang diberi nilai 0 (sebelah kiri) atau 1 (sebelah kanan), sedangkan selanjutnya
untuk dahan kiri selalu diberi nilai 1(kiri) - 0(kanan) dan di dahan kanan diberi nilai
0(kiri) – 1(kanan)
- A bottom-up approach = frekuensi terkecil dikerjakan terlebih dahulu dan
diletakkan ke dalam leaf(daun).
- Kemudian leaf-leaf akan dikombinasikan dan dijumlahkan probabilitasnya
menjadi root di atasnya.
 - Misal:

MAMA SAYA

A = 4 -> 4/8 = 0.5

M = 2 -> 2/8 = 0.25

S = 1 -> 1/8 = 0.125

Y = 1 -> 1/8 = 0.125

Total = 8 karakter

3) ADAPTIVE HUFFMAN CODING (AHC)

Pengkodean Huffman dinamis, atau disebut juga pengkodean Huffman adaptif,
pertama kali disusun oleh Faller dan Gallager. Kemudian, D. E. Knuth melakukan
peningkatan terhadap algoritma tersebut dan menghasilkan algoritma baru yang disebut
algoritma FGK. Versi terbaru dari pengkodean Huffman dinamis dideskripsikan oleh
Vitter pada tahun 1987, yang disebut sebagai Algoritma V.
Proses Encoding dan Decoding
Proses encoding dan decoding dalam pengkodean Huffman dinamis
menginisialisasi pohon Huffman dengan sebuah pohon bersimpul tunggal yang
berkorespondensi dengan sebuah karakter artifisial, ditunjukkan dengan simbol ART.
Bobot dari simpul tunggal ini adalah 1. berikut adalah proses dari encoding dan
decoding:
Proses encoding:
Setiap pembacaan simbol a dari teks sumber, codeword-nya dalam pohon
dikirimkan. Namun, hal ini hanya dilakukan jika a telah muncul sebelumnya.
Jika tidak, kode dari ART dikirimkan diikuti oleh codeword asli dari a. Kemudian,
pohon tersebut dimodifikasi sebagai berikut:

Jika a belum pernah muncul sebelumnya, sebuah simpul internal dibuat dan kedua
simpul anaknya berisi a dan ART. Kemudian, pohon tersebut diperbaharui untuk
mendapat pohon Huffman dari teks yang sudah dibaca.
Input.
Alphabet A = {a[1], a[2], ..., a[n]}memakai simbol alphabet dengan ukuran n.Set
C = {c[1], c[2], ..., c[n]} dengan konfigurasi nilai simbol, c[i] = nilai (a[i]),
1 <= i <= n.

Output.
Code H(A,C) = {h[1], h[2], ..., h[n]} dengan konfigurasi (biner) codewords,
dimana h[i] adalah codeword dari a[i],
1 <= i <= n.

Goal.
Let S(H) = sum (c[i] * length (h[i])) (1 <= i <= n) akan mengembang dari batas
awal kode H. Harus: S(H) <= S(T) untuk semua kode T(A,C).

Contoh:
Sample-1

Sample-2
 Proses Updating
Selama proses encoding dan decoding, pohon sementara harus diperbaharui
untukmendapatkan frekuensi simbol yang benar. Ketika karakter baru diketahui
bobotnya, bobot daun yang berasosiasi dengan karakter tersebut bertambah
satu, dan bobot dari simpul-simpul diatasnya dimodifikasi. Kebenaran pohon
yang terbentuk dilihat dari siblings property pohon tersebut.

Proses updating bekerja sebagai berikut:

1. Bobot dari daun n yang berkorespondensi dengan a ditambah 1
2. Jika siblings property-nya tidak sesuai lagi, maka simpul n ditukar
dengan simpulterdekat, m (m<n) sehingga bobot (m) < bobot (n).
3. Simpul-simpul tersusun menurun sesuai bobotnya.

4) SHANON FANO (SFA)

Algoritma Shannon-Fano coding ditemukan oleh Claude Shannon (bapak teori
informasi) dan Robert Fano pada tahun 1949. Pada saat itu metode ini merupakan
metode yang paling baik tetapi hampir tidak pernah digunakan dan dikembangkan lagi
setelah kemunculan algoritma Hufman. Pada dasarnya metode ini menggantikan setiap
simbol dengan sebuah alternatif kode biner yang panjangnya ditentukan berdasarkan
probabilitas dari simbol tersebut Di bidang kompresi data, Shannon-Fano coding adalah
teknik untuk membangun sebuah kode awalan didasarkan pada seperangkat simbol dan
probabilitas (diperkirakan atau diukur). Namun, algoritmya ini dirasa kurang optimal
dalam arti bahwa ia tidak mampu mencapai kode seefisien mungkin seperti kode
diharapkan panjang seperti algoritma Huffman.
Pada dasarnya cara kerja dari algoritma ShannonFano ini sama persis dengan Huffman.
Algoritma ini membentuk sebuah pohon, kemudian meng1encodingnya, dan yang
terahir adalah megnembalikannya dalam bentuk karakte teks atau decoding. Hanya saja
perbedaan yang fundamental terdapat pada pembuatan pohon. Pembuatan pohon pada
Shannon-Fano dibuat berdasarkan proses dari atas ke bawah – berbeda dengan huffman
yang membuat pohon dari bawah ke atas. Sebuah pohon Shannon-Fano dibangun sesuai
dengan spesifikasi yang dirancang untuk mendefinisikan tabel kode yang efektif.
Algoritma yang sebenarnya sederhana:
1. Untuk daftar simbol-simbol tertentu, mengembangkan sebuah daftar yang sesuai
probabilitas atau frekuensi dihitung sehingga setiap simbol frekuensi relatif
kejadian diketahui.
2. Menyortir daftar simbol-simbol sesuai dengan frekuensi, dengan simbol-simbol
yang paling sering terjadi di sebelah kiri dan yang paling umum di sebelah kanan.
3. Membagi daftar menjadi dua bagian, dengan total frekuensi dihitung dari kiri
setengah menjadi seperti dekat dengan jumlah yang tepat mungkin.
4. Kiri setengah dari daftar ditetapkan angka biner 0, dan hak diberikan setengah digit
1. Ini berarti bahwa kode untuk simbol-simbol pada semester pertama semua akan
dimulai dengan 0, dan aturan - aturan di paruh kedua akan semua mulai dengan 1.
5. Rekursif menerapkan langkah 3 dan 4 untuk masing-masing dari dua bagian,
membagi kelompok dan menambahkan kode bit sampai setiap simbol telah
menjadi kode yang sesuai daun di pohon. Untuk mempermudah, diilustrasikan
dengan gambar berikut.
Contoh menunjukkan pembangunan kode Shannon alfabet kecil. Kelima simbol-
simbol yang dapat dikodekan memiliki frekuensi berikut: A = 15 ; B = 7 ; C = 6 ; D =
6 ; E = 5 Semua simbol-simbol yang diurutkan berdasarkan frekuensi, dari kiri ke kanan
(ditunjukkan pada Gambar a). Menempatkan garis pemisah antara simbol-simbol B dan
C menghasilkan total 22 di grup kiri dan total 17 di kelompok yang tepat. Ini
meminimalkan perbedaan total antara dua kelompok. Dengan pembagian ini, A dan B
akan masing-masing memiliki kode yang dimulai dengan 0 bit, dan C, D, dan E kode
akan semua mulai dengan 1, seperti ditunjukkan pada Gambar b. Kemudian, di sebelah
kiri setengah dari pohon mendapat divisi baru antara A dan B, yang menempatkan A
pada daun dengan kode 00 dan B pada daun dengan kode 01. Setelah empat divisi
prosedur, pohon hasil kode. Pohon di final, tiga simbol dengan frekuensi tertinggi
semuanya telah ditugaskan 2-bit kode, dan dua simbol dengan tuntutan yang lebih
rendah memiliki 3-bit kode seperti ditunjukkan tabel di bawah ini:

Setelah pohon jadi, maka proses selanjutnya adalah sama yaitu encoding dan
decoding.
5) LEMPEL-ZIV-WELCH (LZW)
Algoritma LZW dikembangkan oleh Terry A.Welch dari metode kompresi
sebelumnya yang ditemukan oleh Abraham Lempel dan Jacob Ziv pada tahun 1977.
Algortima ini menggunakan teknik dictionary dalam kompresinya. Dimana string
karakter digantikan oleh kode table yang dibuat setiap ada string yang masuk. Tabel
dibuat untuk referensi masukan string selanjutnya. Ukuran tabel dictionary pada
algoritma LZW asli adalah 4096 sampel atau 12 bit, dimana 256 sampel pertama
digunakan untuk table karakter single (Extended ASCII), dan sisanya digunakan untuk
pasangan karakter atau string dalam data input.
 LANGKAH KERJA, HASIL, DAN ANALISA

1. RUN-LENGTH ENCODING (RLE)

LANGKAH-LANGKAH
Untuk melalukan percobaan ini diperlukan Python versi 2.7. Langkah-langkah
percobaan dijelaskan seperti berikut ini.
1. Buat aplikasi kompresi dan dekompresi menggunakan metode RLE. Source code
program seperti di bawah ini.
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys, struct, re

class RLEPair(object) :
def __init__(self, data=None, length=None):
self.m_data = data
self.m_length = length

class RLE(object) :
def __init__(self):
self.m_RLE = []
self.m_runs=0
self.m_size=0

def CreateRLE(self, p_array):

self.m_RLE.append(RLEPair(p_array[0],chr(1)))
self.m_size=len(p_array)
for index in xrange(1, len(p_array)) :
if p_array[index] != self.m_RLE[-1].m_data:

self.m_RLE.append(RLEPair(p_array[index],chr(1)))
else:
if(ord(self.m_RLE[-1].m_length) ==
255):

self.m_RLE.append(RLEPair(p_array[index],1))
else :
self.m_RLE[-1].m_length =
chr(ord(self.m_RLE[-1].m_length) + 1)
self.m_runs = len(self.m_RLE)

def FillArray(self, p_array):

for currentrun in xrange(0, self.m_runs):
for i in xrange(0,
ord(self.m_RLE[currentrun].m_length)):

p_array.append(self.m_RLE[currentrun].m_data)
 def SaveData(self, p_name):
file = open(p_name, 'wb+')
file.write(struct.pack('i', self.m_size))
file.write(struct.pack('i', self.m_runs))
for i in self.m_RLE : #A la différence de C++
où je pourrais copier un bloc de mémoire dans le
fichier car il est contigüe, je suis obligé d'itérer
sur la liste
file.write(i.m_length)
file.write(i.m_data)

def LoadData(self, p_name):

file = open(p_name, 'rb')
self.m_size = int(struct.unpack('i',
file.read(struct.calcsize('i')))[0])
self.m_runs = int(struct.unpack('i',
file.read(struct.calcsize('i')))[0])
#La liste n'est pas une perception sur les
données en mémoire comme en C mais une structure réél à
remplir (sauf en utilisant ctypes)
length=file.read(1)
while length :
data=file.read(1)
self.m_RLE.append(RLEPair(data,length))
length=file.read(1)

def run_1(filename):
uncompressed=[]
compressed=RLE()
original = open(filename, 'r').read()
compressed.CreateRLE(original)
compressed.SaveData(filename+'.rle')
print 'Original File Size: ' +
str(compressed.m_size)
print 'Compressed File Size: ' +
str(compressed.m_runs*2)
print 'Compression Ratio: ' +
str(float(compressed.m_size)/(compressed.m_runs*2))
compressed.FillArray(uncompressed)
print 'Checking Array Integrity...'
for index in xrange(0, compressed.m_size):
if original[index] != uncompressed[index]:
print 'ERROR, DECOMPRESSION UNSUCCESSFUL!!'
sys.exit(1)
print 'Arrays match!'

def run_2(dataname):
uncompressed=[]
compressed=RLE()
compressed.LoadData(dataname)
 compressed.FillArray(uncompressed)
open(dataname[:-4],'w').write("".join(i for i in
uncompressed))
print 'Decompressed to ' + dataname[:-4]

if len(sys.argv) is 1 :
exit('missing source-file name')

if re.match('.+.rle$', sys.argv[1]) :
run_2(sys.argv[1])
else:
run_1(sys.argv[1])

2. Siapkan file txt yang akan dikompres

3. Untuk melakukan kompresi file dapat melalui CMD atau terminal (pada Linux atau
MacOS). Perintah untuk melakukan kompresi file seperti berikut ini
python rle_compress_decompress.py full-of-As.txt
File rle_compress_decompress.py merupakan program yang sudah dibuat dan file
full-of-As.txt merupakan file txt yang ingin dikompres.
4. Hasil kompresi file berada di dalam folder yang sama dengan program RLE tersebut
dan akan memiliki file format .rle.
5. Untuk melakukan dekompresi dapat melalui CMD atau terminal (pada Linux atau
MacOS) dengan perintah seperti berikut.
python rle_compress_decompress.py full-of-As.txt.rle
File rle_compress_decompress.py merupakan program yang sudah dibuat dan file
full-of-As.txt.rle merupakan file rle yang ingin didekompres.
 HASIL PERCOBAAN

File asli pada percobaan ini berukuran sekitar 11 KB dan hasil kompresi file
menghasilkan file baru dengan ukuran sekitar 1 KB. Di bawah ini merupakan perbandingan
isi dari file asli dengan file hasil kompresi menggunakan metode RLE.

File asli File hasil kompresi

File hasil kompresi akan menghasilkan file dengan format .rle. Jika file hasil kompresi
tersebut didekompresi kembali, maka ukuran file hasil kompresi akan kembali seperti semula,
yakni ukurannya sama persis dengan file asli. Pada percobaan ini file hasil kompresi berukuran
sekitar 1 KB dan file hasil dekompresi berukuran sekitar 11 KB. Di bawah ini merupakan
perbandingan isi dari file hasil kompresi dengan file hasil dekompresi menggunakan metode
RLE.
 File hasil kompresi File hasil dekompresi

ANALISA
Berdasarkan hasil percobaan terlihat bahwa ukuran file setelah dikompresi akan
menjadi lebih kecil dibandingkan file asli. Namun tidak semua jenis file teks akan
menghasilkan ukuran yang lebih kecil ketika dikompresi menggunakan metode RLE. File yang
akan menghasilkan ukuran lebih kecil adalah file yang memiliki urutan data sama yang saling
berdekatan, sebagai contoh file teks dengan data AAAAAAAAAAAADDDDCCAAAA. Jika
berdasarkan data tersebut maka data yang disimpan setelah dikompresi menggunakan RLE
akan menjadi 12A4D2C4A, yang artinya urutan data karakter A sebanyak 12 dan seterusnya.
Jika file yang dikompresi merupakan file teks dengan data urutan yang berdekatan
banyak yang tidak sama, maka akan menghasilkan ukuran kompresi yang jauh lebih besar jika
dibandingkan dengan file asli.
Saat melakukan dekompresi file menggunakan metode RLE, ukuran file hasil
dekompresi akan sama dengan ukuran file sebelum dilakukan kompresi.
 2. STATIC HUFFMAN CODING (SHC)

LANGKAH-LANGKAH

1. Instal terlebih dahulu library yang akan digunakan, pada percobaan ini
menggunakan library bitarray
2. Mengimport modul yang akan digunakan dimana pada percobaan ini
menggunakan modul heapq
3. Memasukkan teks yang akan dikompres
4. Menentukan frekuensi munculnya huruf pada teks yang diinputkan sebelumnya
5. Setelah menentukan frekuensi yang muncul, selanjutnya buat huffman tree pada
program
6. Selanjutnya ke tahap huffman encoding, teks yang dimasukan akan dicetak hasil
kompresinya
7. Terakhir tahap dekompresi atau pada program bernama decoding, file hasil
encoding atau hasil kompresi akan dikembalikan ke ukuran semula

SOURCE CODE

Memasukkan teks yang akan dikompres, teks dalam contoh ini adalah “Urifah
Nur Rohmah” dengan ukuran 17 byte.

Menentukan frekuensi keluarnya dari setiap karakter

Pohon Huffman

Proses kompresi teks. Teks yang semula berukuran 17 byte dikompres sehingga
ukurannya menjadi 5 byte.
Proses dekompresi teks.
ANALISA

Prinsip kerja metode Huffman adalah mengkodekan setiap karakter dalam

representasi bit. Representasi bit untuk setiap karakter berbeda antara satu dengan lainnya
yang didasarkan pada frekuensi kemunculan karakter. Semakin sering karakter itu muncul,
maka semakin pendek representasi bitnya. Sebaliknya, semakin jarang karakter itu muncul,
maka semakin panjang representasi bit untuk karakter tersebut. Analisis pada metode
Huffman akan menggunakan Huffman tree yang dilakukan pada tempat tersendiri, agar
proses kompresi menjadi efektif. Penggunaan Huffman tree berdasarkan hasil penelitian yang
mengemukakan bahwa jika ukuran file yang dikompresi kecil maka file hasil kompresi bisa
jadi bukan semakin kecil tetapi malah semakin besar karena harus menyimpan Huffman tree
yang dihasilkan. Informasi pada Huffman tree baru akan dibuat dengan menggunakan tabel
Huffman yang terbentuk dari tree itu sendiri dalam bentuk biner dan bersifat statis, yang berisi
kode-kode Huffman yang terbentuk dari karakter-karakter yang akan digunakan.
 3. ADAPTIVE HUFFMAN CODING (AHC)
LANGKAH-LANGKAH
1) Buat program untuk kompresi teks menggunakan bahasa python.
2) Membuat class untuk cabang pada adaptive huffman coding.

3) Inisialisasikan fungsi untuk mencetak kode adaptive huffman coding dari huruf
yang akan digunakan.

4) Inisialisasikan fungsi untuk menghitung frekuensi dari huruf yang akan digunakan.
5) Inisialisasikan fungsi untuk menghasilkan hasil encoding.

6) Inisialisasikan fungsi untuk menghitung ukuran file sebelum, sesudah kompresi

dan presentase hasil kompresinya.

7) Masukkan huruf dan banyak frekuensi kedalam pohon biner. Lalu, urutkan semua
node secara ascending berdasarkan banyak frekuensi.

8) Ambil 2 node dengan frekuensi terkecil. Lalu, kombinasikan 2 node terkecil ke

dalam node baru.
9) Melakukan pengujian data.
HASIL DAN ANALISA

Pada praktikum kali ini dilakukan percobaan kompresi teks menggunakan Algoritma
Adaptive Huffman Coding. Cara kerja pengonversian dengan Adaptive Huffman Coding
ini dengan cara mengkonversikan huruf menjadi biner (encoding) setelah itu hasil
encoding akan kembali dikonversi kedalam huruf (decoding). Selanjutnya kami akan
melakukan 4 percobaan dengan dua kondisi yang berbeda. Dimana kondisi yang pertama
adalah ukuran file asli pada percobaan pertama dan kedua berbeda, kemudian kondisi yang
kedua adalah ukuran file asli percobaan ketiga dan keempat sama.

Kondisi Pertama

Pada percobaan ini, pertama–tama kami melakukan pengonversian teks

“TELEKOMUNIKASI”. Berikut adalah hasilnya:

Percobaan pertama didapatkan ukuran file Sebelum Dikompresi sebesar 112 bit dan
Setelah Dikompresi sebesar 48 bit, sehingga didapatkan presentase konversi sebesar
42,8%

Percobaan kedua, kami melakukan pengonversian teks “TELEKOMUNIKASI PENS”.

Berikut adalah hasilnya:

Percobaan kedua didapatkan ukuran file sebelum dikompresi sebesar 152 bit dan
setelah dikompresi sebesar 69 bit, sehingga didapatkan presentase konversi sebesar 45,4%

Dari percobaan pertama dan kedua didapatkan bahwa presentase hasil konversi
berbeda. Dimana pada percobaan kedua hasilnya lebih besar dari percobaan pertama. Hal
ini terjadi karena besar file dan banyak karakter mempengaruhi besar file dan presentase
hasil konversi.
Kondisi Kedua

Percobaan ketiga, kami melakukan pengonversian teks “AAAAAAAAAB”. Berikut

adalah hasilnya:

Percobaan ketiga didapatkan ukuran file sebelum dikompresi sebesar 80 bit dan setelah
dikompresi sebesar 10 bit, sehingga didapatkan presentase konversi sebesar 12,5%

Percobaan keempat, kami melakukan pengonversian teks “AAAAAAABCD”. Berikut

adalah hasilnya:

Percobaan keempat didapatkan ukuran file sebelum dikompresi sebesar 80 bit dan
setelah dikompresi sebesar 15 bit, sehingga didapatkan presentase konversi sebesar
18,75%

Dari percobaan ketiga dan keempat didapatkan bahwa hasil ukuran dan presentase hasil
konversi berbeda, walaupun ukuran file asli sama. Hal ini terjadi karena ragam karakter
percobaan ketiga dan keempat berbeda. Dimana semakin banyak ragam karakter, maka
ukuran file dan presentase hasil konversi semakin besar. Sebaliknya makin sedikit ragam
karakter, maka ukuran file dan presentase hasil konversi semakin kecil. Hal ini
dikarenakan pada Adaptive Huffman Coding memiliki cara kerja bahwa karakter yang
sama akan ditambahkan dalam frekuensi karakter tersebut dan hanya akan dikonversi satu
kali.
 4. SHANON FANO (SFA)
LANGKAH-LANGKAH
• Buka IDE Python menggunakan Visual Studio Code.

• Buka folder untuk pemrograman algoritma Shannon Fano, dengan cara

klik file>open folder.

• Pilih program main.py untuk di run file.

• Untuk melakukan kompresi pilih ‘e’ pada terminal dan masukkan
direktori file yang dikompres.

• Masukkan nama file hasil kompresi beserta direktorinya, amati file

hasil kompresi dan untuk melanjutkan melakukan proses lain seperti
misalnya dekompresi, masukkan ‘y’.

• Masukkan ‘d’ untuk melakukan dekompresi

• Masukkan direktori file yang akan didekompresi serta masukkan nama
dan direktori file hasil dekompresi.
• Masukkan ‘n’ untuk mengakhiri sesi kompresi-dekompresi.
ANALISA:
Source Code(python) :
import json
import sys
from collections import OrderedDict
import tree
import time
import bitstring
import os

def decrypt_data(path):
file = open(path, 'rb+')
char_counter = os.path.getsize(path)
if char_counter == 0:
print('ERROR: SOURCE FILE IS EMPTY')
return

json_bytes = b''
is_loading_json_dic = True

while is_loading_json_dic:
char = file.read(1)
#print(char)
json_bytes += char
char_counter -= 1

if char == b'}':
is_loading_json_dic = False
if char_counter < 0:
print('ERROR: INVALID SOURCE FILE')
return

# wczytanie binarnych danych

bin_array = file.read(char_counter)
file.close()

# convert back to bin and join to one string

bitstring = ""
for i in bin_array:
bitstring += "{:08b}".format(i, "08b")

codes_dict = json.loads(json_bytes.decode("utf-8"))
print(codes_dict)

get_decoded_string(codes_dict, bitstring)
def get_decoded_string(codes_dict, bitstring):
# odwrócenie słownika
new_json = {}
for k, v in codes_dict.items():
new_json[v] = k

decoded_string = ""
substring = ""
for bit in bitstring:
substring += bit
if is_json_key_present(new_json, substring):
if new_json[substring] == "_EOT":
break
elif new_json[substring] == "_NewLine":
decoded_string += "\n"
elif new_json[substring] == "_Space":
decoded_string += " "
elif new_json[substring] == "_CurlyCloseB":
decoded_string += "}"
else:
decoded_string += new_json[substring]

substring = ""

# zapisywanie rozkodowanego wyniku

decoded_string_file = input("Decoded file name: ")
with open(decoded_string_file + ".txt", 'a') as f:
f.write(decoded_string)

def is_json_key_present(json, key):

try:
buf = json[key]
except KeyError:
return False

return True

def encrypt_data(filename, encoded_filename):

char_probability = {}
char_counter = 0
start = time.time()

# wczytanie tekstu z pliku

text = open(filename, encoding="utf-8").read()
if text == '':
print('ERROR: SOURCE FILE IS EMPTY')
return
 # dodanie znaku końca tekstu
eot_char = b'\xE2\x90\x84'.decode('utf-8')
text += eot_char

# tworzenie słownika prawdopodobieństwa wystąpień znaków

for char in text:
char_counter += 1
if char == "\n":
char = "_NewLine"
if char == " ":
char = "_Space"
if char == "}":
char = "_CurlyCloseB"
if char == eot_char:
char = "_EOT"
if char in char_probability:
char_probability[char] += 1
else:
char_probability[char] = 1

char_probability = OrderedDict(sorted(char_probability.items()))

# obliczanie prawdopodobieństw znaków

for char in char_probability:
char_probability[char] = float(char_probability[char]/char_counter)

# tworzenie drzewa kodowania

sorted_probability_dict = {k: v for k, v in sorted(char_probability.items(), key=lambda x: x[1],
reverse=True)}
root = tree.Tree("root")
compute(root, [], sorted_probability_dict)

# pobranie słownika znaków i ich kodów binarnych

codes_dict = {}
codes_dict = root.get_codes_dict(codes_dict, [])
print(codes_dict)

# tworzenie stringa wartości binarnych

bitstr = ''
for character in text:
if character == "\n":
character = "_NewLine"
if character == " ":
character = "_Space"
if character == "}":
character = "_CurlyCloseB"
if character == eot_char:
 character = "_EOT"
bitstr += codes_dict[character]

# zapis słownika znaków i ich kodów binarnych do pliku oraz samych danych binarnych
with open(encoded_filename, 'bw') as f:
f.write(bytes(json.dumps(codes_dict, ensure_ascii=False).encode('utf8')))
bitstring.BitArray(bin=bitstr).tofile(f)

end = time.time()
print("Encoding finished in " + str(end - start) + " seconds.")

def compute(code_tree, path, sorted_probability_dict):

last_sum = 0.0
string_sum = 0.0
substring = {}
temp_string = sorted_probability_dict.copy()

if len(sorted_probability_dict) == 1:
return

if len(sorted_probability_dict) == 2:
dict_keys = list(sorted_probability_dict.keys())
code_tree.add_to_tree(path + [0], dict_keys[0])
code_tree.add_to_tree(path + [1], dict_keys[1])
return

for _, value in sorted_probability_dict.items():

string_sum += value

for key, value in sorted_probability_dict.items():

if last_sum == 0.0:
last_sum = value
substring[key] = value
temp_string.pop(key)
else:
actual_sum = last_sum + value
if ((string_sum/2) - actual_sum < 0 and (string_sum/2) - last_sum >= 0) or ((string_sum/2)
- actual_sum <= 0 and (string_sum/2) - last_sum <= 0):
if abs(actual_sum - (string_sum/2)) >= abs(last_sum - (string_sum/2)):
code_tree.add_to_tree(path + [0], ''.join(list(substring.keys())))
code_tree.add_to_tree(path + [1], ''.join(list(temp_string.keys())))
compute(code_tree, path + [0], substring)
compute(code_tree, path + [1], temp_string)
return
else:
substring[key] = value
temp_string.pop(key)
code_tree.add_to_tree(path + [0], ''.join(list(substring.keys())))
 code_tree.add_to_tree(path + [1], ''.join(list(temp_string.keys())))
compute(code_tree, path + [0], substring)
compute(code_tree, path + [1], temp_string)
return
else:
last_sum = actual_sum
substring[key] = value
temp_string.pop(key)

if __name__ == '__main__':
while True:
print("\nShannon-Fano encryption and decryption utility.")
inp1 = input("Do you want to encrypt or decrypt file? (e/d): ")
if inp1 == 'e':
inp_e1 = input("Relative path to file: ")
if not os.path.isfile(inp_e1):
print('ERROR: FILE NOT FOUND\n')
continue
inp_e2 = input("Encoded file name: ")
encrypt_data(inp_e1, inp_e2 + ".pack")
elif inp1 == 'd':
inp = input("Relative path to file: ")
if not os.path.isfile(inp):
print('ERROR: FILE NOT FOUND\n')
continue
decrypt_data(inp)
else:
print('ERROR: WRONG COMMAND\n')
continue
inp2 = input("\nDo you want to continue with another file? (y/n): ")
if inp2 == 'n':
break

Langkah Kerja :
1. Buka IDE python seperti misalnya Visual studio code

2. Klik explorer dan pilih direktori file program shannon fano

3. Pilih program main.py dan run file

4. Untuk melakukan kompresi pilih ‘e’ pada terminal

5. Inputkan direktori file yang dikompres

6. Inputkan nama file hasil kompresi beserta direktorinya, amati file hasil
kompresi

Shannon-Fano code :
{'_Space': '000', 'e': '001', 't': '0100', 'a': '0101', 'i': '0110', 's': '0111', 'o': '1000', 'n':
'1001', 'r': '10100', 'l': '10101', 'h': '10110', 'd': '10111', 'u': '11000', 'p': '110010', 'm':
'110011', 'c': '11010', 'g': '110110', 'w': '110111', 'y': '111000', 'f': '111001', 'b':
'111010', 'v': '1110110', ',': '1110111', '.': '1111000', '_NewLine': '1111001', 'k':
'11110100', 'T': '11110101', '-': '11110110', '0': '111101110', 'I': '111101111', 'S':
'11111000', 'A': '111110010', '’': '111110011', 'C': '111110100', 'L': '111110101',
'E': '111110110', '5': '1111101110', 'G': '1111101111', 'x': '1111110000', '7':
'1111110001', 'D': '1111110010', 'O': '1111110011', 'W': '1111110100', '2':
'1111110101', 'F': '11111101100', 'H': '11111101101', 'z': '1111110111', '/':
'11111110000', '1': '11111110001', '8': '1111111001', 'M': '11111110100', 'R':
'11111110101', 'B': '11111110110', 'P': '11111110111', 'V': '11111111000', 'q':
'11111111001', '%': '111111110100', '3': '111111110101', ':': '111111110110', '?':
'111111110111', 'N': '11111111100', 'j': '111111111010', '4': '1111111110110', '6':
'1111111110111', '9': '1111111111000', 'U': '1111111111001', 'Y':
'111111111101', '_EOT': '1111111111100', '~': '1111111111101', '“':
'1111111111110', '”': '1111111111111'}

7. Untuk melanjutkan melakukan proses lain seperti misalnya dekompresi,

inputkan ‘y’
 8. Inputkan ‘d’ untuk melakukan dekompresi

9. Inputkan direktori file yang akan didekompresi

10. Inputkan nama dan direktori file hasil dekompresi

11. Inputkan ‘n’ untuk mengakhiri sesi kompresi-dekompresi

Dari percobaan kompresi-dekompresi menggunakan algoritma shannon fano

didapatkan file hasil kompresi memiliki ukuran 23% lebih kecil dari file asli. Sehingga dapat
disimpulkan bahwa proses kompresi berhasil. Disamping itu, file hasil dekompresi memiliki
ukuran 0,6% lebih kecil dari file asli.
Meskipun memiliki ukuran yang lebih besar, isi dari file hasil deskripsi tidak memiliki
perbedaan. Untuk melihat ada tidaknya perbedaan, digunakan website
 Computed Diff - DiffChecker

Tidak adanya perbedaan antara file asli dan file hasil dekompresi ini sesuai dengan sifat
shannon fano algorithm yakni Lossless Compresion.
Dilihat dari shannon-code yang dihasilkan, sesuai dengan algoritmanya, karakter
dengan frekuensi kemunculan tertinggi akan memiliki bit yang paling kecil. Dalam kasus ini
karakter '_Space' lah yang memiliki frekuensi tertinggi dengan bit '000'. Sebaliknya, karakter
'”' memiliki frekuensi kemunculan terkecil akan memiliki bit terbesar yakni '1111111111111'
 5. LEMPEL-ZIV-WELCH (LZW)
LANGKAH-LANGKAH
Untuk melakukan praktikum ini dapat mengikuti Langkah-langkah berikut
1. Buat program encoder dan decoder file string menggunakan algoritma Lempel-Ziv-
Welch (LZW) dalam Bahasa python.
2. Membuat file yang akan dilakukan kompresi dalam format file .txt
3. Jalankan script encoder.py menggunakan CMD atau terminal untuk melakukan
kompresi. Command yang dijalankan adalah python encoder.py <filename.txt>
<number of bits>
4. Hasil encoder memiliki format .lzw dan disimpan pada folder yang sama.
5. Untuk melakukan decompress menjalankan script decoder.py. Command yang
dijalankan adalah python decoder.py <filename.lzw> <number of bits>

HASIL PERCOBAAN
Berikut merupakan hasil percobaan dari kompresi dan dekompresi file string dalam
format .txt

File asli memiliki ukuran 104 bytes. Ketika dilakukan kompresi menghasilkan ukuran 174
bytes. Kompresi menghasilkan file baru dengan format .lzw.
 File hasil kompresi tersebut didekompresi kembali, menghasilkan ukuran file sama
dengan file asli. Kemudian melakukan percobaan kedua dengan ukuran file asli sebesar
3576 bytes. Ketika dilakukan kompresi menghasilkan ukuran 2880 bytes.
Dari file lzw didekompresi menghasilkan ukuran file yang sama dengan file asli, yaitu
sebesar 3576 bytes.
ANALISA
Dalam kompresi LZW digunakan tabel kode, dengan 4096 sebagai jumlah entri tabel.
Setiap karakter didalam Kode ASCII disimpan dengan ukuran 8 bit biner, yang mana
ukurannya bisa mencapai 256. Algoritma ini mencoba untuk memperluas library menjadi
9 sampai 12 bit per karakter. Kode 0-255 dalam tabel kode ditugaskan untuk mewakili byte
tunggal dari file input. Ketika encoding dimulai, tabel kode hanya berisi 256 entri pertama,
dengan sisa tabel kosong. Kompresi dicapai dengan menggunakan kode 256 hingga 4095
untuk mewakili urutan byte. Ketika Encoding berlanjut, LZW mengidentifikasi urutan
berulang dalam data, dan menambahkannya ke tabel kode. Kompresi pada algoritma ini
tidak selalu berjalan dengan baik, terutama dengan string pendek dan beragam. Tetapi
bagus untuk mengompresi data yang berlebihan, dan tidak harus menyimpan kamus baru
dengan data.
Kemudian pada proses decoding dicapai dengan mengambil setiap kode dari file
terkompresi dan menerjemahkannya melalui tabel kode untuk menemukan karakter atau
karakter yang diwakilinya. Pada hasil dekompresi isi file tetap sama dengan isi file asli.
Karena LZW ini menggunakan metode lossless compression.
 TABEL HASIL KOMPRESI
DENGAN 5 METODE BERBEDA

Ukuran File Hasil Ukuran File Hasil

Ukuran File Asli
Metode Kompresi Dekompresi
(Kb)
(Kb) (Kb)

RLE 11 1 11

SHC 0,002125 0,000625 0,002125

AHC 0,019 0,008625 0,019
SFA 1900 1015 1900
LZW 3.576 2.88 3.576
 KESIMPULAN
1. RLE
• Kompresi RLE termasuk algoritma dengan metode lossless compression, karena
tidak ada informasi yang hilang dan hasilnya tepat sama seperti sebelum
dikompres.
• Teknik kompresi dengan RLE ini berguna untuk data yang banyak memiliki
kesamaan (homogen) dan data tersebut berdekatan Untuk file yang tidak
mempunyai kesamaan data yang berdekatan, maka RLE justru akan membuat
ukuran data tersebut menjadi semakin besar.

2. SHC
• Semakin sering karakter pada teks itu muncul, maka semakin pendek representasi
bitnya. Sebaliknya, semakin jarang karakter pada teks itu muncul, maka semakin
panjang representasi bit untuk karakter tersebut.

3. ADAPTIVE HUFFMAN CODING

• Semakin banyak karakter yang berbeda dalam file yang akan dikompresi, maka
presentase hasil konversi akan semakin besar.
• File dengan ukuran yang sama, jika ragam karakternya sedikit maka file hasil
konversinya lebih kecil daripada file yang ragam karakternya lebih banyak.
• Pada Adaptive Huffman Coding memiliki cara kerja bahwa karakter yang sama
akan ditambahkan dalam frekuensi karakter tersebut dan hanya akan dikonversi
satu kali.

4. SHANON FANO
• Tidak adanya perbedaan antara file asli dan file hasil dekompresi ini sesuai dengan
sifat shannon fano algorithm yakni Lossless Compresion.
• Dilihat dari shannon-code yang dihasilkan, sesuai dengan algoritmanya, karakter
dengan frekuensi kemunculan tertinggi akan memiliki bit yang paling kecil. Dalam
kasus ini karakter '_Space' lah yang memiliki frekuensi tertinggi dengan bit '000'.
Sebaliknya, karakter '”' memiliki frekuensi kemunculan terkecil akan memiliki bit
terbesar yakni '1111111111111'

5. LEMPEL-ZIV-WELCH
• Kompresi LZW termasuk algoritma dengan metode lossless compression, karena
tidak ada informasi yang hilang tetapi hanya mengurangi bit dengan
mengidentifikasi dan menghilangkan redundansi statistik.
• Kompresi dengan Lempel-Ziv-Welch tidak selalu berjalan dengan baik, terutama
dengan string pendek dan beragam. Tetapi bagus untuk mengompresi data yang
berlebihan, dan tidak harus menyimpan kamus baru dengan data.