Computational Essays auf Basis von Simulationsmodellen schreiben

Das BPTK-Py Python Package nutzen, um Computational Essays auf Basis von System Dynamics Modellen zu schreiben.

Oliver Grasl
Thursday, August 23, 2018

Ein Überblick über die Verwendung von Jupyter und Python zur schnellen Erstellung interaktiver Geschichten auf der Grundlage von System Dynamics Simulationen

Wie Sie mit Jupyter und Python schnell interaktive Geschichten auf Basis von System Dynamics Simulationen erstellen können

Wenn Sie die aus Simulationsmodellen gewonnenen Erkenntnisse nutzen wollen, um Ihr Unternehmen zu transformieren, reicht es oft nicht aus, nur das Modell und die Erkenntnisse zu haben - Sie müssen eine gute Geschichte entwickeln, die Ihre Stakeholder überzeugt, Entscheidungen zu treffen und Maßnahmen zu ergreifen.

Mit unserer BPTK_PY Bibliothek können Sie System Dynamics Modelle in Python-Code umwandeln und in der leistungsstarken Jupyter-Notebook Umgebung ausführen, die sich hervorragend zum Schreiben interaktiver, datengesteuerter Arbeiten und Berichte eignet.

Das Schreiben solcher interaktiven Geschichten ist eine ziemliche Herausforderung, selbst wenn Ihr Simulationsmodell bereits ziemlich vollständig ist, da Sie die Handlung erstellen müssen, während Sie verschiedene Szenarien mit dem Simulationsmodell testen.

Wir erkannten früh, dass wir eine "interaktive Schreibumgebung" brauchten, die uns helfen würde, einen Prototyp der komplexen Handlung zu erstellen, während wir das Modell noch bauen:

Erstellen Sie ein erstes Simulationsmodell mit einem visuellen Modellierungswerkzeug.
Beginnen Sie mit dem Schreiben einer Geschichte rund um das Modell, indem Sie die interaktive Schreibumgebung verwenden.
Verwenden Sie die neuen Fragen und Erkenntnisse, die sich während des Schreibprozesses ergeben, um Experimente mit dem Simulationsmodell voranzutreiben - dies kann zu Änderungen sowohl am Modell als auch an der Handlung führen.

Im Jahr 2014 haben wir begonnen, solche "computational Essays" mithilfe von Wolfram Research‘ Mathematica® zu schreiben.

Mathematica ist ein wunderbares und sehr leistungsfähiges Werkzeug zur Unterstützung dieses Prozesses - es ist eine komplette Umgebung, die das Schreiben, Berechnen, Präsentieren und sehr anspruchsvolle interaktive Dashboards unterstützt.

Mathematica enthält keine native Unterstützung für System Dynamics, aber wir haben eine kleine Bibliothek erstellt, die es uns ermöglicht, System Dynamics Modelle basierend auf dem XMILE-Standard zu importieren und in Mathematica auszuführen.

Aber seit 2014 hat sich in der Welt der Computermodellierung viel getan ... Python hat sich zur führenden Programmiersprache für Data Science entwickelt und ihre Verwendung ist damit noch allgegenwärtiger geworden und mit ihr die Jupyter-Notebook Umgebung (unter Verwendung des IPython-Kerns).

Sowohl Mathematica als auch Jupyter sind fantastische Umgebungen für die Erstellung von computational Essays und "Simulationen, die auf der Geschichte basieren":

Die Arbeit mit Mathematica und der Wolfram Language ist dank der symbolischen Natur der Sprache und der Art und Weise, wie sie sich in die hoch entwickelte Mathematica-Notebook Umgebung integriert, unglaublich produktiv.
Derzeit fehlt den Jupyter-Notebooks noch die Raffinesse der Mathematica-Notebooks. Aber was das Jupyter/IPython Ökosystem auszeichnet, ist, dass es Open Source (und damit für jeden frei nutzbar), hochgradig erweiterbar und in der Data Science/ Computational Modeling Community sehr weit verbreitet ist - es ist daher viel einfacher, Bücher, Schulungsmaterialien und qualifizierte Ressourcen zu finden.

Einen ausführlicheren Vergleich von Jupyter und Mathematica finden Sie in Paul Romers sehr interessantem Blogbeitrag zu diesem Thema. Lesen Sie auch unbedingt den Artikel in The Atlantic, auf den Paul Romer verweist.

Da Jupyter und Python frei nutzbar sind, haben wir uns entschlossen, unser Business Prototyping Toolkit in das Jupyter/Python Universum zu portieren und ebenfalls kostenlos zur Verfügung zu stellen - das heißt, Sie können nun Simulationsmodelle mit System Dynamics erstellen und in Python laufen lassen.

Unser Ansatz ist sehr mächtig und befreiend, weil er unsere Modelle in berechenbare Objekte verwandelt - wir können unsere Simulationsmodelle nun auf neue Weise nutzen, ganz unabhängig von der Modellierungsumgebung, in der wir das Modell erstellen.

Einige "alltägliche" Beispiele für solche Anwendungen sind:

Verfassen eines Berichts (oder Artikels) basierend auf einem System Dynamics Modell mit Jupyter und Zeichnen aller zugehörigen Diagramme direkt in Jupyter.
Erstellung und Managament eines umfassenden Satzes von Szenarien, die sich auf dieses Modell beziehen.
Erstellung eines interaktiven Dashboards für ein Modell.
Gemeinsame Nutzung von Modellen, Dashboards und Berichten mit Personen, die keinen Zugriff auf die ursprüngliche Modellumgebung haben.
Vergleich von mehreren Versionen eines Modells miteinander.

Beispiele für alle diese Punkte finden Sie später in diesem Dokument.

Fortgeschrittene Beispiele für die Verwendung von Modellen als berechenbare Objekte sind:

Training von Machine Learning Algorithmen unter Verwendung von System Dynamics Modellen.
Die Kombination von System Dynamics Modellen mit anderen Computermodelltechniken wie z. B. der agentenbasierten Modellierung.

Wir stellen das BPTK-Py-Framework als Closed-Source-Framework unter der MIT-Lizenz zur Verfügung, d. h. Sie können das Framework in Ihren eigenen Modellierungsprojekten frei verwenden. Sie können das Jupyter-Notebook und das System Dynamics Modell, das diesem Blogbeitrag entspricht, zusammen mit einer Installationsanleitung und einem ausführlicheren Tutorial hier herunterladen.

Um unseren Ansatz des computational Essays unter Verwendung unseres BPTK-Py-Frameworks zu demonstrieren, werden wir ein sehr einfaches System Dynamics Modell verwenden. Das System Dynamics Modell selbst wurde mit der dynamischen Modellierungs- und Simulationssoftware Stella® von isee systems erstellt.

Stella speichert Modelle im XMILE-Format, einem offenen XML-Protokoll für den Austausch interoperabler System Dynamics Modelle und Simulationen. Der XMILE-Standard wird vom OASIS Standards Consortium gemanagt - unser Framework unterstützt derzeit nur XMILE, möglicherweise erstellen wir in Zukunft einen Compiler für andere Formate (z. B. Vensim® von Ventana Systems) (senden Sie uns eine E-Mail, wenn Sie daran interessiert sind).

Um zu veranschaulichen, wie unser Framework funktioniert, wird in diesem Beitrag das Modell aus unserer Einführung in System Dynamics verwendet.

Wir haben das Bestands- und Flussdiagramm des gesamten Modells unten eingefügt - Sie müssen nicht verstehen, wie das Modell funktioniert, um diesem Beitrag zu folgen, aber die Kenntnis der Bestands- und Flussstruktur wird nützlich sein.

Die folgenden Abschnitte veranschaulichen verschiedene Aspekte unseres Frameworks und dessen Verwendung.

Importieren des Frameworks
Einrichten von Szenarien und Szenario-Managern
Darstellen von Szenarioergebnissen
Aufbau von Szenarioergebnissen
Erstellen von interaktiven Simulations-Dashboards
Zugriff auf das zugrunde liegende System Dynamics Modell
Zugriff auf Modellinformationen
Prüfen und Vergleichen von Modellen

Importieren des Frameworks

Das Business Prototyping Toolkit für Python enthält einen Modelltranspiler, der mit Stella erstellte SD Modelle automatisch in Python-Code konvertiert, einen Modellsimulator, mit dem Sie diese Modelle in einer Python-Umgebung (z. B. einem Jupyter-Notebook) ausführen können, ein einfaches Format zur Definition von Szenarien und einige Methoden zum Darstellen von Simulationsergebnissen - diese Methoden bilden die BPTK-API.

Für die meisten Benutzer wird dies zunächst ausreichen: Sie erstellen das Modell mit Stella und experimentieren damit, indem Sie Szenarien definieren und Diagramme in Jupyter-Notebooks zeichnen. Immer wenn Sie das Modell in Stella ändern, wird das Modell in einem Hintergrundprozess automatisch nach Python transpiliert. Sie können also parallel an Ihrem Modell (in Stella) arbeiten und Ihren computationalen Essay (in Jupyter) schreiben.

Sie benötigen dazu nur sehr begrenzte Python-Kenntnisse - die folgenden Abschnitte zeigen den gesamten Code, der benötigt wird, um loszulegen, unser herunterladbares Tutorial bietet eine detaillierte Installationsanleitung. Wir haben festgestellt, dass selbst Modellierer, die neu in Jupyter und Python sind, innerhalb weniger Stunden mit unserem Toolkit produktiv werden können.

Fortgeschrittene Anwender können die volle Leistungsfähigkeit von Jupyter und Python nutzen, um auf das zugrunde liegende Simulationsmodell und die Simulationsergebnisse zuzugreifen und diese zu manipulieren.

from BPTK_Py.bptk import bptk
bptk = bptk()

Einrichten von Szenarien und Szenario-Managern

Szenarien sind nur bestimmte Einstellungen für die Konstanten und grafischen Funktionen in Ihrem Modell und Szenario-Manager sind eine einfache Möglichkeit, Szenarien zu gruppieren.

Sie können Szenarien direkt in Python erstellen, aber der einfachste Weg, sie zu pflegen, ist, sie in separaten Dateien aufzubewahren - Sie können so viele Szenario-Manager und Szenarien in einer Datei definieren, wie Sie möchten und so viele Dateien verwenden, wie Sie möchten. Jeder Szenario-Manager referenziert das Modell, zu dem er gehört. Sie können also mehrere Simulationsmodelle in einem Notebook ausführen.

Alle Szenariodefinitionsdateien werden im Ordner

scenarios/

aufbewahrt. Das BPTK_Py-Framework durchsucht diesen Ordner automatisch und lädt die Szenarien - einschließlich der zugrunde liegenden Simulationsmodelle - in den Speicher.

Der folgende Code listet alle verfügbaren Szenario-Manager und Szenarien auf:

print("Available Scenario Managers and Scenarios:")

managers = bptk
               .scenario_manager_factory
               .get_scenario_managers(
                   scenario_managers_to_filter=[])

for key, manager in managers.items():
   print("")
   print("*** {} ***".format(key))

for name in manager.get_scenario_names():
   print("\t {}".format(name))

Dies führt zu folgendem Ergebnis:

Verfügbare Szenario-Manager und Szenarien: *** anotherSimpleProjectManagement *** scenario100 scenario80 scenario120 *** smSimpleProjectManagement *** base scenario100 scenario80 scenario120 *** smInteractive *** scenario100 *** smSimpleProjectManagementV0 *** base scenario100 scenario80 scenario120

Wie der Dateiname vermuten lässt, werden die Szenarien im JSON-Format definiert:

"smSimpleProjectManagement":{
   "source":"simulation_models/sd_simple_project.itmx",
   "model":"simulation_models/sd_simple_project",
   "scenarios":{
      "scenario100":{
         "constants": {
            "deadline": 100,
            "effortPerTask": 1,
            "initialOpenTasks": 100,
            "initialStaff": 1
         }
      }
   }
}

Die äußere Klammer definiert den Szenario-Manager. Der Szenario-Manager enthält nicht nur eine Reihe von Szenarien, sondern definiert auch, auf welches Modell sich die Szenarien beziehen (die Dateien

source

und

model

, die den umgesetzten Python-Code des Modells enthält).

Jedes Szenario erhält einen Namen (in diesem Beispiel

scenario100

) und eine Liste von Konstanten, die die Szenarioeinstellungen definieren.

Wir können auch einen Blick darauf werfen, wie das Szenario in unserem Python-Scenario-Manager gespeichert ist:

bptk
    .scenario_manager_factory
    .get_scenario("smSimpleProjectManagement","scenario100")
    .dictionary

Führt zu:

{'constants': { 'deadline': 100, 'effortPerTask': 1, 'initialOpenTasks': 100, 'initialStaff': 1 } }

Der einzige Unterschied in

scenario80

besteht darin, dass wir die Anzahl der anfänglich offenen Aufgaben auf 80 anstelle von 100 festgelegt haben.

bptk
    .scenario_manager_factory
    .get_scenario("smSimpleProjectManagement","scenario80")
    .dictionary

erstellt

{ 'constants': { 'initialOpenTasks': 80, 'deadline': 100, 'effortPerTask': 1, 'initialStaff': 1 } }

Darstellen von Szenario Ergebnissen

Beispiel 1: Mehrere Gleichungen für ein Szenario

Nehmen wir an, dass wir mehrere Gleichungen für dasselbe Szenario darstellen möchten.

Das gesamte Darstellen wird mit der Methode

bptk.plot_scenarios

durchgeführt. Wir müssen nur den Namen des Szenarios (

scenario100

) und die Liste der Gleichungen (

openTasks

und

closedTasks

) übergeben.

bptk.plot_scenarios(
        scenario_managers=["smSimpleProjectManagement"],
        scenarios=["scenario100"],
        equations=['openTasks','closedTasks'],
        title="Tasks remaining vs. Tasks closed",
        freq="D",
        start_date="1/1/2018",
        x_label="Time",
        y_label="Tasks"
 )

Writing Computational Essays Based on Simulation Models Graph 1

Wie Sie sehen, können wir den Namen des Diagramms, die Achsenbeschriftungen und die Zeitskala leicht ändern. Eine Legende mit den Namen der gezeichneten Gleichungen wird automatisch angezeigt.

Die Farben für die Darstellungen werden in einer Konfigurationsdatei eingestellt - wie das geht, erfahren Sie in der erweiterten Dokumentation in unserem Tutorial.

Umbenennen von Gleichungen

Die Gleichungsnamen (z. B.

openTasks

) sind oft nicht die Art von Namen, die Sie dem Leser zeigen wollen - in diesem Fall würden wir z. B. viel lieber die Formulierung

Open Tasks

verwenden.

Glücklicherweise können wir den Parameter

series_name

verwenden, um sie umzubenennen.

bptk.plot_scenarios(
        scenario_managers=["smSimpleProjectManagement"],
        scenarios=["scenario100"],
        equations=['openTasks','closedTasks'],
        title="Renaming Equations",
        freq="D",
        start_date="1/1/2018",
        x_label="Time",
        y_label="Tasks",
        series_names={
           "openTasks" : "Open Tasks",
           "closedTasks" : "Closed Tasks"
        }
 )

Writing Computational Essays Based on Simulation Models Graph 2

Beispiel 2: Eine Gleichung für mehrere Szenarien darstellen

Lassen Sie uns nun die Perspektive ändern. Im obigen Beispiel sind wir von einem Szenario ausgegangen, für das wir mehrere Gleichungen simulieren. Jetzt stellen wir eine Gleichung für mehrere Szenarien dar.

Dies ist immer dann nützlich, wenn wir das Verhalten desselben Modellelements zwischen verschiedenen Szenarien vergleichen wollen.

Um dies zu erreichen, liefern wir nur eine Gleichung und eine Liste von Szenarien an die Methode

plot_scenarios

bptk.plot_scenarios(
   scenario_managers=["smSimpleProjectManagement"],
   scenarios=["scenario80","scenario100","scenario120"],
   equations=["openTasks"],
   title="One Equation for Multiple Scenarios",
   freq="D",
   start_date="1/1/2018",
   x_label="Time",
   y_label="Tasks",
   series_names={
      "scenario80_openTasks":"80 initial open tasks",
      "scenario100_openTasks":"100 initial open tasks",
      "scenario120_openTasks":"120 initial open tasks"
   }
)

Writing Computational Essays Based on Simulation Models Graph 3

bptk.plot_scenarios(
   scenario_managers=["smSimpleProjectManagement"],
   scenarios=["scenario80","scenario100","scenario120"],
   equations=["productivity"],
   title="One Equation for Multiple Scenarios",
   freq="D",
   start_date="1/1/2018",
   x_label="Time",
   y_label="Producitivty %",
   series_names={
      "scenario80_productivity":"80 initial open tasks",
      "scenario100_productivity":"100 initial open tasks",
      "scenario120_productivity":"120 initial open tasks"
    }
)

Writing Computational Essays Based on Simulation Models Graph 4

Was ist, wenn ich eine andere Art von Grafik möchte?

Das Standard-Ausgabeformat für unsere Diagramme zeigt jedes Diagramm mit einem schattierten Bereich an. Dies kann mit dem Parameter

kind

leicht geändert werden. Derzeit unterstützen wir auch die Einstellungen

linie

und

stacked

bptk.plot_scenarios(
   scenario_managers=["smSimpleProjectManagement"],
   scenarios=["scenario80","scenario100","scenario120"],
   equations=["openTasks"],
   kind="line",
   title="One Equation for Multiple Scenarios",
   freq="D",
   start_date="1/1/2018",
   x_label="Time",
   y_label="Tasks",
   series_names={
      "scenario80_openTasks":"80 initial open tasks",
      "scenario100_openTasks":"100 initial open tasks",
      "scenario120_openTasks":"120 initial open tasks"}
)

Writing Computational Essays Based on Simulation Models Graph 5

Was ist, wenn ich die zugrunde liegenden Daten benötige?

Manchmal sind Sie vielleicht nicht am Darstellen eines Diagramms interessiert, sondern möchten lieber die zugrunde liegenden Daten direkt verwenden. Das ist einfach - Sie können die Einstellung

return_df=True

verwenden, um einen Daten-Frame zurückzugeben, der alle Daten des Szenarios enthält. Der Daten-Frame wird als pandas-Daten-Frame bereitgestellt.

data=bptk.plot_scenarios(
        scenario_managers=["smSimpleProjectManagement"],
        scenarios=["scenario80"],
        freq="D",
        start_date="1/1/2018",
        equations=[
           "openTasks",
           "closedTasks",
           "completionRate",
           "remainingTime",
           "schedulePressure",
           "productivity"],
        return_df=True
 )

Der Daten-Frame ist eine Tabelle mit einer Zeile für jeden Tag und einer Spalte für jedes der Szenarien. Mit der Funktion

pandas.DataFrame.head

können wir die ersten fünf Zeilen des Daten-Frames anzeigen:

data.head()

Ausgaben

Writing Computational Essays Based on Simulation Models Graph 6

Sobald Sie den Daten-Frame haben, können Sie die volle Leistungsfähigkeit von Python und der pandas-Bibliothek nutzen, um auf die Daten zuzugreifen, z. B. den

iloc

Indexer, um auf eine bestimmte Zeile zuzugreifen:

data.iloc[4]

erstellt

openTasks 77.286885 closedTasks 2.713115 completionRate 0.683436 remainingTime 96.000000 schedulePressure 0.805072 productivity 0.683436 Name: 2018-01-05 00:00:00, dtype: float64

Erstellen von interaktiven Simulations-Dashboards

Jupyter-Notebooks sind nicht nur eine großartige Umgebung für interaktives Schreiben und Darstellungen, sie ermöglichen auch die Erstellung interaktiver Benutzeroberflächen.

bptk.dashboard(
   scenario_managers=["smInteractive"],
   scenarios=["scenario100"],
   kind="area",
   equations=["openTasks"],
   series_names={"openTasks":"Open Tasks"},
   freq="D",
   start_date="",
   title="Interactive Simulation Dashboard",
   x_label="Date",
   y_label="€",
   constants=[
      ("slider",'initialOpenTasks',50.0,100.0),
      ("slider","deadline",0,150),
      ("timerange")]
)

erstellt dieses Dashboard:

Writing Computational Essays Based on Simulation Models Graph 7

Zugriff auf das zugrunde liegende System Dynamics Modell

Das zugrundeliegende System Dynamics Modell wird automatisch aus dem XMILE-Format in Python-Code konvertiert - derzeit unterstützt unser Transpiler nur die Konvertierung von Modellen im XMILE-Format, aber wir planen, einen Compiler für Modelle in anderen Formaten zu erstellen.

Wir bewahren sowohl die Stella/XMILE-Modelle als auch die kompilierten Modelle im Verzeichnis `/MODELS` auf.

Die eigentlichen Gleichungen, die der Simulation zugrunde liegen, sind in einem Dictionary von Python-Lambda-Funktionen innerhalb der Klasse gespeichert, z. B. hier die Gleichungen für geschlossene Aufgaben, offene Aufgaben und die Fertigstellungsrate:

'closedTasks': lambda t : 0 if t <= self.starttime else self.memoize('closedTasks',t-self.dt)
 + self.dt * ( self.memoize('completionRate',t-self.dt) ),

'openTasks': lambda t : self.memoize('initialOpenTasks', t) if t <= self.starttime else
 self.memoize('openTasks',t-self.dt) +
 self.dt * ( -1 * ( self.memoize('completionRate',t-self.dt) ) ),

'staff': lambda t : self.memoize('initialStaff', t) if t <= self.starttime
 else self.memoize('staff',t-self.dt)
 + self.dt * 0,

'completionRate': lambda t : max( 0, min( self.memoize('openTasks', t), self.memoize('staff', t) *
 self.memoize('productivity', t) / self.memoize('effortPerTask', t) ) ),

Aufgrund der rekursiven Natur von System Dynamics Gleichungen verwenden wir die Memoisierung, um sich vorherige Werte zu merken - das macht die Gleichungen zwar umständlicher zu lesen (und zu schreiben, falls Sie Ihre eigenen erstellen wollen), aber es beschleunigt die Berechnungen dramatisch.

Sie können leicht auf diese Lambda-Funktionen zugreifen (und sie ändern), wenn Sie das möchten. Sie sind in einem Dictionary innerhalb des Modells gespeichert, das selbst mit dem Szenario verknüpft ist. Das Verknüpfen des Modells mit dem Szenario ist wichtig, weil dadurch sichergestellt wird, dass die Szenarioeinstellungen automatisch auf das Modell angewendet werden.

bptk
     .scenario_manager_factory
     .get_scenario("smSimpleProjectManagement","scenario80")
     .model
     .equations

Ausgaben

{ 'closedTasks': .(t)>, 'openTasks': .(t)>, 'staff': .(t)>, 'completionRate': .(t)>, 'currentDate': .(t)>, 'remainingTime': .(t)>, 'schedulePressure': .(t)>, 'productivity': .(t)>, 'deadline': (t)>, 'effortPerTask': (t)>, 'initialOpenTasks': (t)>, 'initialStaff': (t)>}

Sie können diese Gleichungen ausführen, um auf einzelne Werte zuzugreifen:

bptk
    .scenario_manager_factory
    .get_scenario("smSimpleProjectManagement","scenario100")
    .model
    .equations["closedTasks"](10)

führt zu

10.0

Zugriff auf Modellinformationen

Das Modell in einer Python-Klasse zu haben, ist auch für andere Zwecke nützlich - zum Beispiel können Sie auf die Liste der Bestände, Flüsse und Konverter zugreifen, um zu prüfen, welche Elemente in Ihrem Modell sind:

bptk
    .scenario_manager_factory
    .get_scenarios()["scenario100"]
    .model
    .stocks

Ausgaben

[ 'closedTasks', 'openTasks', 'staff']

bptk
    .scenario_manager_factory
    .get_scenarios()["scenario100"]
    .model
    .constants

Ausgaben

[ 'deadline', 'effortPerTask', 'initialOpenTasks', 'initialStaff' ]

Natürlich können wir dann die Macht von Jupyter nutzen, um dies mittels HTML schön auszudrucken:

from functools import reduce
from IPython.display import HTML
HTML("<ul><li>"+   
reduce(
       lambda x, y: x+"</li><li>"+y,  
       bptk
           .scenario_manager_factory
           .get_scenario("smSimpleProjectManagement","scenario100")
           .model
           .stocks
)     
+"</li></ul>")

Ausgaben

closedTasks
openTasks
staff

Wir können auch einfach die Einstellungen für die Konstanten im Modell ausgeben (für jedes der definierten Szenarien):

for constant in 
bptk
     .scenario_manager_factory
     .get_scenario("smSimpleProjectManagement","scenario100")
     .model
     .constants:

print (constant+": "+str(
bptk
    .scenario_manager_factory
    .get_scenario("smSimpleProjectManagement","scenario100")
    .model
    .equations[constant](0)
))

führt zu

deadline: 100 effortPerTask: 1 initialOpenTasks: 100 initialStaff: 1

Und

for constant in 
bptk
    .scenario_manager_factory 
    .get_scenario("smSimpleProjectManagement","scenario80")
    .model
    .constants:

print (constant+": "+str(
bptk
    .scenario_manager_factory
    .get_scenario("smSimpleProjectManagement","scenario80")
    .model
    .equations[constant](0)
))

führt zu

deadline: 100 effortPerTask: 1 initialOpenTasks: 80 initialStaff: 1

Prüfen und Vergleichen von Modellen

Simulationsmodelle können sehr groß werden und sie sind oft über viele Jahre im Einsatz. Dies bedeutet, dass Sie am Ende viele Versionen eines Modells haben, und es wird oft schwierig, sicherzustellen, dass die Modellversionen konsistent sind oder dass Änderungen an einem späteren Modell nicht die früher erzielten Ergebnisse ungültig machen.

Dank des BPTK-Frameworks sind die Modelle jetzt berechenbar und wir können leicht Prüfungen erstellen, um sicherzustellen, dass sich die Modelle so verhalten, wie wir es erwarten:

bptk.model_check(data=bptk.plot_scenarios(
scenario_managers=["smSimpleProjectManagement"],
scenarios=["scenario100"],
equations=['openTasks'],
return_df=True
),
check=(lambda data: data.iloc[-1,-1]>10),
message="Model not behaving as expected")

führt zu

[ERROR] Model Checking failed with message: "Model not behaving as expected"

Die

bptk.model_check

ist sehr einfach - sie erwartet einige Daten und eine Prüffunction, die die Daten als Eingabe nimmt und true oder false zurückgibt, je nachdem, ob die Daten die Prüfung bestehen oder nicht.

In diesem Beispiel haben wir den von einem Szenario zurückgegebenen Daten-Frame verwendet, um die Daten bereitzustellen, und eine Python-Lambda-Funktion, um zu prüfen, ob die Anzahl der

openTasks

im letzten Zeitschritt größer als 10 ist. Das ist nicht der Fall, und daher wird ein Fehler erzeugt.

Aber in diesem Fall ist das Modell eigentlich korrekt, aber die Prüffunktion ist falsch - wenn wir das korrigieren, kommt die Funktion `model_check` mit einer Erfolgsmeldung zurück:

bptk.model_check(data=bptk.plot_scenarios(
scenario_managers=["smSimpleProjectManagement"],
scenarios=["scenario100"],
equations=['openTasks'],
return_df=True
),
check=(lambda data: data.iloc[-1,-1]<10),
message="Model not behaving as expected")

ergibt

[SUCCESS] Model check successful!

Wir können auch leicht zwei verschiedene Versionen eines Modells miteinander vergleichen - nehmen wir z. B. an, wir haben zwei Versionen unseres Projektmanagement-Modells, die z. B. unterschiedliche Einstellungen für die grafische Funktion enthalten, mit der wir die Auswirkung des Zeitplandrucks auf die Produktivität modellieren, und auch die Anzahl der anfänglich offenen Aufgaben (wie im zugrunde liegenden Modell definiert, nicht in den Szenarien).

Lassen Sie uns die Ergebnisse zwischen den Modellen vergleichen:

bptk.plot_scenarios(
     scenario_managers=["smSimpleProjectManagement","smSimpleProjectManagementV0"],
     scenarios=["scenario80"], 
     equations=['openTasks'],
     title="Compare Two Models",
     series_names={
        "smSimpleProjectManagement_scenario80_openTasks":"Current Model", 
        "smSimpleProjectManagementV0_scenario80_openTasks":"Model v0"}
)

Writing Computational Essays Based on Simulation Models Graph 8

Fazit

In diesem Beitrag wurde unser Ansatz zur Erstellung interaktiver Geschichten auf Basis von Simulationsmodellen mit Jupyter, Python und dem BPTKP_PY-Framework detailliert beschrieben. Hier sind die wichtigsten Punkte, die Sie sich merken sollten:

Wenn Sie die aus Simulationsmodellen gewonnenen Erkenntnisse nutzen wollen, um in der realen Welt etwas zu bewirken, reicht es oft nicht aus, nur das Modell und die Erkenntnisse zu haben - Sie müssen eine gute Geschichte entwickeln, die Ihre Stakeholder davon überzeugt, Entscheidungen zu treffen und Maßnahmen zu ergreifen.
Jupyter und Python bieten eine großartige Umgebung für die schnelle Erstellung solcher interaktiven Geschichten, die auf Daten und Simulationen basieren. Mit dem BPTK_PY-Framework ist die Erstellung solcher Dokumente eigentlich recht einfach. Sie können sich auf die Geschichte konzentrieren und das Framework die schwere Arbeit machen lassen.
Die Erstellung komplexer Simulationen mit System Dynamics erfolgt am besten mit visuellen Modellierungsumgebungen wie Stella. Dank des XMILE-Standards und unseres BPTK_PY-Frameworks können wir mit Stella erstellte System Dynamics Modelle direkt in Jupyter importieren und dort ausführen.
Wenn Sie die interaktive Geschichte fertiggestellt haben, können Sie sie einem breiten Publikum zugänglich machen, indem Sie das Jupyter-Notebook freigeben - dies wird besonders einfach gemacht, da Jupyter, Python und BPTK_PY kostenlos sind.

Um interaktive Geschichten und Spiele zu sehen, die mit diesem Ansatz geschrieben wurden, werfen Sie einen Blick auf unsere Blogbeiträge zu Prototyping von Geschäftsmodellen und Marktstrategien, zu Lassen Sie Ihre PSF wachsen oder auf unsere Version des Spielen Sie das Beer Game Spielen Sie das Beer Game.

Infrastruktur-Simulation Overview Eine Python-Bibliothek für System Dynamics