MLOps - કુક બુક, પ્રકરણ 1

કેમ છો બધા! હું CROC ખાતે CV ડેવલપર છું. અમે 3 વર્ષથી CV ના ક્ષેત્રમાં પ્રોજેક્ટ અમલમાં મૂકી રહ્યા છીએ. આ સમય દરમિયાન, અમે ઘણી બધી વસ્તુઓ કરી, ઉદાહરણ તરીકે: અમે ડ્રાઇવરોનું નિરીક્ષણ કર્યું જેથી તેઓ ડ્રાઇવિંગ કરતી વખતે પીતા ન હોય, ધૂમ્રપાન ન કરતા હોય, ફોન પર વાત કરતા ન હોય, રસ્તા તરફ જોતા હોય, અને સપના અથવા વાદળો તરફ ન જોતા હોય. ; અમે એવા લોકોને રેકોર્ડ કર્યા જેઓ સમર્પિત લેનમાં વાહન ચલાવે છે અને ઘણી પાર્કિંગ જગ્યાઓ લે છે; ખાતરી કરો કે કામદારો હેલ્મેટ, મોજા વગેરે પહેરે છે; સુવિધામાં પ્રવેશવા માંગતા કર્મચારીની ઓળખ કરી; અમે જે કરી શકીએ તે બધું ગણી લીધું.

હું આ બધું શેના માટે કરી રહ્યો છું?

પ્રોજેક્ટના અમલીકરણની પ્રક્રિયામાં, અમે મુશ્કેલીઓનો સામનો કરીએ છીએ, ઘણી બધી મુશ્કેલીઓ, કેટલીક સમસ્યાઓ કે જેનાથી તમે કાં તો પરિચિત છો અથવા ભવિષ્યમાં તેનાથી પરિચિત થશો.

ચાલો પરિસ્થિતિનું અનુકરણ કરીએ

ચાલો કલ્પના કરીએ કે અમને એક યુવાન કંપની "N" માં નોકરી મળી છે, જેની પ્રવૃત્તિઓ ML સાથે સંબંધિત છે. અમે ML (DL, CV) પ્રોજેક્ટ પર કામ કરીએ છીએ, પછી કોઈ કારણસર અમે બીજી નોકરી પર સ્વિચ કરીએ છીએ, સામાન્ય રીતે વિરામ લઈએ છીએ અને અમારા પોતાના અથવા બીજા કોઈના ન્યુરોન પર પાછા આવીએ છીએ.

1. સત્યની ક્ષણ આવે છે, તમારે કોઈક રીતે યાદ રાખવાની જરૂર છે કે તમે ક્યાં રોકાયા, તમે કયા હાઇપરપેરામીટર્સનો પ્રયાસ કર્યો અને, સૌથી અગત્યનું, તેઓ કયા પરિણામો તરફ દોરી ગયા. બધા લોંચ પર માહિતી કોણે સંગ્રહિત કરી છે તેના માટે ઘણા વિકલ્પો હોઈ શકે છે: હેડમાં, રૂપરેખાઓ, નોટપેડમાં, ક્લાઉડમાં કાર્યકારી વાતાવરણમાં. જ્યારે હાઇપરપેરામીટર્સ કોડમાં ટિપ્પણી કરેલ લીટીઓ તરીકે સંગ્રહિત થાય ત્યારે મને એક વિકલ્પ જોવા મળ્યો, સામાન્ય રીતે, ફેન્સીની ફ્લાઇટ. હવે કલ્પના કરો કે તમે તમારા પ્રોજેક્ટ પર નહીં, પરંતુ એક વ્યક્તિના પ્રોજેક્ટ પર પાછા ફર્યા કે જેણે કંપની છોડી દીધી અને તમને વારસામાં કોડ અને મોડેલ_1.pb કહેવાય છે. ચિત્રને પૂર્ણ કરવા અને બધી પીડા વ્યક્ત કરવા માટે, ચાલો કલ્પના કરીએ કે તમે શિખાઉ નિષ્ણાત પણ છો.
2. આગળ વધો. કોડ ચલાવવા માટે, આપણે અને તેની સાથે કામ કરનાર દરેકને પર્યાવરણ બનાવવાની જરૂર છે. તે ઘણીવાર થાય છે કે કોઈ કારણોસર તેઓએ તેને અમારા વારસા તરીકે છોડ્યો નથી. આ એક બિન-તુચ્છ કાર્ય પણ બની શકે છે. તમે આ પગલા પર સમય બગાડવા માંગતા નથી, શું તમે?
3. અમે એક મોડેલને તાલીમ આપીએ છીએ (ઉદાહરણ તરીકે, કાર ડિટેક્ટર). અમે તે બિંદુએ પહોંચીએ છીએ જ્યાં તે ખૂબ જ સારું બને છે - પરિણામ સાચવવાનો સમય છે. ચાલો તેને car_detection_v1.pb કહીએ. પછી અમે બીજાને તાલીમ આપીએ છીએ - car_detection_v2.pb. થોડા સમય પછી, અમારા સાથીદારો અથવા આપણે પોતે જ વિવિધ આર્કિટેક્ચરનો ઉપયોગ કરીને વધુને વધુ શીખવીએ છીએ. પરિણામે, કલાકૃતિઓનો સમૂહ રચાય છે, જેના વિશેની માહિતી સખત મહેનતથી એકત્રિત કરવી આવશ્યક છે (પરંતુ અમે આ પછીથી કરીશું, કારણ કે અત્યારે અમારી પાસે વધુ પ્રાથમિકતા બાબતો છે).
4. ઠીક છે હવે બધું સમાપ્ત થઈ ગયું છે! અમારી પાસે એક મોડેલ છે! શું આપણે આગલા મોડલને તાલીમ આપવાનું શરૂ કરી શકીએ છીએ, નવી સમસ્યાને ઉકેલવા માટે આર્કિટેક્ચર વિકસાવી શકીએ છીએ, અથવા આપણે થોડી ચા પીવા જઈ શકીએ? અને કોણ જમાવશે?

સમસ્યાઓની ઓળખ

પ્રોજેક્ટ અથવા પ્રોડક્ટ પર કામ કરવું એ ઘણા લોકોનું કામ છે. અને સમય જતાં, લોકો જાય છે અને આવે છે, ત્યાં વધુ પ્રોજેક્ટ્સ છે, અને પ્રોજેક્ટ્સ પોતે વધુ જટિલ બની જાય છે. એક યા બીજી રીતે, ઉપર વર્ણવેલ ચક્રમાંથી પરિસ્થિતિઓ (અને માત્ર નહીં) અમુક સંયોજનોમાં પુનરાવૃત્તિથી પુનરાવર્તન સુધી આવશે. આ બધાના પરિણામે સમયનો વ્યય, મૂંઝવણ, ચેતા, સંભવતઃ ગ્રાહક અસંતોષ અને છેવટે, નાણાં ગુમાવવામાં આવે છે. જો કે આપણે બધા સામાન્ય રીતે એ જ જૂના રેકને અનુસરીએ છીએ, હું માનું છું કે કોઈ પણ આ ક્ષણોને ફરીથી અને ફરીથી જીવંત કરવા માંગતું નથી.

તેથી, અમે એક વિકાસ ચક્રમાંથી પસાર થયા છીએ અને અમે જોયું છે કે એવી સમસ્યાઓ છે જેને હલ કરવાની જરૂર છે. આ કરવા માટે તમારે જરૂર છે:

• કામના પરિણામોને અનુકૂળ રીતે સંગ્રહિત કરો;
• નવા કર્મચારીઓને સામેલ કરવાની પ્રક્રિયાને સરળ બનાવો;
• વિકાસ પર્યાવરણ જમાવવાની પ્રક્રિયાને સરળ બનાવવી;
• મોડેલ વર્ઝનિંગ પ્રક્રિયાને ગોઠવો;
• મોડેલોને માન્ય કરવાની અનુકૂળ રીત છે;
• મોડલ સ્ટેટ મેનેજમેન્ટ ટૂલ શોધો;
• ઉત્પાદન માટે મોડેલો પહોંચાડવાનો માર્ગ શોધો.

દેખીતી રીતે વર્કફ્લો સાથે આવવું જરૂરી છે જે તમને આ જીવન ચક્રને સરળતાથી અને સગવડતાપૂર્વક સંચાલિત કરવાની મંજૂરી આપે? આ પ્રથાને MLOps કહેવામાં આવે છે

મશીન લર્નિંગ માટે MLOps, અથવા DevOps, ડેટા સાયન્સ અને IT ટીમોને મશીન લર્નિંગ મૉડલ્સ માટે દેખરેખ, માન્યતા અને ગવર્નન્સ દ્વારા મૉડલ ડેવલપમેન્ટ અને ડિપ્લોયમેન્ટની ગતિમાં સહયોગ અને વધારો કરવાની મંજૂરી આપે છે.

તમે કરી શકો છો વાંચવુંગૂગલના લોકો આ બધા વિશે શું વિચારે છે? લેખમાંથી તે સ્પષ્ટ છે કે MLOps એક વિશાળ વસ્તુ છે.

મારા લેખમાં આગળ હું પ્રક્રિયાના માત્ર એક ભાગનું વર્ણન કરીશ. અમલીકરણ માટે, હું MLflow ટૂલનો ઉપયોગ કરીશ, કારણ કે... આ એક ઓપન-સોર્સ પ્રોજેક્ટ છે, કનેક્ટ કરવા માટે થોડી માત્રામાં કોડ જરૂરી છે અને લોકપ્રિય ml ફ્રેમવર્ક સાથે એકીકરણ છે. તમે અન્ય ટૂલ્સ જેમ કે કુબેફ્લો, સેજમેકર, ટ્રેન વગેરે માટે ઇન્ટરનેટ પર શોધી શકો છો અને કદાચ તમારી જરૂરિયાતોને વધુ સારી રીતે અનુકૂળ હોય તે શોધી શકો છો.

MLFlow ટૂલનો ઉપયોગ કરવાના ઉદાહરણનો ઉપયોગ કરીને "બિલ્ડિંગ" MLOps

MLFlow એ ml મોડલ્સના જીવનચક્ર વ્યવસ્થાપન માટે એક ઓપન સોર્સ પ્લેટફોર્મ છે (https://mlflow.org/).

MLflow ચાર ઘટકો સમાવે છે:

• MLflow ટ્રેકિંગ - રેકોર્ડિંગ પરિણામો અને પરિમાણોના મુદ્દાઓને આવરી લે છે જે આ પરિણામ તરફ દોરી જાય છે;
• MLflow પ્રોજેક્ટ - તમને કોડને પેકેજ કરવાની અને તેને કોઈપણ પ્લેટફોર્મ પર પુનઃઉત્પાદિત કરવાની મંજૂરી આપે છે;
• MLflow મૉડલ્સ - મૉડલને ઉત્પાદનમાં જમાવવા માટે જવાબદાર;
• MLflow રજિસ્ટ્રી - તમને મૉડલ સ્ટોર કરવા અને કેન્દ્રિય રિપોઝીટરીમાં તેમની સ્થિતિનું સંચાલન કરવાની મંજૂરી આપે છે.

MLflow બે સંસ્થાઓ પર કાર્ય કરે છે:

• લોન્ચ એ તાલીમ, પરિમાણો અને મેટ્રિક્સનું સંપૂર્ણ ચક્ર છે જેના દ્વારા અમે નોંધણી કરવા માંગીએ છીએ;
• પ્રયોગ એ "વિષય" છે જે એકસાથે ચાલે છે.

ઉદાહરણના તમામ પગલાં ઉબુન્ટુ 18.04 ઓપરેટિંગ સિસ્ટમ પર લાગુ કરવામાં આવ્યા છે.

1. સર્વર જમાવો

અમારા પ્રોજેક્ટને સરળતાથી મેનેજ કરવા અને તમામ જરૂરી માહિતી પ્રાપ્ત કરવા માટે, અમે સર્વર ગોઠવીશું. MLflow ટ્રેકિંગ સર્વરમાં બે મુખ્ય ઘટકો છે:

• બેકએન્ડ સ્ટોર - રજિસ્ટર્ડ મોડલ્સ વિશે માહિતી સ્ટોર કરવા માટે જવાબદાર (4 DBMSs: mysql, mssql, sqlite અને postgresql);
• આર્ટિફેક્ટ સ્ટોર - આર્ટિફેક્ટ સ્ટોર કરવા માટે જવાબદાર છે (7 સ્ટોરેજ વિકલ્પોને સપોર્ટ કરે છે: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP સર્વર, SFTP સર્વર, NFS, HDFS).

જેમ કે આર્ટિફેક્ટ સ્ટોર સરળતા માટે, ચાલો એક sftp સર્વર લઈએ.

• એક જૂથ બનાવો

  $ sudo groupadd sftpg

• વપરાશકર્તા ઉમેરો અને તેના માટે પાસવર્ડ સેટ કરો

  $ sudo useradd -g sftpg mlflowsftp
  $ sudo passwd mlflowsftp 

• ઍક્સેસ સેટિંગ્સ એક દંપતિ સમાયોજિત

  $ sudo mkdir -p /data/mlflowsftp/upload
  $ sudo chown -R root.sftpg /data/mlflowsftp
  $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload

• /etc/ssh/sshd_config માં થોડી લીટીઓ ઉમેરો

  Match Group sftpg
   ChrootDirectory /data/%u
   ForceCommand internal-sftp

• સેવા પુનઃપ્રારંભ કરો

  $ sudo systemctl restart sshd

જેમ કે બેકએન્ડ સ્ટોર ચાલો 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_db

સર્વર શરૂ કરવા માટે, તમારે નીચેના પાયથોન પેકેજો ઇન્સ્ટોલ કરવાની જરૂર છે (હું એક અલગ વર્ચ્યુઅલ વાતાવરણ બનાવવાની ભલામણ કરું છું):

pip install mlflow
pip install pysftp

ચાલો અમારું સર્વર શરૂ કરીએ

$ 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_port

2. ટ્રેકિંગ ઉમેરો

અમારી તાલીમના પરિણામો ખોવાઈ ન જાય તે માટે, વિકાસકર્તાઓની ભાવિ પેઢી શું થઈ રહ્યું છે તે સમજી શકે અને વૃદ્ધ સાથીઓ અને તમે શાંતિથી શીખવાની પ્રક્રિયાનું વિશ્લેષણ કરી શકો તે માટે, અમારે ટ્રેકિંગ ઉમેરવાની જરૂર છે. ટ્રેકિંગનો અર્થ છે પેરામીટર્સ, મેટ્રિક્સ, આર્ટિફેક્ટ્સ અને તાલીમની શરૂઆત વિશેની કોઈપણ વધારાની માહિતી, અમારા કિસ્સામાં, સર્વર પર સાચવવી.

ઉદાહરણ તરીકે, મેં એક નાનું બનાવ્યું ગીથબ પર પ્રોજેક્ટ કેરાસ પર જે છે તે બધું વિભાજિત કરવા માટે COCO ડેટાસેટ. ટ્રેકિંગ ઉમેરવા માટે, મેં mlflow_training.py ફાઇલ બનાવી છે.

અહીં એવી રેખાઓ છે જ્યાં સૌથી વધુ રસપ્રદ વસ્તુઓ થાય છે:

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)

અહીં self.remote_server એ mlflow.tracking પદ્ધતિઓ પર એક નાનું રેપર છે. MlflowClient (મેં તેને અનુકૂળતા માટે બનાવ્યું છે), જેની મદદથી હું એક પ્રયોગ બનાવું છું અને તેને સર્વર પર ચલાવું છું. આગળ, હું સૂચવું છું કે લોન્ચ પરિણામો ક્યાં મર્જ કરવા જોઈએ (mlflow.set_tracking_uri(self.tracking_uri)). હું ઓટોમેટિક લોગીંગ mlflow.keras.autolog() સક્ષમ કરું છું. હાલમાં MLflow ટ્રેકિંગ TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark માટે ઓટોમેટિક લોગીંગને સપોર્ટ કરે છે. જો તમને તમારું ફ્રેમવર્ક અથવા લાઇબ્રેરી ન મળી હોય, તો તમે હંમેશા સ્પષ્ટપણે લૉગ ઇન કરી શકો છો. અમે તાલીમ શરૂ કરી રહ્યા છીએ. રિમોટ સર્વર પર ટૅગ્સ અને ઇનપુટ પરિમાણો નોંધો.

થોડીક લીટીઓ અને તમને, બીજા બધાની જેમ, તમામ લોન્ચ વિશેની માહિતીની ઍક્સેસ હશે. કૂલ?

3. અમે પ્રોજેક્ટ દોરીએ છીએ

હવે ચાલો પ્રોજેક્ટ શરૂ કરવાનું સરળ બનાવીએ. આ કરવા માટે, MLproject અને conda.yaml ફાઇલને પ્રોજેક્ટ રૂટમાં ઉમેરો.
MLપ્રોજેક્ટ

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}"

MLflow પ્રોજેક્ટમાં અનેક ગુણધર્મો છે:

• નામ - તમારા પ્રોજેક્ટનું નામ;
• પર્યાવરણ - મારા કિસ્સામાં, conda_env સૂચવે છે કે Anaconda ચલાવવા માટે વપરાય છે અને અવલંબન વર્ણન conda.yaml ફાઈલમાં છે;
• એન્ટ્રી પોઈન્ટ્સ - સૂચવે છે કે કઈ ફાઇલો અને કયા પરિમાણો સાથે આપણે ચલાવી શકીએ છીએ (તાલીમ શરૂ કરતી વખતે તમામ પરિમાણો આપમેળે લૉગ થઈ જાય છે)

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.0

તમે તમારા રનટાઇમ પર્યાવરણ તરીકે ડોકરનો ઉપયોગ કરી શકો છો, વધુ વિગતો માટે કૃપા કરીને સંદર્ભ લો દસ્તાવેજીકરણ.

4. ચાલો તાલીમ શરૂ કરીએ

અમે પ્રોજેક્ટને ક્લોન કરીએ છીએ અને પ્રોજેક્ટ ડિરેક્ટરીમાં જઈએ છીએ:

git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/

ચલાવવા માટે તમારે લાઇબ્રેરીઓ ઇન્સ્ટોલ કરવાની જરૂર છે

pip install mlflow
pip install pysftp

કારણ કે ઉદાહરણમાં હું conda_env નો ઉપયોગ કરું છું, એનાકોન્ડા તમારા કમ્પ્યુટર પર ઇન્સ્ટોલ કરેલું હોવું જોઈએ (પરંતુ તમે બધા જરૂરી પેકેજો જાતે ઇન્સ્ટોલ કરીને અને લોન્ચ પેરામીટર્સ સાથે રમીને આની આસપાસ મેળવી શકો છો).

તમામ તૈયારીના પગલાં પૂર્ણ થઈ ગયા છે અને અમે તાલીમ શરૂ કરવાનું શરૂ કરી શકીએ છીએ. પ્રોજેક્ટ રુટમાંથી:

$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .

આદેશ દાખલ કર્યા પછી, કોન્ડા વાતાવરણ આપોઆપ બનાવવામાં આવશે અને તાલીમ શરૂ થશે.
ઉપરના ઉદાહરણમાં, મેં તાલીમ માટે યુગની સંખ્યા પસાર કરી છે, જે કેટેગરીઝમાં આપણે વિભાજન કરવા માંગીએ છીએ (તમે સંપૂર્ણ સૂચિ જોઈ શકો છો અહીં) અને અમારા રિમોટ સર્વરનું સરનામું.
સંભવિત પરિમાણોની સંપૂર્ણ સૂચિ MLproject ફાઇલમાં મળી શકે છે.

5. શીખવાના પરિણામોનું મૂલ્યાંકન કરો

તાલીમ પૂર્ણ કર્યા પછી, અમે બ્રાઉઝરમાં અમારા સર્વરના સરનામા પર જઈ શકીએ છીએ http://server_host:server_port

અહીં આપણે બધા પ્રયોગોની સૂચિ (ઉપર ડાબે) તેમજ રન (મધ્યમ) પરની માહિતી જોઈએ છીએ. અમે દરેક લોંચ માટે વધુ વિગતવાર માહિતી (પેરામીટર્સ, મેટ્રિક્સ, આર્ટિફેક્ટ્સ અને કેટલીક વધારાની માહિતી) જોઈ શકીએ છીએ.

દરેક મેટ્રિક માટે આપણે ફેરફારોના ઇતિહાસનું અવલોકન કરી શકીએ છીએ

તે. આ ક્ષણે, અમે "મેન્યુઅલ" મોડમાં પરિણામોનું વિશ્લેષણ કરી શકીએ છીએ, અને તમે MLflow API નો ઉપયોગ કરીને સ્વચાલિત માન્યતા પણ સેટ કરી શકો છો.

6. મોડેલની નોંધણી કરો

અમે અમારા મોડેલનું વિશ્લેષણ કર્યા પછી અને નક્કી કર્યું કે તે યુદ્ધ માટે તૈયાર છે, અમે તેને રજીસ્ટર કરવા માટે આગળ વધીએ છીએ, આ માટે અમે અમને જોઈતા પ્રક્ષેપણને પસંદ કરીએ છીએ (અગાઉના ફકરામાં બતાવ્યા પ્રમાણે) અને નીચે જઈએ છીએ.

અમે અમારા મોડલને નામ આપીએ તે પછી, તેનું એક સંસ્કરણ છે. જો તમે સમાન નામ સાથે અન્ય મોડલ સાચવો છો, તો સંસ્કરણ આપમેળે અપગ્રેડ થઈ જશે.

દરેક મોડેલ માટે, અમે વર્ણન ઉમેરી શકીએ છીએ અને ત્રણ રાજ્યોમાંથી એક પસંદ કરી શકીએ છીએ (સ્ટેજિંગ, પ્રોડક્શન, આર્કાઇવ્ડ); ત્યારબાદ, API નો ઉપયોગ કરીને, અમે આ રાજ્યોને ઍક્સેસ કરી શકીએ છીએ, જે, સંસ્કરણની સાથે, વધારાની સુગમતા પ્રદાન કરે છે.

અમારી પાસે તમામ મોડલ્સની સરળ ઍક્સેસ પણ છે

અને તેમની આવૃત્તિઓ

અગાઉના ફકરાની જેમ, બધી કામગીરી API નો ઉપયોગ કરીને કરી શકાય છે.

7. મોડલ જમાવો

આ તબક્કે, અમારી પાસે પહેલેથી જ પ્રશિક્ષિત (કેરા) મોડેલ છે. તમે તેનો ઉપયોગ કેવી રીતે કરી શકો તેનું ઉદાહરણ:

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 result

અહીં self.registry એ સગવડ માટે, mlflow.tracking.MlflowClient પર ફરીથી એક નાનું રેપર છે. મુદ્દો એ છે કે હું રિમોટ સર્વરને ઍક્સેસ કરું છું અને ત્યાં ઉલ્લેખિત નામ અને નવીનતમ ઉત્પાદન સંસ્કરણ સાથે મોડેલ શોધી રહ્યો છું. આગળ, હું આર્ટિફેક્ટને સ્થાનિક રીતે ./model ફોલ્ડરમાં ડાઉનલોડ કરું છું અને આ ડિરેક્ટરી mlflow.keras.load_model(local_path)માંથી મોડેલ બનાવું છું. હવે અમે અમારા મોડેલનો ઉપયોગ કરી શકીએ છીએ. CV (ML) ડેવલપર્સ સરળતાથી મોડલ સુધારી શકે છે અને નવા વર્ઝન પ્રકાશિત કરી શકે છે.

અંતમા

મેં એક સિસ્ટમ રજૂ કરી જે પરવાનગી આપે છે:

• ML મોડલ્સ, તાલીમની પ્રગતિ અને પરિણામો વિશેની માહિતી કેન્દ્રિય રીતે સંગ્રહિત કરો;
• ઝડપથી વિકાસ વાતાવરણ જમાવવું;
• મોડેલો પર કામની પ્રગતિનું નિરીક્ષણ અને વિશ્લેષણ કરો;
• મોડેલની સ્થિતિનું સંસ્કરણ અને સંચાલન કરવું તે અનુકૂળ છે;
• પરિણામી મોડેલો જમાવવાનું સરળ છે.

આ ઉદાહરણ એક રમકડું છે અને તમારી પોતાની સિસ્ટમ બનાવવા માટે પ્રારંભિક બિંદુ તરીકે સેવા આપે છે, જેમાં પરિણામોના મૂલ્યાંકનનું ઓટોમેશન અને મોડલની નોંધણી (અનુક્રમે પોઈન્ટ 5 અને 6) શામેલ હોઈ શકે છે અથવા તમે ડેટાસેટ્સનું સંસ્કરણ ઉમેરશો, અથવા કદાચ બીજું કંઈક? હું જે મુદ્દો બનાવવાનો પ્રયાસ કરી રહ્યો હતો તે એ છે કે તમારે સમગ્ર એમએલઓપ્સની જરૂર છે, એમએલફ્લો એ સમાપ્ત થવાનું એક સાધન છે.

લખો કે તમને કઈ સમસ્યાઓ આવી જે મેં દર્શાવી નથી?
તમારી જરૂરિયાતોને પૂર્ણ કરવા માટે તમે સિસ્ટમમાં શું ઉમેરશો?
સમસ્યાઓના તમામ અથવા ભાગને ઉકેલવા માટે તમે કયા સાધનો અને અભિગમોનો ઉપયોગ કરો છો?

PS હું કેટલીક લિંક્સ છોડીશ:
ગીથબ પ્રોજેક્ટ - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
પ્રશ્નો માટે મારું કાર્ય ઇમેઇલ - [ઇમેઇલ સુરક્ષિત]

અમારી કંપની સમયાંતરે આઇટી નિષ્ણાતો માટે વિવિધ ઇવેન્ટ્સનું આયોજન કરે છે, ઉદાહરણ તરીકે: 8 જુલાઇએ 19:00 મોસ્કો સમયે ઑનલાઇન ફોર્મેટમાં સીવી મીટઅપ થશે, જો તમને રસ હોય, તો તમે ભાગ લઈ શકો છો, નોંધણી અહીં .

સોર્સ: www.habr.com