Unknown user: Created page with "Untuk mengenerate file `.jsonl` dari sebuah referensi buku dalam format PDF, Anda perlu mengekstrak konten dari PDF, memprosesnya menjadi format terstruktur (misalnya, pasanga..."

2025-10-04T22:07:30Z

Created page with "Untuk mengenerate file `.jsonl` dari sebuah referensi buku dalam format PDF, Anda perlu mengekstrak konten dari PDF, memprosesnya menjadi format terstruktur (misalnya, pasanga..."

New page

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.

### Langkah-Langkah

#### 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).

#### 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

# 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.

#### 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.

#### 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')

# Simpan ke file
output_path = "dataset.jsonl"
save_to_jsonl(qa_pairs, output_path)

# 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..."}
```

#### 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")
```

#### 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
```

#### 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.

#### 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!

LLM: Extract .jsonl dari file pdf - Revision history

Unknown user: Created page with "Untuk mengenerate file `.jsonl` dari sebuah referensi buku dalam format PDF, Anda perlu mengekstrak konten dari PDF, memprosesnya menjadi format terstruktur (misalnya, pasanga..."