MLOps - ספר בישול, פרק 1

שלום לכולם! אני מפתח קורות חיים ב-CROC. אנו מיישמים פרויקטים בתחום קורות החיים כבר 3 שנים. בזמן הזה עשינו הרבה דברים, למשל: עקבנו אחרי נהגים כדי שבזמן הנהיגה הם לא שתו, לא עישנו, לא דיברו בטלפון, הסתכלו על הכביש, ולא על חלומות או על העננים. ; הקלטנו אנשים שנוסעים בנתיבים ייעודיים ותופסים מספר מקומות חניה; דאג לכך שהעובדים יחבשו קסדות, כפפות וכו'; זיהה עובד שרוצה להיכנס למתקן; ספרנו כל מה שיכולנו.

בשביל מה אני עושה את כל זה?

בתהליך ביצוע הפרויקטים פגענו במהמורות, הרבה מהמורות, חלק מהבעיות שאתה מכיר או שתכיר בעתיד.

דוגמנות המצב

בואו נדמיין שקיבלנו עבודה בחברה צעירה "N", שפעילותה קשורה ל-ML. אנחנו עובדים על פרויקט ML (DL, CV), ואז מסיבה כלשהי אנחנו עוברים לעבודה אחרת, בדרך כלל לוקחים הפסקה וחוזרים לנוירון שלנו או של מישהו אחר.

1. רגע האמת מגיע, אתה צריך איכשהו לזכור איפה עצרת, לאילו היפרפרמטרים ניסית ובעיקר, לאילו תוצאות הם הובילו. יכולות להיות אפשרויות רבות למי שמר מידע בכל ההשקות: בראש, בתצורות, בפנקס רשימות, בסביבת עבודה בענן. במקרה ראיתי אפשרות כאשר היפרפרמטרים אוחסנו כשורות הערות בקוד, באופן כללי, מראה מפואר. עכשיו דמיינו שחזרתם לא לפרויקט שלכם, אלא לפרויקט של אדם שעזב את החברה וירשתם קוד ומודל בשם model_1.pb. כדי להשלים את התמונה ולהעביר את כל הכאב, בואו נדמיין שאתה גם מומחה מתחיל.
2. לך על זה. כדי להפעיל את הקוד, אנחנו וכל מי שיעבוד איתו צריכים ליצור סביבה. לעתים קרובות קורה שמשום מה לא השאירו אותו בתור הירושה שלנו. זו יכולה גם להפוך למשימה לא טריוויאלית. אתה לא רוצה לבזבז זמן על הצעד הזה, נכון?
3. אנו מאמנים דגם (למשל, גלאי רכב). הגענו לנקודה שבה זה הופך להיות טוב מאוד - הגיע הזמן לשמור את התוצאה. בואו נקרא לזה car_detection_v1.pb. לאחר מכן אנו מאמנים עוד אחד - car_detection_v2.pb. זמן מה לאחר מכן, הקולגות שלנו או אנחנו בעצמנו מלמדים יותר ויותר, תוך שימוש בארכיטקטורות שונות. כתוצאה מכך נוצרת חבורה של חפצים, שעליהם יש לאסוף מידע בקפידה (אבל נעשה זאת מאוחר יותר, כי לעת עתה יש לנו עניינים עדיפות יותר).
4. בסדר הכל נגמר עכשיו! יש לנו דגם! האם נוכל להתחיל לאמן את המודל הבא, לפתח ארכיטקטורה לפתרון בעיה חדשה, או שנוכל ללכת לשתות תה? ומי יפרס?

זיהוי בעיות

עבודה על פרויקט או מוצר היא עבודה של אנשים רבים. ועם הזמן אנשים עוזבים ובאים, יש יותר פרויקטים, והפרויקטים עצמם הופכים מורכבים יותר. כך או אחרת, מצבים מהמחזור המתואר לעיל (ולא רק) בשילובים מסוימים יתרחשו מאיטרציה לאיטרציה. כל זה גורם לבזבוז זמן, בלבול, עצבים, אולי חוסר שביעות רצון של לקוחות, ובסופו של דבר, כסף אבוד. למרות שכולנו בדרך כלל עוקבים אחר אותה מגרפה ישנה, ​​אני מאמין שאף אחד לא רוצה לשחזר את הרגעים האלה שוב ושוב.

אז, עברנו מחזור פיתוח אחד ואנחנו רואים שיש בעיות שצריך לפתור. כדי לעשות זאת אתה צריך:

• אחסן בצורה נוחה תוצאות עבודה;
• להפוך את תהליך שיתוף העובדים החדשים לפשוט;
• לפשט את תהליך פריסת סביבת פיתוח;
• להגדיר את תהליך גירסת המודל;
• יש דרך נוחה לאמת מודלים;
• למצוא כלי לניהול מצב מודל;
• למצוא דרך להעביר דגמים לייצור.

כנראה שיש צורך להמציא זרימת עבודה שתאפשר לך לנהל בקלות ובנוחות את מחזור החיים הזה? תרגול זה נקרא MLOps

MLOps, או DevOps ללמידת מכונה, מאפשרת לצוותי מדעי הנתונים ו-IT לשתף פעולה ולהגביר את קצב הפיתוח והפריסה של המודלים באמצעות ניטור, אימות וממשל עבור מודלים של למידת מכונה.

אתה יכול לקרואמה חושבים החבר'ה של גוגל על ​​כל זה? מהמאמר ברור ש-MLOps הוא דבר די נפח.

בהמשך המאמר שלי אתאר רק חלק מהתהליך. לצורך הטמעה, אשתמש בכלי MLflow, כי... זהו פרויקט בקוד פתוח, נדרשת כמות קטנה של קוד כדי להתחבר ויש אינטגרציה עם מסגרות ml פופולריות. אתה יכול לחפש באינטרנט כלים אחרים כמו Kubeflow, SageMaker, Trains וכו' ואולי למצוא אחד שמתאים יותר לצרכים שלך.

"בניית" MLOps באמצעות הדוגמה של שימוש בכלי MLFlow

MLFlow היא פלטפורמת קוד פתוח לניהול מחזור החיים של דגמי ml (https://mlflow.org/).

MLflow כולל ארבעה מרכיבים:

• MLflow Tracking - מכסה את הבעיות של רישום תוצאות ופרמטרים שהובילו לתוצאה זו;
• MLflow Project - מאפשר לארוז קוד ולשכפל אותו בכל פלטפורמה;
• MLflow Models - אחראי על פריסת מודלים לייצור;
• MLflow Registry - מאפשר לך לאחסן מודלים ולנהל את מצבם במאגר מרכזי.

MLflow פועלת על שתי ישויות:

• השקה היא מחזור שלם של אימונים, פרמטרים ומדדים שלפיהם אנו רוצים להירשם;
• ניסוי הוא "נושא" שפועל ביחד.

כל השלבים של הדוגמה מיושמים במערכת ההפעלה אובונטו 18.04.

1. פרוס את השרת

על מנת שנוכל לנהל בקלות את הפרויקט שלנו ולקבל את כל המידע הדרוש, נפרוס שרת. לשרת מעקב MLflow שני מרכיבים עיקריים:

• backend store - אחראי על אחסון מידע על דגמים רשומים (תומך ב-4 DBMSs: mysql, mssql, sqlite ו-postgresql);
• חנות artifact - אחראית על אחסון חפצים (תומך ב-7 אפשרויות אחסון: Amazon S3, Azure Blob Storage, Google Cloud Storage, שרת FTP, SFTP Server, 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. הוסף מעקב

כדי שתוצאות ההדרכה שלנו לא יאבדו, דורות העתיד של מפתחים יבינו מה קורה, וכדי שחברים מבוגרים ואתם תוכלו לנתח ברוגע את תהליך הלמידה, עלינו להוסיף מעקב. מעקב משמעו שמירת פרמטרים, מדדים, חפצים וכל מידע נוסף על תחילת האימון, במקרה שלנו, בשרת.

לדוגמה, יצרתי קטן פרויקט ב-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 לשורש הפרויקט.
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}"

לפרויקט 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

אתה יכול להשתמש ב-docer כסביבת זמן הריצה שלך, לפרטים נוספים עיין תיעוד.

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 .

לאחר הזנת הפקודה, סביבת קונדה תיווצר אוטומטית והאימון יתחיל.
בדוגמה למעלה העברתי את מספר העידנים לאימון, הקטגוריות אליהן נרצה לפלח (תוכלו לראות את הרשימה המלאה כאן) והכתובת של השרת המרוחק שלנו.
רשימה מלאה של פרמטרים אפשריים ניתן למצוא בקובץ MLproject.

5. הערכת תוצאות למידה

לאחר השלמת ההדרכה, נוכל לעבור בדפדפן לכתובת השרת שלנו http://server_host:server_port

כאן אנו רואים רשימה של כל הניסויים (משמאל למעלה), וכן מידע על ריצות (באמצע). אנו יכולים להציג מידע מפורט יותר (פרמטרים, מדדים, חפצים ומידע נוסף) עבור כל השקה.

עבור כל מדד נוכל לצפות בהיסטוריה של השינויים

הָהֵן. נכון לעכשיו, אנו יכולים לנתח את התוצאות במצב "ידני", וניתן גם להגדיר אימות אוטומטי באמצעות ה-API של MLflow.

6. רשום את הדגם

לאחר שניתחנו את הדגם שלנו והחלטנו שהוא מוכן לקרב, אנו ממשיכים לרשום אותו, לשם כך נבחר את ההשקה שאנו צריכים (כפי שמוצג בפסקה הקודמת) ויורדים למטה.

לאחר שאנו נותנים לדגם שלנו שם, יש לו גרסה. אם תשמרו דגם אחר באותו שם, הגרסה תשודרג אוטומטית.

עבור כל דגם, נוכל להוסיף תיאור ולבחור באחד משלושת המצבים (Staging, Production, Archived); לאחר מכן, באמצעות ה-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 הוא שוב מעטפת קטנה מעל mlflow.tracking.MlflowClient, מטעמי נוחות. הנקודה היא שאני ניגש לשרת מרוחק ומחפש שם דגם עם השם שצוין, וגרסת הייצור העדכנית ביותר. לאחר מכן, אני מוריד את החפץ באופן מקומי לתיקיית ./model ובונה את המודל מהספרייה הזו mlflow.keras.load_model(local_path). עכשיו אנחנו יכולים להשתמש במודל שלנו. מפתחי CV (ML) יכולים בקלות לשפר את המודל ולפרסם גרסאות חדשות.

לסיכום

הצגתי מערכת שמאפשרת:

• אחסן מידע מרכזי על מודלים של ML, התקדמות האימון והתוצאות;
• לפרוס במהירות סביבת פיתוח;
• לנטר ולנתח את התקדמות העבודה על מודלים;
• זה נוח לגרסה ולנהל את מצב הדגמים;
• קל לפרוס את המודלים המתקבלים.

דוגמה זו היא צעצוע ומשמשת כנקודת התחלה לבניית מערכת משלך, שעשויה לכלול אוטומציה של הערכת תוצאות ורישום מודלים (נקודות 5 ו-6, בהתאמה) או שתוסיף גרסאות של מערכי נתונים, או אולי משהו אחר? הנקודה שניסיתי להבהיר היא שאתה צריך MLOps בכללותו, MLflow הוא רק אמצעי להשגת מטרה.

כתוב באילו בעיות נתקלת שלא הצגתי?
מה הייתם מוסיפים למערכת כדי שתענה על הצרכים שלכם?
באילו כלים וגישות אתה משתמש כדי לפתור את כל הבעיות או חלקן?

נ.ב. אני אשאיר כמה קישורים:
פרויקט github - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
דוא"ל העבודה שלי לשאלות - [מוגן בדוא"ל]

החברה שלנו מארחת מעת לעת אירועים שונים למומחי IT, לדוגמה: ב-8 ביולי בשעה 19:00 שעון מוסקבה יתקיים מפגש קורות חיים בפורמט מקוון, אם אתה מעוניין, אתה יכול לקחת חלק, הרשמה כאן .

מקור: www.habr.com