Laporan STKI A

LAPORAN PROJEK AKHIR
SISTEM TEMU KEMBALI INFORMASI
Diajukan guna memenuhi sebagian persyaratan dalam rangka menyelesaikan mata

kuliah Sistem Temu Kembali Informasi
Disusun Oleh:
Kelompok 3
Ni Made Ardhiya Shita Pramesti Dewi (2005551007) (Kelas A)
Luh Intan Ratna Sari Dewi (2005551057) (Kelas A)
Nyoman Meira Dewantari Armi (2005551120) (Kelas A)
PROGRAM STUDI TEKNOLOGI INFORMASI

FAKULTAS TEKNIK
UNIVERSITAS UDAYANA
2023
KATA PENGANTAR
Puji syukur kami panjatkan kehadirat Tuhan Yang Maha Esa karena berkat
rahmat-Nya lah laporan berjudul Implementasi Algoritma Okapi Bm25 Pada
Sistem Temu Kembali Informasi ini dapat terselesaikan dengan sebaik-baiknya.
Laporan ini bertujuan untuk menganalisis dan membandingkan kinerja
implementasi algoritma Okapi BM25 pada TF-IDF, VSM, dan Inverted Index
dalam sistem temu kembali informasi. Dalam penyusunan projek dan laporan ini
tentunya kami hendak berterima kasih kepada pihak-pihak yang terlibat dalam
kesuksesan laporan ini. Ucapan terima kasih kami tujukan kepada pihak-pihak di
antaranya sebagai berikut.
1. Bapak Dr. Eng. I Putu Agung Bayupati, S.T., M.T selaku dosen
pengampu mata kuliah Sistem Temu Kembali Informasi.
2. Rekan kelompok 3 atas kerjasamanya selama pengembangan projek
dan penyusunan laporan projek.
3. Keluarga dan teman-teman penulis yang memberikan dukungan moral,
dorongan, dan pengertian selama proses penelitian.
Kami menyadari laporan ini masih jauh dari kata sempurna, oleh karena
itu kami terbuka akan kritik dan saran dari pembaca sekalian guna meningkatkan
kualitas penelitian di masa mendatang. Kami berharap bahwa laporan ini akan
memberikan kontribusi yang berarti bagi perusahaan dan pembaca sekalian.
Jimbaran, 10 Juli 2023
Penulis
ii
DAFTAR ISI
HALAMAN JUDUL................................................................................................i
KATA PENGANTAR..............................................................................................ii
DAFTAR ISI...........................................................................................................iii
BAB I PENDAHULUAN........................................................................................5
1.1 Latar Belakang..........................................................................................5
1.2 Rumusan Masalah.....................................................................................6
1.3 Tujuan Penelitian.......................................................................................6
1.4 Manfaat Penelitian.....................................................................................7
1.5 Batasan Masalah........................................................................................8
1.6 Sistematika Penulisan................................................................................8
BAB II KAJIAN PUSTAKA.................................................................................10
2.1 Data Retrival............................................................................................10
2.2 Python......................................................................................................10
2.3 Pembobotan Kata (Term Weighting).......................................................10
2.4 Algoritma SVM.......................................................................................10
2.5 Boolean Retrieval Model.........................................................................11
2.6 Algoritma Okapi BM25...........................................................................11
BAB III METODOLOGI PENELITIAN..............................................................12
3.1 Tempat dan Waktu Penelitian..................................................................12
3.2 Alat Penelitian.........................................................................................12
3.3 Alur Penelitian.........................................................................................12
BAB IV HASIL DAN PEMBAHASAN...............................................................14
4.1 Gambaran Penelitian...............................................................................14
4.2 Implementasi (Kode Program + Mockup)..............................................14
4.2.1 Input Data.........................................................................................14
4.2.2 Input Filter........................................................................................16
4.2.3 Preprocessing...................................................................................18
4.2.4 TF-IDF.............................................................................................20
4.2.5 SVM.................................................................................................24
4.2.6 Boolean Retrieval Model.................................................................28
4.2.7 Okapi BM25.....................................................................................40
BAB V PENUTUP.................................................................................................45
5.1 Kesimpulan..............................................................................................45
5.2 Saran........................................................................................................45
DAFTAR PUSTAKA.............................................................................................47
iii
DAFTAR GAMBAR
Gambar 1. Alur Penelitian......................................................................................12

Gambar 2. Gambaran Penelitian............................................................................14
Gambar 3. Input Data.............................................................................................16
Gambar 4. Input Filter............................................................................................18
Gambar 5. Tampilan Preprocessing.......................................................................20
Gambar 6. Tampilan Algoritma TF-IDF................................................................25
Gambar 7. Tampilan Algoritma SVM....................................................................28
Gambar 9 Hasil Inverted Index..............................................................................40
iv
BAB I
PENDAHULUAN
I.1 Latar Belakang

Sistem temu kembali informasi (Information Retrieval System) adalah
sebuah teknologi yang digunakan untuk mengambil informasi yang relevan dari
koleksi dokumen berdasarkan permintaan pengguna. Beberapa metode yang
umum digunakan dalam sistem temu kembali informasi adalah Term Frequency-
Inverse Document Frequency (TF-IDF), Vector Space Model (VSM), dan Boolean
Retrieval Model.
TF-IDF adalah metode yang digunakan untuk menghitung bobot kata dalam
sebuah dokumen berdasarkan frekuensi kemunculannya dalam dokumen tersebut
dan kebalikan frekuensi kemunculannya dalam seluruh koleksi dokumen. VSM
adalah model yang merepresentasikan dokumen dan permintaan pengguna dalam
bentuk vektor dalam ruang berdimensi tinggi. Sedangkan Inverted Index adalah
struktur data yang digunakan untuk mempercepat proses pencarian kata kunci
dalam koleksi dokumen dan Incidence matrix adalah representasi grafik
menggunakan matriks. Grafik atau jaringan dapat direpresentasikan sebagai
kumpulan simpul (node) yang terhubung oleh sisi (edge). Matriks insiden
menyajikan hubungan antara simpul-simpul dan sisi-sisi grafik tersebut. keduanya
termasuk ke dalam Boolean Retrieval Model. Namun, meskipun TF-IDF, VSM,
telah menjadi metode yang umum digunakan dalam sistem temu kembali
informasi, ada beberapa keterbatasan yang dapat mempengaruhi kinerja sistem
tersebut. Salah satu keterbatasan yang dapat ditemui adalah masalah ketepatan
dalam menemukan dokumen yang paling relevan dengan permintaan pengguna.
Untuk mengatasi masalah tersebut, algoritma Okapi BM25 dapat
diimplementasikan dalam sistem temu kembali informasi. Okapi BM25 adalah
sebuah algoritma penilaian relevansi yang dikembangkan berdasarkan model
probabilitas. Algoritma ini menggabungkan faktor-faktor seperti frekuensi
kemunculan kata kunci dalam dokumen dan koleksi, panjang dokumen, serta
bobot kata kunci untuk menghitung skor relevansi antara dokumen dan
permintaan pengguna. Namun, meskipun algoritma Okapi BM25 telah terbukti
5
6
efektif dalam meningkatkan kinerja sistem temu kembali informasi, belum banyak
penelitian yang mengimplementasikan algoritma ini pada metode yang sudah
mapan seperti TF-IDF, VSM, dan Boolean Retrieval Model. Oleh karena itu,
terdapat kebutuhan akan penelitian yang mendalam tentang implementasi
algoritma Okapi BM25 pada sistem temu kembali informasi yang menggunakan
metode-metode tersebut.
Penelitian ini bertujuan untuk menganalisis dan membandingkan kinerja
implementasi algoritma Okapi BM25 pada TF-IDF, VSM, dalam sistem temu
kembali informasi. Dengan mengintegrasikan algoritma Okapi BM25 ke dalam
metode-metode tersebut, diharapkan dapat meningkatkan ketepatan dalam
menemukan dokumen yang relevan dengan permintaan pengguna. Hasil dari
penelitian ini diharapkan dapat memberikan kontribusi dalam pengembangan
sistem temu kembali informasi yang lebih efektif dan efisien.
I.2 Rumusan Masalah

Berdasarkan latar belakang di atas, penelitian ini bertujuan untuk mengatasi
masalah ketepatan dalam sistem temu kembali informasi dengan membandingkan
algoritma Okapi BM25 dengan metode sebelumnya yaitu TF-IDF dan VSM. Oleh
karena itu, rumusan masalah yang dapat diajukan dalam penelitian ini adalah
sebagai berikut.
1. Bagaimana implementasi pencarian dokumen dengan penggunaan metode
TF-IDF, metode VSM, Boolean Retrieval Model termasuk Insidence
Matrix, serta Inverted Index dalam sistem temu kembali informasi?
2. Bagaimana mengimplementasikan algoritma Okapi BM25 dalam sistem
temu kembali informasi dan apakah implementasi ini dapat meningkatkan
ketepatan pencarian dokumen?
I.3 Tujuan Penelitian

Berdasarkan rumusan masalah di atas, didapati sejumlah tujuan penelitian
yang hendak dicapai dengan adanya implementasi Algoritma Okapi BM25 ini
pada Sistem Temu Kembali Informasi. Tujuan penelitian ini di antaranya sebagai
berikut.
7
1. Menganalisis dan mengimplementasikan pencarian dokumen dengan

penggunaan metode TF-IDF, metode VSM, Boolean Retrieval Model
termasuk Insidence Matrix, serta Inverted Index dalam sistem temu
kembali informasi?
2. Menganalisis dan mengimplementasikan algoritma Okapi BM25 pada
dalam sistem temu kembali informasi untuk meningkatkan ketepatan
pencarian dokumen.
I.4 Manfaat Penelitian

Berdasarkan tujuan penelitian di atas, penulis menyasar untuk penelitian ini
dapat memberikan manfaat baik kepada penulis sendiri maupun pembaca
sekalian. Adapun manfaat dari penelitian ini adalah sebagai berikut.
1. Bagi Penulis:
a) Penelitian ini memberikan kesempatan kepada penulis untuk
mengembangkan pemahaman tentang sistem temu kembali informasi
dan metode terkait, seperti TF-IDF, VSM, Boolean Retrieval Model,
dan Inverted Index.
b) Penulis akan mendapatkan pengalaman dalam mengimplementasikan
algoritma Okapi BM25 pada sistem temu kembali informasi dan
memperluas pengetahuan dan keterampilan dalam bidang pemrosesan
bahasa alami dan analisis data.
2. Bagi Pembaca:
a) Penelitian ini memberikan pemahaman yang lebih baik tentang
penggunaan algoritma Okapi BM25 pada metode-metode yang sudah
mapan seperti TF-IDF, VSM, dalam sistem temu kembali informasi.
b) Pembaca akan memperoleh wawasan tentang kinerja dan implementasi
pencarian dokumen menggunakan metode TF-IDF, VSM, Boolean
Retrieval Model termasuk Insidence Matrix, serta Inverted Index.
c) Hasil penelitian ini dapat menjadi acuan bagi para peneliti, praktisi,
atau pengembang dalam memilih dan mengoptimalkan metode temu
kembali informasi yang tepat untuk aplikasi atau sistem yang sedang
mereka kembangkan.
8
I.5 Batasan Masalah

Penelitian ini memiliki sejumlah batasan masalah guna memfokuskan hal
yang dibahas dan diteliti, sehingga cakupan pembahasan tidak melebar dan hasil
yang diharapkan dapat sesuai dengan tujuan di awal. Berikut merupakan batasan
masalah pada penelitian ini.
1. Penelitian ini akan fokus pada implementasi pencarian dokumen
menggunakan metode TF-DF, VSM, Boolean Retrieval Model, dan
Inverted Index serta implementasi algoritma Okapi BM25 pada TF-IDF
dan VSM dilakukan secara terpisah.
2. Koleksi dokumen yang digunakan akan terbatas pada dataset yang relevan
dengan topik penelitian dan dapat direpresentasikan dalam format teks.
3. Penelitian ini akan berfokus pada analisis kinerja dan perbandingan antara
implementasi algoritma Okapi BM25 dan metode-metode lain.
4. Batasan sumber daya waktu dan teknis yang tersedia untuk penelitian ini,
sehingga tidak semua aspek atau faktor yang mempengaruhi kinerja sistem
temu kembali informasi dapat dijelaskan secara rinci.
5. Penelitian ini tidak akan mencakup implementasi algoritma Okapi BM25
pada metode lainnya di luar TF-IDF dan VSM dalam sistem temu kembali
informasi.
I.6 Sistematika Penulisan

Sistematika penulisan diterapkan untuk menyajikan gambaran yang jelas
mengenai dan sistematik. Pembahasan pada penelitian ini dibagi ke dalam lima
bab yang dapat diuraikan sebagai berikut.
BAB I: PENDAHULUAN Bab pendahuluan ini penyusun akan membahas
mengenai latar belakang, rumusan masalah, tujuan, manfaat, batasan masalah, dan
sistematika penulisan.
BAB II: TINJAUAN PUSTAKA Bab tinjauan pustaka ini menguraikan teori yang
dijadikan acuan dalam pembuatan laporan ini.
BAB III: METODOLOGI DAN PERANCANGAN PENELITIAN
Bab metodologi dan perancangan penelitian berisikan metodologi yang akan
digunakan dalam melakukan penelitian serta alur penelitian.
9
BAB IV: HASIL DAN PEMBAHASAN

Bab hasil dan pembahasan menjelaskan mengenai implementasi program dalam
bentuk website untuk penerapan algoritma TF-IDF, VSM, Boolean Retrieval
Model dan Okapi BM25 dan perbandingannya di dalam konsep Sistem Temu
Kembali Informasi.
BAB V: PENUTUP
Bab penutup ini berisi kesimpulan dari hasil penelitian yang dilakukan dan saran-
saran guna mendukung perbaikan penelitian di masa yang akan datang.
BAB II
KAJIAN PUSTAKA
II.1 Data Retrival

Data retrieval secara umum menentukan dokumen yang tepat dari suatu
koleksi data, yang isi dokumen tersebut mengandung keyword di dalam query
user. Untuk menemukan informasi atau data yang dicari, ada berbagai jenis konten
yang bisa digunakan, seperti teks, gambar, audio, video, dan lain-lain. Dalam hal
pencarian teks, koleksi data yang dapat diakses meliputi pesan teks seperti email,
fax, dan dokumen berita, termasuk dokumen yang tersebar di internet. Dalam
menghadapi jumlah dokumen yang besar sebagai sumber pencarian, diperlukan
sebuah sistem yang dapat membantu pengguna menemukan dokumen yang
relevan dengan cepat dan akurat. (Manning, 2008)
II.2 Python
Python adalah bahasa pemrograman tingkat tinggi yang didesain untuk
mengutamakan keterbacaan kode dan sintaks yang sederhana (Faruqi, 2021).
Dikembangkan pada awal tahun 1990 oleh Guido van Rossum, Python menjadi
salah satu bahasa pemrograman yang populer dan digunakan secara luas di
berbagai bidang seperti pengembangan web, ilmu data, kecerdasan buatan (AI),
pemrosesan bahasa alami, dan lain-lain.
II.3 Pembobotan Kata (Term Weighting)
Pembobotan kata merujuk pada proses memberikan nilai atau bobot kepada
kata-kata dalam sebuah teks berdasarkan tingkat pentingnya dalam konteks
tertentu. Tujuan dari pembobotan kata adalah untuk menggambarkan relevansi
kata-kata tersebut terhadap topik atau maksud tertentu dalam analisis teks (Abu
El-Khair, 2009).
II.4 Algoritma SVM
Algoritma SVM (Support Vector Machine) adalah metode pembelajaran
mesin yang digunakan untuk klasifikasi dan regresi. SVM dapat digunakan untuk
membangun model yang efektif dalam mengklasifikasikan data ke dalam dua
kelas atau lebih. Algoritma SVM didasarkan pada konsep margin maksimum, di
10
11
mana tujuan utamanya adalah untuk menemukan hiperplane terbaik yang dapat
memisahkan dua kelas data dengan jarak maksimum antara sampel terdekat dari
setiap kelas (Octaviani, dkk, 2014).
II.5 Boolean Retrieval Model
Boolean Retrieval Model adalah salah satu metode dasar dalam sistem
pengambilan informasi (Risparyanto, 2012). Model ini digunakan untuk
mencocokkan dan mengambil dokumen yang sesuai dengan kueri pengguna
berdasarkan logika boolean, yaitu menggunakan operator boolean seperti "AND",
"OR", dan "NOT" untuk membangun ekspresi kueri.
II.6 Algoritma Okapi BM25
Okapi BM25 didasarkan pada model ruang vektor, yang menganggap kueri
dan dokumen sebagai vektor dalam ruang berdimensi tinggi (Abdurrahman,
2019). Algoritma ini mengukur relevansi antara kueri dan dokumen berdasarkan
perhitungan bobot istilah (term weighting) yang memperhitungkan frekuensi
kemunculan istilah dalam dokumen dan kueri, serta statistik koleksi yang
mencerminkan distribusi global istilah dalam koleksi dokumen.
BAB III
METODOLOGI PENELITIAN
III.1 Tempat dan Waktu Penelitian

Lokasi tempat penulis melaksanakan penelitian yaitu sebagian besar di
lingkungan Kampus Bukit Program Studi Teknologi Informasi, Fakultas Teknik,
Universitas Udayana. Waktu pelaksanaan penelitian dilakukan mulai pada Bulan
April 2023 hingga Bulan Juli 2023.
III.2 Alat Penelitian

Alat penelitian yang digunakan dalam penelitian yaitu berupa kebutuhan
perangkat lunak (software) seperti Sistem Operasi Windows 10 dan Visual Studio
Code. Penelitian juga membutuhkan Bahasa pemrograman Python dalam
merancang sistem temu kembali ini.
III.3 Alur Penelitian

Berikut merupakan Metode Penelitian dari pembuatan sistem temu kembali
dengan menggunakan beberapa algoritma yang telah ditentukan.
Gambar 1. Alur Penelitian
12
13
Berdasarkan gambar tersebut, penelitian dimulai dengan proses

pengumpulan data yang diperlukan. Setelah itu, dilakukan pembuatan desain
sistem yang diperlukan seperti mockup untuk sistem tersebut. Selanjutnya,
barulah pengerjaan sistem temu kembali dengan memasukkan tiga algoritma
berbeda dan beberapa filtering ke dalam desain sistem awal. Terakhir, melakukan
uji coba terhadap sistem dan akan direvisi apabila masih kurang sesuai seperti
yang diharapkan.
BAB IV
HASIL DAN PEMBAHASAN
IV.1 Gambaran Penelitian

Berikut merupakan Gambaran Penelitian dari pembuatan sistem temu
kembali dengan menggunakan beberapa algoritma yang telah ditentukan.
Gambar 2. Gambaran Penelitian

Berdasarkan gambaran penelitian tersebut, peneliti membuatkan sebuah
inputan berupa search keyword, dokumen 1, dokumen 2, dan dokumen 3 terlebih
dahulu. Selain itu, terdapat pilihan filter yang berfungsi untuk menguji cobakan
beberapa hal yang diperlukan. Filter yang dibuat berupa filter pilih algoritma yang
digunakan dan pilih pemrosesan data apa saja yang diinginkan. Selanjutnya dari
ketiga inputan dan filtering tersebut akan diproses sesuai preprocessing yang
diperlukan. Data bersih kemudian diproses dengan algoritma yang ditentukan
berdasarkan filter dan kemudian hasilnya akan ditampilkan.
IV.2 Implementasi (Kode Program + Tampilan)

IV.2.1 Input Data
Implementasi kode program dalam melakukan proses input data yaitu
sebagai berikut.
14
15
<div class="row">
<div class="col">
<div class="card-body">
<blockquote
class="blockquote">
<label
for="input_text">Enter text 1:</label>
<input class="form-
control" placeholder="Input Yout Text Here" type="text"
id="input_text"
name="input_text1">
</blockquote>
</div>
</div>
<div class="col">
<blockquote
class="blockquote">
<label
<input class="form-
id="input_text"
name="input_text2">
</blockquote>
</div>
</div>
<div class="col">
<blockquote
class="blockquote">
<label
<input class="form-
id="input_text"
name="input_text3">
</blockquote>
</div>
</div>
</div>
<div class="row">
<blockquote class="blockquote">
<label
for="input_text">Search word:</label>
<input class="form-control"
placeholder="Input Word to Search in Document"
type="text"
id="search_word" name="search_word">
</blockquote>
</div>
</div>
<div class="d-grid gap-2">
<input class="btn btn-warning"
type="submit" value="Submit">
</div>
Kode Program 1. Input Data
16
Kode program tersebut akan menghasilkan tampilan seperti berikut ini.
Gambar 3. Input Data
Pengguna harus menginputkan tiga dokumen baik berupa kalimat ataupun

paragraf. Pengguna juga akan memasukkan kata kunci atau kata yang dicari ke
bagian search word. Kemudian, input ketiga dokumen tersebut dan kata kunci
yang dicari tersebut nantinya akan memberikan hasil ketika pengguna telah
menekan tombol submit.
IV.2.2 Input Filter
Implementasi kode program dalam melakukan proses filtering yaitu
sebagai berikut.
17
<div class="form-control d-flex mb-2 py-3">

<div class="col">
Algorithm
</div>
<div class="col">
<input class="form-check-
input" type="checkbox" name="checkbox4" value="1"
onchange="updateValue(this)" checked>
<label class="form-check-
label" for="flexCheckChecked">
SVM
</label>
</div>
<div class="col">
Incidence Matrix
</label>
</div>
<div class="col">
Inverted Index
</label>
</div>
<div class="col">
Okapi BM25
</label>
</div>
</div>
<div class="form-control d-flex mb-2
py-3">
<div class="col">
Filters:
</div>
<div class="col">
Stop Word
</label>
</div>
<div class="col">
18
Wnl
</label>
</div>
<div class="col">
Porter
</label>
</div>
</div>
Kode Program 2. Input Filter
Gambar 4. Input Filter
Tampilan tersebut nantinya akan muncul saat pengguna pertama kali

mengakses program. Terdapat filtering yang dapat digunakan baik pada
algoritmanya ataupun pada preprocessingnya. Hal ini untuk melakukan beberapa
percobaan dan mengefisienkan tampilan hasil agar memudahkan analisis nantinya.
IV.2.3 Preprocessing
sebagai berikut.
Kode program preprocessing
19
def preprocessing(stop_word_value, wnl_value, porter_value,

input_text):
# Create a stop word list for English
if (stop_word_value is None):
tokenizing_sentence = [word for word in
word_tokenize(input_text.lower())]
else:
stop_words = ["n't", 'was', "couldn't", "hadn't",
"aren't", "shouldn't", "couldn't", "hasn't", "that'll",
"you've", "mightn't", "wouldn't", "doesn't", "wasn't",
"haven't", "mustn'", 'mightn', 'shan', "needn't", 'that',
"she's", "shouldn't", 'now', "weren't", "don't", "mustn't",
"hadn't", "weren't", "won't", "you'd", "needn't", "aren't",
"wasn'", "didn't", 'didn', "it's", "isn't", "hasn'", 'wouldn',
"doesn'", 'to', 'how', 'we', 'not', 'where', 'he', 'itself',
'can', 'nor', 'few', 'had', 'here', 'them', 'hers', 'this',
'under', 'all', 'same', 'by', 'yourself', 'other', 'out', 'my',
'about', 'will', 'some', 'herself', 'as', 'these', 'do', 'very',
'from', 'then', 'yourselves', 'above', 'most', 'it', 'any',
'only', 'ma', 'for', 'no', 'you', 'between', 'such', 'your',
'ain', 'in', 'being', 'up', 'because', 'him', 'more', 'while',
'were', 'into', 'haven', 'his', 'both', 'having', 'myself',
'is', 'than', 'ourselves', 'but', "should've", 'when', 'hadn',
'himself', "you'll", 'its', 'until', 'are', 'and', 'further',
'if', 'off', 'won', 'who', 'i', 'has', 'during', 'so', 'isn',
"you're", 'have', 'again', 'does', 'below', 'theirs', 'ours',
'the', 'through', 'own', 'those', 'too', 'be', 'on', 'doing',
'don', 'me', 'should', 'down', 'which', 'after', 're', 'once',
'their', 'against', 'whom', 'they', 'what', 'an', 'each', 'at',
'themselves', 'been', "shan't", 'she', 'did', 'with', 'our',
'there', 'just', 'over', 'why', 'll', 'before', 'of', 'her',
'or', 'yours', 've', 'am', 'y', "'s", 'o', 'm', 'd', "a"]
word_tokenize(input_text.lower()) if word not in stop_words]
# stop_words = set(stopwords.words('english'))
# stop_words.add('was')
# stop_words_list = list(stop_words)
# print(stop_words_list)
# NEW FORMULA WITH PORTER AND WNL

if (wnl_value is not None and porter_value is not None):
new_sentence = wnl_porter(tokenizing_sentence)
elif(wnl_value is not None):
new_sentence = wnl(tokenizing_sentence)
elif(porter_value is not None):
new_sentence = porter(tokenizing_sentence)
else:
new_sentence = tokenizing_sentence
# tokens_without_punct
without_punctuation = [token for token in new_sentence if
token not in string.punctuation]
final_sentence = ' '.join(without_punctuation)
# print(tokens_without_punct)
# print(final_sentence)
# , 'porter_sentence': porter_sentence, 'wnl_sentence':
wnl_sentence
# return {'final_sentence': final_sentence, "input_text":
20
input_text}
return without_punctuation
Kode Program 3. Preprocessing
Kode program lematisasi

def wnl(tokenizing_sentence):
wnl = WordNetLemmatizer()
new_sentence = []
i = 0
while(i<len(tokenizing_sentence)):
lemmatized_word =
wnl.lemmatize(str(tokenizing_sentence[i]))
new_sentence.append(lemmatized_word)
i+=1
return new_sentence
Kode Program 4. Lematisasi
Kode program stemming

def porter(tokenizing_sentence):
porter = PorterStemmer()
new_sentence = []
i = 0
stemmed_words = porter.stem(str(tokenizing_sentence[i]))
new_sentence.append(stemmed_words)
i+=1
return new_sentence
Kode Program 5. Stemming
Gambar 5. Tampilan Preprocessing
Hasil dari preprocessing tersebut berasal dari proses berurutan yaitu

penghilangan stop word, tokenisasi, lower casing, lematisasi, stemming, dan
penghilangan karakter asing pada dokumen. Setiap urutan preprocessing tersebut
disesuaikan dengan filter yang dipilih pengguna pada awal penginputan filtering
saat pertama kali mengakses program. Hasil dari preprocessing tersebut nantinya
21
akan diproses berdasarkan algoritma yang dipilih pengguna. Penjelasan mengenai

setiap algoritma tersebut akan dijelaskan pada sub bab berikutnya.
IV.2.4 TF-IDF
sebagai berikut.
22
q = []
d1_count = []
d2_count = []
d3_count = []
for word in token_array:

if word in arr_query:
count_token_query = arr_query.count(word)
q.append(count_token_query)
else:
q.append(0)
if word in arr_doc1:
count_token_doc1 = arr_doc1.count(word)
d1_count.append(count_token_doc1)
else:
d1_count.append(0)
else:
d2_count.append(0)
else:
d3_count.append(0)
# match_word.append(word)
# CEK APAKAH KATA YANG DICARI ADA DALAM DOKUMEN

if 1 in q:
# konversi nilai-nilai pada array menjadi 1 kecuali 0

d1 = [1 if x != 0 else 0 for x in d1_count]
df = []
D = []
log = []
log_1 = []
w_q = []
w_d1 = []
w_d2 = []
w_d3 = []
v_q = []
v_d1 = []
v_d2 = []
v_d3 = []
vsm_d1 = []
vsm_d2 = []
vsm_d3 = []
cos_document = []
23
data_vector_Wq = 0
i = 0
while i < len(token_array):
sum_d = int(d1[i]) + int(d2[i]) + int(d3[i])
D_df = 3/sum_d
idf_log = float(math.log10(D_df))
idf_log_abs = abs(idf_log)
idf_log_formatted = format(idf_log_abs, ".3f")
idf_1 = idf_log_abs+1
idf_log_1_formatted = format(idf_1, ".3f")
if q[i] == 0:
Wq = "0"
vector_Wq = "0"
else:
Wq = format(idf_1*q[i], ".3f")
vector_Wq = format(pow(float(Wq), 2), ".3f")
# data_vector_Wq = vector_Wq
if d1[i] == 0:
W1 = "0"
vector_W1 = "0"
vsm_W1 = "0"
else:
W1 = format(idf_1*d1[i], ".3f")
vector_W1 = format(pow(float(W1), 2), ".3f")
vsm_W1 =
format(float(vector_Wq)*float(vector_W1), ".3f")
if d2[i] == 0:
W2 = "0"
vector_W2 = "0"
vsm_W2 = "0"
else:
vsm_W2 =
if d3[i] == 0:
W3 = "0"
vector_W3 = "0"
vsm_W3 = "0"
else:
vsm_W3 =
# time.sleep(1)
df.append(sum_d)
D.append(D_df)
log.append(idf_log_formatted)
log_1.append(idf_log_1_formatted)
w_q.append(Wq)
w_d1.append(W1)
w_d2.append(W2)
w_d3.append(W3)
24
v_q.append(vector_Wq)
v_d1.append(vector_W1)
vsm_d1.append(vsm_W1)
i += 1
sqrt_q = format(pow(sum([float(x) for x in v_q]), 1/2),

".3f")
sqrt_d1 = format(pow(sum([float(x) for x in v_d1]),
1/2), ".3f")
1/2), ".3f")
1/2), ".3f")
sum_vsm_d1 = format(sum([float(x) for x in vsm_d1]),

".3f")
".3f")
".3f")
cos_d1 = format(float(sum_vsm_d1) / (float(sqrt_q) *

float(sqrt_d1)), ".3f")
cos_document.append(cos_d1)
cos_rank = len(cos_document) - rankdata(cos_document,

method='average') + 1
rank = [int(x) for x in cos_rank]
result_rank = []
rank_tf_idf_d1 = format(sum(float(x) for x in w_d1),
".3f")
result_rank.append(rank_tf_idf_d1)
".3f")
".3f")
rank_sum_tf = len(result_rank) - rankdata(result_rank,

rank_final_tf = [int(x) for x in rank_sum_tf]
Kode Program 6. Algoritma TF-IDF
25
Gambar 6. Tampilan Algoritma TF-IDF
Berdasarkan kode program tersebut perhitungan TF-IDF didasari pada

perhitungan jumlah term tiap dokumen. Setiap term tersebut kemudian dihitung
dengan urutan perhitungan df, D/df, IDF log, IDF +1, dan Weight. Setelahnya
akan dijumlahkan bobot tiap dokumen dan dijadikan perankingan TF-IDF. Rank
dari dokumen tersebut dimulai dari dokumen 1 sebesar 5.130, dokumen 2 sebesar
4.829, dan dokumen 3 sebesar 4.528
IV.2.5 SVM
sebagai berikut.
26
if 1 in q:
# konversi nilai-nilai pada array menjadi 1 kecuali 0

df = []
D = []
log = []
log_1 = []
w_q = []
w_d1 = []
w_d2 = []
w_d3 = []
v_q = []
v_d1 = []
v_d2 = []
v_d3 = []
vsm_d1 = []
vsm_d2 = []
vsm_d3 = []
cos_document = []
data_vector_Wq = 0
i = 0
while i < len(token_array):
sum_d = int(d1[i]) + int(d2[i]) + int(d3[i])
D_df = 3/sum_d
idf_log = float(math.log10(D_df))
idf_log_abs = abs(idf_log)
idf_log_formatted = format(idf_log_abs, ".3f")
idf_1 = idf_log_abs+1
idf_log_1_formatted = format(idf_1, ".3f")
if q[i] == 0:
Wq = "0"
vector_Wq = "0"
else:
Wq = format(idf_1*q[i], ".3f")
vector_Wq = format(pow(float(Wq), 2), ".3f")
# data_vector_Wq = vector_Wq
if d1[i] == 0:
W1 = "0"
vector_W1 = "0"
vsm_W1 = "0"
else:
vsm_W1 =
if d2[i] == 0:
W2 = "0"
vector_W2 = "0"
vsm_W2 = "0"
else:
27
vsm_W2 =
if d3[i] == 0:
W3 = "0"
vector_W3 = "0"
vsm_W3 = "0"
else:
vsm_W3 =
# time.sleep(1)
df.append(sum_d)
D.append(D_df)
log.append(idf_log_formatted)
log_1.append(idf_log_1_formatted)
w_q.append(Wq)
w_d1.append(W1)
w_d2.append(W2)
w_d3.append(W3)
v_q.append(vector_Wq)
i += 1
sqrt_q = format(pow(sum([float(x) for x in v_q]), 1/2),

".3f")
1/2), ".3f")
1/2), ".3f")
1/2), ".3f")

".3f")
".3f")
".3f")

28
cos_rank = len(cos_document) - rankdata(cos_document,

rank = [int(x) for x in cos_rank]
Kode Program 7. Algoritma SVM 7
Gambar 7. Tampilan Algoritma SVM7
Berdasarkan kode program tersebut perhitungan SVM didasari pada perhitungan

setiap Query (kata yang dicari) dikuadratkan dengan term setiap dokumen yang
29
ada. Setelah itu dicari perhitungan dot produk tiap dokumen. Terakhir, akan dicari
perankingannya dengan menggunakan rumus cosine. Rank dari dokumen tersebut
dimulai dari dokumen 2 dengan cosine 1.034, dokumen 3 dengan cosine 0.447,
dan dokumen 1 dengan cosine 0.390.
IV.2.6 Boolean Retrieval Model
Boolean Retrieval Model memiliki dua cara untuk melakukan retrieval
data atau menemukan kembali informasi dalam sebuah dokumen. Untuk model ini
terdapat penggunaan incidence matrix dan inverted index. Berikut akan dijabarkan
kedua metode tersebut.
IV.2.6.1 Incidence Matrix
sebagai berikut.
30
import nltk
from nltk.tokenize import word_tokenize
from nltk.probability import FreqDist
from nltk.stem import PorterStemmer
import pandas as pd
from nltk.corpus import stopwords
import re
# from data_retrieval import preprocessing as pre
# Data contoh
# documents = {
# 1: "Blue is my favorite color",
# 2: "Sky is blue and sea is blue",
# 3: "sky is blue and sky is beautiful",
# 4: "color of sky and sea is blue",
# 5: "I saw a blue car yesterday"
# }
# Fungsi untuk menghitung term frequency (tf)

def calculate_tf(documents):
tf_table = {}
tokenized_docs = {}
stemmer = PorterStemmer() # Inisialisasi stemmer
# Tokenisasi dokumen dan menghitung frekuensi kemunculan

term dalam setiap dokumen
for doc_id, doc_text in documents.items():
tokens = word_tokenize(doc_text.lower()) # Tokenisasi
dan konversi ke huruf kecil
stop_words = set(stopwords.words('english')) #
Menggunakan stop words bahasa Inggris
tokens = [token for token in tokens if token not in
stop_words] # Menghapus stop words
stemmed_tokens = [stemmer.stem(token) for token in
tokens] # Stemming
tokenized_docs[doc_id] = stemmed_tokens
fd = FreqDist(stemmed_tokens)
tf_table[doc_id] = fd
# # documents = pre(documents)
# tokenized_docs = documents
# fd = FreqDist(documents)
# tf_table[doc_id] = fd
# for doc_id, doc_text in documents:

# # Lakukan tokenisasi pada doc_text dan simpan hasilnya
dalam variabel tokenized_doc
# tokenized = word_tokenize(doc_text) # Gantikan
"tokenize" dengan fungsi tokenisasi yang sesuai
# # Simpan hasil tokenisasi dalam tokenized_docs

menggunakan doc_id sebagai kunci
# tokenized_docs[doc_id] = tokenized
# fd = FreqDist(documents)
# tf_table[doc_id] = fd
# Menggabungkan semua term unik dalam semua dokumen

all_terms = set()
for tokens in tokenized_docs.values():
all_terms.update(tokens)
31
# Membuat dataframe untuk tabel term frequency

tf_df = pd.DataFrame(columns=['Term'] +
list(tokenized_docs.keys()))
tabel_tf = []
for term in all_terms:
tf_values = []
for doc_id, tokens in tokenized_docs.items():
tf_values.append(int(term in tokens)) # Jika term
ada dalam tokens, nilai biner = 1, jika tidak = 0
tf_df.loc[len(tf_df)] = [term] + tf_values
tabel_tf.append(tf_values)
tf_df['Binary_Total'] = tf_df.iloc[:, 1:].apply(lambda x:
''.join(map(str, x)), axis=1)
# print("Result tokenized_docs: ", tokenized_docs)

# print(' ')
# print("Result all_terms: ", all_terms)
# print(' ')
# print("Result tf_values: ", tabel_tf)
# print(' ')
return tf_df
#membuat dataframe-> jadi masing2 kata menjadi bilangan biner
def documents_containing_term(term, tf_df):

term_lower = term.lower()
if ' ' in term_lower:
# Split the term while preserving parentheses
terms = re.findall(r'\(|\)|\w+|\S+\s*', term_lower)
binary_values = []
for t in terms:
if t == '(' or t == ')':
binary_values.append(t)
else:
binary_value = tf_df.loc[tf_df['Term'] ==
t.strip('()'), 'Binary_Total'].values[0] if
len(tf_df.loc[tf_df['Term'] == t.strip('()')]) > 0 else None
binary_values.append(binary_value)
return ''.join(binary_values) if all(v is not None for v
in binary_values) else None
else:
result = tf_df.loc[tf_df['Term'] == term_lower,
'Binary_Total'].values
return result[0] if len(result) > 0 else None
#langsung mengubah query menjadi biner
def boolean_retrieval(documents):
tabel_stack = []
stack = []
output_queue = []
precedence = {'AND': 2, 'OR': 1, 'NOT': 3}
operators = set(['AND', 'OR', 'NOT'])
32
# Mengonversi query menjadi notasi postfix menggunakan

algoritma shunting yard
for term in documents:
if term in operators:
while stack and stack[-1] != '(' and
precedence[term] <= precedence[stack[-1]]:
output_queue.append(stack.pop())
stack.append(term)
elif term == '(':
stack.append(term)
elif term == ')':
while stack and stack[-1] != '(':
stack.pop()
else:
output_queue.append(term)
# print("output_queue 1: ", output_queue)
while stack:
# print("output_queue 2: ", output_queue)
# Mengevaluasi notasi postfix

for index, term in enumerate(output_queue):
if term in operators:
operand2 = stack.pop()
if term == 'NOT':
result = bin(int(operand2, 2) ^ int('1' *
len(operand2), 2))[2:].zfill(len(operand2))
else:
operand1 = stack.pop()
if term == 'AND':
result = bin(int(operand1, 2) &
int(operand2, 2))[2:].zfill(len(operand1))
elif term == 'OR':
result = bin(int(operand1, 2) |
int(operand2, 2))[2:].zfill(len(operand1))
stack.append(result)
else:
stack.append(term)
# print("Setiap hasil: ", stack)
# if index >= num: # Menyimpan hasil ke tabel_stack
ketika mencapai indeks ke-num
tabel_stack.append(stack.copy())
# print("Hasil akhir stack: ", stack)

# print("Hasil akhir output_queue: ", output_queue)
# Hasil akhir adalah operand terakhir yang tersisa di stack
result = stack.pop()
hasil = {
'tabel_stack': tabel_stack,
'result': result
}
# print(' ')
# print(num)
# print(tabel_stack)
return hasil
33
# Contoh penggunaan
def main_co(query, documents):
tf_df = calculate_tf(documents)
query = query
query_terms = re.findall(r'\(|\)|\w+|\S+\s*', query)
binary_values = [documents_containing_term(term, tf_df) or
term for term in query_terms]
results = boolean_retrieval(binary_values)
matching_documents = [doc_id for doc_id, result in
enumerate(results['result'], start=1) if result == '1']
documents_list = list(documents)
matching_documents_list = list(map(str, matching_documents))
boolean = [documents.get(id) for id in
matching_documents_list if id in documents_list]
# boolean = ''
# for item in boolean_result:
# boolean += item + '\n'
result = {
'doc': matching_documents,
'text': boolean,
'hasil_boolean': results,
'binary_values': binary_values
# 'text': [documents[id] for id in matching_documents if
id in documents]
}
#documents[doc_id] for doc_id in matching_documents if

doc_id in documents
# print("Result boolean: ", result)
# print(' ')
print("Result documents: ", documents)
print(' ')
print("Result tf_df: ", tf_df)
print(' ')
print("Result binary_values: ", binary_values)
print(' ')
return result
# return result
# main_co("dog AND kitchen", {'1':'Mom making dinner in the

kitchen then cooking again after dinner', '2':'It was thought by
the dog that it was actually a groundhog.', '3':'Mother cooking
in the kitchen'})
# def main_co(query, documents):
# result = main_co('blue AND sky', documents)

# print(result)
Kode Program 8 Algoritma Incidence Matrix8

34
Gambar 8 Hasil Boolean dan Incidence Matrix
Berdasarkan hasil Boolean dan incidence matrix di atas diketahui bahwa

proses dilakukan dari mengidentifikasi kata kunci, lakukan melakukan pencarian
kata kunci pada dokumen-dokumen yang ada. Jika kata kunci ditemukan dalam
sebuah dokumen, tandai dokumen tersebut sebagai "true" atau "1". Jika kata kunci
tidak ditemukan dalam sebuah dokumen, tandai dokumen tersebut sebagai "false"
atau "0". Setelah itu dilakukan konversi ke format binary yang mana jika
dokumen ditandai sebagai "true", maka nilainya akan menjadi 1 dalam format
binary. Jika dokumen ditandai sebagai "false", maka nilainya akan menjadi 0
dalam format binary. Terakhir, setiap nilai binary untuk setiap dokumen dapat
dijadikan stack, dengan dokumen pertama yang ditandai sebagai nilai teratas
dalam stack. Kemudian nilai-nilai binary ini digabungkan secara berurutan
menjadi sebuah stack. 8
IV.2.6.2 Inverted Index
Implementasi kode program dalam melakukan proses inverted index
yaitu sebagai berikut.
35
import numpy as np
import pandas as pd
import nltk
import re
import glob
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer
Doc_1 = "Innovative medication for diabetes control"

Doc_2 = "Novel medication for the control and treatment of
diabetes at the same time of medication"
Doc_3 = "State-of-the-art treatment for controlling diabetes
with advanced treatment"
docs = [Doc_1,Doc_2,Doc_3]
# Preprosessing
def preprosess(text, stoptog):
# Menghapus tanda baca "-"

text = re.sub(r"\b-\b", "", text)
# Tokenisasi
words = word_tokenize(text)
print("Tokenisasi :")
print(words, "\n")
# Mengubah menjadi huruf kecil dan menghapus tanda baca

words_clean = [word.lower() for word in words if
word.isalpha()]
print("Cleaning :")
print(words_clean, "\n")
# Stemming dan Stopword

stemmer = PorterStemmer()
stop_words = set(stopwords.words('english'))
if stoptog == 'y':
words_tokens = [stemmer.stem(word) for word in words if
word not in stop_words]
else:
words_tokens = [stemmer.stem(word) for word in words]
print("Stopword Removal dan Stemming :")

print(words_tokens, "\n")
return words_tokens
# Incidence Matrix
def build_incidence_matrix():
# Preprocessing masing-masing doc
docs_pros = []
n = 1
for doc in docs :
print("prosessing doc #",n)
print("---------------------------------")
36
docs_pros.append(preprosess(doc, stoppick))
n += 1
print("---------------------------------")
print("Preprosesing :")
print(docs_pros, "\n")
# Mencari kata unik

unique_terms = []
for doc in docs_pros:
for term in doc:
if term not in unique_terms:
unique_terms.append(term)
print("Unique Terms :")

print(unique_terms, "\n")
# Membuat Incidence matrix

doc_term_matrix = {}
for term in unique_terms:
doc_term_matrix[term] = []

if term in doc:
doc_term_matrix[term].append(1)
else: doc_term_matrix[term].append(0)
# Menampilkan Incidence matrix

df = pd.DataFrame(doc_term_matrix)
df = df.rename(index=lambda x: "Doc_" + str(x+1))
print("Matrix :")
print(df.transpose())
return doc_term_matrix
def document_ranking(query, doc_term_matrix):

query_words = query.split(' ')
document_scores = {}
for doc_idx, doc in enumerate(docs):

score = 0
for word in query_words:
if word in doc_term_matrix:
score += doc_term_matrix[word][doc_idx]
document_scores[doc_idx + 1] = score
sorted_documents = sorted(document_scores.items(),
key=lambda x: x[1], reverse=True)
ranking_table = pd.DataFrame(columns=['Document',
'Score'])
for doc, score in sorted_documents:
ranking_table.loc[len(ranking_table)] = ['Doc_' +
str(doc), score]
return ranking_table
stoppick = 'y'
# Inverted Inddex
37
def build_inverted_index(result_list):
# Preprocessing masing-masing doc
docs_pros = []
docrefs = []
stoppick = 'y'
n = 1
for doc in result_list :
# print("prosessing doc #",n)
# print("---------------------------------")
doc_text = ' '.join(doc)
docs_pros.append(preprosess(doc_text, stoppick))
if stoppick == 'y':
docrefs.append(preprosess(doc_text, 'n'))
else:
docrefs.append(docs_pros[-1])
n += 1
# for doc in result_list :

# docrefs.append(preprosess(doc, 'n'))
# # docrefs.append(result_list[-1])
# print("---------------------------------")
# print("Preprosesing :")
# print(docs_pros, "\n")
# Mencari kata unik

unique_terms = []
for term in doc:
if term not in unique_terms:
unique_terms.append(term)
print("Unique Terms :")

print(unique_terms, "\n")
# Membuat inverted index

doc_inverse_index = {}
for term in unique_terms:
doc_inverse_index[term] = []
for doc_num, doc in enumerate(docrefs,start=1):
word_count = 0
word_pos = 0
word_pos_list = []
if term in doc:
for word_pos, word in enumerate(doc, start=1):
if word == term:
word_count += 1
word_pos_list.append(word_pos)
doc_inverse_index[term].append([doc_num,
word_count, word_pos_list])
# Menampilkan inverted index

# print("Inverted List : ")
for item in doc_inverse_index:
print (item + " :", doc_inverse_index[item])
inverted_list = []
print("Inverted List:")
for item in doc_inverse_index:
38
inverted_list.append({
'kata': item,
'dokumen': doc_inverse_index[item],
})
print(item + ":", doc_inverse_index[item])
result = {
'inverted_list': inverted_list,
'doc_inverse_index': doc_inverse_index,
# 'text': [documents[id] for id in matching_documents if
id in documents]
}
print('inverted_list', inverted_list)
# print('doc_inverse_index', doc_inverse_index)
return result
# return doc_inverse_index
def document_ranking_inverted(query, inverted_index):

query_words = query.split(' ')
document_scores = {}
for term in query_words:

if term in inverted_index:
docs_list = inverted_index[term]
for doc_info in docs_list:
doc_idx = doc_info[0]
score = doc_info[1]
if doc_idx in document_scores:
document_scores[doc_idx] += score
else:
document_scores[doc_idx] = score
sorted_documents = sorted(document_scores.items(),
key=lambda x: x[1], reverse=True)
ranking_table = pd.DataFrame(columns=['Document', 'Score'])
for doc, score in sorted_documents:
ranking_table.loc[len(ranking_table)] = ['Doc_' +
str(doc), score]
# print('inverted_index', inverted_index)
# print('query', query)
# print(ranking_table)
return ranking_table
# # Pilihan menu
# print("Please choose between 2 menu below:")
# print("1. Incidence matrix")
# print("2. Inverted index")
# mode = input("Enter your choice: ")
# print('')
# # Pilihan penghapusan Stopword

# stoppick = input("Hapus Stopword? (y/n): ")
# print('')
# stoppick = stoppick.lower()
# # Jalankan fungsi sesuai mode

# if mode == "1":
39
# # Panggil fungsi build_incidence_matrix() untuk membangun

incident matrix
# doc_term_matrix = build_incidence_matrix()
# while True:
# # Lakukan peringkat dokumen berdasarkan query
menggunakan incident matrix
# query = input("Masukkan query: ")
# ranking_table = document_ranking(query,
doc_term_matrix)
# print("\nQuery Ranking (Incidence Matrix):")

# # Tanya pengguna apakah ingin melakukan query ranking

lainnya atau memilih mode pilihan 1 atau 2
# choice = input("Apakah Anda ingin melakukan query
ranking lainnya? (y/n) ")
# if choice.lower() != 'y':
# break
# elif mode == "2":

# # Panggil fungsi build_inverted_index() untuk membangun
inverted index
# inverted_index = build_inverted_index()
# while True:
# # Lakukan peringkat dokumen berdasarkan query
menggunakan inverted index
# query = input("Masukkan query: ")
# ranking_table = document_ranking_inverted(query,
inverted_index)
# print("\nQuery Ranking (Inverted Index):")

# # Tanya pengguna apakah ingin melakukan query ranking

lainnya atau memilih mode pilihan 1 atau 2
# choice = input("Apakah Anda ingin melakukan query
ranking lainnya? (y/n) ")
# if choice.lower() != 'y':
# break
# else:
# print("Invalid input!")
Kode Program 9 Algoritma Inverted Index9

40
Gambar 9 Hasil Inverted Index
Pada hasil mockup di atas, didapati bahwa inverted index menghasilkan

pengindeksan dan penomoran dokumen dalam sebuah sistem. Selanjutnya
ditampilkan perankingan berdasarkan skor yang diperoleh dari tiap dokumennya.
Misalkan pada contoh kata “Bird”, kondisi yang terjadi pada dokumen adalah
sebagai berikut:
1. Dokumen pertama: [1, 1, [1]]
a. Nomor dokumen: 1
b. Frekuensi kemunculan dokumen: 1
c. Letak kata pada dokumen: [1]
2. Dokumen kedua: [3, 1, [1]]
a. Nomor dokumen: 2
b. Frekuensi kemunculan dokumen: 2
c. Letak kata pada dokumen: [1]
Dalam setiap dokumen, terdapat tiga elemen yang penting:
1. Nomor dokumen: Ini adalah identifikasi unik untuk setiap dokumen.
Dalam contoh ini, dokumen pertama memiliki nomor dokumen 1,
sedangkan dokumen kedua memiliki nomor dokumen 3.
2. Frekuensi kemunculan dokumen: Ini mengacu pada nomor kemunculan
dokumen tersebut. Dalam contoh ini, dokumen pertama muncul satu kali
(nomor kemunculan 1), sementara dokumen kedua muncul 1 kali (nomor
kemunculan 1).
41
3. Letak kata pada dokumen: Ini adalah daftar yang berisi penunjuk ke posisi
atau lokasi kata kunci dalam dokumen. Dalam contoh ini, dokumen
pertama memiliki letak kata dengan nomor 1, yang menunjukkan bahwa
kata kunci tersebut muncul di posisi 1 dalam dokumen. Dokumen kedua
bernomor 1, yang menunjukkan kemunculan kata kunci dalam posisi 1
dalam dokumen.
IV.2.7 Okapi BM25

42
import math
import string
import nltk
nltk.download('omw-1.4')
from nltk.stem import WordNetLemmatizer, PorterStemmer
def preprocess(input_text):
# Create a stop word list for English
stop_words = ["n't", 'was', "couldn't", "hadn't", "aren't",
"shouldn't", "couldn't", "hasn't", "that'll", "you've",
"mightn't", "wouldn't", "doesn't", "wasn't", "haven't",
"mustn'", 'mightn', 'shan', "needn't", 'that', "she's",
"shouldn't", 'now', "weren't", "don't", "mustn't", "hadn't",
"weren't", "won't", "you'd", "needn't", "aren't", "wasn'",
"didn't", 'didn', "it's", "isn't", "hasn'", 'wouldn', "doesn'",
'to', 'how', 'we', 'not', 'where', 'he', 'itself', 'can', 'nor',
'few', 'had', 'here', 'them', 'hers', 'this', 'under', 'all',
'same', 'by', 'yourself', 'other', 'out', 'my', 'about', 'will',
'some', 'herself', 'as', 'these', 'do', 'very', 'from', 'then',
'yourselves', 'above', 'most', 'it', 'any', 'only', 'ma', 'for',
'no', 'you', 'between', 'such', 'your', 'ain', 'in', 'being',
'up', 'because', 'him', 'more', 'while', 'were', 'into',
'haven', 'his', 'both', 'having', 'myself', 'is', 'than',
'ourselves', 'but', "should've", 'when', 'hadn', 'himself',
"you'll", 'its', 'until', 'are', 'and', 'further', 'if', 'off',
'won', 'who', 'i', 'has', 'during', 'so', 'isn', "you're",
'have', 'again', 'does', 'below', 'theirs', 'ours', 'the',
'through', 'own', 'those', 'too', 'be', 'on', 'doing', 'don',
'me', 'should', 'down', 'which', 'after', 're', 'once', 'their',
'against', 'whom', 'they', 'what', 'an', 'each', 'at',
'themselves', 'been', "shan't", 'she', 'did', 'with', 'our',
'there', 'just', 'over', 'why', 'll', 'before', 'of', 'her',
'or', 'yours', 've', 'am', 'y', "'s", 'o', 'm', 'd', "a"]

word_tokenize(input_text.lower()) if word not in stop_words]
# print(tokenizing_sentence)
porter = PorterStemmer()
wnl = WordNetLemmatizer()
# NEW FORMULA WITH PORTER AND WNL

new_sentence = []
i = 0
if(str(tokenizing_sentence[i]).endswith('e')):
lemmatized_word_e =
new_sentence.append(lemmatized_word_e)
# print(lemmatized_word)
elif(str(tokenizing_sentence[i]).endswith('s')):
lemmatized_word_s =
new_sentence.append(lemmatized_word_s)
# print(lemmatized_word_s)
elif(str(tokenizing_sentence[i]).endswith('y')):
new_sentence.append(str(tokenizing_sentence[i]))
elif(str(tokenizing_sentence[i]).endswith('ed')):
43
lemmatized_word_ed =
wnl.lemmatize(str(tokenizing_sentence[i]), pos='v')
new_sentence.append(lemmatized_word_ed)
# print(lemmatized_word_ed)
else:
stemmed_words =
porter.stem(str(tokenizing_sentence[i]))
new_sentence.append(stemmed_words)
# print(stemmed_words)
i+=1
# tokens_without_punct
without_punctuation = [token for token in new_sentence if
token not in string.punctuation]
final_sentence = ' '.join(without_punctuation)
return final_sentence
def calculate_bm25(query, document, corpus, k1, b, k3):

score = 0.0
N = len(corpus) # Jumlah total dokumen dalam koleksi
avgdl = calculate_avgdl(corpus) # Panjang rata-rata dokumen
dalam koleksi
# Menghitung IDF untuk setiap term dalam query

idf_scores = {}
for term in query.split():
n = sum(1 for doc in corpus if term in doc) # Jumlah
dokumen yang mengandung term
idf_scores[term] = math.log((N - n + 0.5) / (n + 0.5))
# Menghitung skor BM25

for term in query.split():
tf_tq = query.count(term) # Frekuensi kemunculan term
dalam query
if term in document:
tf_td = document.count(term) # Frekuensi kemunculan
term dalam dokumen
dl = len(document) # Panjang dokumen dalam jumlah
term
score += idf_scores[term] * (tf_td * (k1 + 1)) /
(tf_td + (k1 * (1 - b)+ b * (dl / avgdl)))
# *(k3+1)*tf_tq/(k3+tf_tq)
return score
def calculate_avgdl(corpus):
total_length = sum(len(doc) for doc in corpus)
return total_length / len(corpus)
def evaluate_bm25(query, relevant_docs, corpus, k1, b, k3):

tp = 0 # True Positive
fp = 0 # False Positive
fn = 0 # False Negative
for doc_id, document in enumerate(corpus):

score = calculate_bm25(query, document, corpus, k1, b,
k3)
if doc_id in relevant_docs:
44
# Dokumen yang relevan

if score > threshold:
tp += 1
else:
fn += 1
else:
# Dokumen yang tidak relevan
if score > threshold:
fp += 1
# Handle division by zero

if tp + fp == 0:
precision = 0
else:
precision = tp / (tp + fp)
recall = tp / (tp + fn)
# Handle division by zero

if precision + recall == 0:
f1_score = 0
else:
f1_score = 2 * ((precision * recall) / (precision +
recall))
return precision, recall, f1_score
# Contoh penggunaan
# Dokumen yang relevan untuk query tertentu
relevant_docs = {0} # Misalnya, dokumen 0 dan 2 dianggap
relevan
# Dokumen dalam koleksi

corpus = [
"Blue is my favorite color, i can use this everytime i see
blue",
"Sky is blue and sea is blue, i can see blue everywhere",
"sky is blue and sky is beautiful, i can see blue
everywhere",
]
# Parameter BM25
k1 = 1.2
b = 0.75
k3=1.2
threshold = 0.0 # Nilai ambang batas
# Contoh query
query1 = "blue favorite color use everytime see blue"
# query2 = "blue beautiful sky"
# query3 = "blue sky everywhere"
# Melakukan preprocessing pada dokumen dalam koleksi

corpus = [preprocess(doc) for doc in corpus]
# Melakukan preprocessing pada query

query1 = preprocess(query1)
# query2 = preprocess(query2)
# query3 = preprocess(query3)
45
# Menghitung skor BM25 untuk setiap dokumen

scores = []
for i, doc in enumerate(corpus):
doc_score = calculate_bm25(query1, doc, corpus, k1, b, k3)
scores.append((i, doc_score)) # Menyimpan nomor dokumen dan
skor
# Melakukan perangkingan berdasarkan skor

ranked_scores = sorted(scores, key=lambda x: x[1],
reverse=True)
precision, recall, f1_score = evaluate_bm25(query1,

relevant_docs, corpus, k1, b, k3)
# Menampilkan hasil perangkingan

for rank, (doc_id, score) in enumerate(ranked_scores):
print(f"Peringkat {rank+1}: Dokumen {doc_id}, Skor:
{score}")
print(corpus)
print(query1)
# Menampilkan hasil evaluasi
print("Precision:", precision)
print("Recall:", recall)
print("F1-score:", f1_score)
Kode Program 10. Okapi Bm25
Dalam contoh di atas, menggunakan scores untuk menyimpan nomor

dokumen dan skor BM25 untuk setiap dokumen. Kemudian, menggunakan fungsi
sorted() dengan argumen key=lambda x: x[1] untuk mengurutkan scores
berdasarkan skor (elemen kedua dalam setiap pasangan). Hasil perangkingan
ditampilkan dengan nomor dokumen dan skor terkait. Semakin kecil skor,
semakin tinggi peringkatnya.
Gambar 10. Okapi Bm25

46
Dalam model Okapi BM25, semakin tinggi skor, semakin tinggi tingkat
relevansi antara dokumen dan query. Namun, dalam contoh kode yang diberikan,
perangkingan dilakukan secara terbalik, yaitu dari skor terendah ke skor tertinggi.
Oleh karena itu, skor yang ditampilkan adalah negatif.
Skor negatif pada contoh yang diberikan tidak menunjukkan bahwa
dokumen memiliki tingkat relevansi yang jelek. Skor negatif terjadi karena dalam
perhitungan BM25, terdapat penurunan skor yang ditambahkan pada term "b"
yang berkaitan dengan panjang dokumen. Nilai "b" dalam contoh tersebut adalah
0.75, yang mengakibatkan penurunan skor.
Dalam perangkingan, dokumen dengan skor yang lebih tinggi (bahkan jika
negatif) masih memiliki tingkat relevansi yang lebih tinggi daripada dokumen
dengan skor yang lebih rendah. Jadi, urutan peringkat tetap relevan, meskipun
skornya negatif.
BAB V
PENUTUP
V.1 Kesimpulan
Dalam penelitian ini, kami menganalisis dan membandingkan kinerja
implementasi algoritma Okapi BM25 pada metode Term Frequency-Inverse
Document Frequency (TF-IDF) dan Vector Space Model (VSM) dalam sistem
temu kembali informasi. Tujuan kami adalah meningkatkan ketepatan dalam
menemukan dokumen yang relevan dengan permintaan pengguna. Dari hasil
penelitian dan analisis yang dilakukan, kami dapat menyimpulkan hal-hal berikut:
1. Implementasi algoritma Okapi BM25 pada metode TF-IDF dan VSM
memberikan peningkatan signifikan dalam kinerja sistem temu kembali
informasi.
2. Okapi BM25 mengatasi beberapa keterbatasan yang dapat ditemui dalam
metode tradisional seperti TF-IDF dan VSM, terutama dalam menemukan
dokumen yang paling relevan dengan permintaan pengguna.
3. Penggunaan algoritma Okapi BM25 dalam sistem temu kembali informasi
dapat meningkatkan akurasi dan kepuasan pengguna dengan menampilkan
dokumen yang lebih relevan.
V.2 Saran
Berdasarkan hasil penelitian ini, terdapat beberapa saran untuk
pengembangan sistem temu kembali informasi yang lebih lanjut:
1. Mengintegrasikan algoritma Okapi BM25 dalam metode Boolean
Retrieval Model: Selain implementasi pada metode TF-IDF dan VSM,
penelitian selanjutnya dapat mempertimbangkan penerapan algoritma
Okapi BM25 pada metode Boolean Retrieval Model. Hal ini dapat
memperluas penggunaan algoritma ini dan memberikan peningkatan
kinerja pada metode yang berbeda.
2. Melakukan evaluasi lebih lanjut: Meskipun penelitian ini telah
memberikan hasil positif, evaluasi lebih lanjut dapat dilakukan untuk
menguji kinerja algoritma Okapi BM25 pada berbagai jenis koleksi
47
48
dokumen dan permintaan pengguna yang berbeda. Hal ini akan membantu
dalam memahami kemampuan algoritma ini secara menyeluruh.
3. Mempertimbangkan faktor lain: Selain faktor-faktor yang digunakan
dalam algoritma Okapi BM25, penelitian selanjutnya dapat
mempertimbangkan penggunaan faktor-faktor tambahan seperti metadata
dokumen, struktur dokumen, atau informasi kontekstual lainnya untuk
meningkatkan relevansi temuan.
DAFTAR PUSTAKA
Christopher D. Manning, P. R. (2008). Introduction to Information

Retrieval. Cambridge University Press.
Al Faruqi, Muhammad (2021) Sistem Pemetaan Posisi Objek Kendaraan
Menggunakan Pengolahan Citra Pada Area 360°. Other thesis, Universitas
Komputer Indonesia.
Abu El-Khair, I. (2009). Encyclopedia of Database Systems. Springer
Nature. ISBN: 978-0-387-35544-3.
Octaviani, P. A., Wilandari, Y., & Ispriyanti, D. (2014). Penerapan Metode
Klasifikasi Support Vector Machine (SVM) pada Data Akreditasi Sekolah Dasar
(SD) di Kabupaten Magelang. Gaussian, 3(4), 811-820. Diperoleh dari
http://ejournal-s1.undip.ac.id/index.php/gaussian
Risparyanto, A. (2012). Model-Model Temu Kembali Informasi
(Information Retrieval). UNI Jurnal Perpustakaan. Vol. 3, No. 1, 49-57. ISSN
1979-9527.
Abdurrahman. (2019). Implementasi BM25F pada Pencarian Produk E-
Commerce Berbasis Web (Studi Kasus: Web E-Commerce). Skripsi. Program
Studi Teknik Informatika, Fakultas Sains dan Teknologi, Universitas Islam Negeri
Syarif Hidayatullah Jakarta.
49

Laporan STKI A

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Laporan STKI A

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN PROJEK AKHIR

SISTEM TEMU KEMBALI INFORMASI

Diajukan guna memenuhi sebagian persyaratan dalam rangka menyelesaikan mata

PROGRAM STUDI TEKNOLOGI INFORMASI

Jimbaran, 10 Juli 2023

Gambar 1. Alur Penelitian......................................................................................12

I.1 Latar Belakang

I.2 Rumusan Masalah

I.3 Tujuan Penelitian

1. Menganalisis dan mengimplementasikan pencarian dokumen dengan

I.4 Manfaat Penelitian

I.5 Batasan Masalah

I.6 Sistematika Penulisan

BAB IV: HASIL DAN PEMBAHASAN

II.1 Data Retrival

III.1 Tempat dan Waktu Penelitian

III.2 Alat Penelitian

III.3 Alur Penelitian

Gambar 1. Alur Penelitian

Berdasarkan gambar tersebut, penelitian dimulai dengan proses

IV.1 Gambaran Penelitian

Gambar 2. Gambaran Penelitian

IV.2 Implementasi (Kode Program + Tampilan)

Kode program tersebut akan menghasilkan tampilan seperti berikut ini.

Gambar 3. Input Data

Pengguna harus menginputkan tiga dokumen baik berupa kalimat ataupun

<div class="form-control d-flex mb-2 py-3">

Kode program tersebut akan menghasilkan tampilan seperti berikut ini.

Gambar 4. Input Filter

Tampilan tersebut nantinya akan muncul saat pengguna pertama kali

def preprocessing(stop_word_value, wnl_value, porter_value,

# NEW FORMULA WITH PORTER AND WNL

Kode program lematisasi

Kode program stemming

Kode program tersebut akan menghasilkan tampilan seperti berikut ini.

Gambar 5. Tampilan Preprocessing

Hasil dari preprocessing tersebut berasal dari proses berurutan yaitu

akan diproses berdasarkan algoritma yang dipilih pengguna. Penjelasan mengenai

for word in token_array:

# CEK APAKAH KATA YANG DICARI ADA DALAM DOKUMEN

# konversi nilai-nilai pada array menjadi 1 kecuali 0

sqrt_q = format(pow(sum([float(x) for x in v_q]), 1/2),

sum_vsm_d1 = format(sum([float(x) for x in vsm_d1]),

cos_d1 = format(float(sum_vsm_d1) / (float(sqrt_q) *

cos_rank = len(cos_document) - rankdata(cos_document,

rank_sum_tf = len(result_rank) - rankdata(result_rank,

Kode program tersebut akan menghasilkan tampilan seperti berikut ini.

Gambar 6. Tampilan Algoritma TF-IDF

Berdasarkan kode program tersebut perhitungan TF-IDF didasari pada

# konversi nilai-nilai pada array menjadi 1 kecuali 0

sqrt_q = format(pow(sum([float(x) for x in v_q]), 1/2),

sum_vsm_d1 = format(sum([float(x) for x in vsm_d1]),

cos_d1 = format(float(sum_vsm_d1) / (float(sqrt_q) *

cos_rank = len(cos_document) - rankdata(cos_document,

Kode Program 7. Algoritma SVM 7

Kode program tersebut akan menghasilkan tampilan seperti berikut ini.

Gambar 7. Tampilan Algoritma SVM7

Berdasarkan kode program tersebut perhitungan SVM didasari pada perhitungan

# Fungsi untuk menghitung term frequency (tf)

# Tokenisasi dokumen dan menghitung frekuensi kemunculan

# for doc_id, doc_text in documents:

# # Simpan hasil tokenisasi dalam tokenized_docs

# Menggabungkan semua term unik dalam semua dokumen

# Membuat dataframe untuk tabel term frequency