LLM: Extract .jsonl dari file pdf

From OnnoWiki
Jump to navigation Jump to search

Untuk mengenerate file `.jsonl` dari sebuah referensi buku dalam format PDF, Anda perlu mengekstrak konten dari PDF, memprosesnya menjadi format terstruktur (misalnya, pasangan instruction-output atau Q&A), dan menyimpannya sebagai file JSONL. Berikut adalah panduan langkah demi langkah menggunakan Python, dengan asumsi tujuan Anda adalah membuat dataset untuk fine-tuning model seperti Qwen2. Proses ini mencakup ekstraksi teks, preprocessing, dan konversi ke format JSONL.

    • Prasyarat:**

- Python 3.10+ terinstal. - Library: `PyPDF2`, `pdfplumber`, atau `pypdf` untuk ekstraksi PDF; `pandas` untuk manipulasi data; `json` untuk format JSONL. - File PDF (misalnya, `buku.pdf`). - GPU tidak wajib, karena ini adalah preprocessing.

      1. Langkah-Langkah
        1. Step 1: Instalasi Library

Jalankan perintah berikut di terminal atau Colab untuk menginstal library yang diperlukan:

```bash pip install pdfplumber pandas ```

    • Catatan:** `pdfplumber` lebih akurat untuk ekstraksi teks dan tabel dibandingkan `PyPDF2`. Gunakan `pypdf` jika PDF kompleks (misalnya, berisi gambar teks).
        1. Step 2: Ekstraksi Teks dari PDF

Gunakan `pdfplumber` untuk mengekstrak teks dari file PDF. Berikut contoh kode untuk mengekstrak semua teks:

```python import pdfplumber

def extract_text_from_pdf(pdf_path): 

   text = ""
   with pdfplumber.open(pdf_path) as pdf:
       for page in pdf.pages:
           text += page.extract_text() or ""
   return text
  1. Ganti dengan path file PDF Anda

pdf_path = "path/to/buku.pdf" raw_text = extract_text_from_pdf(pdf_path) print(raw_text[:500]) # Cek 500 karakter pertama ```

    • Alternatif (Jika PDF Berbasis Gambar):**

Jika PDF berisi teks dalam gambar (scanned), gunakan OCR seperti `tesseract`. Instal dulu:

```bash pip install pytesseract sudo apt-get install tesseract-ocr # Untuk Linux, atau unduh untuk Windows/Mac ```

Kode dengan OCR: ```python from pdf2image import convert_from_path import pytesseract

def extract_text_with_ocr(pdf_path): 

   images = convert_from_path(pdf_path)
   text = ""
   for image in images:
       text += pytesseract.image_to_string(image, lang='eng+ind')  # Tambah 'ind' untuk bahasa Indonesia
   return text

raw_text = extract_text_with_ocr(pdf_path) ```

    • Catatan:** Anda perlu `poppler-utils` untuk `pdf2image`. Instal dengan `sudo apt-get install poppler-utils` atau unduh dari Poppler.
        1. Step 3: Preprocessing Teks

Teks dari PDF sering kali berantakan (misalnya, baris baru acak, header/footer). Bersihkan teks dan ubah menjadi format terstruktur (misalnya, instruction-output untuk fine-tuning).

    • Contoh:** Misalkan buku PDF berisi bab-bab dengan penjelasan konsep. Anda ingin membuat dataset Q&A seperti:

```json {"instruction": "Jelaskan konsep X dari buku tersebut.", "output": "Konsep X adalah..."} ```

Kode preprocessing sederhana: ```python import re

def clean_text(text): 

   # Hapus baris kosong berlebih, nomor halaman, header/footer
   text = re.sub(r'\n\s*\n', '\n', text)  # Ganti baris kosong berulang
   text = re.sub(r'Page \d+', , text)  # Hapus nomor halaman
   text = text.strip()
   return text

cleaned_text = clean_text(raw_text) ```

    • Strukturkan Data:**

Misalnya, Anda ingin membuat Q&A berdasarkan subjudul atau paragraf. Anda bisa melakukannya secara manual atau otomatis. Contoh otomatis dengan asumsi subjudul dipisahkan oleh pola tertentu (misalnya, huruf kapital atau nomor bab):

```python def create_qa_pairs(text): 

   qa_pairs = []
   # Contoh: Split berdasarkan subjudul (misalnya, "1.1 Judul")
   sections = re.split(r'\d+\.\d+\s+[A-Z][a-zA-Z\s]+', text)
   headers = re.findall(r'\d+\.\d+\s+[A-Z][a-zA-Z\s]+', text)
   
   for header, content in zip(headers, sections[1:]):  # Skip pertama jika kosong
       instruction = f"Jelaskan {header.strip()} dari buku tersebut."
       output = content.strip()[:500]  # Batasi panjang output
       qa_pairs.append({"instruction": instruction, "output": output})
   
   return qa_pairs

qa_pairs = create_qa_pairs(cleaned_text) ```

    • Catatan:** Logika splitting di atas sederhana. Jika struktur buku kompleks (misalnya, tabel atau daftar isi), gunakan `pdfplumber` untuk ekstrak tabel atau metadata, lalu sesuaikan logika. Anda mungkin perlu manual curation untuk hasil terbaik.
        1. Step 4: Simpan ke File JSONL

Simpan data terstruktur ke format JSONL (satu JSON object per baris).

```python import json

def save_to_jsonl(qa_pairs, output_path): 

   with open(output_path, 'w', encoding='utf-8') as f:
       for pair in qa_pairs:
           json.dump(pair, f, ensure_ascii=False)
           f.write('\n')
  1. Simpan ke file

output_path = "dataset.jsonl" save_to_jsonl(qa_pairs, output_path)

  1. Cek isi file

with open(output_path, 'r', encoding='utf-8') as f: 

   for i, line in enumerate(f):
       print(line.strip())
       if i >= 2:  # Cek 3 baris pertama
           break

```

    • Contoh Isi `dataset.jsonl`:**

```json {"instruction": "Jelaskan 1.1 Pengantar Machine Learning dari buku tersebut.", "output": "Machine Learning adalah cabang AI yang fokus pada..."} {"instruction": "Jelaskan 1.2 Algoritma Dasar dari buku tersebut.", "output": "Algoritma dasar meliputi regresi linier, SVM, dan..."} ```

        1. Step 5: Verifikasi untuk Fine-Tuning

Pastikan format JSONL sesuai dengan kebutuhan fine-tuning (misalnya, Alpaca-style untuk Qwen2). Jika model Qwen2 membutuhkan format lain (misalnya, hanya `"text"` dengan template khusus), ubah struktur di Step 3. Contoh untuk format `"text"`:

```python alpaca_prompt = """<|im_start|>system You are a helpful assistant.<|im_end|> <|im_start|>user {}<|im_end|> <|im_start|>assistant {}<|im_end|>"""

def create_text_format(qa_pairs): 

   texts = []
   for pair in qa_pairs:
       text = alpaca_prompt.format(pair["instruction"], pair["output"])
       texts.append({"text": text})
   return texts

text_data = create_text_format(qa_pairs) save_to_jsonl(text_data, "dataset_text.jsonl") ```

        1. Step 6: Validasi untuk Ollama

Setelah fine-tuning (sesuai panduan sebelumnya), pastikan dataset JSONL: - Tidak ada baris kosong atau JSON rusak. - Teks dalam bahasa yang konsisten (misalnya, Indonesia jika model di-fine-tune untuk bahasa Indonesia). - Panjang sequence sesuai (misalnya, <2048 token untuk Qwen2-1.5B).

Gunakan `datasets` untuk validasi: ```python from datasets import load_dataset

dataset = load_dataset("json", data_files={"train": "dataset.jsonl"}, split="train") print(dataset[0]) # Cek baris pertama ```

        1. Tips Tambahan:

- **PDF Kompleks:** Jika PDF berisi tabel, gunakan `pdfplumber.extract_table()` untuk ekstrak data tabular dan ubah ke Q&A. - **Dataset Kecil:** Jika buku menghasilkan sedikit data, augmentasi dengan pertanyaan tambahan (misalnya, via Grok atau model lain). - **Bahasa Indonesia:** Pastikan teks output dalam JSONL sudah bersih dari kesalahan OCR (misalnya, "1" jadi "l"). Gunakan library seperti `spellchecker` untuk koreksi. - **Sumber:** Proses ini berdasarkan praktik umum ekstraksi PDF dengan `pdfplumber` dan format JSONL untuk fine-tuning LLM seperti Alpaca.

        1. Contoh Workflow End-to-End:

1. Ekstrak teks dari `buku.pdf` → Dapatkan teks mentah. 2. Bersihkan teks (hapus header, footer, dll.). 3. Ubah ke Q&A (misalnya, 100 pasangan dari 10 bab). 4. Simpan ke `dataset.jsonl`. 5. Gunakan JSONL untuk fine-tuning Qwen2 (lihat panduan sebelumnya). 6. Convert ke GGUF dan deploy ke Ollama.

Jika ada error (misalnya, PDF tidak terbaca atau format JSONL salah), beri tahu saya detailnya, termasuk contoh isi PDF atau struktur JSONL yang diinginkan!

Retrieved from "https://onnocenter.or.id/wiki/index.php?title=LLM:_Extract_.jsonl_dari_file_pdf&oldid=72957"