Process Mining: Bagaimana hendak mulakan? Bahagian 2

Kita Lihat Process Map pula

Mari kita sambung daripada rencana yang lepas.

---

---

Photo by British Library on Unsplash

Dalam rencana lepas, analisis yang dijalankan berhenti pada jumlah process variance yang wujud. Kali ini, kita lihat pula event activity

#let check all activity frequency
from pm4py.algo.filtering.log.attributes import attributes_filter
activities = attributes_filter.get_attribute_values(event_log, "concept:name")


activities = sorted(activities.items(), key=lambda x: x[1], reverse=True)

activities

Jika dilihat dari sudut ini, semua event activity dalam process variance utama wujud dalam Top 10 event.

'Create Purchase Order Item' -->
   'Vendor creates invoice' -->
   'Record Goods Receipt' -->
   'Record Invoice Receipt' -->
   'Clear Invoice'

Terdapat banyak process mining algorithm untuk process discovery. Namun kita fokus kepada 3 yang disokong oleh library PM4py:

1. Heuristic Miner

2. Inductive Miner

3. DFG - Direct flows graph

Rujuk rencana ini untuk lebih memahani fungsi algorithm tersebut. Dalam pemilihan algorithm process, tiada istilah the best algorithm. Ini kerana pemilihan algorithm dibuat berdasarkan keperluan masalah yang ingin cuba diselesaikan. Dalam pengalaman saya, saya sering menggunakan algorithm yang lebih simple (sesuatu yang dapat fahami dengan hanya melihat process map).

Ketiga-tiga algorithm ini mengambil kira activity frequency dan cuba untuk menapis proses yang tidak significant.

Untuk Heuristic Miner berikut adalah kod yang digunakan

#Mari kita mulakan dengan  Heuristic Miner
import pm4py
from pm4py.visualization.heuristics_net import visualizer as hn_visualizer


heu_net = pm4py.discover_heuristics_net(event_log, dependency_threshold=0.99)
gviz = hn_visualizer.apply(heu_net)
hn_visualizer.view(gviz)

Berikut adalah process mapping yang dihasilkan

Serabut bukan? Mungkin dalam rencana akan datang, kita adakan cuba mengurangkan spaghetti process ini.

Gunakan pula Inductive Miner

tree = pm4py.discover_process_tree_inductive(event_log)

net, initial_marking, final_marking = pm4py.convert_to_petri_net(tree)

gviz = pn_visualizer.apply(net, initial_marking, final_marking)
pn_visualizer.view(gviz)

Ini pula hasilnya

Lebih baik bukan?

Kali ini DFG pula

 #kita gunakan  pula DFG
import pm4py
from pm4py.algo.discovery.dfg import algorithm as dfg_discovery

dfg = dfg_discovery.apply(event_log)

from pm4py.visualization.dfg import visualizer as dfg_visualization
gviz = dfg_visualization.apply(dfg, log=event_log, variant=dfg_visualization.Variants.FREQUENCY)
dfg_visualization.view(gviz)

Hasilnya

Lagi rumitkan. Nanti kita akan cuba memilih algorithm mana yang lebih sesuai.

Berhenti setakat ini dahulu