Dieser Artikel ist dem Python Gateway gewidmet — einem Open-Source-Community-Projekt für die Datenplattform InterSystems IRIS. Dieses Projekt ermöglicht es, beliebige Machine-Learning-Algorithmen, die in Python (der Hauptumgebung für viele Data Scientists) erstellt wurden, zu orchestrieren und zahlreiche verfügbare Bibliotheken zu verwenden, um schnell adaptive, automatisierte analytische AI/ML-Lösungen auf der InterSystems IRIS-Plattform zu erstellen. In diesem Artikel zeige ich, wie InterSystems IRIS Prozesse in Python orchestrieren, Daten effizient bidirektional übertragen und intelligente Geschäftsprozesse erstellen kann.

Plan

1. Einführung.
2. Werkzeuge.
3. Installation.
4. API.
5. Interoperabilität.
6. Jupyter Notebook.
7. Fazit.
8. Links.
9. MLToolkit.

Einführung

Python ist eine hochgradig flexible Programmiersprache, die auf die Steigerung der Entwicklerproduktivität und die Lesbarkeit des Codes abzielt. In dieser Artikelreihe werde ich die Möglichkeiten der Anwendung von Python auf der InterSystems IRIS-Plattform erläutern, wobei der Schwerpunkt dieses Artikels auf der Verwendung von Python als Sprache zur Erstellung und Anwendung von Machine-Learning-Modellen liegt.

Machine Learning (ML) ist eine Klasse von Methoden der künstlichen Intelligenz, bei denen nicht direkt eine Aufgabe gelöst wird, sondern das Lernen während der Lösung vieler ähnlicher Aufgaben im Vordergrund steht.

Maschinenlernalgorithmen und -modelle werden immer verbreiteter. Es gibt viele Gründe dafür, aber sie lassen sich auf Zugänglichkeit, Einfachheit und das Erzielen praktischer Ergebnisse zurückführen. Ist Clusterbildung oder sogar neuronales Netzmodellierung eine neue Technologie?

Natürlich nicht, aber heutzutage ist es nicht mehr notwendig, Hunderte von Tausenden Zeilen Code zu schreiben, um ein einziges Modell zu starten, und die Kosten für die Erstellung und Anwendung von Modellen werden immer geringer.

Die Werkzeuge entwickeln sich weiter — während wir nicht über vollständig GUI-orientierte AI/ML-Werkzeuge verfügen, beobachten wir den gleichen Fortschritt bei vielen anderen Klassen von Informationssystemen, zum Beispiel BI (von der Codierung bis zur Nutzung von Frameworks und GUI-orientierten konfigurierbaren Lösungen), auch in den Werkzeugen zur Erstellung von AI/ML. Wir haben die Phase des Programmierens hinter uns gelassen und nutzen heute Frameworks zur Erstellung und Schulung von Modellen.

Weitere Verbesserungen, wie die Möglichkeit, vortrainierte Modelle zu verbreiten, bei denen der Endbenutzer nur das Training des Modells mit seinen spezifischen Daten abschließen muss, erleichtern den Einstieg in die Anwendung von maschinellem Lernen. Diese Fortschritte erleichtern das Lernen von maschinellem Lernen sowohl für Fachleute als auch für Unternehmen im Allgemeinen erheblich.

Andererseits sammeln wir immer mehr Daten. Dank einer einheitlichen Datenplattform wie InterSystems IRIS kann all diese Information sofort aufbereitet und als Ausgangsdaten für Modelle des maschinellen Lernens verwendet werden.

Mit dem Übergang in die Cloud wird der Start von AI/ML-Projekten einfacher als je zuvor. Wir können nur die Ressourcen nutzen, die wir benötigen. Darüber hinaus können wir dank der Parallelisierung, die von Cloud-Plattformen angeboten wird, Zeit sparen.

Aber wie sieht es mit den Ergebnissen aus? Hier wird es komplizierter. Es gibt viele Werkzeuge zum Aufbau von Modellen, über die ich im Folgenden sprechen werde. Ein gutes Modell zu erstellen ist nicht einfach, aber was kommt dann? Die Erzielung von Nutzen aus der Nutzung des Modells durch das Unternehmen ist ebenfalls eine keine triviale Aufgabe. Der Kern des Problems liegt in der Trennung von analytischen und transaktionalen Lasten sowie den Datenmodellen. Wenn wir ein Modell trainieren, tun wir dies normalerweise mit historischen Daten. Aber der Platz für das gebaute Modell liegt in der transaktionalen Datenverarbeitung. Was nützt das beste Modell zur Erkennung betrügerischer Transaktionen, wenn wir es nur einmal am Tag ausführen? Die Betrüger sind längst mit dem Geld verschwunden. Wir müssen das Modell mit historischen Daten trainieren, aber wir müssen es auch in Echtzeit auf neue eingehende Daten anwenden, damit unsere Geschäftsprozesse gemäß den Vorhersagen des Modells agieren können.

Das ML Toolkit ist ein Satz von Werkzeugen, dessen Ziel es ist, genau dies zu erreichen: Modelle und die transaktionale Umgebung zu verbinden, damit die erstellten Modelle direkt in Ihren Geschäftsprozessen eingesetzt werden können. Der Python Gateway ist Teil des ML Kit und bietet eine Integration mit der Programmiersprache Python (ähnlich wie der R Gateway, der als Teil des ML Kit die Integration mit der Programmiersprache R ermöglicht).

Werkzeug

Bevor wir fortfahren, möchte ich einige Werkzeuge und Bibliotheken für Python beschreiben, die wir später verwenden werden.

Technologien

• Python ist eine interpretierte, hochgradig einsetzbare Programmiersprache. Der Hauptvorteil dieser Sprache ist die umfangreiche Bibliothek an mathematischen, ML- und AI-Bibliotheken. Ähnlich wie bei ObjectScript handelt es sich um eine objektorientierte Sprache, aber alles wird dynamisch und nicht statisch definiert. Außerdem ist alles ein Objekt. Spätere Artikel setzen ein flüchtiges Verständnis der Sprache voraus. Wenn Sie mit dem Lernen beginnen möchten, empfehle ich Ihnen, mit Dokumentation.
• Für unsere späteren Übungen installieren Sie Python 3.6.7 64 bit.
• IDE: Ich verwende PyCharm, aber generell gibt es auch andere. viele. Wenn Sie Atelier verwenden, gibt es ein Eclipse-Plugin für Python-Entwickler. Wenn Sie VS Code verwenden, gibt es eine Erweiterung für Python.
• Notebook: Anstelle einer IDE können Sie Ihre Skripte in Online-Notebooks schreiben und teilen. Das beliebteste unter ihnen ist Jupyter.

Bibliotheken

Hier ist eine (unvollständige) Liste von Bibliotheken für maschinelles Lernen:

• Numpy — ein grundlegendes Paket für präzise Berechnungen.
• Pandas — hochleistungsfähige Datenstrukturen und Datenanalysetools.
• Matplotlib — Erstellung von Diagrammen.
• Seaborn — Datenvisualisierung, die auf matplotlib basiert.
• Sklearn — Methoden für maschinelles Lernen.
• XGBoost — Algorithmen für maschinelles Lernen innerhalb der Gradienten-Boosting-Methodologie.
• Gensim — NLP.
• Keras — neuronale Netzwerke.
• Tensorflow — Plattform zur Erstellung von Modellen für maschinelles Lernen.
• PyTorch — Plattform zur Erstellung von Modellen für maschinelles Lernen, die auf Python ausgerichtet ist.
• Nyoka — PMML aus verschiedenen Modellen.

AI/ML-Technologien ermöglichen es, Geschäfte effektiver und anpassungsfähiger zu gestalten. Darüber hinaus werden diese Technologien heute einfacher entwickelt und umgesetzt. Beginnen Sie mit dem Lernen über AI/ML-Technologien und wie diese Ihrer Organisation beim Wachsen helfen können.

Installation

Es gibt mehrere Möglichkeiten, Python Gateway zu installieren und zu nutzen:

• dem Betriebssystem
  • Windows
  • Linux
  • Mac
• Docker
  • Verwenden Sie ein Image von DockerHub
  • Erstellen Sie Ihr eigenes Image

Unabhängig von der Installationsmethode benötigen Sie den Quellcode. Der einzige Ort zum Herunterladen des Codes ist die Release-Seite. Sie enthält getestete stabile Releases, nehmen Sie einfach die letzte Version. Momentan ist dies 0.8, aber im Laufe der Zeit werden neue folgen. Klonen Sie nicht das Repository, laden Sie die neueste Version herunter.

dem Betriebssystem

Wenn Sie das Python Gateway auf einem Betriebssystem installieren, müssen Sie zuerst (unabhängig vom Betriebssystem) Python installieren. Dazu:

1. Installieren Sie Python 3.6.7 64 Bit. Es wird empfohlen, Python im Standardverzeichnis zu installieren.
2. Installieren Sie das Modul dill: pip install dill.
3. Laden Sie den ObjectScript-Code (d.h. do $system.OBJ.ImportDir("C:InterSystemsReposPythoniscpy", "*.cls", "c",,1)) in jeden Namensraum mit Produkteinheiten. Falls Sie möchten, dass ein vorhandener Namensraum Produkteinheiten unterstützt, führen Sie aus: write ##class(%EnsembleMgr).EnableNamespace($Namespace, 1).
4. Fügen Sie hinzu callout DLL/SO/DYLIB in den Ordner bin Ihres InterSystems IRIS-Instanz. Die Bibliotheksdatei sollte unter dem Pfad verfügbar sein, der zurückgegeben wird von write ##class(isc.py.Callout).GetLib().

Windows

1. Stellen Sie sicher, dass die Umgebungsvariable PYTHONHOME auf Python 3.6.7 zeigt.
2. Stellen Sie sicher, dass die Systemumgebungsvariable PATH die Variable enthält PYTHONHOME (oder das Verzeichnis, auf das sie zeigt).

Linux (Debian/Ubuntu)

1. Überprüfen Sie, dass die Umgebungsvariable PATH enthält /usr/lib und /usr/lib/x86_64-linux-gnu. Verwenden Sie die Datei /etc/environment zum Setzen der Umgebungsvariablen.
2. Im Falle von Fehlern undefined symbol: _Py_TrueStruct setzen Sie die Einstellung PythonLib. Auch im Readme gibt es einen Abschnitt zur Fehlersuche.

Mac

1. Derzeit wird nur Python 3.6.7 von Python.orgunterstützt. Überprüfen Sie die Variable PATH.

Wenn Sie Umgebungsvariablen geändert haben, starten Sie Ihr Produkt von InterSystems neu.

Docker

Die Nutzung von Containern hat eine Reihe von Vorteilen:

• Portabilität
• Effektivität
• Isolierung
• Leichtigkeit
• Unveränderlichkeit

Schauen Sie sich diese Artikelreihe für weitere Informationen zur Verwendung von Docker mit InterSystems-Produkten an.

Alle Builds des Python Gateways basieren derzeit auf Containern. 2019.4.

Fertiges Image

Führen Sie aus: docker run -d -p 52773:52773 --name irispy intersystemscommunity/irispy-community:latest, um das Python Gateway mit InterSystems IRIS Community Edition herunterzuladen und zu starten. Das war's.

Erstellen Sie Ihr eigenes Image

Führen Sie im Wurzelverzeichnis des Repositories aus: docker build --force-rm --tag intersystemscommunity/irispy:latest ..
Standardmäßig wird das Image auf Basis des Images store/intersystems/iris-community:2019.4.0.383.0, aber Sie können dies ändern, indem Sie die Variable IMAGE.
Für den Build aus InterSystems IRIS führen Sie aus: `docker build —build-arg IMAGE=store/intersystems/iris:2019.4.0.383.0 —force-rm —tag intersystemscommunity/irispy:latest `.

Danach können Sie das Docker-Image starten:

docker run -d 
  -p 52773:52773 
  -v //:/mount 
  --name irispy 
  intersystemscommunity/irispy:latest 
  --key /mount/iris.key

Wenn Sie ein auf InterSystems IRIS Community Edition basierendes Image verwenden, müssen Sie den Schlüssel möglicherweise nicht angeben.

Kommentare

• Testprozess isc.py.test.Process Speichert eine Reihe von Bildern im temporären Verzeichnis. Möglicherweise möchten Sie diesen Pfad auf ein gemountetes Verzeichnis ändern. Dazu bearbeiten Sie die Einstellung WorkingDir indem Sie das gemountete Verzeichnis angeben.
• Zugriff auf das Terminal erhalten Sie mit: docker exec -it irispy sh.
• Zugang zum Systemverwaltungsportal mit Login SuperUser/SYS.
• Um den Container zu stoppen, führen Sie aus: docker stop irispy && docker rm --force irispy.

Überprüfung der Installation

Nachdem Sie das Python Gateway installiert haben, sollten Sie überprüfen, ob es funktioniert. Führen Sie diesen Code im Terminal von InterSystems IRIS aus:

set sc = ##class(isc.py.Callout).Setup() 
set sc = ##class(isc.py.Main).SimpleString("x='HELLO'", "x", , .var).
write var

Es sollte das Folgende ausgegeben werden HELLO — der Wert der Python-Variablen x. Wenn der zurückgegebene Status sc ein Fehler oder var leer ist, überprüfen Sie die Readme – Abschnitt Fehlerbehebung.

API

Das Python Gateway ist installiert, und Sie haben sichergestellt, dass es funktioniert. Es ist Zeit, es zu nutzen!
Das Hauptinterface zu Python ist isc.py.Main. Es bietet die folgenden Gruppen von Methoden (alle geben zurück %Status):

• Codeausführung
• Datenübertragung
• Hilfsmethoden

Codeausführung

Diese Methoden ermöglichen es, beliebigen Python-Code auszuführen.

SimpleString

SimpleString — dies ist die Hauptmethode. Sie nimmt 4 optionale Argumente an:

• code — der auszuführende Code. Zeilenumbruchzeichen: $c(10).
• returnVariable — der Name der Variable für die Rückgabe.
• serialization — wie zu serialisieren returnVariable. 0 — string (Standard), 1 — repr.
• result — ByRef-Verweis auf die Variable, in die der Wert geschrieben wird returnVariable.

Vorhin haben wir ausgeführt:

set sc = ##class(isc.py.Main).SimpleString("x='HELLO'", "x", , .var).

In diesem Beispiel weisen wir der Python-Variable x system-id D Hallo zu und möchten den Wert der Python-Variable x in eine ObjectScript-Variable zurückgeben var.

ExecuteCode

ExecuteCode ist eine sicherere und weniger eingeschränkte Alternative SimpleString.
Strings in der InterSystems IRIS-Plattform sind auf 3.641.144 Zeichen begrenzt, und wenn Sie eine längere Codezeile ausführen möchten, müssen Sie Streams verwenden.
Es werden zwei Argumente angenommen:

• code — einen Python-Code-String oder -Stream zur Ausführung.
• variable — (optional) weist das Ergebnis der Ausführung code dieser Python-Variablen zu.

Verwenden Sie:

set sc = ##class(isc.py.Main).ExecuteCode("2*3", "y").

In diesem Beispiel multiplizieren wir 2 mit 3 und speichern das Ergebnis in der Python-Variable y.

Datenübertragung

Übertragen Sie Daten nach Python und zurück.

Python -> InterSystems IRIS

Es gibt 4 Möglichkeiten, den Wert einer Python-Variable in InterSystems IRIS zu erhalten, je nach der benötigten Serialisierung:

• String für grundlegende Datentypen und Debugging.
• Repr zur Speicherung einfacher Objekte und zur Fehlerbehebung.
• JSON für einfaches Manipulieren von Daten auf der Seite von InterSystems IRIS.
• Pickle zur Speicherung von Objekten.

Diese Methoden ermöglichen es, Variablen aus Python als Strings oder Streams zu erhalten.

• GetVariable(variable, serialization, .stream, useString) — abrufen serialization Variable variable in stream. Wenn useString gleich 1 und die Serialisierung in einen String gespeichert wird, wird ein String und kein Stream zurückgegeben.
• GetVariableJson(variable, .stream, useString) — erhalten Sie die JSON-Serialisierung der Variable.
• GetVariablePickle(variable, .stream, useString, useDill) - erhalten Sie die Pickle- (oder Dill-)Serialisierung der Variable.

Versuchen wir, unsere Variable abzurufen. y.

set sc = ##class(isc.py.Main).GetVariable("y", , .val, 1)
write val
>6

InterSystems IRIS -> Python

Laden von Daten aus InterSystems IRIS in Python.

• ExecuteQuery(query, variable, type, namespace) — erstellt einen Datensatz (pandas dataframe oder die Umwandlung von numerischen und textuellen Daten in die Formate) aus der SQL-Abfrage und weist ihn einer Python-Variable zu. variable. Das Paket isc.py muss im Bereich verfügbar sein, Namespace — hier wird die Abfrage ausgeführt.
• ExecuteGlobal(global, variable, type, start, end, mask, labels, namespace) — lädt Daten aus dem Globalen global vom Subscript start bis end in Python als Variable vom Typ type: die Umwandlung von numerischen und textuellen Daten in die Formate, oder pandas dataframe. Eine Beschreibung der optionalen Argumente mask and labels ist in der Dokumentation der Klasse und im Repository verfügbar. Data Transfer docs.
• ExecuteClass(class, variable, type, start, end, properties, namespace) — lädt Klassendaten class vom ID start bis end in Python als Variable vom Typ type: die Umwandlung von numerischen und textuellen Daten in die Formate, oder pandas dataframe. properties — eine Liste (Trennzeichen: Komma) von Klassenattributen, die in den Datensatz geladen werden sollen. Masken werden unterstützt. * und ?. Standardmäßig — * (alle Attribute). Attribute %%CLASSNAME werden ignoriert.
• ExecuteTable(table, variable, type, start, end, properties, namespace) — lädt Tabellendaten Tabelle vom ID start bis end in Python.

ExecuteQuery — ist universell (jeder korrekte SQL-Befehl wird an Python übergeben). Allerdings ExecuteGlobal und seine Umhüllungen ExecuteClass und ExecuteTable arbeiten unter einer Reihe von Einschränkungen. Sie sind viel schneller (3-5 Mal schneller als der ODBC-Treiber und 20 Mal schneller ExecuteQuery). Weitere Informationen finden Sie in Data Transfer docs.
Alle diese Methoden unterstützen die Datenübertragung aus jedem Bereich. Das Paket isc.py muss im Zielbereich verfügbar sein.

ExecuteQuery

ExecuteQuery(request, variable, type, namespace) — Übertragung der Ergebnisse jeder korrekten SQL-Abfrage nach Python. Dies ist die langsamste Methode zur Datenübertragung. Verwenden Sie sie, wenn ExecuteGlobal und seine Umhüllungen nicht verfügbar sind.

Argumente:

• query — SQL-Abfrage.
• variable — der Name der Python-Variable, in die die Daten geschrieben werden.
• type — die Umwandlung von numerischen und textuellen Daten in die Formate oder Pandas dataframe.
• Namespace — der Bereich, in dem die Abfrage ausgeführt wird.

ExecuteGlobal

ExecuteGlobal(global, variable, type, start, end, mask, labels, namespace) — Übertragung des Globals in Python.

Argumente:

• global — der Name des Globals ohne ^
• variable — der Name der Python-Variable, in die die Daten geschrieben werden.
• type — die Umwandlung von numerischen und textuellen Daten in die Formate oder Pandas dataframe.
• start — das erste Subscript des Globals. Erforderlich. %Integer.
• end — das letzte Subscript des Globals. Erforderlich. %Integer.
• mask — Maskenwerte des Globals. Die Maske kann kürzer sein als die Anzahl der Felder im Global (in diesem Fall werden die Felder am Ende übersprungen). So formatieren Sie die Maske:
  • + Wert so übergeben, wie er ist.
  • - Wert überspringen.
  • b — Boolescher Typ (0 — Falsch, alles andere ist — Wahr).
  • d — Datum (ab $horolog, unter Windows ab 1970, unter Linux ab 1900).
  • t — Zeit ($horolog, Sekunden nach Mitternacht).
  • m — Zeitstempel (String im FORMAT JAHR-MONAT-TAG STUNDE:MINUTE:SEKUNDE).
• labels — %Liste der Spaltennamen. Erstes Element — Name des Subskripts.
• Namespace — der Bereich, in dem die Abfrage ausgeführt wird.

ExecuteClass

Wrapper über ExecuteGlobal. Bereitet den Aufruf basierend auf der Klassendefinition vor ExecuteGlobal und ruft ihn auf.

ExecuteClass(class, variable, type, start, end, properties, namespace) — Übertragung von Klassendaten in Python.

Argumente:

• class — Klassenname
• variable — der Name der Python-Variable, in die die Daten geschrieben werden.
• type — die Umwandlung von numerischen und textuellen Daten in die Formate oder Pandas dataframe.
• start — Start-ID.
• end — End-ID
• properties — eine Liste (Trennzeichen: Komma) von Klassenattributen, die in den Datensatz geladen werden sollen. Masken werden unterstützt. * und ?. Standardmäßig — * (alle Attribute). Attribute %%CLASSNAME werden ignoriert.
• Namespace — der Bereich, in dem die Abfrage ausgeführt wird.

Alle Eigenschaften werden so übergeben, wie sie sind, außer den Eigenschaften der Typen te, %Zeit, %Boolean und %Zeitstempel — sie werden in die entsprechenden Python-Klassen konvertiert.

ExecuteTable

Wrapper über ExecuteClass. Translatiert den Tabellennamen in den Klassennamen und ruft ExecuteClassauf. Signatur:

ExecuteTable(table, variable, type, start, end, properties, namespace) — Übertragung von Tabellendaten in Python.

Argumente:

• Tabelle — Tabellenname.
  Alle anderen Argumente werden so übergeben, wie sie sind, in ExecuteClass.

Notizen

• ExecuteGlobal, ExecuteClass und ExecuteTable arbeiten gleich schnell.
• ExecuteGlobal 20 Mal schneller als ExecuteQuery bei großen Datensätzen (Übertragungszeit mehr als >0.01 Sekunden).
• ExecuteGlobal, ExecuteClass und ExecuteTable arbeiten mit Globals dieser Struktur: ^global(key) = $lb(prop1, prop2, ..., propN) wo key — ganze Zahl.
• Für ExecuteGlobal, ExecuteClass und ExecuteTable unterstützter Wertebereich te entspricht dem Bereich mktime und hängt vom OS ab (windows: 1970-01-01, linux 1900-01-01, mac). Verwenden Sie %Zeitstempelum Daten außerhalb dieses Bereichs zu übergeben oder verwenden Sie ein pandas dataframe, da dies nur eine Einschränkung für die Liste ist.
• Für ExecuteGlobal, ExecuteClass und ExecuteTable Alle Argumente, außer der Datenquelle (Global, Klasse oder Tabelle) und der Variablen, sind optional.

Beispiele

Testklasse isc.py.test.Person enthält eine Methode, die alle Optionen zur Datenübertragung demonstriert:

set global = "isc.py.test.PersonD"
set class = "isc.py.test.Person"
set table = "isc_py_test.Person"
set query = "SELECT * FROM isc_py_test.Person"

// Allgemeine Argumente
set variable = "df"
set type = "dataframe"
set start = 1
set end = $g(^isc.py.test.PersonD, start)

// Methode 0: ExecuteGlobal ohne Argumente
set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 0, type)

// Methode 1: ExecuteGlobal mit Argumenten
// Bei Übergabe des Globals werden die Feldnamen manuell festgelegt
// globalKey - Name des Subskripts
set labels = $lb("globalKey", "Name", "DOB", "TS", "RandomTime", "AgeYears", "AgeDecimal", "AgeDouble", "Bool")

// Mask enthält ein Element weniger als Labels, da "globalKey" der Name des Subskripts ist
// %%CLASSNAME wird übersprungen
set mask = "-+dmt+++b"

set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 1, type, start, end, mask, labels)

// Methode 2: ExecuteClass
set sc = ##class(isc.py.Main).ExecuteClass(class, variable _ 2, type, start, end)

// Methode 3: ExecuteTable
set sc = ##class(isc.py.Main).ExecuteTable(table, variable _ 3, type, start, end)

// Methode 4: ExecuteTable
set sc = ##class(isc.py.Main).ExecuteQuery(query, variable _ 4, type)

Rufen Sie die Methode auf do ##class(isc.py.test.Person).Test() um zu sehen, wie alle Methoden zur Datenübertragung funktionieren.

Hilfsmethoden

• GetVariableInfo(variable, serialization, .defined, .type, .length) — Informationen über die Variable abrufen: ob sie definiert ist, Klasse und Länge der Serialisierung.
• GetVariableDefined(variable, .defined) — ob die Variable definiert ist.
• GetVariableType(variable, .type) — die Klasse der Variable abrufen.
• GetStatus() — das letzte Ausnahmeereignis auf der Python-Seite abrufen und löschen.
• GetModuleInfo(module, .imported, .alias) — die Modulvariable und den Importstatus abrufen.
• GetFunctionInfo(function, .defined, .type, .docs, .signature, .arguments) — Informationen über die Funktion abrufen.

Interoperabilität

Sie haben gelernt, das Python Gateway von der Konsole aus aufzurufen. Jetzt beginnen wir, es in der Produktion zu verwenden. Die Grundlage der Interaktion mit Python in diesem Modus ist isc.py.ens.Operation. Es ermöglicht uns:

• Python-Code auszuführen
• Python-Kontext zu speichern/wiederherzustellen
• Daten in Python zu laden und abzurufen

Im Prinzip ist die Python-Operation eine Wrapper über isc.py.Main. Die Operation isc.py.ens.Operation ermöglicht die Interaktion mit dem Python-Prozess aus InterSystems IRIS. Fünf Anfragen werden unterstützt:

• isc.py.msg.ExecutionRequest zur Ausführung von Python-Code. Gibt zurück isc.py.msg.ExecutionResponse mit dem Ergebnis der Ausführung und den Werten der angeforderten Variablen.
• isc.py.msg.StreamExecutionRequest zur Ausführung von Python-Code. Gibt zurück isc.py.msg.StreamExecutionResponse das Ergebnis der Ausführung und die Werte der angeforderten Variablen. Entspricht isc.py.msg.ExecutionRequest, nimmt jedoch Streams anstelle von Strings entgegen und zurück.
• isc.py.msg.QueryRequest für die Übertragung des Ergebnisses der Ausführung von SQL-Abfragen. Gibt zurück Ens.Response.
• isc.py.msg.GlobalRequest/isc.py.msg.ClassRequest/isc.py.msg.TableRequest für die Übertragung von globalen/kategorischen/tabellarischen Daten. Gibt zurück Ens.Response.
• isc.py.msg.SaveRequest zum Speichern des Python-Kontextes. Gibt zurück Ens.StringResponse mit der Kontext-ID.

• isc.py.msg.RestoreRequest zum Wiederherstellen des Python-Kontextes.

  Außerdem, isc.py.ens.Operation hat zwei Einstellungen:

  • Initializer — Auswahl der Klasse, die das Interface implementiert isc.py.init.Abstract. Sie kann verwendet werden, um Funktionen, Module, Klassen usw. zu laden. Sie wird einmal beim Start des Prozesses ausgeführt.
  • PythonLib — (nur für Linux) Wenn Sie beim Laden Fehler sehen, setzen Sie den Wert auf libpython3.6m.so oder sogar auf den vollständigen Pfad zur Python-Bibliothek.

Erstellung von Geschäftsprozessen

Es stehen zwei Klassen zur Verfügung, die die Entwicklung von Geschäftsprozessen erleichtern:

• isc.py.ens.ProcessUtils ermöglicht das Extrahieren von Annotationen aus Aktivitäten mit Platzhaltern für Variablen.
• isc.py.util.BPEmulator erleichtert das Testen von Geschäftsprozessen mit Python. Es kann Geschäftsprozesse (Teile in Python) im aktuellen Prozess ausführen.

Variablenersetzung

Alle Geschäftsprozesse, die von isc.py.ens.ProcessUtils, erben, können die Methode GetAnnotation(name) verwenden, um den Wert der Aktivitätsannotation nach ihrem Namen zu erhalten. Die Aktivitätsannotation kann Variablen enthalten, die auf der InterSystems IRIS-Seite berechnet werden, bevor sie an Python übergeben werden. Hier ist die Syntax für Platzhalter von Variablen:

• ${class:method:arg1:...:argN} — Methodenaufruf
• #{expr} — Code in ObjectScript ausführen.

Ein Beispiel findet sich im Testgeschäftsprozess isc.py.test.Process, zum Beispiel in der Aktivität Korrelationsmatrix: Grafik: f.savefig(r'#{process.WorkDirectory}SHOWCASE${%PopulateUtils:Integer:1:100}.png'). In diesem Beispiel:

• #{process.WorkDirectory} gibt das Attribut WorkDirectory des Objekts zurück prozess, welches eine Instanz der Klasse ist isc.py.test.Process , also des aktuellen Geschäftsprozesses.
• ${%PopulateUtils:Integer:1:100} anschauen, können wir sehen, dass das Drücken der Schaltfläche Integer Klasse %PopulateUtils, wobei Argumente übergeben werden 1 und 100, die eine zufällige ganze Zahl im Bereich zurückgeben 1...100.

Testgeschäftsprozess

Testprodukt und Testgeschäftsprozess sind standardmäßig als Teil des Python-Gateways verfügbar. Um sie zu verwenden:

1. Führen Sie im Betriebssystem-Terminal aus: pip install pandas matplotlib seaborn.
2. Führen Sie im InterSystems IRIS-Terminal aus: do ##class(isc.py.test.CannibalizationData).Import() zum Ausfüllen von Testdaten.
3. Führen Sie das Produkt aus isc.py.test.Production.
4. Senden Sie eine Anfrage des Typs Ens.Request in isc.py.test.Process.

Schauen wir uns an, wie alles zusammenarbeitet. Öffnen Sie isc.py.test.Process im BPL-Editor:

Codeausführung

Der wichtigste Aufruf ist die Ausführung von Python-Code:

Es wird die Anfrage verwendet isc.py.msg.ExecutionRequest, hier sind ihre Eigenschaften:

• Code — Python-Code.
• SeparateLines — ob der Code zeilenweise ausgeführt werden soll. $c(10) (n) wird verwendet, um Zeilen zu trennen. Beachten Sie, dass es NICHT empfohlen wird, die Nachricht auf einmal zu verarbeiten; diese Funktion dient nur der Verarbeitung. def und ähnlichen mehrzeiligen Ausdrücken. Standardmäßig 0.
• Variablen ist eine durch Kommas getrennte Liste von Variablen, die in die Antwort eingefügt werden sollen.
• Serialisierung — Wie man die Variablen serialisiert, die wir zurückgeben möchten. Optionen: Str, Repr, JSON, Pickle und Dill, standardmäßig Str.

In unserem Fall setzen wir nur die Eigenschaft Code, sodass alle anderen Eigenschaften Standardwerte verwenden. Wir setzen sie, indem wir process.GetAnnotation("Import pandas"), die zur Laufzeit die Annotation nach dem Ersetzen der Variablen zurückgibt. Am Ende wird der Code import pandas as pd nach Python übergeben. GetAnnotation kann nützlich sein, um mehrzeilige Python-Skripte zu erhalten, aber es gibt keine Einschränkungen für diese Art der Codierung. Sie können die Eigenschaft Code auf jede für Sie bequeme Weise festlegen.

Erhalten von Variablen

Ein weiterer interessanter Aufruf unter Verwendung von isc.py.msg.ExecutionRequest — Korrelationsmatrix: Tabellarisch:

Er berechnet die Korrelationsmatrix auf der Python-Seite und extrahiert die Variable corrmat zurück nach InterSystems IRIS im JSON-Format, indem die Abfrage-Eigenschaften festgelegt werden:

• Variablen: "corrmat"
• Serialisierung: "JSON"

Wir können die Ergebnisse im Visual Trace sehen:

Und wenn wir diesen Wert in BP benötigen, können wir ihn so abrufen: callresponse.Variables.GetAt("corrmat").

Datenübertragung

Als nächstes sprechen wir über die Übertragung von Daten von InterSystems IRIS nach Python. Alle Datenübertragungsanfragen implementieren das Interface isc.py.msg.DataRequest, das die folgenden Eigenschaften bereitstellt:

• Variable — die Python-Variable, in die die Daten geschrieben werden.
• Typ — Typ der Variable: dataframe (pandas dataframe) oder die Umwandlung von numerischen und textuellen Daten in die Formate.
• Namespace — Bereich, aus dem wir Daten erhalten. Das Paket isc.py muss in diesem Bereich verfügbar sein. Dies kann ein Bereich ohne Unterstützung für Produkte sein.

Basierend auf diesem Interface sind 4 Klassenanfragen implementiert:

• isc.py.msg.QueryRequest — setzen Sie die Eigenschaft Abfrage zum Übertragen von SQL-Abfragen.
• isc.py.msg.ClassRequest — setzen Sie die Eigenschaft Klasse zum Übertragen von Klassendaten.
• isc.py.msg.TableRequest — setzen Sie die Eigenschaft Tabelle zum Übertragen von Tabellendaten.
• isc.py.msg.GlobalRequest — setzen Sie die Eigenschaft Global zum Übertragen von Globaldaten.

Sehen Sie sich im Testprozess die Aktivität an RAW