Integraciones de herramientas de aprendizaje automático #2 DVC para el control de versiones de sus datos

El control de versiones de datos (DVC) es una herramienta poderosa para administrar y versionar grandes conjuntos de datos y modelos en proyectos de aprendizaje automático.

DVC es una herramienta de código abierto que funciona con una amplia gama de opciones de almacenamiento, incluidos el disco local, los sistemas de archivos de red, Amazon S3, Google Cloud Storage y muchas otras. El DVC se puede usar junto con marcos de aprendizaje automático populares, como TensorFlow, PyTorch y scikit-learn.

Además de rastrear los cambios en los datos y los modelos, DVC también puede ayudar a los usuarios a administrar las dependencias entre los diferentes componentes de un proyecto de aprendizaje automático, como el código, los datos y los modelos. Al llevar un registro de estas dependencias, DVC facilita la reproducción de experimentos de aprendizaje automático y el intercambio de proyectos con otros usuarios.

Desafíos del control de versiones en el aprendizaje automático

El control de versiones en el aprendizaje automático es una tarea más difícil en comparación con la ingeniería de software por las siguientes razones:

1. Conjuntos de datos grandes y complejos: En el aprendizaje automático, los conjuntos de datos que se utilizan para entrenar y probar los modelos pueden ser enormes, lo que dificulta su administración y versión. Además, los datos pueden no estar estructurados, lo que dificulta el seguimiento de los cambios en los datos a lo largo del tiempo.
2. Múltiples componentes: Los proyectos de aprendizaje automático suelen incluir varios componentes, incluidos datos, código y modelos, lo que dificulta el seguimiento de los cambios en cada componente y la forma en que interactúan entre sí.
3. Proceso de desarrollo iterativo: En el aprendizaje automático, el proceso de desarrollo suele ser iterativo, y los desarrolladores actualizan con frecuencia los modelos en función de nuevos datos o mejoran la precisión del modelo. La administración de estos cambios y versiones puede resultar compleja y llevar mucho tiempo.

DVC resuelve estos problemas al proporcionar una forma simple y eficiente de controlar las versiones de los datos y los modelos en los proyectos de aprendizaje automático. El DVC le permite controlar las versiones no solo del código, sino también de los datos y los modelos, y realizar un seguimiento de las relaciones entre ellos. Con DVC, puede reproducir fácilmente experimentos anteriores, colaborar con los miembros del equipo y automatizar los flujos de trabajo para agilizar el proceso de desarrollo.

Instalación y configuración de sistemas de control de versiones

Para empezar a usar DVC, debe instalarlo y configurarlo en su máquina local. En esta sección, proporcionaremos instrucciones paso a paso sobre cómo hacerlo, incluido cómo configurar el DVC para que funcione con diferentes servicios de almacenamiento en la nube y cómo crear un nuevo proyecto de DVC.

1. Instalar DVC: El primer paso es instalar DVC en su máquina local. Puede hacerlo siguiendo las instrucciones de instalación de su sistema operativo en el sitio web de DVC.
2. Crear un nuevo proyecto de DVC: Una vez instalado el DVC, puede crear un nuevo proyecto de DVC ejecutando el siguiente comando en su terminal:

entrada dvc


Esto creará un nuevo proyecto de DVC en su directorio actual.

3. Configure el DVC para que funcione con el almacenamiento en la nube: si desea utilizar el DVC con servicios de almacenamiento en la nube como Amazon S3 o Google Cloud Storage, debe configurar el DVC para que funcione con estos servicios. Para ello, añada un nuevo mando a distancia con el siguiente comando:

dvc remote add -d <remote-name><storage-url>


Por ejemplo, si quiere añadir un control remoto de Amazon S3 denominado «my-s3-remote», puede ejecutar el siguiente comando:

dvc remote add -d my-s3-remote s3://my-bucket-name


Esto añadirá un nuevo mando a distancia a su proyecto de DVC que está configurado para funcionar con Amazon S3.

4. Agregue datos a su proyecto de DVC: una vez que haya configurado su proyecto de DVC y lo haya configurado para que funcione con el almacenamiento en la nube, puede empezar a agregarle datos. Puede hacerlo ejecutando el siguiente comando:

dvc añadir <path-to-data-file>


Esto añadirá el archivo de datos a su proyecto de DVC y creará un archivo de DVC correspondiente que rastreará los cambios en los datos.

5. Insertar cambios en el almacenamiento remoto: si ha configurado su proyecto de DVC para que funcione con el almacenamiento remoto, puede insertar los cambios en este almacenamiento ejecutando el siguiente comando:

push dvc


Esto transferirá cualquier cambio que haya realizado en sus datos o modelos al almacenamiento remoto.

Ejecución de comandos DVC para un control de versiones mejorado

DVC proporciona una serie de comandos útiles para administrar y versionar proyectos de aprendizaje automático. Esta es una lista de algunos de los comandos de DVC más utilizados:

1. entrada dvc: inicializa un nuevo proyecto de DVC en el directorio actual.
2. dvc añadir <path-to-file>: Añade un archivo al DVC y crea el archivo DVC correspondiente para realizar un seguimiento de los cambios realizados en el archivo.
3. ejecución de dvc: ejecuta un comando o un script con el seguimiento de DVC habilitado, de modo que DVC rastrea todas las entradas y salidas.
4. reproducción dvc: reproduce un comando o script rastreado por DVD, garantizando que todas las dependencias estén actualizadas.
5. push dvc: Envía todos los archivos de datos y modelos a un almacenamiento remoto, como AWS S3 o Google Cloud Storage.
6. dvc pull: extrae todos los archivos de datos y modelos del almacenamiento remoto a la máquina local.
7. estado de dvc: muestra el estado de los archivos rastreados, incluido si se han modificado, agregado o eliminado.
8. registro dvc: muestra una lista de todas las versiones de un archivo, junto con sus correspondientes mensajes de confirmación y otros metadatos.

Reproducción de experimentos de ML usando DVC

Una de las ventajas más importantes del uso de DVC es su capacidad para reproducir experimentos de aprendizaje automático. Con DVC, puede definir y rastrear las dependencias entre el código, los datos y los modelos, y utilizar el reproducción dvc comando para reproducir experimentos anteriores.

Ejemplo de flujo de trabajo:
Claro, este es un ejemplo de flujo de trabajo para un conjunto de datos de iris de sklearn con un archivo.yaml:

1. En primer lugar, inicialice un nuevo proyecto de DVC ejecutando el comando entrada dvc.
2. Crea un dato directorio en la carpeta de su proyecto para almacenar el conjunto de datos y descargar el conjunto de datos de iris de sklearn en este directorio.
3. Añada los archivos de datos a DVC mediante el comando dvc add. Por ejemplo: dvc agrega data/iris.csv.
4. Crea un .yaml archivo para definir la canalización. Por ejemplo, iris.yaml. Este archivo contendrá los comandos para preprocesar, entrenar y evaluar el modelo.
5. Defina los pasos en .yaml archivo mediante los comandos DVC. Por ejemplo:

etapas:
preproceso:
cmd: python preprocess.py data/iris.csv data/preprocessed.csv
profundidades:
- data/iris.csv
fuera:
- data/preprocessed.csv

tren:
cmd: python train.py data/preprocessed.csv modelos/model.pkl
profundidades:
- data/preprocessed.csv
fuera:
- modelos/model.pl

evaluar:
cmd: python evaluate.py modelos/model.pl data/iris.csv
profundidades:
- modelos/model.pl
- data/iris.csv


6. Ejecute la canalización con el comando dvc repro. Este comando ejecutará los pasos definidos en el archivo .yaml en el orden correcto, asegurándose de que todas las dependencias estén actualizadas. Por ejemplo: dvc repro iris.yaml.

Al definir tu canalización en un .yaml archivo y uso del reproducción dvc comando, puede reproducir fácilmente sus experimentos, rastrear las versiones de sus datos y modelos y colaborar con los miembros del equipo en su proyecto de aprendizaje automático.

Este es un ejemplo de flujo de trabajo:

1. Configure las credenciales y la información de punto final adecuadas para el servidor S3:

dvc remote add -d s3remote s3://your-s3-bucket-name/path/to/models


2. Extraiga los archivos de modelo necesarios del servidor S3 a la máquina local:

dvc pull -r s3ruta remota/a/models/model.pkl


3. Copie los archivos del modelo descargados en el servidor remoto de destino:

scp path/to/models/model.pkl user @target -remote-server: /path/to/models/


4. Utilice los archivos copiados como inferencia en el servidor remoto de destino:

# Cargue el modelo
pepinillos de importación
con open ('/path/to/models/model.pkl', 'rb') como f:
modelo = pickle.load (f)

# Haz predicciones
x_test = [[5.1, 3.5, 1.4, 0.2], [7.7, 3.0, 6.1, 2.3], [6.0, 3.0, 4.8, 1.8]]
y_pred = modelo.predict (x_Test)
imprimir (y_pred)


Este flujo de trabajo presupone que ha configurado las credenciales y la información de punto final necesarias para el servidor S3 y que tiene acceso tanto a los servidores remotos locales como a los de destino. Puede modificar el flujo de trabajo en función de sus necesidades y configuración específicas.

Cómo se integra TrueFoundry con DVC:

TrueFoundry se integra perfectamente con DVC Model Registry para permitirle implementar modelos registrados en DVC en su clúster de Kubernetes mediante TrueFoundry.

📌

Además de usar DVC para la gestión de modelos y el seguimiento de la experimentación, también puedes usar MLFoundy, el seguimiento de experimentos de Truefoundry.

Paso 1: Instalación y configuración:

• Configurar DVC

# Instale el soporte para DVC y S3
instalación pip dvc dvc-s3

# Inicializar Git en el directorio local
git init

# Inicializar DVC en el directorio local
entrada dvc

# Configure el almacenamiento remoto de DVC como su depósito
dvc remote add s3://<your_bucket_name>

Nota: Tendrá que configurar su s3 cli para que esto funcione

• Importar dvc

importar dvc

x

• Instalar servicefoundry

pip install -U «servicefoundry»

• Iniciar sesión en truefoundry

inicio de sesión sfy

Paso 2: Entrene y registre el modelo:

Entrenaremos nuestro modelo ML y lo guardaremos como un archivo joblib
Luego agregaremos el modelo y las métricas de evaluación usando **`dvc agregar`**
Luego, enviaremos nuestro archivo joblib a dvc a través de **`dvc`**

desde sklearn.datasets importar load_iris
desde sklearn.model_selection importar train_test_split
desde sklearn.linear_model importar LogisticRegression
desde sklearn.metrics import classification_report
importar joblib
sistema operativo de importación

# Cargar y preprocesar los datos
X, y = load_iris (as_frame = verdadero, return_x_y = verdadero)
X = x.Rename (columnas= {
«longitud del sépalo (cm)»: «longitud del sépalo»,
«ancho del sépalo (cm)»: «ancho del sépalo»,
«longitud del pétalo (cm)»: «longitud del pétalo»,
«ancho del pétalo (cm)»: «ancho del pétalo»,
})

X_train, X_test, y_train, y_test = train_test_split (
X, y, tamaño_de_prueba=0.2, estado_aleatorio = 42, estratificación = y
)

# Inicializar el modelo
clf = Regresión logística (solver="liblinear»)

# Se ajusta al modelo
clf.fit (tren X, tren y)

# Evalúe el modelo
preds = clf.predict (x_test)

# Guarde el modelo usando joblib y DVC
joblib.dump (clf, «model.joblib»)
os.system («dvc agregar modelo.joblib»)

# Registrar las métricas de evaluación
report = classification_report (y_test, preds, OUTPUT_DICT=true)
con open (» classification_report.txt «, «w») como si:
f.write (str (informe))

# Traslado el modelo y las métricas de evaluación al almacenamiento remoto
os.system («dvc push»)

Paso 3: Cree una aplicación de inferencia y un archivo de dependencia:

Tendremos que crear dos archivos para desplegarlos en truefoundry, un app.py archivo que contiene el código de nuestra aplicación y un requirements.txt archivo que contiene nuestras dependencias.

.
├── app.py
├── deploy.py
── requirements.txt


• app.py:

sistema operativo de importación
importar joblib
importar pandas como pdf
desde fastapi import FastAPI

# Recupere el modelo de S3 usando DVC
os.system («dvc pull model.joblib.dvc»)

# Cargue el modelo
modelo = joblib.load («model.joblib»)

# Cargue el modelo
aplicación = fastAPI ()

@app .post («/predecir»)
sin embargo, predecir (
sepal_length: float, sepal_width: float, petal_length: float, petal_width: float
):
datos = dict (
sepal_length=sepal_length,
sepal_width=sepal_width,
petal_length=petal_length,
petal_width=petal_width,
)
predicción = int (model.predict (pd.DataFrame ([datos])) [0])
return {"predicción»: predicción}

• requirements.txt:

API rápida
pandas
joblib
dvc

Paso 4: Usa el SDK de python de truefoundry y configura la implementación

• deploy.py:

importar argparse
registro de importación
de servicefoundry import Build, PythonBuild, Service, Resources, Port

# Configurar el registrador
Logging.basicConfig (nivel=Logging.info)

# Configurar el analizador de argumentos
analizador = argParse.ArgumentParser ()
parser.add_argument («--workspace_fqn», obligatorio=True, type=str)
args = parser.parse_args ()

servicio = Servicio (
nombre = «fastapi»,
image=construir (
build_spec=PythonBuild (
command="uvicorn app:app --port 8000 --host 0.0.0.0",
requirements_path=» requirements.txt «,
)
),
puertos= [
Puerto (
puerto=8000,
host="ml-deploy-aditya-ws-8000.demo.truefoundry.com»,
)
],
resources=Recursos (
cpu_request=0.25,
cpu_limit=0.5,
memory_request=200,
memory_limit=400,
ephemeral_storage_request=200,
límite de almacenamiento_efímero=400,
),
)
service.deploy (workspace_fqn=args.workspace_fqn)

Paso 5: Implemente su servicio a través de Truefoundry

Ejecute el siguiente comando y pase su

• FQN del espacio de trabajo: que puedes encontrar en el tablero

python deploy.py --workspace_fqn your_workspace_fqn

¡¡¡Y listo!!! En los registros puede encontrar el panel de control de su servicio desplegado. A continuación, en la esquina superior derecha, encontrará el punto final de las aplicaciones implementadas.

True Foundry es un PaaS de implementación de aprendizaje automático sobre Kubernetes para acelerar los flujos de trabajo de los desarrolladores y, al mismo tiempo, permitirles una flexibilidad total a la hora de probar e implementar modelos, al tiempo que garantiza una seguridad y un control totales para el equipo de Infra. A través de nuestra plataforma, permitimos a los equipos de aprendizaje automático implementar y supervisar modela en 15 minutos con un 100% de confiabilidad, escalabilidad y la capacidad de revertirse en segundos, lo que les permite ahorrar costos y lanzar los modelos a la producción más rápido, lo que permite obtener un verdadero valor empresarial.