🥇MLOps - หนังสือทำอาหารบทที่ 1

สวัสดีทุกคน! ฉันเป็นนักพัฒนา CV ที่ CROC เราได้ดำเนินโครงการในด้าน CV มาเป็นเวลา 3 ปีแล้ว ช่วงนี้เราทำหลายอย่าง เช่น เฝ้าดูคนขับขณะขับรถไม่ดื่ม ไม่สูบบุหรี่ ไม่คุยโทรศัพท์ มองถนน ไม่ฝัน ไม่มองก้อนเมฆ ; เราบันทึกภาพผู้คนที่ขับรถในเลนเฉพาะและที่จอดรถหลายคัน ตรวจสอบให้แน่ใจว่าคนงานสวมหมวกกันน็อค ถุงมือ ฯลฯ ระบุพนักงานที่ต้องการเข้าสถานที่ เรานับทุกสิ่งที่เราทำได้

ฉันทำทั้งหมดนี้ไปเพื่ออะไร?

ในกระบวนการดำเนินโครงการ เราเจออุปสรรค อุปสรรคมากมาย ปัญหาบางอย่างที่คุณคุ้นเคยหรือจะคุ้นเคยในอนาคต

มาจำลองสถานการณ์กัน

ลองนึกดูว่าเราได้งานในบริษัทเล็กๆ “N” ซึ่งมีกิจกรรมที่เกี่ยวข้องกับ ML เราทำงานในโปรเจ็กต์ ML (DL, CV) จากนั้นด้วยเหตุผลบางอย่าง เราจึงเปลี่ยนไปทำงานอื่น โดยทั่วไปจะหยุดพัก และกลับไปสู่เซลล์ประสาทของเราหรือของคนอื่น

ช่วงเวลาแห่งความจริงมาถึงแล้ว คุณต้องจำไว้ว่าคุณหยุดตรงไหน ไฮเปอร์พารามิเตอร์ใดที่คุณลองใช้ และที่สำคัญที่สุดคือผลลัพธ์ใดที่พวกเขานำไปสู่ มีหลายตัวเลือกสำหรับผู้ที่จัดเก็บข้อมูลในการเปิดตัวทั้งหมด: ในส่วนหัว, การกำหนดค่า, แผ่นจดบันทึก, ในสภาพแวดล้อมการทำงานบนคลาวด์ ฉันบังเอิญเห็นตัวเลือกเมื่อไฮเปอร์พารามิเตอร์ถูกจัดเก็บเป็นบรรทัดแสดงความคิดเห็นในโค้ด โดยทั่วไปแล้ว เป็นการบินที่แปลกประหลาด ทีนี้ลองจินตนาการว่าคุณไม่ได้กลับมาที่โปรเจ็กต์ของคุณ แต่กลับมาที่โปรเจ็กต์ของบุคคลที่ลาออกจากบริษัท และคุณได้รับรหัสและโมเดลที่เรียกว่า model_1.pb เพื่อให้ภาพสมบูรณ์และถ่ายทอดความเจ็บปวดทั้งหมด ลองจินตนาการว่าคุณเป็นผู้เชี่ยวชาญมือใหม่เช่นกัน
ไปข้างหน้า. ในการรันโค้ด เราและทุกคนที่จะร่วมงานด้วยจะต้องสร้างสภาพแวดล้อม บ่อยครั้งเกิดขึ้นที่พวกเขาไม่ได้ทิ้งเขาไว้เป็นมรดกของเราด้วยเหตุผลบางอย่าง นี่อาจกลายเป็นงานที่ไม่สำคัญก็ได้ คุณคงไม่อยากเสียเวลากับขั้นตอนนี้ใช่ไหม?
เราฝึกโมเดล (เช่น เครื่องตรวจจับรถยนต์) เรามาถึงจุดที่มันดีมาก – ถึงเวลาบันทึกผลลัพธ์แล้ว เรียกมันว่า car_detection_v1.pb กันดีกว่า จากนั้นเราก็ฝึกอีกอัน - car_detection_v2.pb หลังจากนั้นไม่นาน เพื่อนร่วมงานของเราหรือตัวเราเองก็สอนมากขึ้นเรื่อยๆ โดยใช้สถาปัตยกรรมที่แตกต่างกัน เป็นผลให้มีการสร้างสิ่งประดิษฐ์จำนวนมาก ข้อมูลที่ต้องรวบรวมอย่างระมัดระวัง (แต่เราจะทำสิ่งนี้ในภายหลัง เพราะตอนนี้เรามีเรื่องสำคัญมากกว่า)
โอเค จบแล้ว! เรามีนางแบบแล้ว! เราจะเริ่มฝึกโมเดลถัดไป พัฒนาสถาปัตยกรรมเพื่อแก้ปัญหาใหม่ หรือไปดื่มชากันดี? แล้วใครจะจัดทัพล่ะ?

การระบุปัญหา

การทำงานในโครงการหรือผลิตภัณฑ์เป็นงานของหลายๆ คน และเมื่อเวลาผ่านไป ผู้คนออกและกลับมา มีโครงการเพิ่มมากขึ้น และโครงการเองก็มีความซับซ้อนมากขึ้น ไม่ทางใดก็ทางหนึ่ง สถานการณ์จากวงจรที่อธิบายไว้ข้างต้น (และไม่เพียงเท่านั้น) ในชุดค่าผสมบางอย่างจะเกิดขึ้นจากการวนซ้ำไปจนถึงการวนซ้ำ ทั้งหมดนี้ส่งผลให้เกิดการเสียเวลา ความสับสน ความประหม่า ความไม่พอใจของลูกค้า และท้ายที่สุดคือการสูญเสียเงิน แม้ว่าเราทุกคนมักจะติดตามคราดแบบเดิมๆ แต่ฉันเชื่อว่าไม่มีใครอยากหวนนึกถึงช่วงเวลาเหล่านี้ซ้ำแล้วซ้ำเล่า

ดังนั้นเราจึงได้ผ่านวงจรการพัฒนาหนึ่งรอบและเราเห็นว่ามีปัญหาที่ต้องแก้ไข ในการทำเช่นนี้คุณต้องมี:

จัดเก็บผลงานได้สะดวก
ทำให้กระบวนการดึงดูดพนักงานใหม่ให้ง่ายขึ้น
ลดความซับซ้อนของกระบวนการปรับใช้สภาพแวดล้อมการพัฒนา
กำหนดค่ากระบวนการกำหนดเวอร์ชันของโมเดล
มีวิธีที่สะดวกในการตรวจสอบโมเดล
ค้นหาเครื่องมือการจัดการสถานะแบบจำลอง
ค้นหาวิธีส่งมอบแบบจำลองสู่การผลิต

เห็นได้ชัดว่าจำเป็นต้องมีขั้นตอนการทำงานที่จะช่วยให้คุณจัดการวงจรชีวิตนี้ได้อย่างง่ายดายและสะดวก? การปฏิบัตินี้เรียกว่า MLOps

MLOps หรือ DevOps สำหรับการเรียนรู้ของเครื่อง ช่วยให้ทีมวิทยาศาสตร์ข้อมูลและไอทีสามารถทำงานร่วมกันและเพิ่มความเร็วของการพัฒนาโมเดลและการปรับใช้ผ่านการตรวจสอบ การตรวจสอบ และการกำกับดูแลสำหรับโมเดลการเรียนรู้ของเครื่อง

สามารถ เพื่ออ่านพวก Google คิดอย่างไรกับเรื่องทั้งหมดนี้? จากบทความเป็นที่ชัดเจนว่า MLOps เป็นสิ่งที่ค่อนข้างใหญ่โต

นอกจากนี้ในบทความของฉัน ฉันจะอธิบายเพียงส่วนหนึ่งของกระบวนการเท่านั้น สำหรับการนำไปใช้งาน ฉันจะใช้เครื่องมือ MLflow เพราะ... นี่เป็นโปรเจ็กต์โอเพ่นซอร์ส ต้องใช้โค้ดจำนวนเล็กน้อยในการเชื่อมต่อ และมีการผสานรวมกับเฟรมเวิร์ก ml ยอดนิยม คุณสามารถค้นหาเครื่องมืออื่นๆ ในอินเทอร์เน็ตได้ เช่น Kubeflow, SageMaker, Trains ฯลฯ และอาจพบเครื่องมือที่ตรงกับความต้องการของคุณมากกว่า

“การสร้าง” MLOps โดยใช้ตัวอย่างการใช้เครื่องมือ MLFlow

MLFlow เป็นแพลตฟอร์มโอเพ่นซอร์สสำหรับการจัดการวงจรชีวิตของโมเดล ml (https://mlflow.org/).

MLflow ประกอบด้วยสี่องค์ประกอบ:

การติดตาม MLflow - ครอบคลุมปัญหาของการบันทึกผลลัพธ์และพารามิเตอร์ที่นำไปสู่ผลลัพธ์นี้
โครงการ MLflow - ช่วยให้คุณสามารถจัดทำโค้ดและทำซ้ำบนแพลตฟอร์มใดก็ได้
โมเดล MLflow - รับผิดชอบในการปรับใช้โมเดลกับการผลิต
MLflow Registry - ช่วยให้คุณจัดเก็บโมเดลและจัดการสถานะในที่เก็บข้อมูลส่วนกลาง

MLflow ดำเนินงานในสองหน่วยงาน:

การเปิดตัวคือวงจรการฝึกอบรม พารามิเตอร์ และตัวชี้วัดที่เราต้องการบันทึก
การทดสอบคือ "หัวข้อ" ที่ทำงานร่วมกัน

ขั้นตอนทั้งหมดของตัวอย่างถูกนำไปใช้บนระบบปฏิบัติการ Ubuntu 18.04

1. ปรับใช้เซิร์ฟเวอร์

เพื่อให้เราจัดการโครงการของเราได้อย่างง่ายดายและรับข้อมูลที่จำเป็นทั้งหมด เราจะปรับใช้เซิร์ฟเวอร์ เซิร์ฟเวอร์การติดตาม MLflow มีสององค์ประกอบหลัก:

ร้านค้าแบ็กเอนด์ - รับผิดชอบในการจัดเก็บข้อมูลเกี่ยวกับรุ่นที่ลงทะเบียน (รองรับ 4 DBMS: 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.php
```
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. เพิ่มการติดตาม

เพื่อไม่ให้ผลลัพธ์ของการฝึกอบรมของเราสูญหาย นักพัฒนารุ่นต่อๆ ไปจะต้องเข้าใจสิ่งที่เกิดขึ้น และเพื่อให้สหายที่มีอายุมากกว่าและคุณสามารถวิเคราะห์กระบวนการเรียนรู้อย่างใจเย็น เราจำเป็นต้องเพิ่มการติดตาม การติดตามหมายถึงการบันทึกพารามิเตอร์ ตัวชี้วัด อาร์ติแฟกต์ และข้อมูลเพิ่มเติมใดๆ เกี่ยวกับการเริ่มการฝึกอบรม ในกรณีของเรา บนเซิร์ฟเวอร์

เช่น ฉันสร้างสิ่งเล็กๆ โครงการบน GitHub บน Keras เพื่อแบ่งส่วนทุกอย่างที่มีอยู่ ชุดข้อมูล 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 Tracking รองรับการบันทึกอัตโนมัติสำหรับ TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark หากคุณไม่พบเฟรมเวิร์กหรือไลบรารีของคุณ คุณสามารถบันทึกได้อย่างชัดเจนเสมอ เรากำลังเริ่มการฝึกอบรม ลงทะเบียนแท็กและพารามิเตอร์อินพุตบนเซิร์ฟเวอร์ระยะไกล

สองสามบรรทัดและคุณก็สามารถเข้าถึงข้อมูลเกี่ยวกับการเปิดตัวทั้งหมดได้เช่นเดียวกับคนอื่นๆ เย็น?

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

โครงการ 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 ต้องติดตั้ง Anaconda บนคอมพิวเตอร์ของคุณ (แต่คุณสามารถหลีกเลี่ยงสิ่งนี้ได้ด้วยการติดตั้งแพ็คเกจที่จำเป็นทั้งหมดด้วยตัวเองและเล่นกับพารามิเตอร์การเปิดตัว)

เสร็จสิ้นทุกขั้นตอนการเตรียมการและเริ่มการฝึกอบรมได้ จากรูทโปรเจ็กต์:

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

หลังจากป้อนคำสั่ง สภาพแวดล้อม conda จะถูกสร้างขึ้นโดยอัตโนมัติ และการฝึกอบรมจะเริ่มขึ้น
ในตัวอย่างด้านบน ฉันส่งผ่านจำนวนยุคสำหรับการฝึกอบรม หมวดหมู่ที่เราต้องการแบ่งส่วน (คุณสามารถดูรายการทั้งหมดได้) ที่นี่) และที่อยู่ของเซิร์ฟเวอร์ระยะไกลของเรา
รายการพารามิเตอร์ที่เป็นไปได้ทั้งหมดสามารถพบได้ในไฟล์ MLproject

5. ประเมินผลการเรียนรู้

หลังจากเสร็จสิ้นการฝึกอบรมเราสามารถไปที่เบราว์เซอร์ไปยังที่อยู่เซิร์ฟเวอร์ของเราได้ http://server_host:server_port

ที่นี่เราจะเห็นรายการการทดลองทั้งหมด (ซ้ายบน) รวมถึงข้อมูลเกี่ยวกับการวิ่ง (กลาง) เราสามารถดูข้อมูลโดยละเอียดเพิ่มเติมได้ (พารามิเตอร์ ตัวชี้วัด อาร์ติแฟกต์ และข้อมูลเพิ่มเติม) สำหรับการเปิดตัวแต่ละครั้ง

สำหรับแต่ละเมตริก เราสามารถสังเกตประวัติการเปลี่ยนแปลงได้

เหล่านั้น. ในขณะนี้ เราสามารถวิเคราะห์ผลลัพธ์ในโหมด “ด้วยตนเอง” และคุณยังสามารถตั้งค่าการตรวจสอบอัตโนมัติโดยใช้ MLflow API ได้อีกด้วย

6. ลงทะเบียนโมเดล

หลังจากที่เราได้วิเคราะห์แบบจำลองของเราและตัดสินใจว่าพร้อมสำหรับการต่อสู้แล้ว เราจะดำเนินการลงทะเบียนมัน เพื่อสิ่งนี้ เราเลือกการเปิดตัวที่เราต้องการ (ดังแสดงในย่อหน้าก่อนหน้า) และลงไป

หลังจากที่เราตั้งชื่อโมเดลของเราแล้ว มันก็จะมีเวอร์ชัน หากคุณบันทึกโมเดลอื่นด้วยชื่อเดียวกัน เวอร์ชันนั้นจะได้รับการอัปเกรดโดยอัตโนมัติ

สำหรับแต่ละรุ่น เราสามารถเพิ่มคำอธิบายและเลือกหนึ่งในสามสถานะ (การจัดเตรียม การผลิต และการเก็บถาวร) ต่อมา เมื่อใช้ API เราสามารถเข้าถึงสถานะเหล่านี้ ซึ่งนอกจากการกำหนดเวอร์ชันแล้ว ยังให้ความยืดหยุ่นเพิ่มเติมด้วย

เรายังเข้าถึงได้ทุกรุ่นอย่างง่ายดาย

และเวอร์ชันของพวกเขา

เช่นเดียวกับในย่อหน้าก่อนหน้า การดำเนินการทั้งหมดสามารถทำได้โดยใช้ API

7. ปรับใช้โมเดล

ในขั้นตอนนี้ เรามีโมเดลที่ผ่านการฝึกอบรม (keras) แล้ว ตัวอย่างวิธีการใช้งาน:

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 เป็น wrapper ขนาดเล็กอีกครั้งบน mlflow.tracking.MlflowClient เพื่อความสะดวก ประเด็นก็คือ ฉันเข้าถึงเซิร์ฟเวอร์ระยะไกลและค้นหาโมเดลที่นั่นซึ่งมีชื่อที่ระบุ และเวอร์ชันที่ใช้งานจริงล่าสุด ต่อไป ฉันจะดาวน์โหลดอาร์ติแฟกต์แบบโลคัลไปยังโฟลเดอร์ ./model และสร้างโมเดลจากไดเร็กทอรีนี้ mlflow.keras.load_model(local_path) ตอนนี้เราสามารถใช้โมเดลของเราได้แล้ว นักพัฒนา CV (ML) สามารถปรับปรุงโมเดลและเผยแพร่เวอร์ชันใหม่ได้อย่างง่ายดาย

ในข้อสรุป

ฉันนำเสนอระบบที่ช่วยให้:

จัดเก็บข้อมูลจากส่วนกลางเกี่ยวกับโมเดล ML ความคืบหน้าและผลลัพธ์ของการฝึกอบรม
ปรับใช้สภาพแวดล้อมการพัฒนาอย่างรวดเร็ว
ติดตามและวิเคราะห์ความคืบหน้าของงานในแบบจำลอง
สะดวกในการกำหนดเวอร์ชันและจัดการสถานะของโมเดล
ง่ายต่อการปรับใช้โมเดลผลลัพธ์

ตัวอย่างนี้เป็นของเล่นและทำหน้าที่เป็นจุดเริ่มต้นสำหรับการสร้างระบบของคุณเองซึ่งอาจรวมถึงการประเมินผลลัพธ์อัตโนมัติและการลงทะเบียนแบบจำลอง (จุดที่ 5 และ 6 ตามลำดับ) หรือคุณจะเพิ่มการกำหนดเวอร์ชันของชุดข้อมูลหรืออาจเป็นอย่างอื่น ? จุดที่ฉันพยายามทำคือคุณต้องการ MLOps โดยรวม MLflow เป็นเพียงหนทางสู่จุดจบ

เขียนปัญหาที่คุณพบซึ่งฉันไม่ได้แสดง?
คุณจะเพิ่มอะไรลงในระบบเพื่อให้ตรงตามความต้องการของคุณ?
คุณใช้เครื่องมือและวิธีการใดในการแก้ปัญหาทั้งหมดหรือบางส่วน?

ป.ล. ฉันจะทิ้งลิงก์ไว้สองสามลิงก์:
โครงการ GitHub - https://github.com/simbakot/mlflow_example
เอ็มแอลโฟลว์ - https://mlflow.org/
อีเมลที่ทำงานของฉันสำหรับคำถาม - [ป้องกันอีเมล]

บริษัทของเราจัดกิจกรรมต่างๆ สำหรับผู้เชี่ยวชาญด้านไอทีเป็นระยะๆ เช่น ในวันที่ 8 กรกฎาคม เวลา 19:00 น. ตามเวลามอสโก จะมีการพบปะ CV ในรูปแบบออนไลน์ หากคุณสนใจ สามารถเข้าร่วม ลงทะเบียนได้ ที่นี่ .

ที่มา: will.com

MLOps - หนังสือทำอาหารบทที่ 1