Salut tout le monde! Je suis développeur de CV chez CROC. Nous mettons en œuvre des projets dans le domaine du CV depuis maintenant 3 ans. Pendant ce temps, nous avons fait beaucoup de choses, par exemple : nous avons surveillé les conducteurs pour qu'en conduisant, ils ne boivent pas, ne fument pas, ne parlent pas au téléphone, regardent la route, et non les rêves ou les nuages. ; Nous avons enregistré des personnes qui circulent sur des voies réservées et occupent plusieurs places de stationnement ; veillé à ce que les travailleurs portent des casques, des gants, etc. ; identifié un employé qui souhaite entrer dans l'établissement ; Nous avons compté tout ce que nous pouvions.
Pourquoi je fais tout ça ?
Dans le processus de mise en œuvre des projets, nous avons rencontré des obstacles, beaucoup d'obstacles, certains des problèmes que vous connaissez ou que vous connaîtrez à l'avenir.
Simuler la situation
Imaginons que nous obtenions un emploi dans une jeune entreprise « N », dont les activités sont liées au ML. Nous travaillons sur un projet ML (DL, CV), puis, pour une raison quelconque, nous passons à un autre travail, faisons généralement une pause et retournons dans notre propre neurone ou dans celui de quelqu'un d'autre.
- Le moment de vérité arrive, vous devez d'une manière ou d'une autre vous rappeler où vous vous êtes arrêté, quels hyperparamètres vous avez essayés et, surtout, à quels résultats ils ont conduit. Il peut y avoir de nombreuses options pour savoir qui a stocké les informations sur tous les lancements : dans la tête, les configurations, le bloc-notes, dans un environnement de travail dans le cloud. Il m'est arrivé de voir une option lorsque les hyperparamètres étaient stockés sous forme de lignes commentées dans le code, en général, une envolée de fantaisie. Imaginez maintenant que vous soyez revenu non pas à votre projet, mais au projet d'une personne qui a quitté l'entreprise et que vous ayez hérité d'un code et d'un modèle appelé model_1.pb. Pour compléter le tableau et transmettre toute la douleur, imaginons que vous soyez également un spécialiste débutant.
- Poursuivre. Pour exécuter le code, nous et tous ceux qui travailleront avec lui devons créer un environnement. Il arrive souvent que, pour une raison quelconque, ils ne l'aient pas laissé en héritage. Cela peut également devenir une tâche non triviale. Vous ne voulez pas perdre de temps sur cette étape, n’est-ce pas ?
- Nous formons un modèle (par exemple, un détecteur de voiture). Nous arrivons au point où cela devient très bon – il est temps de sauvegarder le résultat. Appelons-le car_detection_v1.pb. Ensuite, nous en formons un autre - car_detection_v2.pb. Quelque temps plus tard, nos collègues ou nous-mêmes enseignons de plus en plus, en utilisant des architectures différentes. En conséquence, un tas d'artefacts se forment, dont les informations doivent être minutieusement collectées (mais nous le ferons plus tard, car pour l'instant nous avons des questions plus prioritaires).
- OK, c'est fini maintenant ! Nous avons un modèle ! Pouvons-nous commencer à entraîner le prochain modèle, à développer une architecture pour résoudre un nouveau problème, ou pouvons-nous aller prendre un thé ? Et qui va se déployer ?
Identifier les problèmes
Travailler sur un projet ou un produit est le travail de nombreuses personnes. Et au fil du temps, les gens partent et viennent, les projets se multiplient et les projets eux-mêmes deviennent plus complexes. D'une manière ou d'une autre, les situations du cycle décrit ci-dessus (et pas seulement) dans certaines combinaisons se produiront d'itération en itération. Tout cela entraîne une perte de temps, de la confusion, de la nervosité, voire de l'insatisfaction des clients et, en fin de compte, une perte d'argent. Même si nous suivons tous généralement le même vieux rake, je crois que personne ne veut revivre ces moments encore et encore.
Nous avons donc traversé un cycle de développement et nous voyons qu'il y a des problèmes qui doivent être résolus. Pour ce faire, vous avez besoin de :
- stockez facilement les résultats du travail ;
- simplifier le processus d’implication des nouveaux employés ;
- simplifier le processus de déploiement d'un environnement de développement ;
- configurer le processus de gestion des versions du modèle ;
- disposer d'un moyen pratique de valider les modèles ;
- trouver un outil modèle de gestion de l'état ;
- trouver un moyen de livrer les modèles en production.
Apparemment, il est nécessaire de proposer un flux de travail qui vous permettrait de gérer facilement et commodément ce cycle de vie ? Cette pratique s'appelle MLOps
MLOps, ou DevOps pour l'apprentissage automatique, permet aux équipes de science des données et informatiques de collaborer et d'accélérer le rythme de développement et de déploiement des modèles grâce à la surveillance, à la validation et à la gouvernance des modèles d'apprentissage automatique.
Tu peux Que pensent les gars de Google de tout ça ? D'après l'article, il ressort clairement que MLOps est une chose assez volumineuse.
Plus loin dans mon article, je ne décrirai qu'une partie du processus. Pour la mise en œuvre, j'utiliserai l'outil MLflow, car... Il s'agit d'un projet open source, une petite quantité de code est requise pour se connecter et il existe une intégration avec les frameworks ml populaires. Vous pouvez rechercher sur Internet d'autres outils, tels que Kubeflow, SageMaker, Trains, etc., et peut-être en trouver un qui répond mieux à vos besoins.
« Construire » des MLOps à l'aide de l'exemple d'utilisation de l'outil MLFlow
MLFlow est une plateforme open source pour la gestion du cycle de vie des modèles ML ().
MLflow comprend quatre composants :
- MLflow Tracking - couvre les problèmes d'enregistrement des résultats et des paramètres qui ont conduit à ce résultat ;
- Projet MLflow - vous permet de conditionner du code et de le reproduire sur n'importe quelle plateforme ;
- MLflow Models - responsable du déploiement des modèles en production ;
- MLflow Registry - vous permet de stocker des modèles et de gérer leur état dans un référentiel centralisé.
MLflow fonctionne sur deux entités :
- le lancement est un cycle complet de formation, de paramètres et de métriques auquel nous souhaitons nous inscrire ;
- Une expérience est un « sujet » qui se déroule ensemble.
Toutes les étapes de l'exemple sont implémentées sur le système d'exploitation Ubuntu 18.04.
1. Déployez le serveur
Afin que nous puissions gérer facilement notre projet et recevoir toutes les informations nécessaires, nous déploierons un serveur. Le serveur de suivi MLflow comporte deux composants principaux :
- magasin backend - responsable du stockage des informations sur les modèles enregistrés (prend en charge 4 SGBD : mysql, mssql, sqlite et postgresql) ;
- magasin d'artefacts - responsable du stockage des artefacts (prend en charge 7 options de stockage : Amazon S3, Azure Blob Storage, Google Cloud Storage, serveur FTP, serveur SFTP, NFS, HDFS).
Comme l' magasin d'artefacts Pour plus de simplicité, prenons un serveur sftp.
- créer un groupe
$ sudo groupadd sftpg - ajouter un utilisateur et définir un mot de passe pour lui
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - ajuster quelques paramètres d'accès
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - ajoutez quelques lignes à /etc/ssh/sshd_config
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - redémarrer le service
$ sudo systemctl restart sshd
Comme l' magasin backend Prenons 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_dbPour démarrer le serveur, vous devez installer les packages python suivants (je recommande de créer un environnement virtuel séparé) :
pip install mlflow
pip install pysftpDémarrons notre serveur
$ 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_port2. Ajouter un suivi
Pour que les résultats de notre formation ne soient pas perdus, que les futures générations de développeurs comprennent ce qui se passe, et que les camarades plus âgés et vous puissiez analyser sereinement le processus d'apprentissage, nous devons ajouter un suivi. Le suivi signifie sauvegarder les paramètres, les métriques, les artefacts et toute information supplémentaire sur le début de la formation, dans notre cas, sur le serveur.
Par exemple, j'ai créé un petit sur Keras pour segmenter tout ce qui se trouve dans . Pour ajouter du suivi, j'ai créé un fichier mlflow_training.py.
Voici les lignes où se produisent les choses les plus intéressantes :
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)Ici, self.remote_server est un petit wrapper sur les méthodes mlflow.tracking. MlflowClient (je l'ai fait pour plus de commodité), avec l'aide duquel je crée une expérience et l'exécute sur le serveur. Ensuite, j'indique où les résultats du lancement doivent être fusionnés (mlflow.set_tracking_uri(self.tracking_uri)). J'active la journalisation automatique mlflow.keras.autolog(). Actuellement, MLflow Tracking prend en charge la journalisation automatique pour TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Si vous n'avez pas trouvé votre framework ou votre bibliothèque, vous pouvez toujours vous connecter explicitement. Nous commençons la formation. Enregistrez les balises et les paramètres d’entrée sur le serveur distant.
Quelques lignes et vous, comme tout le monde, avez accès aux informations sur tous les lancements. Cool?
3. Nous élaborons le projet
Facilitons maintenant le lancement du projet. Pour ce faire, ajoutez le fichier MLproject et conda.yaml à la racine du projet.
Projet 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}"Le projet MLflow a plusieurs propriétés :
- Nom - le nom de votre projet ;
- Environnement - dans mon cas, conda_env indique qu'Anaconda est utilisé pour s'exécuter et la description de la dépendance se trouve dans le fichier conda.yaml ;
- Points d'entrée - indique quels fichiers et avec quels paramètres nous pouvons exécuter (tous les paramètres sont automatiquement enregistrés au démarrage de la formation)
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.0Vous pouvez utiliser Docker comme environnement d'exécution, pour plus de détails, veuillez vous référer à .
4. Commençons la formation
Nous clonons le projet et allons dans le répertoire du projet :
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/Pour exécuter, vous devez installer des bibliothèques
pip install mlflow
pip install pysftpParce que dans l'exemple que j'utilise conda_env, Anaconda doit être installé sur votre ordinateur (mais vous pouvez contourner ce problème en installant vous-même tous les packages nécessaires et en jouant avec les paramètres de lancement).
Toutes les étapes préparatoires sont terminées et nous pouvons commencer à lancer la formation. Depuis la racine du projet :
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .Après avoir entré la commande, un environnement conda sera automatiquement créé et la formation démarrera.
Dans l'exemple ci-dessus, j'ai passé le nombre d'époques d'entraînement, les catégories dans lesquelles on souhaite segmenter (vous pouvez voir la liste complète ) et l'adresse de notre serveur distant.
Une liste complète des paramètres possibles peut être trouvée dans le fichier MLproject.
5. Évaluer les résultats d'apprentissage
Après avoir terminé la formation, nous pouvons accéder dans le navigateur à l'adresse de notre serveur
Ici, nous voyons une liste de toutes les expériences (en haut à gauche), ainsi que des informations sur les exécutions (au milieu). Nous pouvons afficher des informations plus détaillées (paramètres, métriques, artefacts et quelques informations supplémentaires) pour chaque lancement.
Pour chaque métrique, nous pouvons observer l'historique des changements
Ceux. Pour le moment, nous pouvons analyser les résultats en mode « manuel », et vous pouvez également mettre en place une validation automatique à l'aide de l'API MLflow.
6. Enregistrez le modèle
Après avoir analysé notre modèle et décidé qu'il est prêt pour le combat, nous procédons à son enregistrement, pour cela nous sélectionnons le lancement dont nous avons besoin (comme indiqué dans le paragraphe précédent) et descendons.
Après avoir donné un nom à notre modèle, il a une version. Si vous enregistrez un autre modèle sous le même nom, la version sera automatiquement mise à niveau.
Pour chaque modèle, nous pouvons ajouter une description et sélectionner l'un des trois états (Staging, Production, Archivé) ; ensuite, à l'aide de l'API, nous pouvons accéder à ces états, ce qui, avec le versioning, offre une flexibilité supplémentaire.
Nous avons également un accès facile à tous les modèles
et leurs versions
Comme dans le paragraphe précédent, toutes les opérations peuvent être effectuées à l'aide de l'API.
7. Déployer le modèle
A ce stade, nous disposons déjà d'un modèle entraîné (keras). Un exemple de la façon dont vous pouvez l'utiliser :
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 resultIci, self.registry est à nouveau un petit wrapper sur mlflow.tracking.MlflowClient, pour plus de commodité. Le fait est que j'accède à un serveur distant et y recherche un modèle avec le nom spécifié et la dernière version de production. Ensuite, je télécharge l'artefact localement dans le dossier ./model et crée le modèle à partir de ce répertoire mlflow.keras.load_model(local_path). Nous pouvons maintenant utiliser notre modèle. Les développeurs de CV (ML) peuvent facilement améliorer le modèle et publier de nouvelles versions.
En conclusion
J'ai présenté un système qui permet :
- stocker de manière centralisée des informations sur les modèles ML, les progrès de la formation et les résultats ;
- déployer rapidement un environnement de développement ;
- suivre et analyser l'avancement des travaux sur les modèles ;
- il est pratique de versionner et de gérer l'état des modèles ;
- Il est facile de déployer les modèles résultants.
Cet exemple est un jouet et sert de point de départ pour construire votre propre système, qui peut inclure l'automatisation de l'évaluation des résultats et de l'enregistrement des modèles (points 5 et 6, respectivement) ou vous ajouterez le versionnage des ensembles de données, ou peut-être autre chose ? Le point que j'essayais de faire valoir est que vous avez besoin de MLOps dans son ensemble, MLflow n'est qu'un moyen pour atteindre une fin.
Écrivez quels problèmes vous avez rencontrés et que je n'ai pas affichés ?
Qu’ajouteriez-vous au système pour qu’il réponde à vos besoins ?
Quels outils et approches utilisez-vous pour résoudre tout ou partie des problèmes ?
PS, je laisse quelques liens :
projet github -
MLflow -
Mon e-mail professionnel pour les questions - [email protected]
Notre société organise périodiquement divers événements pour les informaticiens, par exemple : le 8 juillet à 19h00, heure de Moscou, il y aura une rencontre de CV au format en ligne, si vous êtes intéressé, vous pouvez y participer, vous inscrire .
Source: habr.com