Process Modelle mit Petri Nets erstellen Teil 2 … jetzt wirds ernst

Im ersten Beitrag habe ich erklärt was Conformance im Bereich Process Mining ist und was es uns bringen kann. Außerdem habe ich erläutert, dass es häufig mit sogenannten Petri Netzen erzeugt wird. Heute werde ich darauf eingehen aus was Petri netze bestehen und wie ich diese erzeuge. Das Ziel in dem konkreten Use Case ist es, diese Petri Netze für die Nutzung in dem Tool Celonis aufzubereiten. Mit anderen Tools kann das benötigte Ergebnis etwas anders aussehen aber das Prinzip bleibt das gleiche..

Vielleicht, bevor wir einsteigen. Mit welchen Tools kann ich Conformance Funktionen mithilfe von Python einsetzen?

  • Celonis: Über eine Python API kann eine Conformance Abfrage an das Celonis Tool übergeben werden, welche jede Aktivität in dem Prozess auf Konformität überprüft.
  • PM4PY: Open Source Framework direkt in Python vom Frauenhofer. Hier gibt es Funktionen die aus den einzelnen Bausteinen ein Petrinetz erzeugen können und damit auch im Rahmen von Process Mining eine Conformance Funktion bietet.

Folgende Punkte werden in diesem Artikel behandelt:

  • Woraus bestehen Petri Netze
  • Woraus bestehen in der Regel Prozess Modelle
  • Let’s Code – Transformieren des Prozess Modells in ein Petri Netz
  • Weiterer Ausblick



Woraus bestehen Petri Netze?

Petri Netze bestehen in einfachster Form aus Stellen (Places) und Transitionen (Transitions). Dabei sind Transitionen die Aktivitäten im Prozess und Stellen die Zustände. Außerdem gibt es Kanten (Edges/Arcs), welche die verschiedenen Stellen und Transitionen miteinander verbinden. Dabei gilt: Stellen sind mit Transitionen verbunden und Transitionen wiederum mit Stellen. Es gibt aber keine direkten Kanten zwischen 2 Transitionen oder zwischen zwei Stellen. von einer Stelle aus können mehrere Transitionen bedient werden und mehrere Transitionen können eine Stelle bedienen.

Das ganze lässt sich aber auch mathematisch Darstellen. Für P = Petrinetze, S = Stellen, T = Transitionen und K = Kanten gilt

P = (S,T,K)

S ∩ T = ∅

K ⊆ (S x T) ∪ (T x S)

Also P ist eine Tupel aus S, T und K. Für S & T gilt, dass diese endlich sind und das es keine Schnittmenge gibt. Für K gilt das es aus den Teilmengen (S x T) und (T x S ) besteht.

Letzten Endes müssen wir also 3 Dinge berechnen. Alle unsere Stellen, Transitionen und Kanten. Um das zu realisieren müssen wir nun das Prozess Modell anschauen.

Woraus bestehen in der Regel Prozess Modelle?

Gut, jetzt wissen wir was Petri Netze sind. Aber was haben wir bei Prozessmodellen häufig vorliegen? Wenn wir Pech haben, dann gibt es eine Dokumentation in Powerpoint zu den Prozessen und das wars. Dann bleibt uns nichts anderes übrig als die Prozesse entsprechend Maschinen lesbar zu dokumentieren. Häufig gibt es aber in Datenbanken, Excel oder XML Dateien zu den Prozessmodellen bereits Beschreibungen. Häufig in Tabellenform die wie in folgendem Format vorliegt:

RF EVENT VG KÜRZEL
1 Auftrag annehmen AUA
2 Auftrag prüfen 1; AUP
3 Auftrag bestätigen 2; AUB
4 Lagermenge prüfen 3; LAP
5 Ware aus Lager versenden 4; WLS
6 Ware bestellen 3; WBS
7 Wareneingang buchen 6; WEB
8 Warenausgang buchen 7;5; WAB
9 Rechnung erstellen 8; REE
10 Zahlungseingang buchen 9; ZAB
11 Abschluss 10; AB

Dies ist ein fiktives Beispiel, aber man sieht klar die Aktivitäten die in einem Prozess erstellt werden. RF ist die Rangfolge also die Aktivitäten ID innerhalb des Soll Prozesses, Event ist der Event Name. VG zeigt auf den oder die Vorgänger im Prozess und Kürzel ist eine Abkürzung für die Aktivität. Wahrscheinlich gibt es noch weitere Daten im Prozess Modell wie Nachfolger, Subprozesse etc. aber für den Anfang sollte das als Beispiel ausreichen. Von dieser Tabelle aus müssen wir nun zu den Petri Netzen kommen.

Was haben wir denn grundsätzlich bereits vorhanden?

Also, unsere Aktivitäten so sieht es aus ( bzw. die Kürzel), könnten wir bereits als Transitionen verwenden. Durch die RF und die Beschriebenen Vorgänger haben wir auch grundsätzlich eine Verbindung zwischen den einzelnen Aktivitäten. Aber wenn für ein Petri Netz gilt das Transitionen nicht direkt verbunden sind, dann fehlen uns hier die Stellen. Und genau die werden wir jetzt noch berechnen und alles in einem Tupel zusammenfügen die man für Conformance nutzen kann !



Let’s Code ! Transformieren eines Prozess Modells in ein Petri Netz

Um das Prozess Modell zu transformieren verwende ich bei der Entwicklung gerne Jupyter Notebooks und die Programmiersprache Python. Zu Beginn müssen wir die Daten in unser Notebook laden. Ich habe bei dem Beispiel die Daten aus einer Excel eingelesen. Es können aber auch Daten aus Datenbanken mit SQL eingelesen werden.

# import Packages
import pandas as pd

# import data from sources
df = pd.read_excel('Your_Prozessdata_File.xlsx')

Im zweiten Schritt müssen wir evtl. noch ein paar Daten bereinigen oder Spalten umbenennen. ( Ich hab hier z.B. in meinem weiteren Verlauf andere Spaltennamen verwendet. Wenn ich das zu Beginn einmal anpasse kann ich das Programm 1 zu 1 weiter verwenden.

# Fill na's
df['VG'].fillna('-1;', inplace=True)
df.columns = {'RF':'RF','SERG':'EVENT','VG':'VG','KUERZEL':'KÜRZEL'}

Wenn ich nun mit df.head() mir die Daten anzeigen lasse, sehen sie wie folgt aus.

Nun erzeugen wir eine Transition Liste, die jeder Aktivität eine Transition ID zuweist. Man könnte auch direkt mit der Bezeichnung arbeiten. Aber viele Programme brauchen einfach eine standardisierte Zuordnung und machen dann im Nachgang ein Zuordnung der Bezeichnungen in der t_label Liste.

labels = df['SERG'].to_list()

##  CREATE TRANSITION NUMBERS AND MATCH WITH LABEL ##
a = 0
transitions = []
t_label = []
for label in labels:
    a += 1
    transitions.append('T_' + str(a))
    t_label.append([label, 'T_' + str(a)])

Also Teil eins die Transitionen sind vorhanden. Als nächstes entwickeln wir für jede mögliche Verbindung zwischen den Transitionen einen Datensatz. und erzeugen dafür eine eigene Stelle ( Place)

# creating Connection between all Activities
keys = t_label
values = []
a = 0
# go through all transitions
for label,key in keys:
    rfolge = int(df['RF'][df.SERG == label])
    follows = df['VG'][df.SERG == label].str.split(';')
# split all following activities from outgoing activity
    for follow in follows:
        follow = ' '.join(follow).split()
        for fo in follow:
# search all Transitions to the activity and create a list with activityname, following activity, place
            for label2,key2 in keys:
                vg = int(df['RF'][df.SERG == label2])
                if int(fo) == vg:
                    a += 1
                    values.append([key , key2 , 'P_' + str(a)])
                    break
                if rfolge == df['RF'].min():
                    a += 1
                    values.append([key , 'NONE', 'P_' + str(a)])
                    break

Das Ergebnis in Values sieht folgendermaßen aus:

Ich habe für die erste Verbindung von None zur ersten Transition eine P_1 erzeugt.

Außerdem sieht man das für T_8 nun zwei Verbindungen möglich sind. von T_7 und T_5 zu T_8. Zum Schluss extrahieren wir aus dieser Liste noch die Stellen und die Verbindungen für das Petri Netz.

## CREATE THE EDGES AND PLACES ##
arcs =[]
places = []
for c,b,place in values:
    if b != 'NONE': arcs.append([b,place])
    arcs.append([place,c])
    places.append(place)

arcs.append([values [len(values) -1][0],'P_'+str(a+1)])
places.append('P_'+str(a+1))

Jetzt habe ich in der Liste places alle Stellen stehen und in der Liste Arcs alle Verbindungen von Stellen zu Transitionen und umgekehrt.

Um mein Petri Netz zu bauen, brauche ich nur noch P = (places, transitions, arcs) in eine Funktion übergeben und kriege Informationen zurück mit denen ich die Prozesskonformität direkt bewerten kann. Wie das am Beispiel von Celonis oder PM4PY funktioniert werde ich in einem späteren Beitrag zeigen.

Bis dahin hoffe ich, das euch der Beitrag geholfen hat um zu verstehen wie aus Prozess Modellen ein Petri Netz erzeugt werden kann.

Für den gesamten Code habe ich ein Github Repository angelegt, welches ich Stückweise erweitern werde. Finden könnt ihr es hier.