Apa Itu Leiden Algorithm? Pengertian, Cara Kerja, Kelebihan, dan Contohnya

Ketika kita melihat sebuah jaringan yang sangat besar, kita sering kesulitan memahami hubungan di dalamnya. Bayangkan sebuah media sosial dengan jutaan pengguna, sebuah jaringan sitasi yang berisi jutaan artikel ilmiah, atau jaringan transaksi yang menghubungkan banyak pelanggan dan produk.

Di dalam jaringan sebesar itu biasanya terdapat kelompok-kelompok yang secara alami memiliki hubungan lebih kuat satu sama lain. Tantangannya adalah bagaimana menemukan kelompok tersebut secara otomatis.

Di sinilah Leiden Algorithm digunakan.

Leiden Algorithm adalah algoritma untuk community detection, yaitu proses menemukan kelompok atau komunitas yang terbentuk secara alami di dalam sebuah jaringan atau graph. Algoritma ini diperkenalkan oleh Vincent Traag, Ludo Waltman, dan Nees Jan van Eck dalam penelitian yang diterbitkan di Scientific Reports pada 2019. Nama "Leiden" diambil dari kota Leiden di Belanda, yang berkaitan dengan lokasi para penulis penelitian tersebut.

Secara sederhana, Leiden Algorithm mencoba menjawab pertanyaan:

"Dari sekian banyak titik dan hubungan dalam sebuah jaringan, kelompok mana yang sebenarnya memiliki keterikatan paling kuat?"

Algoritma ini sangat dekat hubungannya dengan Louvain Algorithm, tetapi dibuat untuk mengatasi kelemahan penting pada Louvain, terutama kemungkinan terbentuknya komunitas yang tidak benar-benar terhubung dengan baik.

Memahami Leiden Algorithm dari Dasar

Sebelum membahas algoritmanya, kita perlu memahami terlebih dahulu apa yang dimaksud dengan graph dan community.

Dalam network science, sebuah graph biasanya terdiri dari:

• Node (vertex) → objek atau entitas.

• Edge → hubungan antara dua node.

• Weight → seberapa kuat hubungan tersebut, jika jaringan memiliki bobot.

• Community → kelompok node yang memiliki hubungan relatif lebih kuat satu sama lain dibandingkan dengan hubungan mereka terhadap kelompok lain.

Misalnya kita membuat jaringan pertemanan.

Anggap ada 100 orang dalam sebuah komunitas. Setiap orang menjadi satu node, sedangkan hubungan pertemanan menjadi edge.

Setelah dianalisis, ternyata terdapat beberapa kelompok:

• Kelompok A banyak berinteraksi satu sama lain.

• Kelompok B juga memiliki interaksi yang sangat kuat.

• Kelompok C lebih banyak berhubungan dengan anggota kelompoknya sendiri.

Kita mungkin tidak mengetahui kelompok tersebut sebelumnya. Leiden Algorithm dapat mencoba menemukannya berdasarkan struktur hubungan yang ada.

Jadi, algoritma ini bukan sekadar "mengelompokkan data" seperti clustering pada dataset tabular. Leiden bekerja berdasarkan struktur hubungan dalam graph.

Apa Tujuan Utama Leiden Algorithm?

Tujuan utamanya adalah menemukan partition atau pembagian jaringan menjadi beberapa komunitas dengan kualitas tertentu.

Kualitas tersebut ditentukan menggunakan fungsi objektif, misalnya:

• Modularity

• Constant Potts Model (CPM)

Keduanya digunakan untuk menilai seberapa baik suatu pembagian jaringan menjadi komunitas. Implementasi leidenalg, misalnya, menyediakan berbagai jenis VertexPartition, termasuk Modularity dan CPM.

Secara intuitif, algoritma berusaha menghasilkan kondisi seperti ini:

Komunitas A
●──●──●
│ ╲ │
●──●──●

         hubungan antar-komunitas relatif lebih sedikit

Komunitas B
●──●──●
│ ╲ │
●──●──●

Node yang berada dalam komunitas yang sama idealnya memiliki hubungan yang cukup kuat dan struktur internal yang baik.

Mengapa Leiden Algorithm Dibuat?

Untuk memahami alasan munculnya Leiden, kita perlu melihat algoritma yang lebih lama dan sangat populer, yaitu Louvain Algorithm.

Louvain juga digunakan untuk community detection. Secara umum, Louvain melakukan dua tahap utama:

1. Memindahkan node dari satu komunitas ke komunitas lain untuk meningkatkan nilai fungsi kualitas.

2. Menggabungkan komunitas menjadi node baru dan menjalankan proses tersebut kembali.

Proses itu diulang sampai tidak ada peningkatan kualitas yang berarti.

Masalahnya, penelitian Traag, Waltman, dan van Eck menunjukkan bahwa Louvain dapat menghasilkan komunitas yang terhubung dengan buruk, bahkan dalam kasus tertentu dapat menghasilkan komunitas yang secara internal terputus. Dalam eksperimen mereka, hingga 25% komunitas ditemukan memiliki konektivitas yang buruk dan hingga 16% dapat terputus, tergantung jaringan dan kondisi eksperimennya.

Bayangkan seperti ini.

Sebuah komunitas seharusnya:

A ─ B ─ C ─ D

Namun hasil tertentu dari Louvain bisa menyerupai:

A ─ B          C ─ D

tetapi A, B, C, dan D tetap dianggap sebagai satu komunitas.

Secara matematis, pembagian tersebut mungkin menghasilkan nilai fungsi kualitas yang baik. Namun secara struktural, hasilnya kurang masuk akal karena komunitas tersebut sebenarnya terpecah menjadi dua bagian.

Leiden dirancang untuk mengatasi masalah tersebut.

Bagaimana Cara Kerja Leiden Algorithm?

Salah satu hal paling penting untuk dipahami adalah bahwa Leiden bukan sekadar "Louvain yang lebih baru".

Leiden menggunakan tiga fase utama:

1. Local Moving of Nodes

2. Refinement

3. Aggregation

Ketiga fase tersebut dilakukan secara iteratif sampai hasilnya stabil atau tidak ada peningkatan yang berarti.

Mari kita sederhanakan.

Fase 1: Local Moving

Pada awalnya setiap node dapat dianggap sebagai komunitasnya sendiri.

Misalnya:

A   B   C   D   E   F

Kemudian algoritma melihat hubungan masing-masing node.

Misalnya A jauh lebih terhubung dengan B daripada node lainnya. Algoritma dapat memindahkan A ke komunitas B jika perpindahan tersebut meningkatkan fungsi kualitas.

Hasilnya mungkin berubah menjadi:

{A,B}   {C}   {D,E}   {F}

Algoritma terus melakukan perpindahan node selama perpindahan tersebut meningkatkan kualitas partition.

Leiden menggunakan fast local move procedure. Berbeda dari Louvain yang terus memeriksa semua node, Leiden lebih fokus mengunjungi node yang lingkungan atau koneksinya telah berubah. Hal ini membuat proses local moving lebih efisien.

Fase 2: Refinement

Inilah salah satu bagian yang paling penting dari Leiden.

Setelah mendapatkan komunitas awal, Leiden tidak langsung menganggap komunitas tersebut sudah benar.

Algoritma melakukan refinement, yaitu mencoba melihat apakah sebuah komunitas sebenarnya dapat dibagi menjadi subkomunitas yang lebih baik dan lebih terhubung.

Misalnya hasil fase pertama adalah:

Community A
A B C D E F

Setelah diperiksa lebih lanjut, ternyata strukturnya sebenarnya:

A ─ B ─ C

D ─ E ─ F

Leiden dapat memperhalus komunitas tersebut menjadi:

Community A1
A B C

Community A2
D E F

Proses refinement ini dilakukan dengan memulai substruktur dari singleton partition dan melakukan penggabungan secara lokal di dalam komunitas sebelumnya. Penggabungan tersebut hanya dilakukan ketika kondisi kualitas dan konektivitasnya memenuhi kriteria algoritma.

Inilah salah satu pembeda terbesar antara Leiden dan Louvain.

Fase 3: Aggregation

Setelah refinement, komunitas yang telah diperbaiki digunakan untuk membentuk aggregate network.

Bayangkan sebelumnya terdapat 1.000 node.

Setelah Leiden menemukan 20 komunitas, jaringan tersebut bisa direpresentasikan dalam bentuk jaringan baru dengan komunitas atau subkomunitas sebagai node tingkat lebih tinggi.

Misalnya:

Network asli
1.000 node
↓
Community detection
↓
20 communities
↓
Aggregate network
20 super-nodes

Kemudian Leiden menjalankan proses optimisasi lagi pada jaringan tersebut.

Jadi algoritma bekerja secara hierarkis dan iteratif.

Secara sederhana:

Graph awal
   ↓
Local Moving
   ↓
Refinement
   ↓
Aggregation
   ↓
Graph yang lebih sederhana
   ↓
Local Moving lagi
   ↓
Refinement lagi
   ↓
Aggregation lagi
   ↓
Berhenti ketika stabil

Struktur tiga fase tersebut dijelaskan secara eksplisit dalam paper asli Leiden Algorithm.

Apa yang Dimaksud dengan Community Detection?

Karena istilah ini sangat penting dalam memahami Leiden, kita perlu membahasnya secara khusus.

Community detection adalah proses menemukan struktur komunitas yang tidak ditentukan sebelumnya.

Berbeda dengan supervised classification.

Dalam classification, kita biasanya sudah memiliki label:

Data 1 → Kategori A
Data 2 → Kategori B
Data 3 → Kategori A

Pada community detection, kita belum mengetahui kelompoknya.

Kita hanya memiliki jaringan:

A──B──C
│  │
D──E

F──G──H
│     │
I─────J

Kemudian algoritma mencari struktur kelompok secara otomatis.

Hasilnya mungkin:

Community 1
A B C D E

Community 2
F G H I J

Jadi Leiden bersifat unsupervised community detection.

Apa Itu Modularity?

Salah satu fungsi kualitas paling populer yang dapat dioptimalkan Leiden adalah modularity.

Gagasan sederhananya adalah membandingkan:

berapa banyak koneksi yang benar-benar terjadi di dalam komunitas

dengan

berapa banyak koneksi yang seharusnya terjadi berdasarkan model acak tertentu.

Semakin besar perbedaan positifnya, semakin baik struktur komunitas menurut modularity. Penelitian asli menjelaskan modularity sebagai ukuran yang membandingkan jumlah edge aktual dalam komunitas dengan jumlah edge yang diharapkan.

Secara matematis, bentuk yang umum digunakan adalah:

[ Q = \frac{1}{2m} \sum_{ij} \left( A_{ij} - \frac{k_i k_j}{2m} \right) \delta(\sigma_i,\sigma_j) ]

Tidak perlu takut dengan rumus tersebut.

Intinya:

• Jika dua node berada dalam komunitas yang sama, kontribusinya diperhitungkan.

• Hubungan aktual dibandingkan dengan hubungan yang diharapkan.

• Partition yang membuat hubungan internal komunitas relatif kuat akan mendapatkan nilai kualitas yang lebih baik.

Dalam dokumentasi leidenalg, modularity tersedia sebagai ModularityVertexPartition.

Apa Itu Resolution Parameter?

Ini merupakan salah satu konsep paling penting ketika menggunakan Leiden.

Resolution parameter mengontrol seberapa besar atau kecil komunitas yang ingin ditemukan.

Secara umum:

Resolution lebih tinggi → lebih banyak komunitas yang lebih kecil.

Resolution lebih rendah → lebih sedikit komunitas yang lebih besar.

Hubungan tersebut dijelaskan baik dalam paper Leiden maupun dokumentasi implementasi igraph.

Contohnya:

Resolution rendah
        ↓
[ Komunitas Besar ]

Sedangkan:

Resolution tinggi
        ↓
[A] [B] [C] [D] [E]

Namun, hal ini tidak berarti kita bisa sembarang menaikkan resolution sampai mendapatkan jumlah komunitas yang kita inginkan. Nilainya harus disesuaikan dengan tujuan analisis dan karakteristik jaringan.

CPM Sebagai Alternatif Modularity

Leiden juga dapat menggunakan Constant Potts Model atau CPM.

CPM memiliki interpretasi resolution parameter yang lebih langsung: parameter tersebut dapat dipandang sebagai ambang kepadatan komunitas. Secara umum, semakin tinggi resolution, semakin besar kecenderungan terbentuknya komunitas yang lebih kecil.

Salah satu kelebihan CPM adalah kemampuannya menghindari resolution-limit problem yang dikenal pada modularity. Dalam konteks tertentu, modularity dapat menyebabkan komunitas-komunitas kecil "tersembunyi" di dalam komunitas yang lebih besar.

Karena itu, memilih antara modularity dan CPM bukan sekadar masalah teknis. Pilihan tersebut berhubungan dengan pertanyaan analisis yang ingin kita jawab.

Perbedaan Leiden dan Louvain

Perbandingan sederhananya:

Penelitian asli menyimpulkan bahwa Leiden lebih cepat daripada Louvain dalam eksperimen yang mereka lakukan, menghasilkan partition dengan kualitas lebih baik dalam benchmark mereka, sekaligus memberikan jaminan konektivitas komunitas. Namun ini sebaiknya dipahami sebagai hasil algoritmik dan benchmark, bukan berarti Leiden selalu mengungguli setiap metode dan setiap dataset.

Mengapa Refinement Sangat Penting?

Bayangkan sebuah organisasi yang terdiri dari tiga departemen:

Marketing
Sales
Finance

Misalnya seseorang bekerja sama dengan Marketing dan Finance. Ia bisa menjadi "jembatan" antara dua kelompok.

Algoritma yang hanya melakukan perpindahan node bisa saja memindahkan orang tersebut ke kelompok lain.

Akibatnya:

Kelompok lama
A B C [jembatan] D E F

menjadi:

A B C        D E F

tetapi keduanya masih dianggap satu komunitas.

Refinement membantu mendeteksi struktur internal seperti ini sebelum jaringan diagregasi ke tingkat berikutnya.

Karena setelah sebuah komunitas diubah menjadi satu node pada aggregate network, struktur internalnya tidak lagi mudah dipecah. Paper Leiden secara khusus menjelaskan bahwa refinement memberikan ruang tambahan untuk menemukan partition berkualitas lebih tinggi.

Apa Arti "Connected Community" dalam Leiden?

Sebuah komunitas yang terhubung berarti node-node di dalam komunitas tersebut dapat saling mencapai melalui jalur yang seluruhnya berada dalam komunitas tersebut.

Misalnya:

A ─ B ─ C ─ D

Semua node tersebut terhubung.

Tetapi:

A ─ B       C ─ D

merupakan dua komponen terpisah.

Jika keduanya diberi label komunitas yang sama, maka community tersebut tidak connected.

Leiden secara khusus dirancang agar komunitas yang dihasilkan memiliki konektivitas yang lebih baik, dan paper asli memberikan jaminan matematis bahwa komunitas yang dihasilkan memenuhi kondisi konektivitas tertentu.

Apa Saja yang Bisa Dianalisis Menggunakan Leiden?

Leiden dapat digunakan pada banyak jenis network.

Social Network

Misalnya:

• Facebook

• LinkedIn

• Twitter/X

• jaringan pertemanan

• jaringan komunikasi

Node bisa mewakili pengguna, sedangkan edge mewakili interaksi.

Leiden kemudian dapat digunakan untuk menemukan kelompok pengguna yang memiliki pola hubungan yang mirip.

Citation Network

Node adalah artikel ilmiah.

Edge adalah hubungan sitasi.

Leiden dapat membantu menemukan cluster penelitian, misalnya:

AI
├── Machine Learning
├── Deep Learning
└── Computer Vision

Collaboration Network

Node adalah individu.

Edge menunjukkan kolaborasi.

Misalnya pada jaringan ilmiah:

Peneliti A
   ↓
Peneliti B
   ↓
Peneliti C

Leiden dapat membantu menemukan kelompok peneliti yang sering bekerja sama.

Product Network

Dalam e-commerce, node dapat berupa produk.

Edge dapat menunjukkan:

• sering dibeli bersama,

• sering dilihat bersama,

• sering direkomendasikan bersama.

Leiden kemudian dapat menemukan cluster produk.

Customer Network

Node dapat berupa customer.

Edge dapat merepresentasikan:

• hubungan,

• kesamaan perilaku,

• interaksi,

• transaksi tertentu.

Community detection kemudian dapat membantu menemukan kelompok pelanggan dengan pola hubungan yang serupa.

Biological Network

Leiden juga digunakan dalam analisis jaringan biologis dan berbagai data omik.

Dalam analisis single-cell, metode Leiden dapat digunakan untuk melakukan clustering terhadap sel berdasarkan struktur graf tetangga. Karena itu, istilah Leiden cukup sering muncul dalam workflow bioinformatika modern.

Contoh Sederhana

Bayangkan kita memiliki 12 node:

A B C D E F G H I J K L

Setelah melihat koneksinya, ternyata terbentuk pola:

A ─ B ─ C ─ D
│   │
E ─ F

G ─ H ─ I ─ J
│   │
K ─ L

Leiden mungkin menemukan:

Community 1
A B C D E F

Community 2
G H I J K L

Tetapi hasil sebenarnya tidak ditentukan hanya oleh bentuk visual.

Algoritma menghitung kualitas berdasarkan edge, bobot, objective function, resolution, dan proses optimisasi.

Karena itu, dua jaringan yang tampak mirip secara visual belum tentu menghasilkan community structure yang sama.

Bagaimana dengan Edge Weight?

Leiden juga dapat bekerja dengan graph berbobot.

Misalnya:

A ── B
 10

berarti hubungan A-B memiliki kekuatan 10.

Sementara:

A ─ C
 2

berarti hubungan A-C memiliki kekuatan 2.

Dalam implementasi leidenalg, bobot edge dapat diberikan sebagai input, dan bobot yang lebih besar diperlakukan sebagai koneksi yang lebih kuat. Untuk ModularityVertexPartition, dokumentasi juga mencatat bahwa objective tersebut ditujukan untuk edge weight positif.

Ini sangat berguna pada dunia nyata karena hubungan biasanya tidak sekadar "ada" atau "tidak ada".

Contoh:

• 1 kali transaksi = weight 1.

• 100 kali transaksi = weight 100.

Dengan demikian, struktur komunitas dapat mempertimbangkan intensitas hubungan.

Apakah Leiden Harus Digunakan pada Graph Tidak Berbobot?

Tidak selalu.

Graph dapat memiliki:

• edge tanpa bobot,

• edge berbobot,

• node dengan ukuran atau bobot tertentu,

• bahkan struktur yang lebih kompleks dalam implementasi tertentu.

Dokumentasi leidenalg juga menyediakan dukungan untuk jaringan multiplex dan temporal, sehingga Leiden dapat digunakan pada skenario di mana jaringan memiliki beberapa layer atau berubah berdasarkan waktu.

Leiden pada Temporal Network

Dalam jaringan temporal, hubungan dapat berubah dari waktu ke waktu.

Misalnya:

Januari
A ─ B ─ C

Februari
A ─ B ─ C ─ D

Maret
A ─ D ─ E

Community pada Januari belum tentu sama dengan community pada Maret.

Implementasi leidenalg menyediakan fungsi untuk community detection pada temporal graphs dengan coupling antar time slice.

Ini membuka peluang untuk menganalisis bukan hanya:

"Siapa berada di komunitas mana?"

tetapi juga:

"Bagaimana komunitas berubah dari waktu ke waktu?"

Leiden Bersifat Random atau Deterministik?

Leiden melibatkan komponen randomisasi dalam proses tertentu.

Dalam fase refinement, pemilihan komunitas yang akan digabung tidak selalu dilakukan secara greedy dengan memilih peningkatan terbesar. Pemilihan dilakukan secara acak dengan probabilitas yang dipengaruhi oleh peningkatan quality function dan parameter tertentu.

Karena itu, dua kali menjalankan algoritma pada data yang sama dapat menghasilkan partition yang sedikit berbeda, terutama jika random seed berbeda.

Untuk eksperimen yang membutuhkan reproducibility, implementasi seperti leidenalg menyediakan parameter seed.

Praktiknya, jangan hanya menjalankan Leiden sekali lalu menganggap hasilnya pasti "jawaban tunggal".

Untuk analisis serius, lebih baik mengevaluasi stabilitas hasil terhadap beberapa seed atau pengaturan yang relevan.

Apa Itu Number of Iterations?

Leiden dijalankan secara iteratif.

Secara sederhana:

Iteration 1
↓
Partition A

Iteration 2
↓
Partition B

Iteration 3
↓
Partition C

Pada setiap iterasi, partition dapat menjadi lebih baik menurut objective function yang digunakan.

Implementasi leidenalg memiliki parameter n_iterations. Dokumentasinya menyatakan bahwa default pada fungsi find_partition adalah dua iterasi, sedangkan nilai negatif dapat digunakan untuk menjalankan algoritma sampai tidak ada peningkatan lagi.

Namun, angka default implementasi tidak boleh dianggap sebagai aturan universal. Jumlah iterasi sebaiknya dipilih berdasarkan kebutuhan analisis dan stabilitas hasil.

Contoh Implementasi Python

Salah satu library yang umum digunakan adalah leidenalg bersama igraph.

Instalasi sederhananya:

pip install igraph leidenalg

Contoh paling sederhana untuk community detection berbasis modularity:

import igraph as ig
import leidenalg as la

# Membuat graph
graph = ig.Graph.Famous("Zachary")

# Menjalankan Leiden dengan modularity
partition = la.find_partition(
    graph,
    la.ModularityVertexPartition,
    seed=42
)

print("Jumlah komunitas:", len(partition))
print("Membership:", partition.membership)

Pola penggunaan tersebut sesuai dengan dokumentasi resmi leidenalg, yang menggunakan igraph sebagai representasi graph dan find_partition() untuk menjalankan community detection.

Menggunakan CPM

Contoh lainnya:

import igraph as ig
import leidenalg as la

graph = ig.Graph.Famous("Zachary")

partition = la.find_partition(
    graph,
    la.CPMVertexPartition,
    resolution_parameter=0.1,
    seed=42
)

print("Jumlah komunitas:", len(partition))
print("Membership:", partition.membership)

CPM memungkinkan kita menggunakan resolution parameter dengan interpretasi yang berbeda dibandingkan modularity.

Bagaimana Cara Memilih Resolution yang Tepat?

Tidak ada satu angka resolution yang otomatis benar untuk semua jaringan.

Misalnya Anda mendapatkan:

Resolution = 0.1
→ 4 communities

Resolution = 0.5
→ 12 communities

Resolution = 1.0
→ 30 communities

Pertanyaannya bukan:

"Mana yang paling banyak?"

Tetapi:

"Skala komunitas mana yang paling masuk akal untuk pertanyaan penelitian saya?"

Contohnya, untuk menganalisis struktur organisasi perusahaan, Anda mungkin tertarik pada departemen besar.

Tetapi untuk menganalisis pola kolaborasi, Anda mungkin ingin melihat subkelompok yang lebih kecil.

Karena itu, resolution sebaiknya dipilih berdasarkan tujuan analisis, bukan hanya berdasarkan jumlah cluster yang dihasilkan.

Jangan Terjebak pada Angka Modularity

Salah satu kesalahan umum adalah menganggap:

"Semakin tinggi modularity, semakin benar komunitasnya."

Belum tentu.

Modularity adalah fungsi kualitas tertentu. Ia mengukur seberapa baik partition menurut definisi matematis tersebut, bukan memberikan kebenaran absolut tentang dunia nyata.

Dua partition dapat memiliki nilai kualitas yang berdekatan tetapi memiliki interpretasi yang berbeda.

Selain itu, modularity memiliki resolution limit, sehingga komunitas kecil dapat tidak terdeteksi secara terpisah. Paper Leiden membahas masalah ini dan menjelaskan bahwa CPM dirancang untuk menghindari masalah resolution-limit tersebut.

Jadi hasil Leiden tetap membutuhkan interpretasi domain.

Kelebihan Leiden Algorithm

1. Komunitas Lebih Terhubung

Ini merupakan keunggulan utama yang melatarbelakangi pembuatannya.

Leiden memberikan jaminan terkait konektivitas komunitas yang tidak diberikan oleh Louvain secara umum.

2. Biasanya Cepat

Leiden menggunakan fast local move procedure yang menghindari pemeriksaan ulang terhadap node yang tidak mengalami perubahan lingkungan.

Dalam penelitian aslinya, Leiden ditemukan lebih cepat daripada Louvain pada jaringan yang diuji.

3. Partition Berkualitas Tinggi

Dalam benchmark penelitian asli, Leiden menemukan partition yang memiliki kualitas lebih baik dibandingkan Louvain pada pengujian mereka.

Namun, kualitas tetap bergantung pada objective function, parameter, dan dataset.

4. Fleksibel

Leiden dapat digunakan dengan berbagai objective function melalui implementasinya.

leidenalg, misalnya, mendukung Modularity, CPM, RBConfiguration, Significance, Surprise, dan lainnya.

5. Cocok untuk Network Besar

Leiden dirancang sebagai metode community detection yang efisien sehingga cocok untuk network yang besar dan kompleks.

6. Mendukung Analisis Lanjutan

Implementasi tertentu memungkinkan penggunaan graph berbobot, multiplex network, dan temporal network.

Kekurangan Leiden Algorithm

Leiden bukan berarti sempurna.

1. Tidak Memberikan "Label Bisnis" Secara Otomatis

Leiden mungkin menghasilkan:

Community 1
Community 2
Community 3

Tetapi algoritma tidak otomatis mengetahui bahwa Community 1 adalah:

"Pelanggan retail premium"

atau:

"Departemen Marketing"

Interpretasi tersebut tetap menjadi tanggung jawab analis.

2. Hasil Dipengaruhi Parameter

Resolution, objective function, weights, seed, dan jumlah iterasi dapat memengaruhi hasil.

3. Tidak Selalu Menemukan Satu Jawaban Unik

Network dapat memiliki lebih dari satu struktur komunitas yang masuk akal.

4. Tidak Sama dengan Clustering Biasa

Orang yang terbiasa dengan K-Means terkadang menganggap semua clustering sama.

Padahal Leiden memanfaatkan topologi network, bukan sekadar jarak antar-record dalam feature space.

5. Hasil Harus Divalidasi

Community structure yang ditemukan secara matematis tetap harus dibandingkan dengan pengetahuan domain, data eksternal, atau analisis lanjutan.

Leiden vs K-Means

Perbedaan ini penting.

K-Means biasanya bekerja pada data numerik yang memiliki fitur.

Misalnya:

Customer
- umur
- pendapatan
- frekuensi pembelian
- total transaksi

K-Means mencari kelompok berdasarkan kemiripan fitur.

Leiden berbeda.

Misalnya:

Customer A ─ Customer B
Customer B ─ Customer C
Customer C ─ Customer D

Leiden melihat hubungan antar-node.

Jadi:

K-Means → "data mana yang mirip?"

Leiden → "node mana yang membentuk komunitas berdasarkan hubungan jaringan?"

Keduanya bisa digunakan dalam satu project, tetapi untuk tujuan yang berbeda.

Leiden vs DBSCAN

DBSCAN juga merupakan metode clustering, tetapi pendekatannya berbeda.

DBSCAN mencari kelompok berdasarkan kepadatan titik dalam ruang fitur.

Leiden mencari struktur komunitas dalam graph.

Dengan kata lain:

DBSCAN
Data points → density

Leiden
Graph → connectivity/community structure

Leiden vs Louvain

Secara praktis, jika Anda menemukan tutorial lama yang menggunakan Louvain, jangan langsung menganggap tutorial tersebut salah.

Louvain tetap merupakan algoritma penting dalam sejarah community detection.

Namun Leiden dikembangkan sebagai perbaikan yang secara khusus menangani kelemahan struktur komunitas Louvain, terutama masalah komunitas yang dapat terhubung secara buruk atau terputus.

Dalam banyak workflow modern, Leiden menjadi pilihan yang sangat menarik ketika kita ingin community detection yang cepat sekaligus memiliki jaminan struktur yang lebih kuat.

Contoh Penggunaan dalam Dunia Nyata

Misalnya sebuah marketplace mempunyai 10 juta pengguna.

Setiap pengguna memiliki hubungan dengan produk berdasarkan:

• pembelian,

• klik,

• wishlist,

• review,

• atau interaksi lainnya.

Kita dapat membuat graph:

User → Product

atau membentuk graph pengguna berdasarkan kemiripan interaksi:

User A ─ User B
User B ─ User C
User C ─ User D

Setelah itu Leiden dapat digunakan untuk menemukan komunitas.

Misalnya hasilnya:

Community 1
Laptop
Monitor
Keyboard
Mouse

Community 2
Kulkas
Mesin Cuci
Rice Cooker

Community 3
TV
Soundbar
Speaker

Perusahaan kemudian dapat menggunakan hasil tersebut untuk:

• rekomendasi produk,

• segmentasi pengguna,

• personalisasi,

• analisis perilaku,

• merchandising,

• strategi marketing.

Leiden sendiri tidak otomatis melakukan semua hal tersebut. Algoritma hanya menemukan struktur komunitas. Pemanfaatan bisnis dilakukan pada tahap berikutnya.

Contoh dalam Analisis Media Sosial

Misalnya Anda memiliki jaringan 1 juta akun.

Edge menunjukkan interaksi antar-akun.

Setelah dijalankan:

Community 1 → 15.000 akun
Community 2 → 8.000 akun
Community 3 → 27.000 akun
...

Anda kemudian dapat menghitung:

• ukuran komunitas,

• node paling berpengaruh,

• density,

• centrality,

• topik dominan,

• hubungan antar-komunitas.

Leiden menjadi langkah awal untuk menemukan struktur jaringan, bukan seluruh analisis.

Leiden dalam Analisis SEO dan Topical Authority

Leiden juga dapat menarik ketika diterapkan pada analisis jaringan konten.

Misalnya kita memiliki:

URL
Keyword
Internal Link
Entity
Topic

Kita dapat membangun graph berdasarkan hubungan antarhalaman.

Contohnya:

SEO
├── Technical SEO
├── On-Page SEO
├── Off-Page SEO
├── Local SEO
└── Enterprise SEO

Jika setiap halaman dianggap sebagai node dan hubungan internal link atau semantic similarity dijadikan edge, Leiden dapat membantu menemukan community/topical cluster yang muncul secara alami dari struktur jaringan.

Namun perlu dibedakan:

Leiden tidak secara otomatis menentukan "topical authority" Google.

Leiden hanya menemukan pola komunitas dalam graph yang kita berikan.

Untuk SEO, kualitas hasil sangat bergantung pada bagaimana graph dibangun.

Hal yang Sangat Penting: Garbage In, Garbage Out

Ini prinsip yang berlaku sangat kuat pada Leiden.

Misalnya graph dibangun secara buruk.

Jika edge tidak relevan:

A ─ B
A ─ X
A ─ Z

algoritma akan tetap melakukan community detection berdasarkan hubungan tersebut.

Artinya:

Algoritma yang bagus tidak dapat memperbaiki graph yang dibangun secara salah.

Dalam project nyata, kualitas:

• definisi node,

• definisi edge,

• edge weight,

• preprocessing,

• filtering,

• resolution,

• dan objective function

sangat memengaruhi hasil akhir.

Karena itu, tahap membangun graph sering kali sama pentingnya dengan memilih algoritma.

Bagaimana Workflow Leiden yang Baik?

Workflow yang masuk akal biasanya seperti ini:

Data mentah
   ↓
Definisikan node
   ↓
Definisikan edge
   ↓
Tentukan bobot
   ↓
Bersihkan graph
   ↓
Pilih objective function
   ↓
Pilih resolution
   ↓
Jalankan Leiden
   ↓
Evaluasi hasil
   ↓
Uji stabilitas
   ↓
Interpretasi komunitas
   ↓
Gunakan hasil untuk keputusan

Jadi jangan berhenti di:

"Saya sudah menjalankan Leiden dan mendapatkan 12 cluster."

Pertanyaan berikutnya justru lebih penting:

"Apakah 12 cluster tersebut stabil, masuk akal, dan berguna?"

Bagaimana Mengevaluasi Hasil Leiden?

Beberapa hal dapat diperiksa.

Kualitas Objective

Misalnya modularity atau objective function lain.

Connectivity

Pastikan komunitas memiliki konektivitas yang masuk akal.

Stability

Jalankan beberapa seed dan lihat apakah struktur komunitas relatif konsisten.

Sensitivity terhadap Resolution

Coba beberapa nilai resolution.

Contohnya:

0.1 → 5 communities
0.2 → 7 communities
0.3 → 10 communities
0.5 → 18 communities

Kemudian lihat pada rentang mana struktur komunitas relatif stabil.

Validasi Domain

Ini yang sering dilupakan.

Jika Anda menganalisis pelanggan dan Leiden menghasilkan:

Community A
70% pelanggan premium

hasil tersebut perlu dibandingkan dengan data bisnis lain.

Semakin sesuai hasil algoritma dengan bukti independen, semakin kuat interpretasinya.

Apakah Leiden Selalu Lebih Baik daripada Louvain?

Tidak tepat jika mengatakan:

"Leiden selalu lebih baik."

Yang lebih akurat adalah:

Leiden dirancang untuk mengatasi kelemahan penting Louvain dan dalam penelitian aslinya menunjukkan performa yang lebih baik pada benchmark yang mereka evaluasi.

Tetapi kualitas algoritma tetap bergantung pada:

• dataset,

• graph construction,

• objective function,

• resolution,

• random seed,

• dan tujuan analisis.

Karena itu, dalam pekerjaan ilmiah atau enterprise analytics, perbandingan empiris tetap lebih baik daripada sekadar mengikuti tren.

Apakah Leiden Sulit Dipelajari?

Untuk pengguna biasa, tidak terlalu sulit.

Anda tidak harus memahami seluruh matematika Leiden untuk menggunakannya.

Level pemahamannya dapat dibagi menjadi tiga.

Level 1 — Pengguna

Cukup pahami:

• graph,

• node,

• edge,

• community,

• resolution,

• hasil clustering.

Level 2 — Data Analyst

Mulai memahami:

• modularity,

• CPM,

• edge weight,

• parameter,

• stability,

• evaluasi hasil.

Level 3 — Data Scientist / Researcher

Perlu memahami:

• objective function,

• optimization,

• refinement,

• local moving,

• aggregation,

• resolution limit,

• stochasticity,

• convergence,

• graph theory.

Untuk sebagian besar kebutuhan bisnis, Level 1 dan Level 2 sudah sangat memadai.

Ringkasnya, Leiden Algorithm Itu Apa?

Cara paling sederhana untuk mengingatnya adalah:

Leiden Algorithm adalah algoritma community detection yang digunakan untuk menemukan kelompok alami dalam sebuah jaringan berdasarkan pola hubungan antar-node.

Ia bekerja melalui tiga konsep utama:

Local Moving → Refinement → Aggregation

Local moving mencari perpindahan node yang meningkatkan kualitas.

Refinement memeriksa dan memperbaiki struktur internal komunitas.

Aggregation menyederhanakan jaringan agar proses optimisasi dapat dilanjutkan pada level yang lebih tinggi.

Keunggulan utama Leiden dibandingkan Louvain adalah kemampuannya menghasilkan komunitas yang lebih terhubung dengan jaminan teoretis tertentu, sementara fast local move procedure membuatnya efisien pada jaringan besar.

Dalam praktiknya, Leiden dapat digunakan pada social network, citation network, biological network, collaboration network, product network, customer network, hingga jaringan temporal dan multiplex melalui implementasi tertentu.

Hal terpenting yang perlu diingat adalah bahwa Leiden bukan mesin yang secara otomatis mengetahui "kelompok yang benar". Ia mengoptimalkan suatu definisi kualitas pada graph yang kita berikan. Karena itu, kualitas graph, pemilihan objective function, resolution, stabilitas hasil, dan interpretasi domain tetap sangat penting.

Dengan memahami prinsip tersebut, Leiden Algorithm akan jauh lebih mudah dipahami: bukan sebagai algoritma yang rumit dan penuh rumus, tetapi sebagai cara sistematis untuk menemukan struktur tersembunyi di balik jaringan yang sangat kompleks.