🥇MLOps - சமையல் புத்தகம், அத்தியாயம் 1

அனைவருக்கும் வணக்கம்! நான் CROC இல் CV டெவலப்பர். சிவி துறையில் 3 ஆண்டுகளாக திட்டங்களை செயல்படுத்தி வருகிறோம். இந்த நேரத்தில், நாங்கள் நிறைய விஷயங்களைச் செய்தோம், எடுத்துக்காட்டாக: நாங்கள் ஓட்டுநர்களைக் கண்காணித்தோம், இதனால் வாகனம் ஓட்டும்போது அவர்கள் மது அருந்துவதில்லை, புகைபிடிக்க மாட்டார்கள், தொலைபேசியில் பேசக்கூடாது, சாலையைப் பார்த்தார்கள், கனவுகள் அல்லது மேகங்களைப் பார்க்க மாட்டார்கள். ; பிரத்யேக பாதைகளில் வாகனம் ஓட்டுபவர்கள் மற்றும் பல வாகன நிறுத்துமிடங்களை எடுத்துக் கொண்டவர்களை நாங்கள் பதிவு செய்துள்ளோம்; தொழிலாளர்கள் ஹெல்மெட், கையுறைகள் போன்றவற்றை அணிந்திருப்பதை உறுதி செய்தது; வசதிக்குள் நுழைய விரும்பும் ஒரு பணியாளரை அடையாளம் கண்டார்; எங்களால் முடிந்த அனைத்தையும் எண்ணினோம்.

நான் எதற்காக இதையெல்லாம் செய்கிறேன்?

திட்டங்களைச் செயல்படுத்தும் செயல்பாட்டில், நாங்கள் புடைப்புகள், நிறைய புடைப்புகள், உங்களுக்குத் தெரிந்த சில சிக்கல்கள் அல்லது எதிர்காலத்தில் உங்களுக்குத் தெரிந்திருக்கும்.

சூழ்நிலையை உருவகப்படுத்துவோம்

ML உடன் தொடர்புடைய ஒரு இளம் நிறுவனமான "N" இல் எங்களுக்கு வேலை கிடைத்தது என்று கற்பனை செய்துகொள்வோம். நாங்கள் ஒரு ML (DL, CV) திட்டத்தில் வேலை செய்கிறோம், பிறகு சில காரணங்களால் வேறொரு வேலைக்கு மாறுகிறோம், பொதுவாக ஓய்வு எடுத்து, நம்முடைய சொந்த அல்லது வேறொருவரின் நியூரானுக்குத் திரும்புவோம்.

உண்மையின் தருணம் வருகிறது, நீங்கள் எங்கு நிறுத்தியுள்ளீர்கள், நீங்கள் எந்த ஹைப்பர் பாராமீட்டர்களை முயற்சித்தீர்கள் மற்றும் மிக முக்கியமாக அவை என்ன முடிவுகளுக்கு வழிவகுத்தன என்பதை எப்படியாவது நினைவில் கொள்ள வேண்டும். எல்லா லாஞ்ச்களிலும் யார் தகவலைச் சேமித்து வைத்தார்கள் என்பதற்கான பல விருப்பங்கள் இருக்கலாம்: தலையில், கட்டமைப்புகள், நோட்பேட், மேகக்கணியில் வேலை செய்யும் சூழலில். குறியீட்டில் கருத்துரைக்கப்பட்ட வரிகளாக ஹைப்பர் பாராமீட்டர்கள் சேமிக்கப்படும் போது ஒரு விருப்பத்தை நான் பார்க்க நேர்ந்தது, பொதுவாக, ஆடம்பரமான ஒரு விமானம். இப்போது நீங்கள் உங்கள் திட்டத்திற்குத் திரும்பவில்லை, நிறுவனத்தை விட்டு வெளியேறிய நபரின் திட்டத்திற்குத் திரும்பியுள்ளீர்கள் என்று கற்பனை செய்து பாருங்கள், மேலும் நீங்கள் ஒரு குறியீட்டையும் model_1.pb என்ற மாதிரியையும் பெற்றுள்ளீர்கள். படத்தை முடிக்க மற்றும் அனைத்து வலிகளையும் தெரிவிக்க, நீங்களும் ஒரு புதிய நிபுணர் என்று கற்பனை செய்யலாம்.
மேலே போ. குறியீட்டை இயக்க, நாமும் அதனுடன் பணிபுரியும் அனைவரும் ஒரு சூழலை உருவாக்க வேண்டும். சில காரணங்களால் அவர்கள் அவரை எங்கள் பரம்பரையாக விட்டுவிடவில்லை என்பது அடிக்கடி நிகழ்கிறது. இது அற்பமான பணியாகவும் மாறலாம். இந்த படியில் நேரத்தை வீணடிக்க விரும்பவில்லை, இல்லையா?
நாங்கள் ஒரு மாதிரியைப் பயிற்றுவிப்போம் (உதாரணமாக, ஒரு கார் டிடெக்டர்). அது மிகவும் நன்றாக இருக்கும் இடத்திற்கு நாங்கள் வருகிறோம் - முடிவைச் சேமிக்க வேண்டிய நேரம் இது. அதை car_detection_v1.pb என்று அழைப்போம். பிறகு இன்னொருவருக்குப் பயிற்சி அளிக்கிறோம் - car_detection_v2.pb. சிறிது நேரம் கழித்து, எங்கள் சகாக்கள் அல்லது நாமே வெவ்வேறு கட்டிடக்கலைகளைப் பயன்படுத்தி மேலும் மேலும் கற்பிக்கிறோம். இதன் விளைவாக, ஒரு கொத்து கலைப்பொருட்கள் உருவாகின்றன, அவை பற்றிய தகவல்கள் கடினமாக சேகரிக்கப்பட வேண்டும் (ஆனால் இதை நாங்கள் பின்னர் செய்வோம், ஏனென்றால் இப்போதைக்கு எங்களுக்கு அதிக முன்னுரிமை விஷயங்கள் உள்ளன).
சரி இப்போது எல்லாம் முடிந்துவிட்டது! எங்களிடம் ஒரு மாதிரி இருக்கிறது! அடுத்த மாடலைப் பயிற்சி செய்ய ஆரம்பிக்கலாமா, ஒரு புதிய சிக்கலைத் தீர்க்க ஒரு கட்டிடக்கலையை உருவாக்கலாமா அல்லது தேநீர் அருந்தலாமா? மற்றும் யார் வரிசைப்படுத்துவார்கள்?

பிரச்சனைகளை கண்டறிதல்

ஒரு திட்டம் அல்லது தயாரிப்பில் வேலை செய்வது பலரின் வேலை. மேலும் காலப்போக்கில், மக்கள் வெளியேறி வருகிறார்கள், மேலும் திட்டங்கள் உள்ளன, மேலும் திட்டங்கள் மிகவும் சிக்கலானதாகின்றன. ஒரு வழி அல்லது வேறு, சில சேர்க்கைகளில் மேலே விவரிக்கப்பட்ட (மற்றும் மட்டுமல்ல) சுழற்சியின் சூழ்நிலைகள் மறு செய்கையிலிருந்து மறு செய்கை வரை ஏற்படும். இவை அனைத்தும் வீணான நேரம், குழப்பம், நரம்புகள், வாடிக்கையாளரின் அதிருப்தி மற்றும் இறுதியில் பணத்தை இழக்க நேரிடும். நாம் அனைவரும் பொதுவாக அதே பழைய ரேக்கைப் பின்பற்றுகிறோம் என்றாலும், இந்த தருணங்களை யாரும் மீண்டும் மீண்டும் அனுபவிக்க விரும்பவில்லை என்று நான் நம்புகிறேன்.

எனவே, நாங்கள் ஒரு வளர்ச்சி சுழற்சியைக் கடந்துவிட்டோம், மேலும் தீர்க்கப்பட வேண்டிய பிரச்சினைகள் இருப்பதைக் காண்கிறோம். இதைச் செய்ய உங்களுக்குத் தேவை:

வேலை முடிவுகளை வசதியாக சேமிக்கவும்;
புதிய பணியாளர்களை ஈடுபடுத்தும் செயல்முறையை எளிதாக்குங்கள்;
வளர்ச்சி சூழலை வரிசைப்படுத்தும் செயல்முறையை எளிதாக்குதல்;
மாதிரி பதிப்பு செயல்முறையை கட்டமைக்கவும்;
மாதிரிகளை சரிபார்க்க ஒரு வசதியான வழி உள்ளது;
ஒரு மாதிரி மாநில மேலாண்மை கருவியைக் கண்டறியவும்;
உற்பத்திக்கு மாதிரிகளை வழங்குவதற்கான வழியைக் கண்டறியவும்.

இந்த வாழ்க்கைச் சுழற்சியை எளிதாகவும் வசதியாகவும் நிர்வகிக்க உங்களை அனுமதிக்கும் பணிப்பாய்வுகளைக் கொண்டு வருவது அவசியமா? இந்த நடைமுறை MLOps என்று அழைக்கப்படுகிறது

MLOps, அல்லது இயந்திர கற்றலுக்கான DevOps, தரவு அறிவியல் மற்றும் IT குழுக்கள் இணைந்து, இயந்திர கற்றல் மாதிரிகளுக்கான கண்காணிப்பு, சரிபார்ப்பு மற்றும் ஆளுகை மூலம் மாதிரி மேம்பாடு மற்றும் வரிசைப்படுத்தலின் வேகத்தை அதிகரிக்க அனுமதிக்கிறது.

நீங்கள் முடியும் படிக்கஇதைப் பற்றி கூகுள் தோழர்கள் என்ன நினைக்கிறார்கள்? MLOps என்பது ஒரு பெரிய விஷயம் என்பது கட்டுரையிலிருந்து தெளிவாகிறது.

மேலும் எனது கட்டுரையில் நான் செயல்முறையின் ஒரு பகுதியை மட்டுமே விவரிக்கிறேன். செயல்படுத்த, நான் MLflow கருவியைப் பயன்படுத்துவேன், ஏனெனில்... இது ஒரு திறந்த மூல திட்டமாகும், இணைக்க சிறிய அளவு குறியீடு தேவைப்படுகிறது மற்றும் பிரபலமான ml கட்டமைப்புகளுடன் ஒருங்கிணைக்கப்பட்டுள்ளது. Kubeflow, SageMaker, Trains போன்ற பிற கருவிகளை நீங்கள் இணையத்தில் தேடலாம், மேலும் உங்கள் தேவைகளுக்கு மிகவும் பொருத்தமான ஒன்றைக் கண்டறியலாம்.

MLFlow கருவியைப் பயன்படுத்துவதற்கான உதாரணத்தைப் பயன்படுத்தி "கட்டிடுதல்" MLOps

MLFlow என்பது ml மாதிரிகளின் வாழ்க்கை சுழற்சி மேலாண்மைக்கான ஒரு திறந்த மூல தளமாகும் (https://mlflow.org/).

MLflow நான்கு கூறுகளை உள்ளடக்கியது:

MLflow கண்காணிப்பு - இந்த முடிவுக்கு வழிவகுத்த முடிவுகள் மற்றும் அளவுருக்களை பதிவுசெய்வதில் உள்ள சிக்கல்களை உள்ளடக்கியது;
MLflow ப்ராஜெக்ட் - குறியீட்டை தொகுக்கவும் மற்றும் எந்த தளத்திலும் அதை மீண்டும் உருவாக்கவும் உங்களை அனுமதிக்கிறது;
MLflow மாதிரிகள் - உற்பத்திக்கு மாதிரிகளை வரிசைப்படுத்துவதற்கு பொறுப்பு;
MLflow ரெஜிஸ்ட்ரி - மாதிரிகளை சேமிக்கவும், அவற்றின் நிலையை மையப்படுத்தப்பட்ட களஞ்சியத்தில் நிர்வகிக்கவும் உங்களை அனுமதிக்கிறது.

MLflow இரண்டு நிறுவனங்களில் செயல்படுகிறது:

துவக்கம் என்பது பயிற்சி, அளவுருக்கள் மற்றும் அளவீடுகளின் முழு சுழற்சியாகும், இதன் மூலம் நாங்கள் பதிவு செய்ய விரும்புகிறோம்;
சோதனை என்பது ஒன்றாக இயங்கும் ஒரு "தலைப்பு".

எடுத்துக்காட்டின் அனைத்து படிகளும் உபுண்டு 18.04 இயக்க முறைமையில் செயல்படுத்தப்படுகின்றன.

1. சேவையகத்தை வரிசைப்படுத்தவும்

எங்கள் திட்டத்தை எளிதாக நிர்வகிக்க மற்றும் தேவையான அனைத்து தகவல்களையும் பெற, நாங்கள் ஒரு சேவையகத்தை வரிசைப்படுத்துவோம். MLflow கண்காணிப்பு சேவையகம் இரண்டு முக்கிய கூறுகளைக் கொண்டுள்ளது:

பின்தளத்தில் கடை - பதிவு செய்யப்பட்ட மாதிரிகள் பற்றிய தகவல்களைச் சேமிப்பதற்கான பொறுப்பு (4 DBMSகளை ஆதரிக்கிறது: mysql, mssql, sqlite மற்றும் postgresql);
கலைப்பொருள் அங்காடி - கலைப்பொருட்களை சேமிப்பதற்கான பொறுப்பு (7 சேமிப்பக விருப்பங்களை ஆதரிக்கிறது: Amazon S3, Azure Blob Storage, Google Cloud Storage, FTP server, 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. கண்காணிப்பைச் சேர்க்கவும்

எங்கள் பயிற்சியின் முடிவுகள் இழக்கப்படாமல் இருக்க, டெவலப்பர்களின் எதிர்கால சந்ததியினர் என்ன நடக்கிறது என்பதைப் புரிந்துகொள்வதற்கும், பழைய தோழர்களுக்கும் நீங்களும் கற்றல் செயல்முறையை அமைதியாக பகுப்பாய்வு செய்வதற்கும், நாங்கள் கண்காணிப்பைச் சேர்க்க வேண்டும். கண்காணிப்பு என்பது அளவுருக்கள், அளவீடுகள், கலைப்பொருட்கள் மற்றும் பயிற்சியின் தொடக்கத்தைப் பற்றிய கூடுதல் தகவல்களை, எங்கள் விஷயத்தில், சேவையகத்தில் சேமிப்பதாகும்.

உதாரணமாக, நான் ஒரு சிறிய ஒன்றை உருவாக்கினேன் கிதுப்பில் திட்டம் உள்ள அனைத்தையும் பிரிப்பதற்காக 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 கண்காணிப்பு 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 என்பது அனகோண்டாவை இயக்க பயன்படுகிறது மற்றும் சார்பு விளக்கம் 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. மாதிரியை பதிவு செய்யவும்

நாங்கள் எங்கள் மாதிரியை ஆராய்ந்து, அது போருக்குத் தயாராக உள்ளது என்று முடிவு செய்த பிறகு, அதை பதிவு செய்யத் தொடர்கிறோம், இதற்காக நமக்குத் தேவையான வெளியீட்டைத் தேர்ந்தெடுத்து (முந்தைய பத்தியில் காட்டப்பட்டுள்ளபடி) கீழே செல்கிறோம்.

எங்கள் மாடலுக்கு ஒரு பெயரைக் கொடுத்த பிறகு, அதற்கு ஒரு பதிப்பு உள்ளது. அதே பெயரில் மற்றொரு மாடலைச் சேமித்தால், பதிப்பு தானாகவே மேம்படுத்தப்படும்.

ஒவ்வொரு மாடலுக்கும், நாம் ஒரு விளக்கத்தைச் சேர்த்து, மூன்று நிலைகளில் ஒன்றைத் தேர்ந்தெடுக்கலாம் (நிலைப்படுத்துதல், உற்பத்தி, காப்பகப்படுத்தப்பட்டது); பின்னர், 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 நான் இரண்டு இணைப்புகளை விட்டுவிடுகிறேன்:
கிதுப் திட்டம் - https://github.com/simbakot/mlflow_example
MLflow - https://mlflow.org/
கேள்விகளுக்கான எனது பணி மின்னஞ்சல் - [மின்னஞ்சல் பாதுகாக்கப்பட்டது]

எங்கள் நிறுவனம் அவ்வப்போது தகவல் தொழில்நுட்ப நிபுணர்களுக்காக பல்வேறு நிகழ்வுகளை நடத்துகிறது, எடுத்துக்காட்டாக: ஜூலை 8 அன்று மாஸ்கோ நேரப்படி 19:00 மணிக்கு ஆன்லைன் வடிவத்தில் CV சந்திப்பு இருக்கும், நீங்கள் ஆர்வமாக இருந்தால், நீங்கள் பங்கேற்கலாம், பதிவு செய்யலாம் இங்கே .

ஆதாரம்: www.habr.com

MLOps - சமையல் புத்தகம், அத்தியாயம் 1