Den här artikeln handlar om Python Gateway — ett community-projekt med öppen källkod för InterSystems IRIS dataplattform. Detta projekt möjliggör orkestrering av alla maskininlärningsalgoritmer som skapats i Python (den primära miljön för många datavetare), och att använda ett flertal färdiga bibliotek för att snabbt skapa anpassningsbara, robotiserade analytiska AI/ML-lösningar på InterSystems IRIS-plattformen. I den här artikeln kommer jag att visa hur InterSystems IRIS kan orkestrera processer på Python, effektivt genomföra tvåvägsdataöverföring och skapa intelligenta affärsprocesser.

Plan

1. Introduktion.
2. Verktyg.
3. Installation.
4. API.
5. Interoperabilitet.
6. Jupyter Notebook.
7. Slutsatser.
8. Länkar.
9. MLToolkit.

Introduktion

Python är ett hög-nivå programmeringsspråk för allmänna ändamål som fokuserar på att öka utvecklarens produktivitet och kodens läsbarhet. I denna artikelserie kommer jag att diskutera möjligheterna att använda Python på InterSystems IRIS-plattformen, där huvudfokus för denna artikel är att använda Python för att skapa och tillämpa maskininlärningsmodeller.

Maskininlärning (ML) är en klass av metoder inom artificiell intelligens, vars kännetecken är att de inte löser problem direkt utan lär sig genom att lösa ett antal liknande problem.

Algoritmer och modeller för maskininlärning blir alltmer vanliga. Anledningarna till detta är många, men allt handlar om tillgänglighet, enkelhet och att uppnå praktiska resultat. Är klustring eller till och med neuronär nätverksmodellering en ny teknologi?

Självklart inte, men idag är det inte nödvändigt att skriva hundratusentals rader kod för att köra en modell, och kostnaderna för att skapa och tillämpa modeller blir allt lägre.

Verktygen utvecklas — även om vi inte har helt GUI-orienterade AI/ML-verktyg, så ser vi samma framsteg som vi har sett inom många andra klasser av informationssystem, till exempel BI (från kodskrivning till användning av ramverk och GUI-orienterade konfigurerbara lösningar), även i verktyg för att skapa AI/ML. Vi har redan passerat fasen av att skriva kod och använder idag ramverk för att bygga och träna modeller.

Andra förbättringar, som möjligheten att sprida en förutbildad modell, där slutanvändaren bara måste slutföra träningen av modellen med sina specifika data, underlättar också början av tillämpningen av maskininlärning. Dessa framsteg gör det betydligt lättare att lära sig maskininlärning, både för specialister och för företag som helhet.

Å andra sidan samlar vi in ​​allt mer data. Tack vare en enhetlig dataplattform, såsom InterSystems IRIS, kan all denna information omedelbart förberedas och användas som grunddata för maskininlärningsmodeller.

Med övergången till molnet blir lanseringen av AI/ML-projekt lättare än någonsin. Vi kan använda endast de resurser som vi behöver. Dessutom, tack vare parallelliseringen som erbjuds av molnplattformar, kan vi spara tid.

Men hur är det med resultaten? Här blir allt mer komplicerat. Det finns många verktyg för att bygga modeller, vilket jag kommer att gå in på senare. Att bygga en bra modell är inte enkelt, men vad händer sen? Att få företagets verksamhet att dra nytta av modellen är också en utmanande uppgift. Kärnan i problemet ligger i att separera analytiska och transaktionella belastningar, samt datamodeller. När vi tränar en modell gör vi det vanligtvis på historiska data. Men platsen för den byggda modellen är i den transaktionella databehandlingen. Vad är poängen med den bästa modellen för att upptäcka bedrägliga transaktioner, om vi bara kör den en gång om dagen? Bedragarna har redan försvunnit med pengarna. Vi behöver träna modellen på historiska data, men vi måste också tillämpa den i realtid på de nya inkommande data så att våra affärsprocesser kan agera i enlighet med de förutsägelser som modellen gör.

ML Toolkit är en uppsättning verktyg vars syfte är just detta: att förena modeller och transaktionsmiljöer så att byggda modeller enkelt kan användas direkt i dina affärsprocesser. Python Gateway är en del av ML Toolkit och möjliggör integration med Python-språket (på samma sätt som R Gateway, som är en del av ML Toolkit, möjliggör integration med R-språket).

Verktygslåda

Innan vi fortsätter, skulle jag vilja beskriva några verktyg och bibliotek för Python som vi kommer att använda senare.

Teknologier

• Python är ett tolkat, hög-nivå programmeringsspråk för allmän användning. Den främsta fördelen med språket är det stora biblioteket av matematiska, ML- och AI-bibliotek. Precis som ObjectScript är det ett objektorienterat språk, men allt definieras dynamiskt snarare än statiskt. Dessutom är allt ett objekt. Senare artiklar förutsätter ett flyktigt bekantskap med språket. Om du vill börja lära dig rekommenderar jag att du börjar med dokumentationen.
• För våra kommande övningar, installera Python 3.6.7 64 bit.
• IDE: Jag använder PyCharm, men det finns också män. Om du använder Atelier finns det en Eclipse-plugin för Python-utvecklare. Om du använder VS Code, finns det en extension för Python.
• Notebook: istället för en IDE kan du skriva och dela dina skript i online-notebooks. Den mest populära är Jupyter.

Bibliotek

Här är en (ofullständig) lista över bibliotek för maskininlärning:

• Numpy — det grundläggande paketet för exakta beräkningar.
• Pandas — högpresterande datatyper och verktyg för dataanalys.
• Matplotlib — skapande av grafer.
• Seaborn — datavisualisering baserat på matplotlib.
• Sklearn — maskininlärningsmetoder.
• XGBoost — maskininlärningsalgoritmer inom ramen för metodologin för gradientboosting.
• Gensim — NLP.
• Keras — neurala nätverk.
• Tensorflow — en plattform för att bygga maskininlärningsmodeller.
• PyTorch — en plattform för att bygga maskininlärningsmodeller med fokus på Python.
• Nyoka — PMML från olika modeller.

AI/ML-teknologier möjliggör att företag blir mer effektiva och anpassningsbara. Dessutom blir dessa teknologier idag enklare att utveckla och implementera. Börja studera AI/ML-teknologier och hur de kan hjälpa din organisation att växa.

Installation

Det finns flera sätt att installera och använda Python Gateway:

• OS
  • Windows
  • Linux
  • Mac
• Docker
  • Använd en bild från DockerHub
  • Skapa din egen bild

Oavsett installationsmetod kommer du att behöva källkoden. Den enda platsen för att ladda ner koden är versionssidan. Den innehåller testade stabila utgåvor, ta bara den senaste. Just nu är det 0.8, men fler kommer med tiden. Klona inte/ladda inte ner repository, ladda ner bara den senaste utgåvan.

OS

När du installerar Python Gateway på ett operativsystem måste du först (oavsett operativsystem) installera Python. För att göra detta:

1. Installera Python 3.6.7 64 bit. Det rekommenderas att installera Python i standardkatalogen.
2. Installera modulen dill: pip install dill.
3. Ladda ner ObjectScript-koden (dvs. do $system.OBJ.ImportDir("C:InterSystemsReposPythoniscpy", "*.cls", "c",,1)) till valfritt namnutrymme med produkter. Om du vill att ett befintligt namnutrymme ska stödja produkter, kör: write ##class(%EnsembleMgr).EnableNamespace($Namespace, 1).
4. Placera callout DLL/SO/DYLIB till mappen bin din instans av InterSystems IRIS. Biblioteksfilen måste vara tillgänglig på en väg som återges av write ##class(isc.py.Callout).GetLib().

Windows

1. Se till att miljövariabeln PYTHONHOME pekar på Python 3.6.7.
2. Kontrollera att systemets miljövariabler PATH innehåller variabeln PYTHONHOME (eller katalogen som den pekar på).

Linux (Debian/Ubuntu)

1. Kontrollera att miljövariabeln PATH innehåller /usr/lib och /usr/lib/x86_64-linux-gnu. Använd filen /etc/environment för att ställa in miljövariabler.
2. Vid fel undefined symbol: _Py_TrueStruct ställ in inställningen PythonLib. Det finns också en Readme som har en avsnitt om felsökning.

Mac

1. För närvarande stöds bara Python 3.6.7 från Python.org. Kontrollera variabeln PATH.

Om du har ändrat miljövariabler, starta om din InterSystems-produkt.

Docker

Användning av containrar har flera fördelar:

• Portabilitet
• Effektivitet
• Isolering
• Lättviktighet
• Immutabilitet

Läs denna serie artiklar för mer information om att använda Docker med InterSystems-produkter.

Alla versioner av Python Gateway är för närvarande baserade på containrar. 2019.4.

Färdig bild

Kör: docker run -d -p 52773:52773 --name irispy intersystemscommunity/irispy-community:latest, för att ladda ner och köra Python Gateway med InterSystems IRIS Community Edition. Det är allt.

Skapa din egen bild

För att bygga dockerbilden kör du i rotkatalogen för repositoriet: docker build --force-rm --tag intersystemscommunity/irispy:latest ..
Standardbilden byggs baserat på bilden store/intersystems/iris-community:2019.4.0.383.0, men du kan ändra detta genom att ställa in variabeln IMAGE.
För att bygga från InterSystems IRIS kör: `docker build —build-arg IMAGE=store/intersystems/iris:2019.4.0.383.0 —force-rm —tag intersystemscommunity/irispy:latest`.

Efter detta kan du köra dockerbilden:

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

Om du använder en bild baserad på InterSystems IRIS Community Edition, behöver du inte ange nyckeln.

Kommentarer

• Testprocessen isc.py.test.Process sparar en rad bilder i en temporär katalog. Du kan vilja ändra denna sökväg till en monterad katalog. För att göra detta, redigera inställningen WorkingDir genom att ange den monterade katalogen.
• För att få tillgång till terminalen, kör: docker exec -it irispy sh.
• Åtkomst till System Management Portal med inloggning SuperUser/SYS.
• För att stoppa containern, kör: docker stop irispy && docker rm --force irispy.

Verifiera installationen

Efter att du har installerat Python Gateway, bör du kontrollera att den fungerar. Kör denna kod i terminalen för InterSystems IRIS:

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

Det bör resultera i HELLO — värdet på Python-variabeln x. Om den returnerade statusen sc är ett fel eller var tom, kontrollera Readme — avsnitt för felsökning.

API

Python Gateway är installerad och du har verifierat att den fungerar. Dags att börja använda den!
Huvudgränssnittet för Python är isc.py.Main. Det erbjuder följande grupper av metoder (alla returnerar %Status):

• Körning av kod
• Datatransmission
• Hjälpmetoder

Körning av kod

Dessa metoder möjliggör körning av godtycklig Python-kod.

SimpleString

SimpleString — är den primära metoden. Den tar 4 valfria argument:

• code — kodsträng att köra. Radbrytning: $c(10).
• returnVariable — namnet på variabeln som ska returneras.
• serialization — hur du ska seriellisera returnVariable. 0 — string (standard), 1 — repr.
• result — ByRef-referens till variabeln där värdet skrivs. returnVariable.

Ovanför har vi kört:

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

I detta exempel tilldelar vi en Python-variabel x värdet Hej och vill returnera värdet på Python-variabeln x till en ObjectScript-variabel var.

ExecuteCode

ExecuteCode är ett mer säkert och mindre begränsat alternativ SimpleString.
Strängar på InterSystems IRIS-plattformen är begränsade till 3 641 144 tecken, och om du vill köra en längre kodsnutt, måste du använda flöden.
Tar två argument:

• code — sträng eller flöde av Python-kod att köra.
• variable — (valfritt) tilldelar resultatet av körningen code denna Python-variabel.

Exempel att använda:

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

I detta exempel multiplicerar vi 2 med 3 och lagrar resultatet i en Python-variabel y.

Datatransmission

Skicka data till Python och tillbaka.

Python -> InterSystems IRIS

Det finns 4 sätt att få värdet på en Python-variabel i InterSystems IRIS, beroende på vilken serialisering du behöver:

• Sträng för enkla datatyper och felsökning.
• Repr för att lagra enkla objekt och för felsökning.
• JSON för att enkelt manipulera data på InterSystems IRIS-sidan.
• Pickle för att spara objekt.

Dessa metoder gör det möjligt att hämta variabler från Python som strängar eller flöden.

• GetVariable(variable, serialization, .stream, useString) — hämta serialization variabeln variable på stream. Om useString är 1 och serialisering placeras i en sträng, så returneras en sträng istället för ett flöde.
• GetVariableJson(variable, .stream, useString) — hämta JSON-serialisering av variabeln.
• GetVariablePickle(variable, .stream, useString, useDill) — hämta Pickle (eller Dill) serialisering av variabeln.

Vi ska försöka hämta vår variabel y.

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

InterSystems IRIS -> Python

Vi laddar data från InterSystems IRIS till Python.

• ExecuteQuery(query, variable, type, namespace) — skapar en dataset (pandas dataframe eller list) från SQL-förfrågan och sätter den i Python-variabeln variable. Paketet isc.py måste vara tillgängligt i området namnrymd — där frågan kommer att utföras.
• ExecuteGlobal(global, variable, type, start, end, mask, labels, namespace) — laddar data från globalen global från subscriptet start till end till Python som en variabel av typen typ: list, eller pandas dataframe. Beskrivning av valfria argument mask och labels finns i dokumentationen för klassen och i förvaret Data Transfer docs.
• ExecuteClass(class, variable, type, start, end, properties, namespace) — laddar klassdata klass från id start till end till Python som en variabel av typen typ: list, eller pandas dataframe. properties — lista (separator — kommatecken) av klassens egenskaper som ska laddas in i datasetet. Masker stöds * och ?. Som standard — * (alla egenskaper). Egenskapen %%CLASSNAME är inställd.
• ExecuteTable(table, variable, type, start, end, properties, namespace) — laddar tabelldata tabell från id start till end in i Python.

ExecuteQuery — är universell (vilken som helst korrekt SQL-förfrågan kommer att skickas till Python). Men, ExecuteGlobal och dess omslag ExecuteClass och ExecuteTable har vissa begränsningar. De är mycket snabbare (3-5 gånger snabbare än ODBC-drivrutinen och 20 gånger snabbare ExecuteQuery). Ytterligare information finns i Data Transfer docs.
Alla dessa metoder stöder datatransfer från vilket område som helst. Paketet isc.py måste vara tillgängligt i målområdet.

ExecuteQuery

ExecuteQuery(request, variable, type, namespace) — överför resultat av vilken korrekt SQL-förfrågan till Python. Detta är den långsammaste metoden för datatransfer. Använd den om ExecuteGlobal och dess omslag inte är tillgängliga.

Argument:

• query — SQL-förfrågan.
• variable — namnet på Python-variabeln där data sparas.
• typ — list eller Pandas dataframe.
• namnrymd — området där frågan kommer att utföras.

ExecuteGlobal

ExecuteGlobal(global, variable, type, start, end, mask, labels, namespace) — överför globalen till Python.

Argument:

• global — namnet på globalen utan ^
• variable — namnet på Python-variabeln där data sparas.
• typ — list eller Pandas dataframe.
• start — första subscriptet av globalen. Obligatoriskt %Integer.
• end — sista subscriptet av globalen. Obligatoriskt %Integer.
• mask — mask av globala värden. Masken kan vara kortare än antalet fält i globalen (i så fall kommer fälten i slutet att ignoreras). Så här formaterar du masken:
  • + skicka värdet som det är.
  • - hoppa över värdet.
  • b — Logisk typ (0 — Falskt, allt annat — Sant).
  • d — Datum (från $horolog, på Windows från 1970, på Linux från 1900).
  • t — Tid ($horolog, sekunder efter midnatt).
  • m — Tidsstämpel (sträng i formatet ÅR-MÅNAD-DAG TIMME:MINUT:SEKUND).
• labels — %List över kolumnnamn. Första elementet — namnet på subscriptet.
• namnrymd — området där frågan kommer att utföras.

ExecuteClass

Inpackning över ExecuteGlobal. Baserat på klassdefinitionen förbereder den ett anrop ExecuteGlobal och anropar det.

ExecuteClass(class, variable, type, start, end, properties, namespace) — överföring av klassdata i Python.

Argument:

• klass — klassnamn
• variable — namnet på Python-variabeln där data sparas.
• typ — list eller Pandas dataframe.
• start — start Id.
• end — slut Id
• properties — lista (separator — kommatecken) av klassens egenskaper som ska laddas in i datasetet. Masker stöds * och ?. Som standard — * (alla egenskaper). Egenskapen %%CLASSNAME är inställd.
• namnrymd — området där frågan kommer att utföras.

Alla egenskaper överförs som de är utom typ-egenskaperna te, %Time, %Boolean och %TimeStamp — de konverteras till motsvarande Python-klasser.

ExecuteTable

Inpackning över ExecuteClass. Översätter tabellnamnet till klassnamn och anropar ExecuteClass. Signatur:

ExecuteTable(table, variable, type, start, end, properties, namespace) — överföring av tabelldata till Python.

Argument:

• tabell — tabellnamn.
  Alla andra argument överförs som de är till ExecuteClass.

Anteckningar

• ExecuteGlobal, ExecuteClass och ExecuteTable arbetar lika snabbt.
• ExecuteGlobal 20 gånger snabbare än ExecuteQuery på stora datamängder (överföringstid mer än >0.01 sekunder).
• ExecuteGlobal, ExecuteClass och ExecuteTable fungerar på globaler med denna struktur: ^global(key) = $lb(prop1, prop2, ..., propN) w key — heltal.
• För ExecuteGlobal, ExecuteClass och ExecuteTable stödd värdeområde te motsvarar intervallet mktime och beror på operativsystemet (windows: 1970-01-01, linux 1900-01-01, mac). Använd %TimeStampför att överföra data utanför detta intervall eller använd pandas dataframe eftersom detta begränsning endast gäller listan.
• För ExecuteGlobal, ExecuteClass och ExecuteTable alla argument utom datakällan (global, klass eller tabell) och variabeln är valfria.

Exempel

Testklass isc.py.test.Person innehåller en metod som visar alla alternativ för datöverföring:

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"

// Allmänna argument
set variable = "df"
set type = "dataframe"
set start = 1
set end = $g(^isc.py.test.PersonD, start)

// Metod 0: ExecuteGlobal utan argument
set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 0, type)

// Metod 1: ExecuteGlobal med argument
// Vid överföring av globalen anges fältnamn för hand
// globalKey - namnet på subskriptet
set labels = $lb("globalKey", "Namn", "Födelsedatum", "TS", "Slumptid", "År", "Decimaltal", "Dubbel", "Bool")

// mask innehåller ett element mindre än labels eftersom "globalKey" är namnet på subskripten
// Vi hoppar över %%CLASSNAME
set mask = "-+dmt+++b"

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

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

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

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

Anropa metoden do ##class(isc.py.test.Person).Test() för att se hur alla metoder för datatransfer fungerar.

Hjälpmetoder

• GetVariableInfo(variable, serialization, .defined, .type, .length) — hämta information om variabeln: om den är definierad, klass och längd av serialiseringen.
• GetVariableDefined(variable, .defined) — är variabeln definierad.
• GetVariableType(variable, .type) — hämta klass för variabeln.
• GetStatus() — hämta och ta bort det senaste undantaget på Python-sidan.
• GetModuleInfo(module, .imported, .alias) — hämta modulens variabel och importstatus.
• GetFunctionInfo(function, .defined, .type, .docs, .signature, .arguments) — hämta information om funktionen.

Interoperabilitet

Du har lärt dig att anropa Python Gateway från terminalen, nu börjar vi använda den i produktion. Grunden för interaktionen med Python i detta läge — isc.py.ens.Operation. Den gör det möjligt för oss att:

• Köra Python-kod
• Spara/återställa Python-kontext
• Ladda och hämta data från Python

I princip är Python-operation en inslagning av isc.py.Main. Operationen isc.py.ens.Operation ger möjlighet att interagera med Python-processen från InterSystems IRIS-produkterna. Fem typer av förfrågningar stöds:

• isc.py.msg.ExecutionRequest för att köra Python-kod. Returnerar isc.py.msg.ExecutionResponse med resultatet av körningen och värden för begärda variabler.
• isc.py.msg.StreamExecutionRequest för att köra Python-kod. Returnerar isc.py.msg.StreamExecutionResponse resultatet av körningen och värden för begärda variabler. Motsvarande isc.py.msg.ExecutionRequest, men tar emot och returnerar strömmar istället för strängar.
• isc.py.msg.QueryRequest för att överföra resultatet av SQL-frågan. Returnerar Ens.Response.
• isc.py.msg.GlobalRequest/isc.py.msg.ClassRequest/isc.py.msg.TableRequest för datatransfer av global/kategori/tabell. Returnerar Ens.Response.
• isc.py.msg.SaveRequest för att spara Python-kontext. Returnerar Ens.StringResponse med kontextidentifierare.

• isc.py.msg.RestoreRequest för att återställa Python-kontext.

  Dessutom, isc.py.ens.Operation har två inställningar:

  • Initializer — val av klass som implementerar gränssnittet isc.py.init.Abstract. Den kan användas för att ladda funktioner, moduler, klasser etc. Den körs en gång vid processens start.
  • PythonLib — (endast för Linux) om du ser fel vid laddning, ställ in dess värde till libpython3.6m.so eller till och med till den fullständiga sökvägen till Python-biblioteket.

Skapande av affärsprocesser

Det finns två klasser som underlättar utvecklingen av affärsprocesser:

• isc.py.ens.ProcessUtils möjliggör att extrahera annoteringar från aktiviteter med variabelinsättning.
• isc.py.util.BPEmulator gjör att enkelt testa affärsprocesser med Python. Den kan utföra affärsprocesser (delar på Python-språk) i den aktuella processen.

Variabelersättning

Alla affärsprocesser som ärver från isc.py.ens.ProcessUtils, kan använda metoden GetAnnotation(name) för att hämta värdet av aktivitetens annotering baserat på dess namn. Aktivitetens annotering kan innehålla variabler som kommer beräknas på sidan av InterSystems IRIS innan de skickas till Python. Här är syntaxen för variabelinsättning:

• ${class:method:arg1:...:argN} — anrop till metoden
• #{expr} — exekvera kod i ObjectScript.

Ett exempel finns i den testade affärsprocessen isc.py.test.Process, t.ex. i aktiviteten Korrelationsmatris: Graf: f.savefig(r'#{process.WorkDirectory}SHOWCASE${%PopulateUtils:Integer:1:100}.png'). I detta exempel:

• #{process.WorkDirectory} returnerar egenskapen WorkDirectory från objektet process, som är en instans av klassen isc.py.test.Process dvs. den aktuella affärsprocessen.
• ${%PopulateUtils:Integer:1:100} anropar metoden Heltal klassen %PopulateUtils, genom att skicka argument 1 och 100, som returnerar ett slumpmässigt heltal inom spannet 1...100.

Testaffärsprocess

Testprodukt och testaffärsprocess är som standard tillgängliga som en del av Python Gateway. För att använda dem:

1. Kör följande i OS-terminalen: pip install pandas matplotlib seaborn.
2. Kör följande i InterSystems IRIS-terminalen: do ##class(isc.py.test.CannibalizationData).Import() för att fylla i testdata.
3. Kör produkten isc.py.test.Production.
4. Skicka en begäran av typen Ens.Request på isc.py.test.Process.

Låt oss se hur allt fungerar tillsammans. Öppna isc.py.test.Process i BPL-redigeraren:

Körning av kod

Det viktigaste anropet är att exekvera Python-kod:

Används begäran isc.py.msg.ExecutionRequest, här är dess egenskaper:

• Code — Python-kod.
• SeparateLines — ska koden delas upp i rader för exekvering. $c(10) (n) används för att separera rader. Observera att det INTE rekommenderas att bearbeta meddelandet helt på en gång, denna funktion är avsedd endast för behandling def och liknande fler-rads uttryck. Som standard 0.
• Variabler — en kommaseparerad lista av variabler som kommer att läggas till svaret.
• Serialisering — Hur man serialiserar variabler som vi vill returnera. Alternativ: Str, Repr, JSON, Pickle och Dill, som standard Str.

I vårt fall ställer vi bara in egenskapen Code, så alla andra egenskaper använder standardvärden. Vi ställer in den genom att anropa process.GetAnnotation("Import pandas"), vilket under körning returnerar annotationen efter att ha utfört variabelsubstitution. I slutändan kommer koden import pandas as pd att överföras till Python. GetAnnotation kan vara användbart för att få fler-rads Python-skript, men det finns inga begränsningar för detta sätt att hämta kod. Du kan ställa in egenskapen Code på ett sätt som passar dig.

Hämtning av variabler

Ännu en intressant utmaning med användning av isc.py.msg.ExecutionRequest — Korrelationsmatris: Tabellarisk:

Den beräknar Korrelationsmatrisen på Python-sidan och hämtar variabeln corrmat tillbaka till InterSystems IRIS i JSON-format, genom att ställa in frågeegenskaperna:

• Variabler: "corrmat"
• Serialisering: "JSON"

Vi kan se resultaten i Visual Trace:

Och om vi behöver det här värdet i BP kan det hämtas så här: callresponse.Variables.GetAt("corrmat").

Datatransmission

Nu ska vi prata om att överföra data från InterSystems IRIS till Python, alla datatransferfrågor implementerar gränssnittet isc.py.msg.DataRequest, som tillhandahåller följande egenskaper:

• Variabel — Python-variabeln i vilken data skrivs.
• Type — datatypes: dataframe (pandas dataframe) eller list.
• Namespace — området från vilket vi hämtar data. Paketet isc.py måste vara tillgängligt i detta område. Det kan vara ett område utan produktstöd.

Baserat på detta gränssnitt har 4 klasser av frågor implementerats:

• isc.py.msg.QueryRequest — ställ in egenskapen Query för att överföra SQL-frågan.
• isc.py.msg.ClassRequest — ställ in egenskapen Klass för att överföra klassdata.
• isc.py.msg.TableRequest — ställ in egenskapen Tabell för att överföra tabelldata.
• isc.py.msg.GlobalRequest — ställ in egenskapen Global för att överföra globala data.

Under testprocessen, titta på aktiviteten RAW, där isc.py.msg.QueryRequest visad i aktion.

Spara/Återställ Python-kontext

Slutligen kan vi spara Python-kontexten i InterSystems IRIS, för att göra detta skickar vi isc.py.msg.SaveRequest med argument:

• Mask — Endast variabler som uppfyller masken sparas. Stöder * och ?. Exempel: "Data*, Figure?". Som standard *.
• MaxLength — Maximal längd för den lagrade variabeln. Om serialiseringen av variabeln är längre, kommer den att ignoreras. Ställ in 0 för att tillåta variabler av valfri längd. Standardinställning: $$$MaxStringLength.
• Namn — Kontextnamn (valfritt).
• Beskrivning — Kontextbeskrivning (valfritt).

Returnerar Ens.StringResponse med Id av den sparade kontexten. Under testprocessen, titta på aktiviteten Spara kontext.

Relaterad begäran isc.py.msg.RestoreRequest laddar kontext från InterSystems IRIS i Python:

• ContextId — kontextidentifierare.
• Rensa — rensa kontexten innan återställning.

Jupyter Notebook

Jupyter Notebook — detta är en öppen källkodswebbapplikation som gör det möjligt att skapa notebookar som innehåller kod, visualiseringar och text och publicera dem. Python Gateway gör det möjligt att visa och redigera BPL-processer i form av Jupyter Notebook. Observera att en vanlig Python 3-executor för närvarande används.

Detta tillägg förutsätter att kommentarerna innehåller Python-kod och använder aktiviteters namn som föregående rubriker. Nu är det möjligt att utveckla PythonGateway affärsprocesser i Jupyter Notebook. Här är vad som är möjligt:

• Skapa nya affärsprocesser
• Ta bort affärsprocesser
• Skapa nya aktiviteter
• Ändra aktiviteter
• Ta bort aktiviteter

Här är demo-video. Och några skärmdumpar:

Processutforskare

Processredigerare

Installation

1. Du behöver InterSystems IRIS 2019.2+.
2. Installera PythonGateway v0.8+ (krävs endast isc.py.util.Jupyter, isc.py.util.JupyterCheckpoints och isc.py.ens.ProcessUtils).
3. Uppdatera ObjectScript-koden från lagret.
4. Kör do ##class(isc.py.util.Jupyter).Install() och följ anvisningarna.

Dokumentation.

Slutsatser

MLToolkit är en uppsättning verktyg vars syfte är att förena modeller och transaktionella miljöer så att de byggda modellerna enkelt kan användas direkt i dina affärsprocesser. Python Gateway är en del av MLToolkit och tillhandahåller integration med Python-språket, vilket möjliggör orkestrering av vilken maskininlärningsalgoritm som helst, skapad på Python (huvudmiljön för många datavetare), med hjälp av många färdiga bibliotek för snabb utveckling av adaptiva, automatiserade analytiska AI/ML-lösningar på InterSystems IRIS-plattformen.

Länkar

• Föregående artikel
• Python Gateway
• Python Gateway-exempel
• Convergent-Analytics
• Python 3.6.7 64 bit
• Dokumentation och kurser om Python

MLToolkit

MLToolkit-användargruppen är ett privat GitHub-repo, skapat som en del av företags-GitHub-organisationen InterSystems. Den är avsedd för externa användare som installerar, utforskar eller redan använder komponenter från MLToolkit, inklusive Python Gateway. Gruppen erbjuder en mängd implementerade fallstudier (med källkod och testdata) inom områden som marknadsföring, produktion, medicin och många andra industrier. För att gå med i ML Toolkit-användargruppen, vänligen skicka ett kort meddelande via e-post till följande adress: MLToolkit@intersystems.com och ange följande uppgifter i ditt meddelande:

• GitHub-användarnamn
• Organisation (där du arbetar eller studerar)
• Befattning (din faktiska titel inom din organisation, eller "Student", eller "Frilans").
• Land

Till dem som har läst artikeln och är intresserade av möjligheterna med InterSystems IRIS som en plattform för utveckling eller hosting av AI- och maskininlärningslösningar erbjuder vi att diskutera möjliga scenarier av intresse för ert företag. Vi ser fram emot att analysera ert företags behov och tillsammans definiera en handlingsplan; kontaktadressen till vår AI/ML-expertgrupp är MLToolkit@intersystems.com.

Källa: habr.com