Ciao a tutti! Sono uno sviluppatore di CV presso CROC. Realizziamo progetti nel campo del CV ormai da 3 anni. Durante questo periodo abbiamo fatto molte cose, ad esempio: abbiamo monitorato gli autisti in modo che durante la guida non bevessero, non fumassero, non parlassero al telefono, guardassero la strada e non i sogni o le nuvole ; Abbiamo registrato le persone che guidano in corsie riservate e occupano più posti auto; assicurarsi che i lavoratori indossassero caschi, guanti, ecc.; individuato un dipendente che vuole entrare nella struttura; Abbiamo contato tutto quello che potevamo.
Per cosa sto facendo tutto questo?
Nel processo di implementazione dei progetti incontriamo ostacoli, molti ostacoli, alcuni dei problemi che conosci o che conoscerai in futuro.
Simula la situazione
Immaginiamo di aver trovato lavoro presso una giovane azienda "N", le cui attività sono legate al ML. Lavoriamo su un progetto ML (DL, CV), poi per qualche motivo passiamo a un altro lavoro, generalmente facciamo una pausa e torniamo al nostro neurone o a quello di qualcun altro.
- Arriva il momento della verità, devi in qualche modo ricordare dove ti sei fermato, quali iperparametri hai provato e, soprattutto, a quali risultati hanno portato. Possono esserci molte opzioni per chi ha archiviato le informazioni su tutti i lanci: nella testa, nelle configurazioni, nel blocco note, in un ambiente di lavoro nel cloud. Mi è capitato di vedere un'opzione quando gli iperparametri venivano memorizzati come righe commentate nel codice, in generale, un volo di fantasia. Ora immagina di essere tornato non al tuo progetto, ma al progetto di una persona che ha lasciato l'azienda e di cui hai ereditato un codice e un modello chiamato model_1.pb. Per completare il quadro e trasmettere tutto il dolore, immaginiamo che tu sia anche uno specialista principiante.
- Andare avanti. Per eseguire il codice, noi e tutti coloro che lavoreranno con esso dobbiamo creare un ambiente. Accade spesso che per qualche motivo non lo abbiano lasciato in eredità. Questo può anche diventare un compito non banale. Non vuoi perdere tempo con questo passaggio, vero?
- Addestriamo un modello (ad esempio, un rilevatore di auto). Arriviamo al punto in cui diventa molto buono: è ora di salvare il risultato. Chiamiamolo car_detection_v1.pb. Quindi ne addestriamo un altro: car_detection_v2.pb. Qualche tempo dopo, i nostri colleghi o noi stessi insegniamo sempre di più, utilizzando architetture diverse. Di conseguenza, si forma una serie di artefatti, le cui informazioni devono essere raccolte scrupolosamente (ma lo faremo più tardi, perché per ora abbiamo più questioni prioritarie).
- OK, è tutto finito adesso! Abbiamo un modello! Possiamo iniziare ad addestrare il modello successivo, sviluppare un'architettura per risolvere un nuovo problema o possiamo andare a prendere un tè? E chi schiererà?
Identificazione dei problemi
Lavorare su un progetto o un prodotto è il lavoro di molte persone. E col tempo, le persone vanno e vengono, ci sono più progetti e i progetti stessi diventano più complessi. In un modo o nell'altro, le situazioni del ciclo sopra descritto (e non solo) in determinate combinazioni si verificheranno di iterazione in iterazione. Tutto ciò si traduce in perdita di tempo, confusione, nervosismo, forse insoddisfazione dei clienti e, in definitiva, perdita di denaro. Anche se di solito seguiamo tutti lo stesso vecchio rastrello, credo che nessuno voglia rivivere questi momenti ancora e ancora.
Quindi, abbiamo attraversato un ciclo di sviluppo e abbiamo visto che ci sono problemi che devono essere risolti. Per fare questo è necessario:
- archiviare comodamente i risultati del lavoro;
- semplificare il processo di coinvolgimento dei nuovi dipendenti;
- semplificare il processo di distribuzione di un ambiente di sviluppo;
- configurare il processo di controllo delle versioni del modello;
- disporre di un modo conveniente per convalidare i modelli;
- trovare uno strumento modello di gestione dello stato;
- trovare un modo per consegnare i modelli alla produzione.
Apparentemente è necessario elaborare un flusso di lavoro che consenta di gestire facilmente e comodamente questo ciclo di vita? Questa pratica si chiama MLOps
MLOps, o DevOps per il machine learning, consente ai team di data science e IT di collaborare e aumentare il ritmo di sviluppo e implementazione dei modelli attraverso il monitoraggio, la convalida e la governance per i modelli di machine learning.
Puoi Cosa ne pensano i ragazzi di Google di tutto questo? Dall'articolo è chiaro che MLOps è una cosa piuttosto voluminosa.
Più avanti nel mio articolo descriverò solo una parte del processo. Per l'implementazione, utilizzerò lo strumento MLflow, perché... Questo è un progetto open source, è necessaria una piccola quantità di codice per connettersi e c'è l'integrazione con i più diffusi framework ml. Puoi cercare su Internet altri strumenti, come Kubeflow, SageMaker, Trains, ecc., e magari trovarne uno più adatto alle tue esigenze.
"Costruire" MLOps utilizzando l'esempio dell'utilizzo dello strumento MLFlow
MLFlow è una piattaforma open source per la gestione del ciclo di vita dei modelli ml ().
MLflow include quattro componenti:
- MLflow Tracking: copre le questioni relative alla registrazione dei risultati e dei parametri che hanno portato a questo risultato;
- MLflow Project: consente di impacchettare il codice e riprodurlo su qualsiasi piattaforma;
- Modelli MLflow: responsabile della distribuzione dei modelli in produzione;
- MLflow Registry: consente di archiviare modelli e gestirne lo stato in un repository centralizzato.
MLflow opera su due entità:
- il lancio è un ciclo completo di formazione, parametri e metriche con cui vogliamo registrarci;
- Un esperimento è un “argomento” che funziona insieme.
Tutti i passaggi dell'esempio sono implementati nel sistema operativo Ubuntu 18.04.
1. Distribuire il server
Per poter gestire facilmente il nostro progetto e ricevere tutte le informazioni necessarie, implementeremo un server. Il server di tracciamento MLflow ha due componenti principali:
- negozio backend - responsabile della memorizzazione delle informazioni sui modelli registrati (supporta 4 DBMS: mysql, mssql, sqlite e postgresql);
- archivio di artefatti: responsabile dell'archiviazione di artefatti (supporta 7 opzioni di archiviazione: Amazon S3, Azure Blob Storage, Google Cloud Storage, server FTP, server SFTP, NFS, HDFS).
Come l' negozio di manufatti Per semplicità, prendiamo un server sftp.
- crea un gruppo
$ sudo groupadd sftpg - aggiungi un utente e imposta una password per lui
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - modificando un paio di impostazioni di accesso
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - aggiungi alcune righe a /etc/ssh/sshd_config
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - riavviare il servizio
$ sudo systemctl restart sshd
Come l' negozio di backend Prendiamo 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_dbPer avviare il server è necessario installare i seguenti pacchetti Python (consiglio di creare un ambiente virtuale separato):
pip install mlflow
pip install pysftpAvviamo il nostro server
$ 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. Aggiungi il monitoraggio
Affinché i risultati della nostra formazione non vadano persi, le future generazioni di sviluppatori capiscano cosa stava succedendo e affinché tu e i tuoi compagni più anziani possiate analizzare con calma il processo di apprendimento, dobbiamo aggiungere il monitoraggio. Tracciare significa salvare parametri, metriche, artefatti ed eventuali informazioni aggiuntive sull'inizio dell'allenamento, nel nostro caso, sul server.
Ad esempio, ho creato un piccolo su Keras per segmentare tutto ciò che è presente . Per aggiungere il monitoraggio, ho creato un file mlflow_training.py.
Ecco le righe in cui accadono le cose più interessanti:
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)Qui self.remote_server è un piccolo wrapper sui metodi mlflow.tracking. MlflowClient (l'ho realizzato per comodità), con l'aiuto del quale creo un esperimento e lo eseguo sul server. Successivamente, indico dove devono essere uniti i risultati del lancio (mlflow.set_tracking_uri(self.tracking_uri)). Abilito la registrazione automatica mlflow.keras.autolog(). Attualmente MLflow Tracking supporta la registrazione automatica per TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Se non hai trovato il tuo framework o libreria, puoi sempre accedere esplicitamente. Stiamo iniziando la formazione. Registra tag e parametri di input sul server remoto.
Un paio di righe e tu, come tutti gli altri, avrai accesso alle informazioni su tutti i lanci. Freddo?
3. Elaboriamo il progetto
Ora semplifichiamo il lancio del progetto. Per fare ciò, aggiungi il file MLproject e conda.yaml alla root del progetto.
Progetto 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}"Il progetto MLflow ha diverse proprietà:
- Nome: il nome del tuo progetto;
- Ambiente: nel mio caso, conda_env indica che Anaconda viene utilizzato per l'esecuzione e la descrizione della dipendenza si trova nel file conda.yaml;
- Punti di ingresso: indica quali file e con quali parametri possiamo eseguire (tutti i parametri vengono registrati automaticamente all'avvio dell'allenamento)
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.0Puoi utilizzare docker come ambiente di runtime, per maggiori dettagli fai riferimento a .
4. Iniziamo la formazione
Cloniamo il progetto e andiamo nella directory del progetto:
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/Per eseguire è necessario installare le librerie
pip install mlflow
pip install pysftpPerché nell'esempio che utilizzo conda_env, Anaconda deve essere installato sul tuo computer (ma puoi aggirare il problema installando tu stesso tutti i pacchetti necessari e giocando con i parametri di avvio).
Tutte le fasi preparatorie sono state completate e possiamo iniziare a lanciare la formazione. Dalla radice del progetto:
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .Dopo aver inserito il comando, verrà creato automaticamente un ambiente conda e inizierà l'addestramento.
Nell'esempio sopra ho passato il numero di epoche per l'allenamento, le categorie in cui vogliamo segmentare (puoi vedere l'elenco completo ) e l'indirizzo del nostro server remoto.
Un elenco completo dei possibili parametri è disponibile nel file MLproject.
5. Valutare i risultati dell'apprendimento
Dopo aver completato la formazione, possiamo andare nel browser all'indirizzo del nostro server
Qui vediamo un elenco di tutti gli esperimenti (in alto a sinistra), nonché le informazioni sulle esecuzioni (al centro). Possiamo visualizzare informazioni più dettagliate (parametri, metriche, artefatti e alcune informazioni aggiuntive) per ogni lancio.
Per ogni metrica possiamo osservare la storia dei cambiamenti
Quelli. Al momento possiamo analizzare i risultati in modalità "manuale" ed è anche possibile impostare la convalida automatica utilizzando l'API MLflow.
6. Registrare il modello
Dopo aver analizzato il nostro modello e deciso che è pronto per la battaglia, procediamo alla registrazione, per questo selezioniamo il lancio di cui abbiamo bisogno (come mostrato nel paragrafo precedente) e scendiamo.
Dopo aver dato un nome al nostro modello, avrà una versione. Se salvi un altro modello con lo stesso nome, la versione verrà automaticamente aggiornata.
Per ogni modello possiamo aggiungere una descrizione e selezionare uno dei tre stati (Staging, Produzione, Archiviato); successivamente, utilizzando l'API, possiamo accedere a questi stati, che, insieme al controllo delle versioni, fornisce ulteriore flessibilità.
Abbiamo anche un facile accesso a tutti i modelli
e le loro versioni
Come nel paragrafo precedente, tutte le operazioni possono essere eseguite utilizzando l'API.
7. Distribuire il modello
In questa fase, abbiamo già un modello addestrato (keras). Un esempio di come puoi usarlo:
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 resultAnche in questo caso self.registry è un piccolo wrapper su mlflow.tracking.MlflowClient, per comodità. Il punto è che accedo a un server remoto e cerco lì un modello con il nome specificato e l'ultima versione di produzione. Successivamente, scarico l'artefatto localmente nella cartella ./model e creo il modello da questa directory mlflow.keras.load_model(local_path). Ora possiamo usare il nostro modello. Gli sviluppatori CV (ML) possono facilmente migliorare il modello e pubblicare nuove versioni.
insomma
Ho presentato un sistema che permette:
- archiviare centralmente informazioni su modelli ML, progressi e risultati della formazione;
- distribuire rapidamente un ambiente di sviluppo;
- monitorare e analizzare lo stato di avanzamento dei lavori sui modelli;
- è conveniente versionizzare e gestire lo stato dei modelli;
- È facile distribuire i modelli risultanti.
Questo esempio è un giocattolo e serve come punto di partenza per costruire il proprio sistema, che può includere l'automazione della valutazione dei risultati e la registrazione dei modelli (punti 5 e 6, rispettivamente) oppure si aggiungerà il controllo delle versioni dei set di dati, o forse qualcos'altro? Il punto che stavo cercando di sottolineare è che hai bisogno di MLOps nel suo insieme, MLflow è solo un mezzo per raggiungere un fine.
Scrivi quali problemi hai riscontrato che non ho visualizzato?
Cosa aggiungeresti al sistema per farlo soddisfare le tue esigenze?
Quali strumenti e approcci utilizzate per risolvere tutti o parte dei problemi?
PS lascio un paio di link:
progetto github -
flussoML-
La mia email di lavoro per domande - [email protected]
La nostra azienda ospita periodicamente vari eventi per specialisti IT, ad esempio: l'8 luglio alle 19:00 ora di Mosca si terrà un incontro con i CV in formato online, se sei interessato puoi partecipare, registrazione .
Fonte: habr.com