🥇 Industriell Maschinn Léieren: 10 Prinzipien vun der Entwécklung

Industriell Maschinn Léieren: 10 Design Prinzipien

Hautdesdaags ginn all Dag nei Servicer, Applikatiounen an aner wichteg Programmer erstallt, déi et méiglech maachen onheemlech Saachen ze kreéieren: vu Software fir eng SpaceX Rakéit ze kontrolléieren bis zum Interaktioun mat engem Kettel am nächste Raum iwwer e Smartphone.

An, heiansdo, all Ufänger Programméierer, egal ob hien e passionéierte Startupper ass oder e gewéinleche Full Stack oder Data Scientist, fréier oder spéider kënnt zu der Erkenntnis datt et bestëmmte Reegele gëtt fir ze programméieren a Software ze kreéieren déi d'Liewen immens vereinfachen.

An dësem Artikel wäert ech kuerz beschreiwen 10 Prinzipien vun wéi industriell Maschinn Léieren programméiere sou datt et einfach an eng Applikatioun / Service integréiert ka ginn, baséiert op der 12-Faktor App Methodik. proposéiert vum Heroku Team. Meng Initiativ ass d'Sensibiliséierung vun dëser Technik ze erhéijen, wat vill Entwéckler an Datenwëssenschaftsleit hëllefe kann.

Dësen Artikel ass e Prolog zu enger Serie vun Artikelen iwwer industriell Machine Learning. An hinnen wäert ech weider schwätzen iwwer wéi een eigentlech e Modell mécht an en an d'Produktioun lancéiert, eng API dofir erstellt, souwéi Beispiller vu verschiddene Beräicher a Firmen, déi ML an hire Systemer agebaut hunn.

Prinzip 1: Ee Code Basis

E puer Programméierer an den éischten Etappen, aus Faulegkeet fir et erauszefannen (oder aus iergendengem Grond vun hiren eegene), vergiessen Git. Entweder vergiessen se d'Wuert ganz, dat heescht, si geheien Dateien uneneen an den Drive / werfen einfach Text / schécken vun Dauwen, oder se denken net duerch hiren Workflow, a verpflichte jidderee fir seng eegen Branche, an dann op d' Meeschtesch.

Dëse Prinzip seet: hunn eng Codebase a vill Détachementer.

Git ka souwuel an der Produktioun wéi an der Fuerschung an der Entwécklung (R&D) benotzt ginn, an där et net sou dacks benotzt gëtt.

Zum Beispill, an der R&D Phase kënnt Dir Verpflichtungen mat verschiddenen Dateveraarbechtungsmethoden a Modeller hannerloossen, fir dann déi bescht auszewielen an einfach weider domat weider ze schaffen.

Zweetens, an der Produktioun ass dëst eng irreplaceable Saach - Dir musst dauernd kucken wéi Äre Code ännert a wësse wéi ee Modell déi bescht Resultater produzéiert huet, wéi ee Code um Enn geschafft huet a wat geschitt ass, wat dozou bruecht huet datt et ophalen ze schaffen oder falsch Resultater ze produzéieren. . Dat ass wat Verpflichtungen sinn fir!

Dir kënnt och e Package vun Ärem Projet erstellen, en zum Beispill op Gemfury setzen, an dann einfach Funktiounen dovunner fir aner Projeten importéieren, fir se net 1000 Mol ëmzeschreiwen, awer méi spéit méi doriwwer.

Prinzip 2: Ofhängegkeeten kloer deklaréieren an isoléieren

All Projet huet verschidde Bibliothéiken déi Dir vu baussen importéiert fir se iergendwou anzesetzen. Egal ob et Python Bibliothéike sinn, oder Bibliothéike vun anere Sprooche fir verschidden Zwecker, oder System Tools - Är Aufgab ass:

Kloer Ofhängegkeeten erklären, dat heescht, e Fichier deen all d'Bibliothéiken, Tools an hir Versiounen enthält, déi an Ärem Projet benotzt ginn an déi installéiert musse ginn (zum Beispill am Python kann dëst mat Pipfile oder requirements.txt gemaach ginn. A Link deen et erlaabt gutt ze verstoen: realpython.com/pipenv-guide)
Isoléiert Ofhängegkeete speziell fir Äre Programm wärend der Entwécklung. Dir wëllt net permanent Versiounen änneren an nei installéieren, zum Beispill, Tensorflow?

Op dës Manéier kënnen d'Entwéckler, déi an Zukunft mat Ärem Team bäitrieden, séier mat de Bibliothéiken an hir Versioune vertraut ginn, déi an Ärem Projet benotzt ginn, an Dir wäert och d'Méiglechkeet hunn d'Versioune a Bibliothéike selwer ze verwalten, déi fir eng spezifesch installéiert sinn. Projet, deen Iech hëlleft Inkompatibilitéit vu Bibliothéiken oder hir Versiounen ze vermeiden.

Är Applikatioun soll och net op System Tools vertrauen, déi op engem spezifeschen OS installéiert kënne ginn. Dës Tools mussen och an den Ofhängegkeetsmanifest deklaréiert ginn. Dëst ass néideg fir Situatiounen ze vermeiden wou d'Versioun vun den Tools (wéi och hir Disponibilitéit) net mat de System Tools vun engem bestëmmten OS entsprécht.

Also, och wann Curl op bal all Computer benotzt ka ginn, sollt Dir et ëmmer nach an Ofhängegkeeten deklaréieren, well wann Dir op eng aner Plattform migréiert, ass et vläicht net do oder d'Versioun ass net déi, déi Dir ursprénglech gebraucht hutt.

Zum Beispill, Äre requirements.txt kéint esou ausgesinn:

# Model Building Requirements
numpy>=1.18.1,<1.19.0
pandas>=0.25.3,<0.26.0
scikit-learn>=0.22.1,<0.23.0
joblib>=0.14.1,<0.15.0

# testing requirements
pytest>=5.3.2,<6.0.0

# packaging
setuptools>=41.4.0,<42.0.0
wheel>=0.33.6,<0.34.0

# fetching datasets
kaggle>=1.5.6,<1.6.0

Prinzip 3: Konfiguratiounen

Vill hunn d'Geschichte vu verschiddenen Entwéckler héieren, déi zoufälleg Code op GitHub an ëffentleche Repositories mat Passwierder an aner Schlësselen vun AWS eropluede, den nächsten Dag erwächen mat enger Schold vu $6000, oder souguer $50000.

Natierlech sinn dës Fäll extrem, awer ganz bedeitend. Wann Dir Är Umeldungsinformatiounen oder aner Donnéeën, déi fir d'Konfiguratioun am Code néideg sinn, späichert, maacht Dir e Feeler, an ech mengen et ass net néideg ze erklären firwat.

Eng Alternativ zu dësem ass Konfiguratiounen an Ëmfeldvariablen ze späicheren. Dir kënnt méi iwwer Ëmweltvariablen liesen hei.

Beispiller vun Daten déi typesch an Ëmfeldvariablen gespäichert ginn:

Domain Nimm
API URLen/URIs
Ëffentlech a privat Schlësselen
Kontakter (Mail, Telefon, etc.)

Op dës Manéier musst Dir de Code net konstant änneren wann Är Konfiguratiounsvariablen änneren. Dëst hëlleft Iech Zäit, Effort a Suen ze spueren.

Zum Beispill, wann Dir de Kaggle API benotzt fir Tester auszeféieren (zum Beispill d'Software eroflueden an de Modell duerch et lafen fir ze testen wann Dir leeft datt de Modell gutt funktionnéiert), da sollten privat Schlësselen vu Kaggle, wéi KAGGLE_USERNAME a KAGGLE_KEY, sinn an Ëmweltvariablen gespäichert.

Prinzip 4: Drëtt Partei Services

D'Iddi hei ass de Programm esou ze kreéieren datt et keen Ënnerscheed tëscht lokalen an Drëtt-Partei Ressourcen a punkto Code ass. Zum Beispill kënnt Dir souwuel lokal MySQL an Drëtt Partei verbannen. Datselwecht gëlt fir verschidde APIen wéi Google Maps oder Twitter API.

Fir en Drëtt Partei Service auszeschalten oder en aneren ze verbannen, musst Dir just d'Schlësselen an der Konfiguratioun an den Ëmfeldvariablen änneren, iwwer déi ech am Paragraph hei uewen geschwat hunn.

Also, zum Beispill, amplaz de Wee fir Dateien mat Datesätz am Code all Kéier ze spezifizéieren, ass et besser d'pathlib Bibliothéik ze benotzen an de Wee zu den Datesets an config.py ze deklaréieren, sou datt egal wéi ee Service Dir benotzt (fir zum Beispill CircleCI), konnt de Programm de Wee fir d'Datesätz erausfannen, andeems d'Struktur vum neie Dateiesystem am neie Service berücksichtegt gëtt.

Prinzip 5. Bauen, Fräisetzung, Runtime

Vill Leit an Data Science fannen et nëtzlech fir hir Software Schreiffäegkeeten ze verbesseren. Wa mir wëllen datt eise Programm sou selten wéi méiglech crasht an esou laang wéi méiglech ouni Feeler funktionnéiert, musse mir de Prozess vun der Verëffentlechung vun enger neier Versioun an 3 Etappen opdeelen:

Bühn Versammlungen. Dir transforméiert Äre bloe Code mat individuellen Ressourcen an e sougenannte Package deen all déi néideg Coden an Daten enthält. Dëse Package gëtt eng Versammlung genannt.
Bühn Fräisetzung - hei verbannen mir eis Configuratioun un d'Assemblée, ouni déi mir eise Programm net kënnen erausginn. Elo ass dëst eng komplett prett-fir-lancéiere Verëffentlechung.
Als nächst kënnt d'Bühn Erfëllung. Hei befreien mir d'Applikatioun andeems Dir déi néideg Prozesser aus eiser Verëffentlechung ausféiert.

Sou e System fir nei Versioune vun engem Modell oder der ganzer Pipeline ze verëffentlechen erlaabt Iech Rollen tëscht Administrateuren an Entwéckler ze trennen, erlaabt Iech Versiounen ze verfolgen a verhënnert ongewollte Stopp vum Programm.

Fir d'Verëffentlechungsaufgab gi vill verschidde Servicer erstallt, an deenen Dir Prozesser schreift fir Iech selwer an enger .yml Datei ze lafen (zum Beispill, am CircleCI ass dëst config.yml fir de Prozess selwer z'ënnerstëtzen). Wheely ass super fir Packagen fir Projeten ze kreéieren.

Dir kënnt Pakete mat verschiddene Versioune vun Ärem Maschinnléiermodell erstellen, a packen se dann a verweisen op déi néideg Packagen an hir Versioune fir d'Funktiounen ze benotzen, déi Dir vun do geschriwwen hutt. Dëst hëlleft Iech eng API fir Äre Modell ze kreéieren, an Äre Package kann zum Beispill op Gemfury gehost ginn.

Prinzip 6. Run Äre Modell als een oder méi Prozesser

Ausserdeem sollten Prozesser keng gedeelt Daten hunn. Dat ass, Prozesser musse getrennt existéieren, an all Zort vun Daten musse separat existéieren, zum Beispill op Drëtt-Partei Servicer wéi MySQL oder anerer, jee no wat Dir braucht.

Dat ass, et ass definitiv net derwäert Donnéeën am Prozess Dateiesystem ze späicheren, soss kann dëst zu der Läschung vun dësen Donnéeën während der nächster Verëffentlechung / Ännerung vun de Konfiguratiounen oder Transfer vum System féieren, op deem de Programm leeft.

Awer et gëtt eng Ausnahm: fir Maschinnléiereprojeten kënnt Dir e Cache vu Bibliothéike späicheren fir se net all Kéier wann Dir eng nei Versioun lancéiert nei installéiere wëllt, wa keng zousätzlech Bibliothéiken oder Ännerunge fir hir Versioune gemaach goufen. Op dës Manéier reduzéiert Dir d'Zäit déi et brauch fir Äre Modell an der Industrie ze lancéieren.

Fir de Modell als verschidde Prozesser auszeféieren, kënnt Dir eng .yml Datei erstellen, an där Dir déi néideg Prozesser an hir Sequenz uginn.

Prinzip 7: Recycling

D'Prozesser, déi an Ärer Modellapplikatioun lafen, sollten einfach sinn ze starten an ze stoppen. Also, dëst erlaabt Iech séier Code Ännerungen z'installéieren, Konfiguratiounsännerungen, séier a flexibel Skala, a méiglech Decompte vun der Aarbechtsversioun ze vermeiden.

Dat ass, Äre Prozess mam Modell soll:

Miniméiere Startzäit. Idealerweis sollt d'Startzäit (vum Moment vum Startbefehl erausginn bis de Moment wou de Prozess a Betrib kommt) net méi wéi e puer Sekonnen sinn. Bibliothéik Caching, uewen beschriwwen, ass eng Technik fir d'Startzäit ze reduzéieren.
Enn richteg. Dat ass, d'Nolauschteren um Serviceport ass tatsächlech suspendéiert, an nei Ufroe, déi op dësen Hafen ofginn ginn, ginn net veraarbecht. Hei musst Dir entweder eng gutt Kommunikatioun mat DevOps Ingenieuren opbauen, oder verstoen wéi et selwer funktionnéiert (am léifsten, natierlech, dat lescht, awer d'Kommunikatioun sollt ëmmer erhale bleiwen, an all Projet!)

Prinzip 8: Kontinuéierlech Détachement / Integratioun

Vill Firmen benotzen eng Trennung tëscht Applikatiounsentwécklung an Deploymentteams (d'Applikatioun fir Endbenotzer verfügbar ze maachen). Dëst kann d'Software Entwécklung staark verlangsamen a Fortschrëtter fir se ze verbesseren. Et verwinnt och d'DevOps Kultur, wou Entwécklung an Integratioun sinn, ongeféier geschwat, kombinéiert.

Dofir seet dëse Prinzip datt Äert Entwécklungsëmfeld sou no wéi méiglech un Ärem Produktiounsëmfeld sollt sinn.

Dëst erlaabt:

Reduzéiert d'Verëffentlechungszäit ëm zéng Mol
Reduzéieren d'Zuel vu Feeler wéinst Code Inkompatibilitéit.
Dëst reduzéiert och d'Aarbechtslaascht op d'Personal, well d'Entwéckler an d'Leit, déi d'Applikatioun ofsetzen, elo een Team sinn.

Tools déi Iech erlaben mat dësem ze schaffen sinn CircleCI, Travis CI, GitLab CI an anerer.

Dir kënnt séier Ergänzunge fir de Modell maachen, aktualiséieren an direkt starten, wärend et einfach ass, am Fall vu Feeler, ganz séier an d'Aarbechtsversioun zréckzekommen, sou datt den Endbenotzer et net emol bemierkt. Dëst kann besonnesch einfach a séier gemaach ginn wann Dir gutt Tester hutt.

Differenzen minimiséieren!!!

Prinzip 9. Är Logbicher

Logbicher (oder "Logbicher") sinn Eventer, normalerweis am Textformat opgeholl, déi an der Applikatioun optrieden (Event Stream). En einfacht Beispill: "2020-02-02 - Systemniveau - Prozessnumm." Si sinn entworf sou datt den Entwéckler wuertwiertlech gesinn wat geschitt wann de Programm leeft. Hie gesäit de Fortschrëtt vu Prozesser a versteet ob et ass wéi den Entwéckler selwer geduecht huet.

Dëse Prinzip seet datt Dir Är Logbicher net an Ärem Dateiesystem späichere sollt - Dir sollt se just op den Ecran "output" maachen, zum Beispill, dëst op der Standardoutput vum System maachen. An op dës Manéier wäert et méiglech sinn de Flow am Terminal während der Entwécklung ze iwwerwaachen.

Heescht dat datt et guer net néideg ass Logbicher ze späicheren? Natierlech net. Är Applikatioun sollt dat just net maachen - léisst et op Drëtt Partei Servicer. Är Applikatioun kann nëmme Logbicher op eng spezifesch Datei oder Terminal weiderginn fir Echtzäit ze gesinn, oder weider op en allgemeng Zweck Datelagerungssystem (wéi Hadoop) weiderginn. Är Applikatioun selwer soll net mat Logbicher späicheren oder interagéieren.

Prinzip 10. Test!

Fir industriell Maschinnléieren ass dës Phase extrem wichteg, well Dir musst verstoen datt de Modell richteg funktionnéiert a produzéiert wat Dir wollt.

Tester kënne mat pytest erstallt ginn, a getest mat engem klengen Dataset wann Dir eng Regressioun / Klassifikatioun Aufgab hutt.

Vergiesst net déi selwecht Som fir déif Léiermodeller ze setzen, sou datt se net stänneg verschidde Resultater produzéieren.

Dëst war eng kuerz Beschreiwung vun den 10 Prinzipien, an natierlech ass et schwéier se ze benotzen ouni ze probéieren a kucken wéi se funktionnéieren, also ass dësen Artikel just e Prolog zu enger Serie vun interessanten Artikelen an deenen ech wäert verroden wéi een erstellt industriell Maschinn Léieren Modeller , wéi se a Systemer integréieren, a wéi dës Prinzipien d'Liewe méi einfach fir eis all kënne maachen.

Ech probéieren och cool Prinzipien ze benotzen déi jidderee kann an de Kommentarer hannerloossen wa se wëllen.

Source: will.com