5803025054/Kecerdasan_Buatan_1_54
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
Kecerdasan_Buatan_1_54/lab_rag/lab1_chunking.py
T
5803025054 6a4c7fa4c6 1
2026-11-02 11:13:19 +07:00

300 lines
13 KiB
Python
Raw Permalink Blame History

"""Lab 1 - Eksperimen chunking (15 menit).
1. Baca satu PDF dengan baca_pdf() dan cetak 500 karakter pertama.
2. Potong dengan potong() memakai tiga ukuran (500, 1000, 1500) dan overlap 10-20%.
3. Lihat 3 chunk acak tiap ukuran: terpotong di tengah kalimat atau tabel?
Versi ini dijalankan untuk ketiga PDF AI. Satu laporan PDF dibuat per dokumen:
Lab1_Eksperimen_Chunking_1.pdf, _2.pdf, _3.pdf
Jalankan semua : python lab1_chunking.py
Jalankan satu : python lab1_chunking.py 2_Machine_Learning_dan_Deep_Learning.pdf
"""
import os
import random
import re
import sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from laporan_utils import Laporan
from rag_utils import FOLDER_DOKUMEN, baca_pdf, norm, potong, potong_dengan_posisi
BASE = os.path.dirname(os.path.abspath(__file__))
# Ketiga PDF yang dipakai. Letakkan di FOLDER_DOKUMEN, di folder skrip ini, atau di folder kerja.
DAFTAR_PDF = [
"1_Pengenalan_Kecerdasan_Buatan.pdf",
"2_Machine_Learning_dan_Deep_Learning.pdf",
"3_Etika_Risiko_dan_Masa_Depan_AI.pdf",
]
# PDF ini tidak memakai penanda "Tabel N." / "Sumber:", jadi wilayah tabel ditentukan lewat
# teks baris judul kolom (awal) dan teks akhir baris terakhir tabel (akhir).
PENANDA_TABEL = {
"1_Pengenalan_Kecerdasan_Buatan.pdf": [
("Periode Peristiwa Penting", "secara luas."),
("Sektor Contoh Penerapan", "pembuatan musik dan gambar."),
],
"2_Machine_Learning_dan_Deep_Learning.pdf": [
("Paradigma Penjelasan Contoh", "hadiah dan hukuman."),
("Arsitektur Kegunaan Utama", "konten sintetis."),
],
"3_Etika_Risiko_dan_Masa_Depan_AI.pdf": [
("Isu Penjelasan", "pelatihan."),
],
}
UKURAN = [500, 1000, 1500]
OVERLAP = [0.10, 0.15, 0.20]
OVERLAP_UTAMA = 0.15
SEED = 42
# --------------------------------------------------------------------------- utilitas
def cari_pdf(nama):
"""Cari file PDF di FOLDER_DOKUMEN, folder skrip, lalu folder kerja."""
kandidat = [os.path.join(d, nama) for d in (FOLDER_DOKUMEN, BASE, os.getcwd())]
for k in kandidat:
if os.path.isfile(k):
return k
raise FileNotFoundError(f"{nama} tidak ditemukan. Sudah dicari di:\n " + "\n ".join(kandidat))
def bersihkan_footer(teks):
"""Buang baris nomor halaman ('Halaman 1') yang ikut terbaca di tengah isi.
Dilakukan sebelum pemotongan, sehingga semua posisi karakter konsisten."""
baru, n = re.subn(r"^[ \t]*Halaman \d+[ \t]*\n?", "", teks, flags=re.MULTILINE)
return baru, n
def wilayah_tabel(teks, penanda):
"""Rentang karakter tiap tabel: dari teks judul kolom sampai akhir baris terakhir tabel.
Penanda yang tidak ditemukan dilaporkan, bukan diam-diam dilewati."""
hasil = []
for awal, akhir in penanda:
a = teks.find(awal)
if a < 0:
print(f" [PERINGATAN] awal tabel tidak ditemukan: {awal!r}")
continue
z = teks.find(akhir, a)
if z < 0:
print(f" [PERINGATAN] akhir tabel tidak ditemukan: {akhir!r}")
continue
hasil.append((a, z + len(akhir)))
return hasil
def batas_bersih(teks, pos):
"""True bila posisi `pos` jatuh di batas satuan teks yang wajar (bukan di tengah kalimat).
Newline TIDAK otomatis dianggap batas, karena PDF memecah baris di tengah kalimat.
Batas bersih bila: awal/akhir dokumen; ATAU tidak memotong kata dan teks sebelumnya
berakhir . ! ? : ; ATAU bagian berikutnya diawali butir daftar ('- ') / judul bernomor
('3. ') sehingga teks sebelumnya adalah butir atau judul yang sudah selesai."""
if pos <= 0 or pos >= len(teks):
return True
kiri, kanan = teks[:pos], teks[pos:]
if kiri[-1] not in " \n" and kanan[0] not in " \n":
return False # memotong di tengah kata
kiri_s, kanan_s = kiri.rstrip(), kanan.lstrip()
if not kiri_s or not kanan_s:
return True
kata_akhir = kiri_s.split()[-1]
if re.fullmatch(r"\d+\.", kata_akhir):
return False # nomor judul ("3.") yang terpisah dari judulnya
if kiri_s[-1] in ".!?:":
return True
return bool(re.match(r"(-\s|\d+\.\s)", kanan_s))
def awal_di_tengah_kalimat(teks, mulai):
return not batas_bersih(teks, mulai)
def akhir_di_tengah_kalimat(teks, akhir):
return not batas_bersih(teks, akhir)
def memotong_tabel(wil, mulai, akhir):
"""True bila chunk beririsan dengan tabel tetapi tidak memuat seluruh tabel."""
for a, b in wil:
beririsan = mulai < b and akhir > a
utuh = mulai <= a and akhir >= b
if beririsan and not utuh:
return True
return False
def pct(x, n):
return f"{x}/{n} ({x / n:.0%})" if n else "0/0"
# --------------------------------------------------------------------------- narasi dari data
def catatan_kualitas(k, n_footer):
"""Penilaian kualitas teks yang dihitung dari angka, bukan ditulis tetap."""
masalah = []
if k["Karakter rusak (U+FFFD)"]:
masalah.append(f"{k['Karakter rusak (U+FFFD)']} karakter rusak (U+FFFD)")
if k["Sisa kode glyph (cid:)"]:
masalah.append(f"{k['Sisa kode glyph (cid:)']} kode glyph '(cid:N)' (simbol gagal diterjemahkan)")
if n_footer:
masalah.append(f"{n_footer} baris nomor halaman 'Halaman N' yang menyelip di tengah isi "
"(sudah dibuang sebelum pemotongan)")
if not masalah:
return "Teks terbaca bersih: tidak ada karakter rusak, kode glyph, atau sisa footer."
return "Temuan kualitas teks: " + "; ".join(masalah) + "."
def buat_kesimpulan(statistik_angka, jumlah_tabel):
"""Kesimpulan yang seluruh klaimnya dihitung dari statistik, jadi benar untuk PDF apa pun."""
rincian = "; ".join(
f"ukuran {u}: awal di tengah kalimat {pct(a, n)}, akhir di tengah kalimat {pct(z, n)}, "
f"memotong tabel {pct(t, n)}" for u, n, a, z, t in statistik_angka)
kal = [f"Pemotongan per karakter tidak mengenal batas kalimat maupun tabel. Hasil seluruh chunk "
f"(overlap {int(OVERLAP_UTAMA * 100)}%) - {rincian}."]
pz = [z / n for _, n, _, z, _ in statistik_angka if n]
pa = [a / n for _, n, a, _, _ in statistik_angka if n]
if pz:
if min(pz) > 0.5:
kal.append("Pada setiap ukuran, mayoritas chunk berakhir di tengah kalimat.")
elif max(pz) < 0.5:
kal.append("Pada setiap ukuran, kurang dari separuh chunk berakhir di tengah kalimat.")
else:
kal.append("Proporsi chunk yang berakhir di tengah kalimat berbeda antar ukuran "
f"({min(pz):.0%} sampai {max(pz):.0%}).")
kal.append(f"Chunk yang dimulai di tengah kalimat berkisar {min(pa):.0%} sampai {max(pa):.0%}; "
"chunk pertama selalu dimulai bersih.")
if max(pz) - min(pz) <= 0.15:
kal.append("Persentase chunk yang terpotong tidak banyak berubah saat ukuran diperbesar; "
"yang berubah adalah jumlah chunk dan banyaknya topik per chunk.")
kecil = [u for u, n, *_ in statistik_angka if n < 10]
if kecil:
kal.append(f"Catatan: dokumen ini pendek sehingga ukuran {', '.join(map(str, kecil))} hanya menghasilkan "
"kurang dari 10 chunk; persentasenya mudah bergeser oleh satu chunk saja.")
if jumlah_tabel == 0:
kal.append("Tidak ada tabel yang terdeteksi pada dokumen ini.")
else:
kena = [str(u) for u, _, _, _, t in statistik_angka if t > 0]
if len(kena) == len(statistik_angka):
kal.append(f"Dari {jumlah_tabel} tabel, minimal satu terpotong oleh sedikitnya satu chunk pada "
"setiap ukuran; baris tabel yang terpisah dari judul kolomnya sulit dipahami.")
elif kena:
kal.append(f"Dari {jumlah_tabel} tabel, pemotongan tabel terjadi pada ukuran {', '.join(kena)}.")
else:
kal.append(f"Dari {jumlah_tabel} tabel, tidak ada yang terpotong pada pengaturan ini.")
kal.append("Perbaikan yang layak dicoba: pemotongan berbasis kalimat/paragraf dan memperlakukan "
"tabel sebagai satu chunk utuh.")
return " ".join(kal)
# --------------------------------------------------------------------------- satu dokumen
def jalankan(nama_pdf, nomor):
pdf = cari_pdf(nama_pdf)
print("\n" + "#" * 70 + f"\n# {nama_pdf}\n" + "#" * 70)
# ---- Langkah 1
mentah = baca_pdf(pdf)
teks, n_footer = bersihkan_footer(mentah)
if not teks.strip():
raise ValueError(f"{nama_pdf}: tidak ada teks yang terbaca (mungkin PDF hasil scan).")
n_huruf = sum(c.isalpha() for c in teks)
kualitas = {
"File": os.path.basename(pdf),
"Total karakter": len(teks),
"Karakter rusak (U+FFFD)": teks.count("\ufffd"),
"Sisa kode glyph (cid:)": teks.count("(cid:"),
"Persentase huruf": f"{n_huruf / len(teks):.0%}",
}
print("=== Langkah 1: 500 karakter pertama ===")
print(teks[:500])
print(kualitas)
# ---- Langkah 2
print("\n=== Langkah 2: jumlah chunk ===")
tabel_jumlah = [["Ukuran (karakter)"] + [f"overlap {int(o * 100)}%" for o in OVERLAP]]
for u in UKURAN:
baris = [u]
for o in OVERLAP:
n = len(potong(teks, u, o))
baris.append(n)
print(f"ukuran={u:5d} overlap={o:.0%} -> {n} chunk")
tabel_jumlah.append(baris)
# ---- Langkah 3
wil = wilayah_tabel(teks, PENANDA_TABEL.get(nama_pdf, []))
print(f"\nTabel terdeteksi: {len(wil)} -> {wil}")
rnd = random.Random(SEED)
cuplikan = {}
statistik = [["Ukuran", "Jumlah chunk", "Awal di tengah kalimat",
"Akhir di tengah kalimat", "Memotong tabel"]]
statistik_angka = []
for u in UKURAN:
pot = potong_dengan_posisi(teks, u, OVERLAP_UTAMA)
n = len(pot)
a = sum(awal_di_tengah_kalimat(teks, m) for m, _, _ in pot)
z = sum(akhir_di_tengah_kalimat(teks, e) for _, e, _ in pot)
t = sum(memotong_tabel(wil, m, e) for m, e, _ in pot)
statistik.append([u, n, pct(a, n), pct(z, n), pct(t, n)])
statistik_angka.append((u, n, a, z, t))
pilih = sorted(rnd.sample(range(n), min(3, n)))
cuplikan[u] = [(i + 1, pot[i][0], pot[i][1], pot[i][2],
awal_di_tengah_kalimat(teks, pot[i][0]),
akhir_di_tengah_kalimat(teks, pot[i][1]),
memotong_tabel(wil, pot[i][0], pot[i][1])) for i in pilih]
print(f"\n=== Langkah 3: ukuran {u} ({len(pilih)} chunk acak) ===")
for no, m, e, isi, aw, ak, tb in cuplikan[u]:
print(f"--- chunk #{no} [{m}:{e}] awal_tengah={aw} akhir_tengah={ak} potong_tabel={tb}")
print(isi)
catatan = catatan_kualitas(kualitas, n_footer)
kesimpulan = buat_kesimpulan(statistik_angka, len(wil))
print("\nKualitas:", catatan)
print("Kesimpulan:", kesimpulan)
# ---- Laporan PDF
keluar = os.path.join(BASE, f"Lab1_Eksperimen_Chunking_{nomor}.pdf")
L = Laporan(keluar, f"Lab 1 - Eksperimen Chunking ({nomor}/{len(DAFTAR_PDF)})",
f"{os.path.basename(pdf)} | Python (pdfplumber + fungsi potong)")
L.h1("Langkah 1. Membaca PDF dan memeriksa teks")
L.p(f"File yang dibaca: {os.path.basename(pdf)}. Berikut 500 karakter pertama hasil baca_pdf():")
L.kode(teks[:500])
L.spasi()
L.tabel([["Pemeriksaan", "Hasil"]] + [[k, v] for k, v in kualitas.items()], [6 * 28.35, 8 * 28.35])
L.p(catatan)
L.h1("Langkah 2. Jumlah chunk tiap pengaturan")
L.p("Fungsi potong(teks, ukuran, overlap) memakai jendela geser per karakter; langkah = ukuran x (1 - overlap).")
L.tabel(tabel_jumlah)
L.cap("Tabel 1. Jumlah chunk untuk 3 ukuran x 3 overlap. Makin besar ukuran, makin sedikit chunk; "
"makin besar overlap, makin banyak chunk.")
L.h1(f"Langkah 3. Tiga chunk acak per ukuran (overlap {int(OVERLAP_UTAMA * 100)}%, seed {SEED})")
L.tabel(statistik)
L.cap("Tabel 2. Statistik seluruh chunk pada tiap ukuran (bukan hanya yang dicuplik).")
for u in UKURAN:
L.h2(f"Ukuran {u} karakter")
for no, m, e, isi, aw, ak, tb in cuplikan[u]:
L.p(f"Chunk #{no} (karakter {m}-{e}) | awal di tengah kalimat: {'ya' if aw else 'tidak'} | "
f"akhir di tengah kalimat: {'ya' if ak else 'tidak'} | memotong tabel: {'ya' if tb else 'tidak'}")
L.kode(isi)
L.spasi(4)
L.h1("Kesimpulan")
L.p(kesimpulan)
L.halaman_baru()
L.h1("Lampiran: kode lab1_chunking.py")
L.kode(open(__file__, encoding="utf-8").read())
L.simpan()
print(f"\nLaporan: {os.path.basename(keluar)}")
def main():
# Argumen opsional: nama satu/lebih PDF. Tanpa argumen, ketiga PDF diproses.
daftar = sys.argv[1:] or DAFTAR_PDF
for i, nama in enumerate(daftar, 1):
jalankan(os.path.basename(nama), i)
if __name__ == "__main__":
main()
Reference in New Issue View Git Blame Copy Permalink