¡Hola a todos! Soy desarrollador de CV en CROC. Llevamos 3 años implementando proyectos en el campo del CV. Durante este tiempo hicimos muchas cosas, por ejemplo: monitoreamos a los conductores para que mientras conducían no bebieran, no fumaran, no hablaran por teléfono, miraran la carretera, ni los sueños ni las nubes. ; Registramos a personas que conducen en carriles exclusivos y ocupan varios espacios de estacionamiento; aseguró que los trabajadores usaran cascos, guantes, etc.; identificó a un empleado que quiere ingresar a las instalaciones; Contamos todo lo que pudimos.
¿Para qué estoy haciendo todo esto?
En el proceso de implementación de proyectos, nos topamos con obstáculos, muchos obstáculos, algunos de los problemas con los que están familiarizados o con los que se familiarizarán en el futuro.
Simular la situacion
Imaginemos que conseguimos un trabajo en una empresa joven “N”, cuyas actividades están relacionadas con ML. Trabajamos en un proyecto de ML (DL, CV), luego, por alguna razón, cambiamos de trabajo, generalmente tomamos un descanso y volvemos a nuestra neurona o a la de otra persona.
- Llega el momento de la verdad, debes recordar de alguna manera dónde te detuviste, qué hiperparámetros probaste y, lo más importante, a qué resultados te llevaron. Puede haber muchas opciones sobre quién almacena la información en todos los lanzamientos: en la cabeza, en las configuraciones, en el bloc de notas, en un entorno de trabajo en la nube. Vi una opción cuando los hiperparámetros se almacenaban como líneas comentadas en el código, en general, un vuelo de fantasía. Ahora imagina que no regresaste a tu proyecto, sino al proyecto de una persona que dejó la empresa y heredaste un código y un modelo llamado model_1.pb. Para completar el cuadro y transmitir todo el dolor, imaginemos que tú también eres un especialista principiante.
- Adelante. Para ejecutar el código, nosotros y todos los que trabajaremos con él necesitamos crear un entorno. Muchas veces sucede que por alguna razón no lo dejaron como herencia nuestra. Esto también puede convertirse en una tarea no trivial. No querrás perder el tiempo en este paso, ¿verdad?
- Entrenamos un modelo (por ejemplo, un detector de automóviles). Llegamos al punto en el que todo se vuelve muy bueno: es hora de guardar el resultado. Llamémoslo car_detection_v1.pb. Luego entrenamos a otro: car_detection_v2.pb. Un tiempo después, nuestros compañeros o nosotros mismos enseñamos cada vez más, utilizando arquitecturas diferentes. Como resultado, se forma un montón de artefactos, cuya información debe recopilarse minuciosamente (pero lo haremos más adelante, porque por ahora tenemos asuntos más prioritarios).
- OK, ¡todo terminó ahora! ¡Tenemos modelo! ¿Podemos empezar a entrenar el siguiente modelo, desarrollar una arquitectura para resolver un nuevo problema o podemos ir a tomar un té? ¿Y quién lo desplegará?
Identificando problemas
Trabajar en un proyecto o producto es el trabajo de muchas personas. Y con el tiempo, la gente viene y se va, hay más proyectos y los proyectos en sí se vuelven más complejos. De una forma u otra, situaciones del ciclo descrito anteriormente (y no solo) en ciertas combinaciones ocurrirán de iteración en iteración. Todo esto resulta en pérdida de tiempo, confusión, nervios, posiblemente insatisfacción del cliente y, en última instancia, pérdida de dinero. Aunque todos solemos seguir el mismo rastrillo de siempre, creo que nadie quiere revivir estos momentos una y otra vez.
Entonces, hemos pasado por un ciclo de desarrollo y vemos que hay problemas que deben resolverse. Para hacer esto necesitas:
- almacenar cómodamente los resultados del trabajo;
- simplificar el proceso de involucrar a nuevos empleados;
- simplificar el proceso de implementación de un entorno de desarrollo;
- configurar el proceso de versionado del modelo;
- tener una manera conveniente de validar modelos;
- encontrar una herramienta modelo de gestión del estado;
- encontrar una manera de entregar los modelos a producción.
¿Aparentemente es necesario idear un flujo de trabajo que le permita gestionar fácil y cómodamente este ciclo de vida? Esta práctica se llama MLOps.
MLOps, o DevOps para aprendizaje automático, permite que los equipos de TI y ciencia de datos colaboren y aumenten el ritmo de desarrollo e implementación de modelos a través del monitoreo, la validación y la gobernanza de los modelos de aprendizaje automático.
Puedes ¿Qué opinan los chicos de Google de todo esto? Del artículo se desprende claramente que MLOps es algo bastante voluminoso.
Más adelante en mi artículo describiré sólo una parte del proceso. Para la implementación, usaré la herramienta MLflow, porque... Este es un proyecto de código abierto, se requiere una pequeña cantidad de código para conectarse y existe integración con marcos ml populares. Puedes buscar en Internet otras herramientas, como Kubeflow, SageMaker, Trains, etc., y quizás encontrar una que se adapte mejor a tus necesidades.
“Construir” MLOps usando el ejemplo del uso de la herramienta MLFlow
MLFlow es una plataforma de código abierto para la gestión del ciclo de vida de modelos ml ().
MLflow incluye cuatro componentes:
- Seguimiento de MLflow: cubre las cuestiones de registro de resultados y parámetros que llevaron a este resultado;
- Proyecto MLflow: le permite empaquetar código y reproducirlo en cualquier plataforma;
- Modelos MLflow: responsable de implementar modelos en producción;
- Registro MLflow: le permite almacenar modelos y administrar su estado en un repositorio centralizado.
MLflow opera en dos entidades:
- el lanzamiento es un ciclo completo de entrenamiento, parámetros y métricas por los cuales queremos registrarnos;
- Un experimento es un “tema” que va de la mano.
Todos los pasos del ejemplo se implementan en el sistema operativo Ubuntu 18.04.
1. Implementar el servidor
Para que podamos gestionar fácilmente nuestro proyecto y recibir toda la información necesaria, implementaremos un servidor. El servidor de seguimiento de MLflow tiene dos componentes principales:
- almacén backend: responsable de almacenar información sobre los modelos registrados (admite 4 DBMS: mysql, mssql, sqlite y postgresql);
- almacén de artefactos: responsable de almacenar artefactos (admite 7 opciones de almacenamiento: Amazon S3, Azure Blob Storage, Google Cloud Storage, servidor FTP, servidor SFTP, NFS, HDFS).
A medida que el tienda de artefactos Para simplificar, tomemos un servidor SFTP.
- crear un grupo
$ sudo groupadd sftpg - agregue un usuario y establezca una contraseña para él
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - ajustando un par de configuraciones de acceso
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - agregue algunas líneas a /etc/ssh/sshd_config
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - reiniciar el servicio
$ sudo systemctl restart sshd
A medida que el tienda de backend Tomemos 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_dbPara iniciar el servidor, debe instalar los siguientes paquetes de Python (recomiendo crear un entorno virtual separado):
pip install mlflow
pip install pysftpIniciemos nuestro servidor.
$ 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. Agregar seguimiento
Para que los resultados de nuestra capacitación no se pierdan, las generaciones futuras de desarrolladores comprendan lo que estaba sucediendo y para que los camaradas mayores y usted puedan analizar con calma el proceso de aprendizaje, debemos agregar el seguimiento. El seguimiento significa guardar parámetros, métricas, artefactos y cualquier información adicional sobre el inicio del entrenamiento, en nuestro caso, en el servidor.
Por ejemplo, creé un pequeño en Keras para segmentar todo lo que hay en . Para agregar seguimiento, creé un archivo mlflow_training.py.
Aquí están las líneas donde suceden las cosas más interesantes:
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)Aquí self.remote_server es un pequeño contenedor sobre los métodos mlflow.tracking. MlflowClient (lo hice por conveniencia), con la ayuda del cual creo un experimento y lo ejecuto en el servidor. A continuación, indico dónde se deben fusionar los resultados del lanzamiento (mlflow.set_tracking_uri(self.tracking_uri)). Habilito el registro automático mlflow.keras.autolog(). Actualmente, MLflow Tracking admite el registro automático para TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark. Si no ha encontrado su marco o biblioteca, siempre puede iniciar sesión explícitamente. Estamos empezando a entrenar. Registre etiquetas y parámetros de entrada en el servidor remoto.
Un par de líneas y usted, como todos los demás, tendrá acceso a información sobre todos los lanzamientos. ¿Fresco?
3. Redactamos el proyecto
Ahora hagamos que sea más fácil iniciar el proyecto. Para hacer esto, agregue el archivo MLproject y conda.yaml a la raíz del proyecto.
proyecto 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}"El proyecto MLflow tiene varias propiedades:
- Nombre: el nombre de su proyecto;
- Entorno: en mi caso, conda_env indica que se usa Anaconda para ejecutar y la descripción de la dependencia está en el archivo conda.yaml;
- Puntos de entrada: indica qué archivos y con qué parámetros podemos ejecutar (todos los parámetros se registran automáticamente al iniciar el entrenamiento)
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.0Puede utilizar Docker como entorno de ejecución; para obtener más detalles, consulte .
4. Empecemos a entrenar
Clonamos el proyecto y vamos al directorio del proyecto:
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/Para ejecutarlo necesitas instalar bibliotecas.
pip install mlflow
pip install pysftpPorque en el ejemplo que uso conda_env, Anaconda debe estar instalado en su computadora (pero puede solucionar esto instalando usted mismo todos los paquetes necesarios y jugando con los parámetros de inicio).
Se completan todos los pasos preparatorios y podemos comenzar a iniciar la capacitación. Desde la raíz del proyecto:
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .Después de ingresar el comando, se creará automáticamente un entorno conda y comenzará la capacitación.
En el ejemplo anterior, pasé el número de épocas para el entrenamiento, las categorías en las que queremos segmentar (puedes ver la lista completa ) y la dirección de nuestro servidor remoto.
Puede encontrar una lista completa de posibles parámetros en el archivo MLproject.
5. Evaluar los resultados del aprendizaje
Después de completar la capacitación, podemos ir en el navegador a la dirección de nuestro servidor.
Aquí vemos una lista de todos los experimentos (arriba a la izquierda), así como información sobre las ejecuciones (en el medio). Podemos ver información más detallada (parámetros, métricas, artefactos y alguna información adicional) para cada lanzamiento.
Para cada métrica podemos observar el historial de cambios.
Aquellos. Por el momento, podemos analizar los resultados en modo "manual" y también puede configurar la validación automática utilizando la API de MLflow.
6. Registra el modelo
Luego de haber analizado nuestro modelo y decidido que está listo para la batalla, procedemos a registrarlo, para ello seleccionamos el lanzamiento que necesitamos (como se muestra en el párrafo anterior) y bajamos.
Después de darle un nombre a nuestro modelo, tiene una versión. Si guarda otro modelo con el mismo nombre, la versión se actualizará automáticamente.
Para cada modelo podemos agregar una descripción y seleccionar uno de tres estados (Staging, Production, Archived); posteriormente, usando la API, podemos acceder a estos estados, lo que, junto con el versionado, proporciona flexibilidad adicional.
También tenemos fácil acceso a todos los modelos.
y sus versiones
Como en el párrafo anterior, todas las operaciones se pueden realizar mediante la API.
7. Implementar el modelo
En esta etapa, ya tenemos un modelo entrenado (keras). Un ejemplo de cómo puedes 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 resultAquí, self.registry es nuevamente un pequeño contenedor sobre mlflow.tracking.MlflowClient, por conveniencia. El caso es que accedo a un servidor remoto y busco allí un modelo con el nombre especificado y la última versión de producción. A continuación, descargo el artefacto localmente en la carpeta ./model y construyo el modelo desde este directorio mlflow.keras.load_model(local_path). Ahora podemos usar nuestro modelo. Los desarrolladores de CV (ML) pueden mejorar fácilmente el modelo y publicar nuevas versiones.
en conclusión
Presenté un sistema que permite:
- almacenar de forma centralizada información sobre modelos de ML, progreso y resultados de la capacitación;
- implementar rápidamente un entorno de desarrollo;
- monitorear y analizar el progreso del trabajo sobre modelos;
- es conveniente versionar y gestionar el estado de los modelos;
- Es fácil implementar los modelos resultantes.
Este ejemplo es un juguete y sirve como punto de partida para construir su propio sistema, que puede incluir la automatización de la evaluación de resultados y el registro de modelos (puntos 5 y 6, respectivamente), o agregará control de versiones de conjuntos de datos, ¿o tal vez algo más? Lo que estaba tratando de señalar es que necesitas MLOps en su conjunto, MLflow es solo un medio para un fin.
Escribe qué problemas encontraste y que no mostré.
¿Qué agregaría al sistema para que satisfaga sus necesidades?
¿Qué herramientas y enfoques utiliza para resolver todos o parte de los problemas?
PD te dejo un par de enlaces:
proyecto github -
flujo ml -
Mi correo electrónico de trabajo para preguntas - [email protected]
Nuestra empresa organiza periódicamente varios eventos para especialistas en TI, por ejemplo: el 8 de julio a las 19:00 hora de Moscú tendrá lugar una reunión de CV en formato online, si está interesado, puede participar, registrarse .
Fuente: habr.com