MLOps - მზარეულის წიგნი, თავი 1

Სალამი ყველას! მე ვარ CV დეველოპერი CROC-ში. უკვე 3 წელია ვახორციელებთ პროექტებს CV-ის მიმართულებით. ამ ხნის განმავლობაში ჩვენ ბევრი რამ გავაკეთეთ, მაგალითად: ვაკვირდებოდით მძღოლებს ისე, რომ მართვის დროს არ ეწეოდნენ, არ ეწეოდნენ, არ ელაპარაკებოდნენ ტელეფონზე, უყურებდნენ გზას და არა სიზმრებს ან ღრუბლებს. ; ჩვენ ჩავწერეთ ადამიანები, რომლებიც გადაადგილდებიან სპეციალურ ზოლში და იკავებენ რამდენიმე პარკირების ადგილს; უზრუნველყოფდა, რომ მუშებს ეცვათ ჩაფხუტი, ხელთათმანები და ა.შ. დაადგინა თანამშრომელი, რომელსაც სურს დაწესებულებაში შესვლა; ყველაფერი დავთვალეთ, რაც შეგვეძლო.

რისთვის ვაკეთებ ამ ყველაფერს?

პროექტების განხორციელების პროცესში ვხვდებით მუწუკებს, ბევრ მუწუკს, ზოგიერთ პრობლემას ან იცნობთ ან მომავალში გაეცნობით.

მოდით სიტუაციის სიმულაცია

წარმოვიდგინოთ, რომ ჩვენ მივიღეთ სამუშაო ახალგაზრდა კომპანია "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 და ა.შ. და შესაძლოა იპოვოთ ის, რომელიც უკეთესად შეესაბამება თქვენს საჭიროებებს.

MLO-ების „შენება“ MLFlow ინსტრუმენტის გამოყენების მაგალითის გამოყენებით

MLFlow არის ღია კოდის პლატფორმა ml მოდელების სასიცოცხლო ციკლის მართვისთვის (https://mlflow.org/).

MLflow მოიცავს ოთხ კომპონენტს:

• MLflow Tracking - მოიცავს შედეგების ჩაწერის საკითხებს და პარამეტრებს, რამაც გამოიწვია ეს შედეგი;
• MLflow Project - საშუალებას გაძლევთ შეფუთოთ კოდი და განახორციელოთ იგი ნებისმიერ პლატფორმაზე;
• MLflow Models - პასუხისმგებელი მოდელების წარმოებაში განთავსებაზე;
• MLflow Registry - საშუალებას გაძლევთ შეინახოთ მოდელები და მართოთ მათი მდგომარეობა ცენტრალიზებულ საცავში.

MLflow მუშაობს ორ ერთეულზე:

• გაშვება არის ტრენინგის სრული ციკლი, პარამეტრები და მეტრიკა, რომლითაც გვინდა რეგისტრაცია;
• ექსპერიმენტი არის „თემა“, რომელიც ერთად მიმდინარეობს.

მაგალითის ყველა ნაბიჯი დანერგილია Ubuntu 18.04 ოპერაციულ სისტემაზე.

1. განათავსეთ სერვერი

იმისათვის, რომ ჩვენ მარტივად ვმართოთ ჩვენი პროექტი და მივიღოთ ყველა საჭირო ინფორმაცია, ჩვენ განვათავსებთ სერვერს. MLflow თვალთვალის სერვერს აქვს ორი ძირითადი კომპონენტი:

• backend store - პასუხისმგებელია რეგისტრირებული მოდელების შესახებ ინფორმაციის შესანახად (მხარდაჭერილია 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

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

• გადატვირთეთ სერვისი

  $ sudo systemctl restart sshd

როგორც backend მაღაზია ავიღოთ 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-ზე კერასზე ყველაფრის სეგმენტაციისთვის, რაც არის 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 ფაილი პროექტის root-ში.
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 ფაილში;
• შესვლის წერტილები - მიუთითებს, რომელი ფაილები და რომელი პარამეტრებით შეგვიძლია გაშვება (ყველა პარამეტრი ავტომატურად იწერება ტრენინგის დაწყებისას)

კონდა.იამლი

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 .

ბრძანების შეყვანის შემდეგ ავტომატურად შეიქმნება კონდა გარემო და დაიწყება სწავლება.
ზემოთ მოყვანილ მაგალითში გავიარე ტრენინგის ეპოქების რაოდენობა, კატეგორიები, რომლებშიც გვინდა სეგმენტირება (სრული სია შეგიძლიათ ნახოთ აქ) და ჩვენი დისტანციური სერვერის მისამართი.
შესაძლო პარამეტრების სრული სია შეგიძლიათ იხილოთ MLproject ფაილში.

5. შეაფასეთ სწავლის შედეგები

ტრენინგის დასრულების შემდეგ შეგვიძლია ბრაუზერში გადავიდეთ ჩვენი სერვერის მისამართზე http://server_host:server_port

აქ ჩვენ ვხედავთ ყველა ექსპერიმენტის ჩამონათვალს (ზედა მარცხნივ), ასევე ინფორმაციას გაშვებების შესახებ (შუაში). ჩვენ შეგვიძლია ნახოთ უფრო დეტალური ინფორმაცია (პარამეტრები, მეტრიკა, არტეფაქტები და რამდენიმე დამატებითი ინფორმაცია) თითოეული გაშვებისთვის.

თითოეული მეტრიკისთვის შეგვიძლია დავაკვირდეთ ცვლილებების ისტორიას

იმათ. ამ მომენტში, ჩვენ შეგვიძლია გავაანალიზოთ შედეგები "ხელით" რეჟიმში და ასევე შეგიძლიათ დააყენოთ ავტომატური ვალიდაცია MLflow API-ის გამოყენებით.

6. მოდელის რეგისტრაცია

მას შემდეგ რაც გავაანალიზეთ ჩვენი მოდელი და გადავწყვიტეთ, რომ ის მზად არის ბრძოლისთვის, ვაგრძელებთ მის რეგისტრაციას, ამისთვის ვირჩევთ ჩვენთვის საჭირო გაშვებას (როგორც ნაჩვენებია წინა აბზაცში) და ჩავდივართ ქვემოთ.

მას შემდეგ რაც ჩვენს მოდელს სახელს ვაძლევთ, მას აქვს ვერსია. თუ შეინახავთ სხვა მოდელს იმავე სახელით, ვერსია ავტომატურად განახლდება.

თითოეულ მოდელს შეგვიძლია დავამატოთ აღწერა და ავირჩიოთ სამი მდგომარეობიდან ერთ-ერთი (Staging, Production, Archived); შემდგომში, 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, შესაბამისად) ან დაამატებთ მონაცემთა ნაკრების ვერსიებს, ან იქნებ სხვა რამეს? პუნქტი, რისი თქმაც ვცდილობდი არის ის, რომ თქვენ გჭირდებათ MLOps მთლიანობაში, MLflow მხოლოდ მიზნის მიღწევის საშუალებაა.

დაწერეთ რა პრობლემები შეგხვდათ რაც არ გამოვიტანე?
რას დაამატებდით სისტემას, რათა ის დააკმაყოფილოს თქვენს საჭიროებებს?
რა ინსტრუმენტებსა და მიდგომებს იყენებთ პრობლემების მთლიანად ან ნაწილის გადასაჭრელად?

PS დავტოვებ რამდენიმე ლინკს:
github პროექტი - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
ჩემი სამუშაო ელ.წერილი კითხვებისთვის - [ელ.ფოსტით დაცულია]

ჩვენი კომპანია პერიოდულად მასპინძლობს სხვადასხვა ღონისძიებებს IT სპეციალისტებისთვის, მაგალითად: 8 ივლისს მოსკოვის დროით 19:00 საათზე გაიმართება CV შეხვედრა ონლაინ ფორმატში, დაინტერესების შემთხვევაში შეგიძლიათ მიიღოთ მონაწილეობა, რეგისტრაცია. აქ .

წყარო: www.habr.com