Mit Fast­Score stellt das Unter­neh­men Open Data Group ein Deploy­m­ent­werk­zeug bereit, das die Ent­wick­lung, das Tes­ten, die Pro­duk­tiv­set­zung und Über­wa­chung von Model­len zusam­men bringt und es auf Basis von Micro­ser­vices bereit stellt. Mit Model­len sind in die­sem Kon­text Ana­lyse- und Aus­wer­tungs­ver­fah­ren gemeint, die auf Daten­ströme Anwen­dung fin­den, um dar­aus einen infor­ma­ti­ons­be­zo­ge­nen  Mehr­wert zu gene­rie­ren. Die­ser Auf­baut ist, laut der Open­Da­ta­Group, ein Kon­zept für die Zukunft, in der der Model­lie­rungs­pro­zess per­ma­nen­ten Anpas­sun­gen unter­liegt. Die­ser Anwen­dungs­be­reich wird mehr und mehr an Bedeu­tung gewin­nen. Darum soll der Anpas­sungs­pro­zess am Modell mög­lichst fle­xi­bel gestal­tet wer­den. Beim Deploy­ment­pro­zess soll auf fol­gende Aspekte im Hin­blick auf Sys­tem­auf­bau und Orga­ni­sa­ti­ons­truk­tur Wert gelegt werden:

•  Aut­ark und Skalierbar
•  Überwachung/Monitoring
•  Organisation/Governance/Zuordnung von Zuständigkeiten

Ein­zelne Sys­tem­kom­po­nen­ten sol­len aut­ark und ska­lier­bar sein, d.h. Res­sour­cen sol­len unkom­pli­ziert erwei­tert oder redu­ziert wer­den kön­nen, sowie Aus­fälle oder Stö­run­gen leicht iso­liert und besei­tigt. Dem ent­spre­chend wird die Sys­tem­struk­tur als Micro­ser­vices auf­ge­baut, um der­art mög­lichst große Fle­xi­bi­li­tät und Aus­fall­si­cher­heit sicher zu stellen.

Im Ide­al­fall soll der modu­lare Sys­tem­auf­bau auf die Soft­ware­ebene über­tra­gen wer­den, sodass Imple­men­ta­tio­nen in Ein­hei­ten ent­wi­ckelt wer­den, die sich auf spe­zi­fi­sche Auf­ga­ben- und Sys­tem­be­rei­che beschrän­ken. Als ein wei­ter wich­ti­ger Punkt wird die Über­wa­chung des Ver­ar­bei­tungs­pro­zes­ses gese­hen, um zum Einen die Test­phase effi­zi­ent zu gestall­ten und zum Ande­ren im Pro­duk­tiv­strang Unre­gel­mä­ßig­kei­ten und Stö­run­gen schnell iden­ti­fi­zie­ren zu kön­nen. Nicht zuletzt soll die Zustän­dig­keit und die Orga­ni­sa­ti­ons­struk­tur hin­ter den ein­zel­nen Kom­po­nen­ten trans­pa­rent sein und wohl­de­fi­nier­ten Abläu­fen folgen.

Diese Leit­li­nien und Orga­ni­sa­ti­ons­struk­tur zum Vor­bild neh­mend, ist Fast­Score modu­lar auf­ge­baut und die ein­zel­nen Module ste­hen als (Docker)-Container zur Ver­fü­gung. Wich­tige zu nen­nende Kom­po­nen­ten sind:

•  Engine (core-Instanz)
•  Dash­board (Web-Inter­face)
•  Model-Mana­ger (Ver­wal­tung der Modelle)
•  Com­po­ser (Auf­bau und Steue­rung von Verarbeitungsketten)
•  Deploy (SDK für Jupyther)
•  Access (Benut­zer­ver­wal­tung)
•  Lineage (Meta­da­ten­ver­wal­tung der Prozessabläufen)

Die ein­zel­nen Kom­po­nen­ten sind im Fol­gen­den näher beschrieben:

Eine Engine-Instanz ist die zen­trale Ein­heit, auf der die Ver­ar­bei­tung und Aus­wer­tung des Modells aus­ge­führt wird. Ein Ver­ar­bei­tungs­pro­zess wird jeweils einer Engine-Instanz zuge­teilt. Auf die­sem Weg wer­den die Ver­ar­bei­tungs­pro­zesse von­ein­an­der iso­liert und kön­nen indi­vi­du­ell mit den benö­tig­ten Res­sour­cen aus­ge­stat­tet wer­den. Gene­rell setzt sich ein Ver­ar­bei­tungs­pro­zess aus dem eigent­li­chen Modell, aus zwei Streams und Sche­mata zusam­men. Über die Streams wer­den die Daten­quelle (Ein­gangs­stream) und das Ziel (Aus­gangs­stream) defi­niert. Die Schnitt­stel­len zwi­schen Ein­gangs­stream-Modell und Modell-Aus­gangs­stream wer­den über Sche­mata fest­ge­legt, vgl. Abb. 1.

Die drei Kom­po­nen­ten, Modell, Stream und Schema, wer­den in fast­score als unab­hän­gige Kom­po­nen­ten ange­legt, müs­sen jedoch in einem auf­ge­setz­ten Ver­ar­bei­tungs­pro­zess kon­sis­tent sein. Über die Abkap­se­lung der ein­zel­nen Ver­ar­bei­tungs­pro­zesse kann die Sepa­ra­tion zwi­schen Produktions‑, Test- und Ent­wick­lungs­ein­hei­ten erfol­gen. Dar­über lässt sich der Trans­fer zwi­schen den Ein­hei­ten unkom­pli­ziert gestalten.

Die Dash­board-Instanz stellt eine gra­fi­sche Web­ober­flä­che für die Erstel­lung, Steue­rung und Über­wa­chung von Ver­ar­bei­tungs­pro­zes­sen bereit. Dar­über kann die Zutei­lung der Ver­ar­bei­tungs­pro­zesse zu den Engine-Instan­zen erfol­gen, dazu steht eine Über­sicht über alle Engins bereit. Das Web­in­ter­face bie­tet ebenso die Mög­lich­keit den Quell­code für das Modell und das Schema anzu­pas­sen. Alle Mög­lich­kei­ten, die das Dash­board bie­tet, las­sen sich eben­falls über ein CLI, APIs und SDKs ansteu­ern. Für die Imple­men­tie­rung eines Modells steht eine breite Aus­wahl an gän­gi­gen Pro­gram­mier­spra­chen bereit.

Die Model-Mana­ger-Instanz über­nimmt die Ver­wal­tung und Ver­sio­nie­rung der Ver­ar­bei­tungs­pro­zess­kom­po­nen­ten. Dies kann der­zeit über eine Anbin­dung an eine MySQL Daten­bank, git­hub oder bit­bu­cket erfolgen.

Mit der Com­po­ser-Instanz kön­nen Work­flows erstellt, ver­wal­ten und ein­ge­setzt wer­den. Die Access-Instanz ist eine Basis­be­nut­zer­ver­wal­tung mit Zugriffs­be­schrän­kun­gen. Die Deploy-Instanz ist ein Jupy­ter Note­book Ser­ver mit inte­grier­tem Deploy­ment Tool­kit (SDK). Mit der Lineage-Instanz wer­den die Meta­da­ten zu Ver­ar­bei­tungs­ab­läu­fen bereit­ge­stellt. Diese kön­nen über eine REST API abge­grif­fen werden.

Fazit

Gene­rell ist Fast­Score ein inter­es­san­tes Pro­dukt im Feld von Data­Sci­ence Deploy­ment Platt­for­men. Es hält die selbst gesetz­ten Para­dig­men­vor­ga­ben und ist ohne gro­ßen Auf­wand auf­zu­set­zen und zu ver­wal­ten. Die Res­sour­cen­zu­tei­lung kann kom­plett über Docker gesteu­ert wer­den. Zudem ist es fle­xi­bel in Bezug auf den Ein­satz und Zusam­men­spiel von unter­schied­li­chen Pro­gram­mier­spra­chen. Der­zeit ist Fast­Score ein recht neues Pro­dukt und wird inten­siv wei­ter­ent­wi­ckelt. Dies wird an eini­gen Stel­len über gerin­gen Funk­ti­ons­um­fang und Kon­fi­gu­ra­ti­ons­mög­lich­kei­ten deut­lich. Ande­rer­seits kön­nen, laut Open Data Group Web­seite, eigene Imple­men­tie­rungs­wün­sche an das Fast­Score Ent­wick­ler­team heran getra­gen werden.

Links

• https://www.opendatagroup.com/