Kamusta kayong lahat! Isa akong CV developer sa CROC. Kami ay nagpapatupad ng mga proyekto sa larangan ng CV sa loob ng 3 taon na ngayon. Sa panahong ito, marami kaming ginawa, halimbawa: sinusubaybayan namin ang mga driver upang habang nagmamaneho ay hindi sila umiinom, hindi naninigarilyo, hindi nakikipag-usap sa telepono, tumingin sa kalsada, at hindi sa mga panaginip o sa mga ulap ; Nag-record kami ng mga taong nagmamaneho sa mga nakalaang daan at sumasakay sa ilang mga parking space; tiniyak na ang mga manggagawa ay nakasuot ng helmet, guwantes, atbp.; nakilala ang isang empleyado na gustong pumasok sa pasilidad; Binilang namin ang lahat ng aming makakaya.
Para saan ko ba ginagawa ang lahat ng ito?
Sa proseso ng pagpapatupad ng mga proyekto, naabutan namin ang mga bumps, maraming mga bumps, ilan sa mga problemang pamilyar ka o makikilala mo sa hinaharap.
Gayahin natin ang sitwasyon
Isipin natin na nakakuha tayo ng trabaho sa isang batang kumpanya na "N", na ang mga aktibidad ay nauugnay sa ML. Nagtatrabaho kami sa isang ML (DL, CV) na proyekto, pagkatapos ay lumipat kami sa ibang trabaho, karaniwang nagpapahinga, at bumalik sa sarili namin o sa neuron ng ibang tao.
- Dumating ang sandali ng katotohanan, kailangan mong kahit papaano ay matandaan kung saan ka huminto, anong mga hyperparameter ang sinubukan mo at, higit sa lahat, kung ano ang naging resulta ng mga ito. Maaaring mayroong maraming mga pagpipilian para sa kung sino ang nag-imbak ng impormasyon sa lahat ng mga paglulunsad: sa ulo, mga config, notepad, sa isang nagtatrabaho na kapaligiran sa cloud. Nagkataon na nakakita ako ng isang opsyon kapag ang mga hyperparameter ay naka-imbak bilang mga linya ng komento sa code, sa pangkalahatan, isang flight ng magarbong. Ngayon isipin na hindi ka bumalik sa iyong proyekto, ngunit sa proyekto ng isang taong umalis sa kumpanya at nagmana ka ng isang code at isang modelo na tinatawag na model_1.pb. Para makumpleto ang larawan at maihatid ang lahat ng sakit, isipin natin na ikaw ay isang baguhan na espesyalista.
- Sige lang. Upang patakbuhin ang code, kami at lahat ng taong gagana dito ay kailangang lumikha ng isang kapaligiran. Madalas na nangyayari na sa ilang kadahilanan ay hindi nila siya iniwan bilang ating mana. Ito ay maaari ding maging isang hindi maliit na gawain. Hindi mo nais na mag-aksaya ng oras sa hakbang na ito, hindi ba?
- Nagsasanay kami ng isang modelo (halimbawa, isang detektor ng kotse). Dumating tayo sa punto kung saan ito ay nagiging napakahusay - oras na upang i-save ang resulta. Tawagin natin itong car_detection_v1.pb. Pagkatapos ay nagsasanay kami ng isa pa - car_detection_v2.pb. Pagkaraan ng ilang oras, ang aming mga kasamahan o kami mismo ay nagtuturo ng higit pa, gamit ang iba't ibang mga arkitektura. Bilang isang resulta, isang bungkos ng mga artifact ang nabuo, ang impormasyon tungkol sa kung saan ay dapat na maingat na kolektahin (ngunit gagawin namin ito sa ibang pagkakataon, dahil sa ngayon ay mayroon kaming higit na priyoridad na mga bagay).
- OK tapos na ang lahat Ngayon! May model tayo! Maaari ba nating simulan ang pagsasanay sa susunod na modelo, pagbuo ng isang arkitektura upang malutas ang isang bagong problema, o maaari ba tayong uminom ng tsaa? At sino ang magpapakalat?
Pagkilala sa mga problema
Ang paggawa sa isang proyekto o produkto ay gawain ng maraming tao. At sa paglipas ng panahon, ang mga tao ay umaalis at dumarating, mas maraming mga proyekto, at ang mga proyekto mismo ay nagiging mas kumplikado. Sa isang paraan o iba pa, ang mga sitwasyon mula sa cycle na inilarawan sa itaas (at hindi lamang) sa ilang partikular na kumbinasyon ay magaganap mula sa pag-ulit hanggang sa pag-ulit. Ang lahat ng ito ay nagreresulta sa nasayang na oras, kalituhan, nerbiyos, posibleng hindi kasiyahan ng customer, at sa huli, nawalan ng pera. Bagama't karaniwan nating sinusundan ang parehong lumang kalaykay, naniniwala ako na walang gustong balikan ang mga sandaling ito nang paulit-ulit.
So, dumaan tayo sa isang development cycle at nakita natin na may mga problemang kailangang lutasin. Upang gawin ito kailangan mo:
- maginhawang mag-imbak ng mga resulta ng trabaho;
- gawing simple ang proseso ng pagsali ng mga bagong empleyado;
- gawing simple ang proseso ng pag-deploy ng development environment;
- i-configure ang proseso ng bersyon ng modelo;
- magkaroon ng isang maginhawang paraan upang mapatunayan ang mga modelo;
- maghanap ng modelong tool sa pamamahala ng estado;
- maghanap ng paraan upang maihatid ang mga modelo sa produksyon.
Tila kinakailangan na makabuo ng isang daloy ng trabaho na magpapahintulot sa iyo na madali at maginhawang pamahalaan ang siklo ng buhay na ito? Ang pagsasanay na ito ay tinatawag na MLOps
Ang MLOps, o DevOps para sa machine learning, ay nagbibigay-daan sa data science at mga IT team na mag-collaborate at pataasin ang bilis ng pag-develop at pag-deploy ng modelo sa pamamagitan ng pagsubaybay, pagpapatunay, at pamamahala para sa mga modelo ng machine learning.
Pwede ba Ano ang iniisip ng mga taga-Google tungkol sa lahat ng ito? Mula sa artikulo ay malinaw na ang MLOps ay isang napakalaking bagay.
Dagdag pa sa aking artikulo, ilalarawan ko lamang ang bahagi ng proseso. Para sa pagpapatupad, gagamitin ko ang tool na MLflow, dahil... Ito ay isang open-source na proyekto, isang maliit na halaga ng code ang kinakailangan upang kumonekta at mayroong pagsasama sa mga sikat na ml frameworks. Maaari kang maghanap sa Internet para sa iba pang mga tool, tulad ng Kubeflow, SageMaker, Trains, atbp., at marahil ay makahanap ng isa na mas angkop sa iyong mga pangangailangan.
"Pagbuo" ng mga MLO gamit ang halimbawa ng paggamit ng tool na MLFlow
Ang MLFlow ay isang open source na platform para sa pamamahala ng lifecycle ng mga modelo ng ml ().
Kasama sa MLflow ang apat na bahagi:
- MLflow Tracking - sumasaklaw sa mga isyu ng pagtatala ng mga resulta at mga parameter na humantong sa resultang ito;
- MLflow Project - pinapayagan kang mag-package ng code at kopyahin ito sa anumang platform;
- Mga Modelo ng MLflow - responsable para sa pag-deploy ng mga modelo sa produksyon;
- MLflow Registry - nagbibigay-daan sa iyo na mag-imbak ng mga modelo at pamahalaan ang kanilang estado sa isang sentralisadong imbakan.
Gumagana ang MLflow sa dalawang entity:
- ang paglulunsad ay isang buong cycle ng pagsasanay, mga parameter at sukatan kung saan gusto naming magparehistro;
- Ang isang eksperimento ay isang "paksa" na tumatakbo nang magkasama.
Ang lahat ng mga hakbang ng halimbawa ay ipinatupad sa Ubuntu 18.04 operating system.
1. I-deploy ang server
Upang madali naming pamahalaan ang aming proyekto at matanggap ang lahat ng kinakailangang impormasyon, magde-deploy kami ng isang server. Ang server ng pagsubaybay sa MLflow ay may dalawang pangunahing bahagi:
- backend store - responsable para sa pag-iimbak ng impormasyon tungkol sa mga rehistradong modelo (sumusuporta sa 4 na DBMS: mysql, mssql, sqlite, at postgresql);
- tindahan ng artifact - responsable sa pag-iimbak ng mga artifact (sumusuporta sa 7 opsyon sa storage: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, SFTP Server, NFS, HDFS).
Bilang ang tindahan ng artifact Para sa pagiging simple, kumuha tayo ng sftp server.
- gumawa ng grupo
$ sudo groupadd sftpg - magdagdag ng user at magtakda ng password para sa kanya
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - pagsasaayos ng ilang setting ng pag-access
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - magdagdag ng ilang linya sa /etc/ssh/sshd_config
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - i-restart ang serbisyo
$ sudo systemctl restart sshd
Bilang ang backend na tindahan Kunin natin ang postgresql.
$ sudo apt update
$ sudo apt-get install -y postgresql postgresql-contrib postgresql-server-dev-all
$ sudo apt install gcc
$ pip install psycopg2
$ sudo -u postgres -i
# Create new user: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Enter name of role to add: mlflow_user
Enter password for new role: mlflow
Enter it again: mlflow
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
# Create database mlflow_bd owned by mlflow_user
$ createdb -O mlflow_user mlflow_dbUpang simulan ang server, kailangan mong i-install ang mga sumusunod na pakete ng python (inirerekumenda ko ang paglikha ng isang hiwalay na virtual na kapaligiran):
pip install mlflow
pip install pysftpSimulan natin ang ating server
$ mlflow server
--backend-store-uri postgresql://mlflow_user:mlflow@localhost/mlflow_db
--default-artifact-root sftp://mlflowsftp:mlflow@sftp_host/upload
--host server_host
--port server_port2. Magdagdag ng pagsubaybay
Upang ang mga resulta ng aming pagsasanay ay hindi mawala, ang mga susunod na henerasyon ng mga developer ay maunawaan kung ano ang nangyayari, at para sa mas matatandang mga kasama at ikaw ay mahinahon na pag-aralan ang proseso ng pag-aaral, kailangan naming magdagdag ng pagsubaybay. Ang pagsubaybay ay nangangahulugan ng pag-save ng mga parameter, sukatan, artifact at anumang karagdagang impormasyon tungkol sa pagsisimula ng pagsasanay, sa aming kaso, sa server.
Halimbawa, gumawa ako ng maliit sa Keras para sa pagse-segment ng lahat ng nasa . Upang magdagdag ng pagsubaybay, gumawa ako ng file mlflow_training.py.
Narito ang mga linya kung saan nangyayari ang mga pinakakawili-wiling bagay:
def run(self, epochs, lr, experiment_name):
# getting the id of the experiment, creating an experiment in its absence
remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
# creating a "run" and getting its id
remote_run_id = self.remote_server.get_run_id(remote_experiment_id)
# indicate that we want to save the results on a remote server
mlflow.set_tracking_uri(self.tracking_uri)
mlflow.set_experiment(experiment_name)
with mlflow.start_run(run_id=remote_run_id, nested=False):
mlflow.keras.autolog()
self.train_pipeline.train(lr=lr, epochs=epochs)
try:
self.log_tags_and_params(remote_run_id)
except mlflow.exceptions.RestException as e:
print(e)Narito ang self.remote_server ay isang maliit na wrapper sa mga paraan ng mlflow.tracking. MlflowClient (ginawa ko ito para sa kaginhawahan), sa tulong kung saan lumikha ako ng isang eksperimento at patakbuhin ito sa server. Susunod, ipinapahiwatig ko kung saan dapat pagsamahin ang mga resulta ng paglulunsad (mlflow.set_tracking_uri(self.tracking_uri)). Pinagana ko ang awtomatikong pag-log mlflow.keras.autolog(). Kasalukuyang sinusuportahan ng MLflow Tracking ang awtomatikong pag-log para sa TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Kung hindi mo pa nahanap ang iyong framework o library, maaari kang palaging mag-log nang tahasan. Nagsisimula na kaming mag-training. Magrehistro ng mga tag at input parameter sa remote server.
Ang ilang linya at ikaw, tulad ng iba, ay may access sa impormasyon tungkol sa lahat ng paglulunsad. Malamig?
3. Iginuhit namin ang proyekto
Ngayon gawin nating madali ang paglunsad ng proyekto. Upang gawin ito, idagdag ang MLproject at conda.yaml file sa root ng proyekto.
MLproject
name: flow_segmentation
conda_env: conda.yaml
entry_points:
main:
parameters:
categories: {help: 'list of categories from coco dataset'}
epochs: {type: int, help: 'number of epochs in training'}
lr: {type: float, default: 0.001, help: 'learning rate'}
batch_size: {type: int, default: 8}
model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
backbone_name: {type: str, default: 'resnet18', help: 'exampe resnet18, resnet50, mobilenetv2 ...'}
tracking_uri: {type: str, help: 'the server address'}
experiment_name: {type: str, default: 'My_experiment', help: 'remote and local experiment name'}
command: "python mlflow_training.py
--epochs={epochs}
--categories={categories}
--lr={lr}
--tracking_uri={tracking_uri}
--model_name={model_name}
--backbone_name={backbone_name}
--batch_size={batch_size}
--experiment_name={experiment_name}"Ang MLflow Project ay may ilang mga katangian:
- Pangalan - ang pangalan ng iyong proyekto;
- Kapaligiran - sa aking kaso, ang conda_env ay nagpapahiwatig na ang Anaconda ay ginagamit upang tumakbo at ang paglalarawan ng dependency ay nasa conda.yaml file;
- Mga Entry Point - ipinapahiwatig kung aling mga file at kung aling mga parameter ang maaari naming patakbuhin (lahat ng mga parameter ay awtomatikong naka-log kapag nagsisimula ng pagsasanay)
conda.yaml
name: flow_segmentation
channels:
- defaults
- anaconda
dependencies:
- python==3.7
- pip:
- mlflow==1.8.0
- pysftp==0.2.9
- Cython==0.29.19
- numpy==1.18.4
- pycocotools==2.0.0
- requests==2.23.0
- matplotlib==3.2.1
- segmentation-models==1.0.1
- Keras==2.3.1
- imgaug==0.4.0
- tqdm==4.46.0
- tensorflow-gpu==1.14.0Maaari mong gamitin ang docker bilang iyong runtime environment, para sa higit pang mga detalye mangyaring sumangguni sa .
4. Magsimula tayo sa pagsasanay
I-clone namin ang proyekto at pumunta sa direktoryo ng proyekto:
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/Upang tumakbo kailangan mong mag-install ng mga aklatan
pip install mlflow
pip install pysftpkasi sa halimbawang ginagamit ko ang conda_env, ang Anaconda ay dapat na naka-install sa iyong computer (ngunit maaari mong lampasan ito sa pamamagitan ng pag-install ng lahat ng kinakailangang mga pakete sa iyong sarili at paglalaro sa mga parameter ng paglulunsad).
Nakumpleto na ang lahat ng hakbang sa paghahanda at maaari na nating simulan ang pagsasanay. Mula sa ugat ng proyekto:
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .Pagkatapos ipasok ang command, isang conda environment ay awtomatikong malilikha at ang pagsasanay ay magsisimula.
Sa halimbawa sa itaas, naipasa ko ang bilang ng mga panahon para sa pagsasanay, ang mga kategorya kung saan gusto naming i-segment (makikita mo ang buong listahan ) at ang address ng aming malayong server.
Ang isang kumpletong listahan ng mga posibleng parameter ay matatagpuan sa MLproject file.
5. Suriin ang mga resulta ng pag-aaral
Pagkatapos makumpleto ang pagsasanay, maaari kaming pumunta sa browser sa address ng aming server
Dito nakikita namin ang isang listahan ng lahat ng mga eksperimento (kaliwa sa itaas), pati na rin ang impormasyon sa mga pagtakbo (gitna). Maaari naming tingnan ang mas detalyadong impormasyon (mga parameter, sukatan, artifact at ilang karagdagang impormasyon) para sa bawat paglulunsad.
Para sa bawat sukatan maaari nating obserbahan ang kasaysayan ng mga pagbabago
Yung. Sa ngayon, maaari naming suriin ang mga resulta sa isang "manual" na mode, at maaari ka ring mag-set up ng awtomatikong pagpapatunay gamit ang MLflow API.
6. Irehistro ang modelo
Matapos naming masuri ang aming modelo at magpasya na handa na ito para sa labanan, nagpapatuloy kami upang irehistro ito, para dito pipiliin namin ang paglulunsad na kailangan namin (tulad ng ipinakita sa nakaraang talata) at bumaba.
Pagkatapos naming bigyan ng pangalan ang aming modelo, mayroon itong bersyon. Kung magse-save ka ng isa pang modelo na may parehong pangalan, awtomatikong maa-upgrade ang bersyon.
Para sa bawat modelo, maaari kaming magdagdag ng isang paglalarawan at pumili ng isa sa tatlong mga estado (Staging, Production, Archived); pagkatapos, gamit ang API, maaari naming i-access ang mga estado na ito, na, kasama ang pag-bersyon, ay nagbibigay ng karagdagang flexibility.
Mayroon din kaming madaling access sa lahat ng mga modelo
at ang kanilang mga bersyon
Tulad ng sa nakaraang talata, lahat ng mga operasyon ay maaaring gawin gamit ang API.
7. I-deploy ang modelo
Sa yugtong ito, mayroon na tayong sinanay (keras) na modelo. Isang halimbawa kung paano mo ito magagamit:
class SegmentationModel:
def __init__(self, tracking_uri, model_name):
self.registry = RemoteRegistry(tracking_uri=tracking_uri)
self.model_name = model_name
self.model = self.build_model(model_name)
def get_latest_model(self, model_name):
registered_models = self.registry.get_registered_model(model_name)
last_model = self.registry.get_last_model(registered_models)
local_path = self.registry.download_artifact(last_model.run_id, 'model', './')
return local_path
def build_model(self, model_name):
local_path = self.get_latest_model(model_name)
return mlflow.keras.load_model(local_path)
def predict(self, image):
image = self.preprocess(image)
result = self.model.predict(image)
return self.postprocess(result)
def preprocess(self, image):
image = cv2.resize(image, (256, 256))
image = image / 255.
image = np.expand_dims(image, 0)
return image
def postprocess(self, result):
return resultNarito ang self.registry ay muling isang maliit na wrapper sa mlflow.tracking.MlflowClient, para sa kaginhawahan. Ang punto ay na-access ko ang isang malayong server at naghahanap ng isang modelo doon na may tinukoy na pangalan, at ang pinakabagong bersyon ng produksyon. Susunod, lokal kong dina-download ang artifact sa ./model na folder at bubuo ng modelo mula sa direktoryong ito na mlflow.keras.load_model(local_path). Ngayon ay magagamit na natin ang ating modelo. Madaling mapahusay ng mga developer ng CV (ML) ang modelo at mag-publish ng mga bagong bersyon.
Sa pagtatapos
Nagpakita ako ng isang sistema na nagbibigay-daan sa:
- sentral na mag-imbak ng impormasyon tungkol sa mga modelo ng ML, pag-unlad ng pagsasanay at mga resulta;
- mabilis na mag-deploy ng isang kapaligiran sa pag-unlad;
- subaybayan at pag-aralan ang pag-unlad ng trabaho sa mga modelo;
- ito ay maginhawa sa bersyon at pamahalaan ang estado ng mga modelo;
- Madaling i-deploy ang mga resultang modelo.
Ang halimbawang ito ay isang laruan at nagsisilbing panimulang punto para sa pagbuo ng sarili mong system, na maaaring magsama ng automation ng pagsusuri ng mga resulta at pagpaparehistro ng mga modelo (mga puntos 5 at 6, ayon sa pagkakabanggit) o ββmagdaragdag ka ng pag-bersyon ng mga dataset, o maaaring iba pa ? Ang puntong sinisikap kong gawin ay kailangan mo ng mga MLOp sa kabuuan, ang MLflow ay isang paraan lamang sa isang dulo.
Isulat kung anong mga problema ang iyong naranasan na hindi ko ipinakita?
Ano ang idaragdag mo sa system para matugunan nito ang iyong mga pangangailangan?
Anong mga tool at diskarte ang iyong ginagamit upang malutas ang lahat o bahagi ng mga problema?
PS Mag-iiwan ako ng ilang link:
proyekto ng github -
MLflow -
Ang email ko sa trabaho para sa mga tanong - [protektado ng email]
Ang aming kumpanya ay pana-panahong nagho-host ng iba't ibang mga kaganapan para sa mga espesyalista sa IT, halimbawa: sa Hulyo 8 sa 19:00 oras sa Moscow magkakaroon ng isang CV meetup sa isang online na format, kung interesado ka, maaari kang makilahok, pagpaparehistro .
Pinagmulan: www.habr.com