Optimasi Performa Perbandingan Dokumen di Python: Ketika CPU Lo Kerja Rodi!

Optimasi Performa Perbandingan Dokumen di Python: Ketika CPU Lo Kerja Rodi!

Pendahuluan

Pernah nggak sih lo ngerasa komputer lo tiba-tiba lemot pas lagi bandingin banyak file atau dokumen? Itu tandanya lo butuh optimasi, bro! Di dunia pemrograman, terutama dalam text analysis, perbandingan dokumen jadi salah satu tugas yang sering dilakukan, baik buat deteksi plagiarisme, analisis sentimen, atau sekadar ngecek kesamaan antara dua teks.

Tapi masalahnya, kalau lo punya ribuan file yang harus dibandingin satu per satu, CPU lo bakal ngerasa kayak disuruh lari maraton tanpa air minum. Nah, solusinya? Multiprocessing!

Di artikel ini, kita bakal bahas cara ngeboost performa program Python lo menggunakan multiprocessing, queue, dan beberapa metode lain buat bandingin dokumen dengan lebih efisien. Siap? Yuk, kita mulai!

Kenapa Harus Pakai Multiprocessing?

Sebelum masuk ke kode, kita bahas dulu kenapa multiprocessing penting buat kasus ini.

1. CPU Lo Gak Cuma Satu, Bro!

Kalau lo punya CPU multi-core (misalnya 4, 8, atau bahkan lebih), sayang banget kalau cuman satu core yang kerja sementara yang lain santai ngopi. Multiprocessing memungkinkan lo memanfaatkan semua core CPU biar tugas bisa dikerjain lebih cepat.

2. File Loading vs. Perhitungan

Dalam proses ini, ada dua bagian utama:

• Loading file → Ini bagian di mana program lo baca file dari disk (biasanya bottleneck kalau lo pakai HDD biasa).
• Menghitung kesamaan → Ini butuh pemrosesan intensif buat ngitung similarity score antara dua dokumen.

Dengan multiprocessing, kita bisa bikin satu proses khusus buat loading file, dan beberapa proses lain buat ngitung similarity. Jadi, nggak ada yang harus nungguin satu sama lain.

Baca Juga

• Cara Install Laragon
• 6 Framework Terbaik Untuk Python

 

Strategi Optimasi: Cara Kerjanya

Oke, sekarang kita bahas strategi yang dipakai buat ngeboost performa perbandingan dokumen ini.

1. Buat Loader Process

Alih-alih semua proses baca file sendiri-sendiri (yang bikin antrian di disk), kita bikin satu proses khusus buat baca file dan masukin ke queue. Ini bikin loading lebih efisien karena sistem nggak harus bolak-balik baca file yang beda di waktu bersamaan.

2. Gunakan Multiple Worker Process

Setelah file masuk ke queue, kita bikin beberapa worker process buat ngitung similarity dokumen. Semakin banyak core CPU yang lo punya, semakin banyak worker yang bisa lo jalankan.

3. Queue Buat Sinkronisasi

Biar semua proses bisa jalan tanpa bentrok, kita pakai multiprocessing.Queue buat komunikasi antara loader, worker, dan main process. Loader bakal masukin file ke queue, worker bakal ambil dari queue, dan hasil akhirnya dikirim ke result queue.

 

Kode Python: Optimasi Perbandingan Dokumen

Nah, sekarang kita lihat gimana implementasi strateginya di kode Python.

1. Import Library yang Dibutuhkan

import multiprocessing
import os
from difflib import SequenceMatcher
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity

Kita pakai multiprocessing buat multi-core processing, difflib buat cek similarity, dan sklearn buat hitung cosine similarity.

 

2. Fungsi Buat Menghitung Similarity

def get_tf_vectors(doc1, doc2):
    text = [doc1, doc2]
    vectorizer = CountVectorizer()
    vectorizer.fit(text)
    return vectorizer.transform(text).toarray()

Fungsi ini bikin vector dari teks biar bisa dibandingkan pakai cosine similarity.

def calculate_similarities(doc_pairs_queue, results_queue):
    while True:
        pair = doc_pairs_queue.get()
        if pair is None:
            break
        pair_id, doc1, doc2 = pair
        words_doc1, words_doc2 = set(doc1.split()), set(doc2.split())
        vectors = get_tf_vectors(doc1, doc2)
        results_queue.put((pair_id,
                           cosine_similarity(vectors)[0][1],
                           len(words_doc1 & words_doc2) / len(words_doc1 | words_doc2),
                           SequenceMatcher(None, doc1, doc2).ratio()))

Worker ini bakal ambil dokumen dari queue, hitung similarity, lalu masukin hasilnya ke results queue.

 

3. Loader Process Buat Baca File

def load_files(doc_pair_list, loaded_queue):
    for item in doc_pair_list:
        with open(item[1], 'r', encoding='utf-8') as f1, open(item[2], 'r', encoding='utf-8') as f2:
            loaded_queue.put((item[0], f1.read(), f2.read()))
    loaded_queue.put(None)  # Sinyal kalau loading selesai

Loader ini bakal baca file dari disk dan masukin ke queue buat diproses worker.

 

4. Main Function: Koordinator Utama

def data_analysis(doc_pair_list):
    loaded_pairs_queue = multiprocessing.Queue(maxsize=1000)
    loader = multiprocessing.Process(target=load_files, args=(doc_pair_list, loaded_pairs_queue))
    loader.start()


    results_queue = multiprocessing.Queue(maxsize=1000)
    worker_count = os.cpu_count() or 2
    workers = [multiprocessing.Process(target=calculate_similarities, args=(loaded_pairs_queue, results_queue)) for _ in range(worker_count)]


    for worker in workers:
        worker.start()


    results = {}
    while True:
        res = results_queue.get()
        if res is None:
            break
        results[res[0]] = res[1:]


    loader.join()
    for worker in workers:
        worker.terminate()
        worker.join()


    return results

Fungsi utama ini bakal jalankan loader, distribusi kerja ke worker, lalu simpan hasil akhir ke dictionary.

 

Kenapa Metode Ini Lebih Cepat?

• Menggunakan Semua Core CPU → Dibanding satu core doang, ini bikin perhitungan jauh lebih cepat.
• Memisahkan Proses Loading & Processing → Loading file lebih cepat karena nggak bentrok sama proses kalkulasi.
• Queue Buat Sinkronisasi → Semua proses bisa jalan bareng tanpa harus saling nungguin.

 

Optimalisasi Lebih Lanjut: Biar Makin Ngebut!

Oke, kode kita udah lebih cepat berkat multiprocessing, tapi ada beberapa trik lagi yang bisa lo lakuin biar makin optimal.

1. Gunakan Asynchronous Processing (asyncio)

Kalau proyek lo lebih banyak baca data dari database atau API ketimbang CPU-heavy processing, lo bisa coba asyncio buat paralelisasi proses tanpa harus bikin banyak worker. Async cocok banget buat IO-bound tasks!

import asyncio


async def load_file_async(path):
    async with aiofiles.open(path, 'r') as f:
        return await f.read()

 

2. Coba Gunakan Dask atau Ray

Kalau lo beneran butuh performa tinggi buat dataset besar (misalnya jutaan dokumen), pertimbangkan buat pake Dask atau Ray. Ini framework buat distributed computing, yang berarti lo bisa ngejalanin proses di beberapa mesin sekaligus!

import dask
import dask.bag as db


bag = db.from_sequence(doc_list)
processed = bag.map(process_doc).compute()

Kesimpulannya? Kalau lo makin sering kerja sama data besar, makin penting buat ngerti teknik parallel & distributed computing. Jangan biarkan CPU lo kerja sendirian, bro—optimalkan pake multiprocessing, async, atau bahkan distributed frameworks!

 

Kesimpulan: Nggak Ada Lagi CPU Loyo!

Dengan metode multiprocessing ini, lo bisa:

• Bandingin ribuan dokumen lebih cep
•  
• at tanpa harus nunggu lama.
• Memanfaatkan semua core CPU lo biar nggak ada yang nganggur.
• Bikin kode yang scalable buat proyek lebih besar di masa depan.

Jadi, kalau lo lagi kerja di proyek NLP, machine learning, atau data analysis yang melibatkan banyak teks, multiprocessing adalah salah satu cara paling efektif buat ngeboost performa kode lo! Udah siap bikin CPU lo kerja maksimal? Gaskeun, bro!

Published on August 09, 2025
Last updated on June 03, 2026