🥇MLOps - कुक बुक, अध्याय 1

नमस्ते! मैं सीआरओसी में सीवी डेवलपर हूं। हम पिछले तीन वर्षों से सीवी के क्षेत्र में परियोजनाएं क्रियान्वित कर रहे हैं। इस दौरान हमने बहुत सी चीजें कीं, उदाहरण के लिए: हमने ड्राइवरों पर नजर रखी ताकि वे गाड़ी चलाते समय शराब न पीएं, धूम्रपान न करें, फोन पर बात न करें, सड़क की ओर न देखें, सपनों या बादलों की ओर न देखें। ; हमने ऐसे लोगों को रिकॉर्ड किया जो समर्पित लेन में गाड़ी चलाते हैं और कई पार्किंग स्थान घेरते हैं; यह सुनिश्चित किया गया कि श्रमिकों ने हेलमेट, दस्ताने आदि पहने हों; एक कर्मचारी की पहचान की गई जो सुविधा में प्रवेश करना चाहता है; हमने वह सब कुछ गिना जो हम कर सकते थे।

मैं यह सब किस लिये कर रहा हूँ?

परियोजनाओं को कार्यान्वित करने की प्रक्रिया में, हमें अनेक बाधाओं का सामना करना पड़ता है, कुछ ऐसी समस्याओं का सामना करना पड़ता है जिनसे आप या तो परिचित हैं या भविष्य में परिचित होंगे।

आइए स्थिति का अनुकरण करें

आइए कल्पना करें कि हमें एक युवा कंपनी "एन" में नौकरी मिली, जिसकी गतिविधियाँ एमएल से संबंधित हैं। हम एक एमएल (डीएल, सीवी) प्रोजेक्ट पर काम करते हैं, फिर किसी कारण से हम दूसरी नौकरी पर चले जाते हैं, आम तौर पर ब्रेक लेते हैं, और अपने या किसी और के न्यूरॉन पर लौट आते हैं।

सच्चाई का क्षण आता है, आपको किसी तरह यह याद रखने की ज़रूरत है कि आप कहाँ रुके थे, आपने कौन से हाइपरपैरामीटर आज़माए थे और, सबसे महत्वपूर्ण बात यह है कि उनके परिणाम क्या थे। सभी लॉन्चों की जानकारी किसने संग्रहीत की, इसके लिए कई विकल्प हो सकते हैं: हेड, कॉन्फ़िगरेशन, नोटपैड में, क्लाउड में कार्यशील वातावरण में। मुझे एक विकल्प देखने को मिला जब हाइपरपैरामीटर को कोड में टिप्पणी वाली पंक्तियों के रूप में संग्रहीत किया गया था, सामान्य तौर पर, कल्पना की उड़ान। अब कल्पना करें कि आप अपने प्रोजेक्ट पर नहीं, बल्कि किसी ऐसे व्यक्ति के प्रोजेक्ट पर लौटे हैं, जिसने कंपनी छोड़ दी है और आपको model_1.pb नामक एक कोड और मॉडल विरासत में मिला है। चित्र को पूरा करने और सारा दर्द बताने के लिए, आइए कल्पना करें कि आप भी एक शुरुआती विशेषज्ञ हैं।
आगे बढ़ो। कोड को चलाने के लिए, हमें और इसके साथ काम करने वाले सभी लोगों को एक वातावरण बनाने की आवश्यकता है। अक्सर ऐसा होता है कि किसी कारणवश उन्होंने उसे हमारी विरासत के रूप में नहीं छोड़ा। यह एक गैर-मामूली कार्य भी बन सकता है. आप इस कदम पर समय बर्बाद नहीं करना चाहेंगे, है ना?
हम एक मॉडल को प्रशिक्षित करते हैं (उदाहरण के लिए, एक कार डिटेक्टर)। हम उस बिंदु पर पहुंच जाते हैं जहां यह बहुत अच्छा हो जाता है - परिणाम को बचाने का समय आ गया है। चलिए इसे car_detection_v1.pb कहते हैं। फिर हम एक और प्रशिक्षण देते हैं - car_detection_v2.pb। कुछ समय बाद, हमारे सहकर्मी या हम स्वयं विभिन्न आर्किटेक्चर का उपयोग करके अधिक से अधिक सिखाते हैं। परिणामस्वरूप, कलाकृतियों का एक समूह बनता है, जिसके बारे में जानकारी श्रमसाध्य रूप से एकत्र की जानी चाहिए (लेकिन हम इसे बाद में करेंगे, क्योंकि अभी हमारे पास अधिक प्राथमिकता वाले मामले हैं)।
ठीक है अब सब ख़त्म हो गया! हमारे पास एक मॉडल है! क्या हम अगले मॉडल का प्रशिक्षण शुरू कर सकते हैं, एक नई समस्या को हल करने के लिए एक वास्तुकला विकसित कर सकते हैं, या क्या हम कुछ चाय पी सकते हैं? और कौन तैनात करेगा?

समस्याओं की पहचान करना

किसी प्रोजेक्ट या प्रोडक्ट पर काम करना कई लोगों का काम होता है। और समय के साथ, लोग चले जाते हैं और आते हैं, अधिक परियोजनाएँ होती हैं, और परियोजनाएँ स्वयं अधिक जटिल हो जाती हैं। एक तरह से या किसी अन्य, ऊपर वर्णित चक्र से (और न केवल) कुछ संयोजनों में स्थितियाँ पुनरावृत्ति से पुनरावृत्ति तक घटित होंगी। इन सबके परिणामस्वरूप समय की बर्बादी, भ्रम, घबराहट, संभवतः ग्राहक असंतोष और अंततः पैसे की हानि होती है। हालाँकि हम सभी आम तौर पर उसी पुराने ढर्रे पर चलते हैं, लेकिन मेरा मानना है कि कोई भी इन पलों को बार-बार नहीं जीना चाहता।

इसलिए, हम एक विकास चक्र से गुज़रे हैं और हम देखते हैं कि ऐसी समस्याएं हैं जिन्हें हल करने की आवश्यकता है। ऐसा करने के लिए आपको चाहिए:

कार्य परिणामों को सुविधाजनक रूप से संग्रहीत करना;
नए कर्मचारियों को शामिल करने की प्रक्रिया को सरल बनाएं;
विकास परिवेश को तैनात करने की प्रक्रिया को सरल बनाना;
मॉडल संस्करण प्रक्रिया को कॉन्फ़िगर करें;
मॉडलों को मान्य करने का एक सुविधाजनक तरीका है;
एक मॉडल राज्य प्रबंधन उपकरण ढूंढें;
मॉडलों को उत्पादन तक पहुंचाने का तरीका खोजें।

जाहिरा तौर पर एक ऐसे वर्कफ़्लो के साथ आना आवश्यक है जो आपको इस जीवन चक्र को आसानी से और आसानी से प्रबंधित करने की अनुमति देगा? इस अभ्यास को एमएलओपीएस कहा जाता है

मशीन लर्निंग के लिए एमएलओप्स या डेवऑप्स, डेटा साइंस और आईटी टीमों को मशीन लर्निंग मॉडल के लिए निगरानी, सत्यापन और शासन के माध्यम से मॉडल विकास और तैनाती की गति को सहयोग करने और बढ़ाने की अनुमति देता है।

आप कर सकते हैं आदरGoogle वाले इस सब के बारे में क्या सोचते हैं? लेख से यह स्पष्ट है कि एमएलओपीएस काफी बड़ी चीज़ है।

आगे अपने लेख में मैं प्रक्रिया के केवल एक भाग का वर्णन करूँगा। कार्यान्वयन के लिए, मैं एमएलफ्लो टूल का उपयोग करूंगा, क्योंकि... यह एक ओपन-सोर्स प्रोजेक्ट है, कनेक्ट करने के लिए थोड़ी मात्रा में कोड की आवश्यकता होती है और लोकप्रिय एमएल फ्रेमवर्क के साथ एकीकरण होता है। आप इंटरनेट पर अन्य टूल, जैसे कि क्यूबफ्लो, सेजमेकर, ट्रेन इत्यादि खोज सकते हैं, और संभवतः वह टूल ढूंढ सकते हैं जो आपकी आवश्यकताओं के लिए बेहतर हो।

MLFlow टूल का उपयोग करने के उदाहरण का उपयोग करके "बिल्डिंग" MLOps

एमएलफ्लो एमएल मॉडल के जीवनचक्र प्रबंधन के लिए एक खुला स्रोत मंच है (https://mlflow.org/).

एमएलफ़्लो में चार घटक शामिल हैं:

एमएलफ़्लो ट्रैकिंग - रिकॉर्डिंग परिणामों और मापदंडों के मुद्दों को शामिल करता है जिनके कारण यह परिणाम आया;
एमएलफ़्लो प्रोजेक्ट - आपको कोड को पैकेज करने और इसे किसी भी प्लेटफ़ॉर्म पर पुन: पेश करने की अनुमति देता है;
एमएलफ्लो मॉडल - उत्पादन में मॉडल तैनात करने के लिए जिम्मेदार;
एमएलफ़्लो रजिस्ट्री - आपको मॉडलों को संग्रहीत करने और एक केंद्रीकृत भंडार में उनकी स्थिति का प्रबंधन करने की अनुमति देती है।

एमएलफ़्लो दो संस्थाओं पर काम करता है:

लॉन्च प्रशिक्षण, मापदंडों और मेट्रिक्स का एक पूरा चक्र है जिसके द्वारा हम पंजीकरण करना चाहते हैं;
एक प्रयोग एक "विषय" है जो एक साथ चलता है।

उदाहरण के सभी चरण Ubuntu 18.04 ऑपरेटिंग सिस्टम पर लागू किए गए हैं।

1. सर्वर तैनात करें

अपने प्रोजेक्ट को आसानी से प्रबंधित करने और सभी आवश्यक जानकारी प्राप्त करने के लिए, हम एक सर्वर तैनात करेंगे। एमएलफ्लो ट्रैकिंग सर्वर के दो मुख्य घटक हैं:

बैकएंड स्टोर - पंजीकृत मॉडलों के बारे में जानकारी संग्रहीत करने के लिए जिम्मेदार (4 DBMS का समर्थन करता है: mysql, mssql, sqlite, और postgresql);
आर्टिफैक्ट स्टोर - कलाकृतियों को संग्रहीत करने के लिए जिम्मेदार (7 भंडारण विकल्पों का समर्थन करता है: अमेज़ॅन एस 3, एज़्योर ब्लॉब स्टोरेज, Google क्लाउड स्टोरेज, एफ़टीपी सर्वर, एसएफटीपी सर्वर, एनएफएस, एचडीएफएस)।

जैसा कलाकृतियों की दुकान सरलता के लिए, आइए एक 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
```

जैसा बैकएंड स्टोर आइए पोस्टग्रेस्क्ल लें।

$ 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() सक्षम करता हूँ। वर्तमान में एमएलफ्लो ट्रैकिंग टेन्सरफ्लो, केरास, ग्लूऑन एक्सजीबूस्ट, लाइटजीबीएम, स्पार्क के लिए स्वचालित लॉगिंग का समर्थन करती है। यदि आपको अपना ढांचा या लाइब्रेरी नहीं मिली है, तो आप हमेशा स्पष्ट रूप से लॉग इन कर सकते हैं। हम प्रशिक्षण शुरू कर रहे हैं. रिमोट सर्वर पर टैग और इनपुट पैरामीटर पंजीकृत करें।

कुछ पंक्तियाँ और हर किसी की तरह, आपके पास भी सभी लॉन्च के बारे में जानकारी तक पहुंच होगी। ठंडा?

3. हम परियोजना तैयार करते हैं

आइए अब प्रोजेक्ट लॉन्च करना आसान बनाएं। ऐसा करने के लिए, प्रोजेक्ट रूट में MLproject और conda.yaml फ़ाइल जोड़ें।
एमएलप्रोजेक्ट

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

एमएलफ़्लो प्रोजेक्ट में कई गुण हैं:

नाम - आपके प्रोजेक्ट का नाम;
पर्यावरण - मेरे मामले में, conda_env इंगित करता है कि एनाकोंडा को चलाने के लिए उपयोग किया जाता है और निर्भरता विवरण 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 .

कमांड दर्ज करने के बाद, एक कॉन्डा वातावरण स्वचालित रूप से बनाया जाएगा और प्रशिक्षण शुरू हो जाएगा।
उपरोक्त उदाहरण में, मैंने प्रशिक्षण के लिए युगों की संख्या पारित की, जिन श्रेणियों को हम विभाजित करना चाहते हैं (आप पूरी सूची देख सकते हैं) यहां) और हमारे रिमोट सर्वर का पता।
संभावित मापदंडों की पूरी सूची एमएलप्रोजेक्ट फ़ाइल में पाई जा सकती है।

5. सीखने के परिणामों का मूल्यांकन करें

प्रशिक्षण पूरा करने के बाद, हम ब्राउज़र में अपने सर्वर के पते पर जा सकते हैं http://server_host:server_port

यहां हम सभी प्रयोगों की एक सूची (ऊपर बाएं), साथ ही रनों (मध्य) पर जानकारी देखते हैं। हम प्रत्येक लॉन्च के लिए अधिक विस्तृत जानकारी (पैरामीटर, मेट्रिक्स, कलाकृतियाँ और कुछ अतिरिक्त जानकारी) देख सकते हैं।

प्रत्येक मीट्रिक के लिए हम परिवर्तनों का इतिहास देख सकते हैं

वे। फिलहाल हम "मैनुअल" मोड में परिणामों का विश्लेषण कर सकते हैं, और आप एमएलफ़्लो एपीआई का उपयोग करके स्वचालित सत्यापन भी सेट कर सकते हैं।

6. मॉडल पंजीकृत करें

जब हमने अपने मॉडल का विश्लेषण किया और निर्णय लिया कि यह युद्ध के लिए तैयार है, तो हम इसे पंजीकृत करने के लिए आगे बढ़ते हैं, इसके लिए हम उस लॉन्च का चयन करते हैं जिसकी हमें आवश्यकता है (जैसा कि पिछले पैराग्राफ में दिखाया गया है) और नीचे जाएं।

जब हम अपने मॉडल को एक नाम देते हैं, तो उसका एक संस्करण होता है। यदि आप समान नाम से कोई अन्य मॉडल सहेजते हैं, तो संस्करण स्वचालित रूप से अपग्रेड हो जाएगा।

प्रत्येक मॉडल के लिए, हम एक विवरण जोड़ सकते हैं और तीन राज्यों (स्टेजिंग, उत्पादन, संग्रहीत) में से एक का चयन कर सकते हैं; बाद में, एपीआई का उपयोग करके, हम इन राज्यों तक पहुंच सकते हैं, जो संस्करण के साथ-साथ अतिरिक्त लचीलापन प्रदान करता है।

हमारे पास सभी मॉडलों तक आसान पहुंच भी है

और उनके संस्करण

पिछले पैराग्राफ की तरह, सभी ऑपरेशन एपीआई का उपयोग करके किए जा सकते हैं।

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 के ऊपर एक छोटा आवरण है। मुद्दा यह है कि मैं एक दूरस्थ सर्वर तक पहुंचता हूं और वहां निर्दिष्ट नाम और नवीनतम उत्पादन संस्करण के साथ एक मॉडल की तलाश करता हूं। इसके बाद, मैं आर्टिफैक्ट को स्थानीय रूप से ./मॉडल फ़ोल्डर में डाउनलोड करता हूं और इस निर्देशिका mlflow.keras.load_model(local_path) से मॉडल बनाता हूं। अब हम अपने मॉडल का उपयोग कर सकते हैं। सीवी (एमएल) डेवलपर्स आसानी से मॉडल में सुधार कर सकते हैं और नए संस्करण प्रकाशित कर सकते हैं।

अंत में

मैंने एक प्रणाली प्रस्तुत की जो अनुमति देती है:

एमएल मॉडल, प्रशिक्षण प्रगति और परिणामों के बारे में जानकारी केंद्रीय रूप से संग्रहीत करें;
एक विकास वातावरण को शीघ्रता से तैनात करें;
मॉडलों पर कार्य की प्रगति की निगरानी और विश्लेषण करना;
मॉडलों की स्थिति का संस्करण और प्रबंधन करना सुविधाजनक है;
परिणामी मॉडलों को तैनात करना आसान है।

यह उदाहरण एक खिलौना है और आपके स्वयं के सिस्टम के निर्माण के लिए शुरुआती बिंदु के रूप में कार्य करता है, जिसमें परिणामों के मूल्यांकन का स्वचालन और मॉडलों का पंजीकरण (क्रमशः अंक 5 और 6) शामिल हो सकता है या आप डेटासेट का संस्करण जोड़ देंगे, या शायद कुछ और? मैं जो कहना चाह रहा था वह यह है कि आपको समग्र रूप से MLOps की आवश्यकता है, MLflow केवल अंत का एक साधन है।

लिखें कि आपको किन समस्याओं का सामना करना पड़ा जिन्हें मैंने प्रदर्शित नहीं किया?
अपनी आवश्यकताओं को पूरा करने के लिए आप सिस्टम में क्या जोड़ेंगे?
सभी या कुछ समस्याओं को हल करने के लिए आप कौन से उपकरण और दृष्टिकोण का उपयोग करते हैं?

पुनश्च मैं कुछ लिंक छोड़ूंगा:
जीथब परियोजना - https://github.com/simbakot/mlflow_example
एमएलफ्लो - https://mlflow.org/
प्रश्नों के लिए मेरा कार्य ईमेल - [ईमेल संरक्षित]

हमारी कंपनी समय-समय पर आईटी विशेषज्ञों के लिए विभिन्न कार्यक्रम आयोजित करती है, उदाहरण के लिए: 8 जुलाई को 19:00 मास्को समय पर ऑनलाइन प्रारूप में एक सीवी मीटअप होगा, यदि आप रुचि रखते हैं, तो आप भाग ले सकते हैं, पंजीकरण कर सकते हैं यहां .

स्रोत: www.habr.com

एमएलओपीएस - कुक बुक, अध्याय 1