DVC: cómo crear un sistema de control de versión de datos para MLOps

Crear un sistema de versionado de datos es fundamental cuando queremos implementar nuestros procesos de MLOps. Al fin y al cabo, cuando hablamos de Machine Learning, para poder reproducir unos mismos resultados no solo basta con saber el modelo que se ha usado y los parámetros que tenía, también necesitamos conocer con qué datos se ha entrenado este modelo.

Y es que, cuando hablamos de MLOPs y puesta en producción de modelos de Machine Learning, resulta fundamental saber por qué el modelo en producción en ese momento ha hecho esas predicciones, ya sea por cuestiones legales o, simplemente, para poder entender los casos en los que el modelo falla y así poder arreglarlo. Y claro, para poder saber cómo ha hecho las predicciones, necesitamos comprobar el modelo y ver cómo eran los datos con los que se ha entrenado.

Así pues, en este post vamos a aprender a utilizar una de las herramientas de versionado de datos más usadas en el mundo del Machine Learning: DVC. Más concretamente veremos cómo funciona DVC, cómo podemos instalarlo y cómo utilizar DVC como sistema de control de versiones de datos para nuestros procesos de MLOPs. ¿Te suena interesante?, ¡veámos cómo DVC crea un sistema de versionado de datos!

Cómo funciona DVC

DVC, como indican sus siglas en inglés (Data Version Control) es una herramienta de control de versiones de datos. ¿Control de versiones? ¿Como Github? Pues sí, efectivamente, la idea de DVC es crear un sistema de control de versiones para nuestros datos que funcione igual que Github. Es más, DVC está montado encima de Github.

Si no conoces cómo funciona Github, te recomiendo que leas este post donde explico qué es y cómo usarlo en R. Sin duda alguna, Github es fundamental si desarrollas proyectos de ciencia de datos.

Seguramente, puede que te estés preguntando ¿y por qué usar DVC y no usar Github directamente? El punto principal es que en Github no puedes guardar ficheros que pesen más de 100Mb. Esto puede no ser un problema si desarrollas software, pero si entrenas modelos de Machine Learning, lo más probable es que tus datasets pesen más que 100Mb.

Por contra, DVC no tiene limites en el peso de los datos que puede gestionar. Y esto es por una sencilla razón: DVC no guarda los datos en su servidor. En su lugar, con DVC tú guardas los datos en tu unidad de almacenamiento preferida,como Cloud Storage, Amazon S3, Azure Blob Storage, Drive, SFTP, etc. Por su parte, DVC guardará de forma automática un fichero de muy poco peso para que sepas dónde se han guardado tus datos (ubicación, nombre, etc.).

De esta forma, cuando entrenes un modelo puedes hacer referencia a los datos con los que ha sido entrenado. Como DVC guada dicha referencia a la ubicación donde están almacenados los datos, sabes con que datos ha sido entrenado el modelo.

Por otro lado, además de permitir realizar el versionado de datos de forma sencilla y de ser agnóstico a la plataforma donde se guardan los datos, DVC también ofrece una serie de funcionalidades muy interesantes:

  • Es agnóstico al lenguaje que estemos utilizando. Vamos, que nos sirve tanto utilicemos Python, como R, Julia o cualquier otro lenguaje. Este es un punto que facilita mucho su implantación en las organizaciones.
  • Permite crear data pipelines sencillos, de tal forma que todo el mundo pueda visualizar el data pipeline en forma de DAG y, cómo no, también reproducirlo. Además, cada paso del datapipeline solo se ejecuta en caso de que un elemento de la misma (datos o fichero) se haya modificado, por lo que permite una ejecución muhco más eficiente (más adelante veremos esta cuestión).

Dicho esto, veamos cómo instalar y hacer funcionar nuestro sistema de versiones de datos con DVC. ¡Vamos a ello!

Primeros pasos con DVC

Instalación de DVC

Lo primero de dato, vas a necesitar descargar DVC lo cual puedes hacer dese esta página. Una vez lo hayas descargado, puedes ejecutar el siguiente comando en la consola:

dvc version

Si esto te devuelve algún código como el siguiente, es que DVC está instalado correctamente:

DVC Install

Usando DVC por primera vez

Ahora que tenemos DVC instalado, a inicializar nuestro repopsitorio con Github. Si no conoces en profundidad Github, si eres usuario de R te recomiendo este post y, si usas Python o cualquier otro lenguaje, te recomiendo este post.

Simplemente, vamos a inicializar nuestro repositorio con un git init. Tras ello, tenemos que inicializar DVC. Para ello, debemos ejecutar el siguiente comando:

dvc init

Como ves, los comandos de DVC son muy similares a los de git. De hecho, a continuación vamos a:

  1. Crear una carpeta llamada data donde guardar nuestros datos (esto no es obligatorio, pero sí una buena práctica).
  2. Descargar un fichero de internet y guardarlo en nuestra carpeta data.
  3. Añadir este fichero a dvc.
mkdir data
cd data
curl -o data.csv https://raw.githubusercontent.com/anderfernandez/Donostia-empty-parking-lots-forecast/main/data/data.csv
dvc add data/data.csv

Como puedes ver, el comando para añadir ficheros a DVC es exactamente el mismo que para Git. Sin embargo, una vez hayamos ejecutado los pasos anteriores veremos como en consola nos ha aparecido el siguiente mensaje:

Si vamos a la carpeta data, veremos como, además de estar el fichero data.csv que nos acabamos de descargar, también aparece un fichero .gitignore y otro llamado data.csv.dvc.

Por un lado, el fichero .gitignore busca que todos los ficheros que añadamos a DVC se excluyan, de forma automática, de añadirse a Github, ya que el fichero puede pesar mucho para usarlo en Github (por eso mismo usamos DVC). En el fondo, DVC nos ahorra tener que hacer esta exclusión nosotros mismos, lo cual estáa bien.

Por otro lado, el fichero data.csv.dvc es un fichero que hace referencia a nuestro fichero de origen data.csv y que incluye algunos metadatados hasheados (encriptados) de este fichero. Este es el fichero que podemos subir a Github, ya que pesa muy poco y es el fichero que usará DVC para identificar los datos con los que se ha entrenado el modelo.

Perfecto, ya sabes como añadir ficheros a DVC y ya ves los ficheros que se subirán a nuestra herramienta Git. Sin embargo, ¿donde guardamos realmente los datos? ¡Veámoslo!

Cómo almacenar los datos con DVC

Como comentaba en la introducción, con DVC los datos no se almacenan en Git, sino que se almacenan en la herramienta de almacenamiento que nosotros queramos: AWS S3, Azure Blob Storage, Google Cloud Storage, Google Drive, FTP, etc.

Para que los datos se guarden en esta ubicación, primero debemos añadir un remote a DVC. El remote en DVC es el lugar donde se guardarán los datos que se hayan añadido a DVC. Uno de los aspectos muy positivos de DVC es que permite añadir muchas plataformas como remote: S3, Cloud Storage, Azure Blob Storage, Google Drive, etc.

En las siguientes secciones veremos, paso a paso, cómo incluir como remote cada una de las diferentes opciones que hemos comentado previamente.

De cara al uso de DVC solo deberías añadir una de las siguientes opciones como remote, no todas ellas. Explico todas para que sepas cómo funcionan cada una de ellas y te sea más fácil usarlo en tu caso.

Cómo almacenar los datos con DVC en Google Cloud Storage

Para añadir datos en Cloud Storage requerimos tener descargado e instalado la línea de comandos (CLI) de Google Cloud en nuestro ordenador. Puedes descargarlo desde esta página. Una vez lo tienes descargado, tendrás que conectarte a tu cuenta, lo cual puedes hacer ejecutando el siguiente comando:

gcloud auth application-default login

Nota 1: si sueles trabajar con varias cuentas de Google Cloud en un mismo ordenador, como es mi caso (trabajo y personal), te recomiendo que en vez de ejecutar el comando gcloud auth application-default login ejecutes el comando gcloud auth login. Y es que, con la primera secuencia de comandos GCloud guarda las credenciales en el ordenador y las usa por defecto, lo cual te puede dar problemas más adelante al cambiar entre cuentas.

Nota 2: si tu proceso de MLOps se va a reentrenar automáticamente, no podrás usar este sistema de logueo a la cuenta de Google Cloud, ya que requiere de interactividad humana. En ese caso, deberías crear un service account y pasar su ubación con el parámetro --cred-file al ejecutar el login. Ejemplo: gcloud auth login --cred-file=/path/to/workload/configuration/file. En este post se explica cómo crear un service account en Google Cloud.

Perfecto, ahora que tienes instalado el CLI de Google Cloud, vamos a crear nuestro bucket donde guardar los documentos. Lo ideal es que cada proyecto en el que trabajemos sea un proyecto en Google Cloud y, además, tenga su propio bucket donde ir guardando los datos. Para crear un bucket en Google Cloud nos dirijimos a este enlace y hacemos clic en el botón «Create Bucket» de la parte superior izquierda, tal como aparece a continuación:

Al crear el bucket le tendremos que dar un nombre. Con ese nombre ya podemos añadir este bucket como remote a DVC con el siguiente comando:

dvc remote add -d myremote gs://mybucket/path

Ahora que hemos visto cómo subir los datos a Google Cloud, veamos cómo subir los datos a AWS S3.

Cómo almacenar los datos con DVC en AWS S3

En el caso de AWS, el procedimiento a seguir es exactamente igual que en el caso de Google Cloud. Primero de todo, debemos descargar la línea de comandos (CLI) de AWS, lo cual puedes hacer desde este enlace.

Asimismo, para poder loguearnos en el CLI de AWS, primero deberemos crear un usuario que tenga acceso a los buckets de S3. La creación de un usuario se puede realzar desde este enlace. Una vez creado el usuario tendremos dos piezas de información: el Access Key ID y el Secret access key.

Así pues, teniendo esta información, vamos a ejecutar el siguiente comando en consola de nuestro ordenador:

aws configure

Al hacerlo, nos pedirá unas claves. Primero deberemos indicar el Access Key ID y después el Secret Access Key. Asimismo, hay otras cuestiones que deberemos indicar como la región, que dependerá de dónde vivas. En este enlace puedes ver las regiones que ofrece AWS.

Una vez logueados, deberemos crear nuestro bucket de almacenamiento en S3 (ver imagen a continuación), al cual le tendremos que dar un nombre, en mi caso ha sido dvc-bucket-ander.

Por último, simplemente debemos añadir el bucket que acabamos de crear como un remote de nuestro repositorio de DVC. Para ello debemos ejecutar el siguiente comando:

dvc remote add -d myremote s3://dvc-bucket-ander

Con esto, cada vez que indiquemos a DVC que guarde la información en remoto (lo cual veremos en el siguiente punto), automáticamente lo guardará en nuestro bucket de S3.

Cómo almacenar los datos con DVC en Azure

Para poder almacenar los datos en Azure Blob Storage, primero debemos tener instalado el CLI de Azure, el cual podemos descargar desde esta página.

Una vez descargado e instalado, deberemos loguearnos a nuestra cuenta de Azure, lo cual podemos hacer con el siguiente comando:

az login

Al hacerlo, se nos abrirá una ventana donde tendremos que logueranos con nuestros datos de Azure. Una vez hecho esto ya tendremos nuestra cuenta de Azure vinculado al CLI.

Ahora, solo nos queda crear un bucket en Blob Storage donde almacenar los datos de DVC. Para ello, primero de todoo debemos crear una cuenta de almacenamiento, lo cual puedes hacer siguiedo estos pasos. En mi caso, la cuenta de storage se llama anderstorage.

Una vez tengas la cuenta creada, para crear el bucket de Blobg Storage debes:

  1. Ir a tu cuenta de almacenamiento en Azure.
  2. En la parte lateral izquierda, hacer clic sobre «contenedores» (ver imagen)

Ahí podrás crear un nuevo contenedor o bucket. Al hacerlo, le estarás dando un nombre al contenedor, que en mi caso es dvc-example-ander.

Así pues, una vez hayas hecho esto, para añadir Azure como nuestro remoto de DVC, simplemente debes ejecutar las siguientes líneas de comando:

dvc remote add -d myremote azure://dvc-example-ander
dvc remote modify myremote account_name 'anderstorage'

Hecho esto, cada vez que indiques a DVC que suba los datos al repositorio remoto, se subirán de forma automática a tu repositorio en Azure Blob Storage.

Otros lugares donde almacenar los datos con DVC

Además de los lugares previamente comentados, DVC permite guardar los datos en otras ubicaciones, como Google Drive, un FTP, HDFS o mediante SSH.

Personalmente, considero que, aunque Google Drive sea una opción, como para almacenar los datos en Google Drive hace falta tener una cuenta de Google Cloud, es más interesante guardar los datos en Cloud Storage. En cualquier caso, si quieres guardar los datos en Google Drive, aquí te explica cómo hacerlo.

Perfecto, ya sabemos cómo añadir un remote para guardar la información de forma remota. Sin emabrgo, ¿cómo podemos subir la información al remoto? Veámoslo.

Cómo subir la información al repositorio remoto en DVC

Si has seguido los pasos anteriores tendrás un fichero llamado data.csv. Para subir este fichero a nuestro repositorio remoto (sea cual sea) simplemente debemos ejecutar el siguiente comando:

dvc push

Tras ello, si hemos configurado de forma correcta nuestro repositorio en remoto, nuestro fichero se subirá automáticamente a dicho repositorio. Como ves, el funcionamiento es exactamente igual que como funcionaría una herramienta Git.

Además, también podemos descargar los contenidos que ya están en nuestro repositorio remoto mediante el siguiente comando:

dvc pull 

Perfecto, ya sabemos cómo funciona DVC en su forma más básica. Sin embargo, hay mucho más. Y es que con DVC nos ayuda en varias cuestiones importantes de nuestro proceso de MLOps, como es capturar el data pipeline o guardar las métricas de nuestro modelo. Veámoslo.

Creación de Data Pipelines con DVC

Cuando trabajamos en un proyecto de Machine Learning, generalmente no tenemos un solo script que haga todo el proceso de extracción de datos, limpieza, entrenamiento y evaluación. En su lugar, cada uno de estos pasos suele ir en uno o varios ficheros separados.

La problemática viene cuando una nueva persona ajena al proyecto entra al mismo , ya que antes de empezar a trabajar necesita saber qué procesos se siguen en qué orden. Esto generalmente se suele incluir en la documentación del repositorio, aunque puede ser aún más fácil.

Y es que con DVC podemos crear un DAG (un gráfico secuencial), de tal forma que podamos ver, de forma muy visual cómo es nuestro Data Pipeline. Además, como cada paso del pipeline va asociado a un fichero, DVC sabe cuáles de esos ficheros no han cambiado, de tal forma que, cuando ejecutas un data pipeline solo se ejecutan aquellos pasos cuyos datos han cambiado. Esto es muy interesante, puesto que permite reducir tiempo de ejecución.

Veamos cómo crear un data pipeline con DVC. Para ello vamos a usar un caso real de predicción del número de plazas de parking libres en Donostia.

Entrenamiento del modelo

Para entrenar el modelo, primero hay que extraer los datos. El proceso ETL ya se realiza mediante Github Actions, por lo que los datos se actualizan de forma automática en este repositorio (puede haber casos donde la API en origen no devuelva datos o los datos sean erróneos, lo cual afectará a las métricas que veamos en los resultados de los modelos).

Si no conoces sobre Github Actions, te recomiendo que le eches un vistazo puesto que es una herramienta muy útil. Puedes aprender más sobre ella en este post.

Así pues, primero contamos con un fichero llamado extract_data.py que cuenta con la siguiente información:

import pandas as pd
url = 'https://raw.githubusercontent.com/anderfernandez/Donostia-empty-parking-lots-forecast/main/data/data.csv'
data = pd.read_csv(url)
data.to_csv('data/raw.csv', index=False)

Después de extraer los datos en bruto, vamos a filtrarnos. En nuestro caso, vamos a quedarnos únicamente con un parking. Esto lo hacemos con el script prepare.py:

import pandas as pd
import yaml

params = yaml.safe_load(open("params.yaml"))["prepare"]

# Read Data
data = pd.read_csv('data/raw.csv')

# Data
parking = params['parking']

# Filter data 
data = data.loc[data['properties.nombre'] == parking, :]\
    .drop(['properties.nombre', 'timestamp'], axis = 1)\
    .reset_index(drop = True)

# Save the data
data.to_csv('data/prepared.csv', index = False)

De cara a entrenar el modelo, tenemos un script dedicado, que es el siguiente:

import os
import pandas as pd
import pickle
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from sklearn.ensemble import RandomForestRegressor
import yaml

params = yaml.safe_load(open("params.yaml"))["train"]

# Data0
seed = params['seed']
steps = params['steps']
lags = params['lags']
output = 'models/model.pickle'

# Read Data
data = pd.read_csv('data/prepared.csv')

data_train = data[:-steps]['properties.libres']
data_test  = data[-steps:]['properties.libres']

forecaster = ForecasterAutoreg(
                    regressor = RandomForestRegressor(random_state=seed),
                    lags      = lags
                )

forecaster.fit(y=data_train)


with open(output, "wb") as fd:
    pickle.dump(forecaster, fd)

Por último, evaluamos el rendimiento de nuestras predicciones sobre los últimos datos del dataset. Esto lo realizamos con el script evaluate.py:

import json
import pandas as pd
import pickle
import sklearn.metrics as metrics 
import yaml

params = yaml.safe_load(open("params.yaml"))["train"]

metrics_file = 'metrics.json'

tmp = pd.read_csv('data/prepared.csv')
predict_steps = params['steps']

with open('models/model.pickle', "rb") as f:
    forecaster = pickle.load(f)

data_test  = tmp[-predict_steps:]
predictions = forecaster.predict(steps = predict_steps)

mae = metrics.mean_absolute_error(data_test, predictions)
mse = metrics.mean_squared_error(data_test, predictions)

with open(metrics_file, "w") as f:
    json.dump({'mae': mae, "mse": mse}, f, indent = 2)

Además, todos los parámetros que utilizo en el modelo se encuentran en el fichero params.yaml, que contiene la siguiente información:

prepare:
  parking: "Easo"

train:
  seed: 1234
  steps: 36
  lags: 15

Así pues, siendo este nuestro proceso de datos, veamos cómo podemos crear un data pipeline con DVC.

Cómo crear un data pipeline con DVC

Existen dos formas para crear un data pipeline en DVC: usar el comando dvc run o crear un fichero dvc.yaml.

En mi opinión, la forma más sencilla es conocer los principales parámetros de dvc run, y de esta forma el propio DVC se encargará de crear el fichero dvc.yaml.

En este sentido, los principales parámetros de dvc run son los siguientes:

  • -n: se refiere al nombre del paso del pipeline.
  • -d: indica el o los ficheros de los cuales depende ese paso del pipeline.
  • -o: indica el o los ficheros que son resultado directo del pipeline.
  • -p: sirve para indicar el fichero de parámetros del cual depende nuestro fichero.
  • -m: sirve para indicar un fichero de métricas que es generado por este paso.
  • -f: si quieres, o no, forzar el cambio del fichero dvc.yaml

Aunque estos son los parámetros principales, en este enlace puedes encontrar el detalle de todos los parámetros disponibles.

Así pues, si nuestro data pipeline cuenta de varios steps, tendremos que ir definiendo cada uno de ellos con dvc run. En nuestro caso, los comandos ejecutados son los siguientes:

# Add extract data
dvc run -n extract_data \
        -d src/extract_data.py \
        -o data/raw.csv \
        python src/extract_data.py

# Add prepare
dvc run -n prepare \
        -d data/raw.csv -d src/extract_data.py \
        -o data/prepared.csv \
        -p prepare.parking \
        python src/prepare.py

# Train Model
dvc run -n train \
        -d data/prepared.csv -d src/train.py \
        -o models/model.pickle \
        -p train.seed,train.steps,train.lags \
        python src/train.py

# Evaluate model
dvc run -n evaluate \
        -d data/prepared.csv -d evaluate.py models/model.pickle\
        -o metric.json \
        -p train.steps \
        python evaluate.py

Al ejecutar estos comando, DVC nos habrá creado el fichero dvc.yaml con el siguiente contenido:

stages:
  extract_data:
    cmd: python src/extract_data.py
    deps:
    - src/extract_data.py
    outs:
    - data/raw.csv
  prepare:
    cmd: python src/prepare.py
    deps:
    - data/raw.csv
    - src/extract_data.py
    params:
    - prepare.parking
    outs:
    - data/prepared.csv
  train:
    cmd: python src/train.py
    deps:
    - data/prepared.csv
    - src/train.py
    params:
    - train.lags
    - train.seed
    - train.steps
    outs:
    - models/model.pickle
  evaluate:
    cmd: python src/evaluate.py
    deps:
    - models/model.pickle
    - data/prepared.csv
    - src/evaluate.py
    params:
    - train.steps
    metrics:
    - metrics.json:
        cache: false

Perfecto, ya tenemos nuestro Data Pipeline definido. Pero, ¿para qué sirve esto? Veamoslo.

Cómo usar un Data Pipeline en DVC

La primera utilidad es que, al tener definido nuestro data pipeline podemos visualizarlo. Esto lo podemos conseguir ejecutando el comando dvc dag. Con ello, nos mostrará un gráfico de cuáles son nuestros pasos en el data pipeline, tal como se muestra a continuación:

DAG en DVC

Asimismo, además de poder visualizar el pipeline, DVC nos permite otra cuestión bastante interesante: poder ejecutar y reproducir el pipeline completo. Para ello, simplemente tenemos que ejecutar el comando dvc repro.

Además, DVC sabe si ha habido, o no, cambios en los ficheros que se genern o utilizan en el pipeline, ya que deberían ser registrados por DVC. Gracias a ello, DVC únicamente ejcutará un paso de nuestro data pipeline si el fichero o los datos que componen ese paso han cambiado.

Es decir, si cambiáramos un valor del fichero params.yaml para entrenar el modelo con más lags, al ejecutar dvc repro DVC no ejecutaría los primeros pasos, puesto que no habrían cambiado. En su lugar, ejecutará el paso train. Además, como el paso evaluate depende de train, este también lo ejecutará.

Esto nos abre una puerta a poder realizar experimentaciones pequeñas de una forma más sencilla. Sin embargo, lo más importante en mi opinión es la claridad que se gana al trabajar varias personas sobre el mismo proyecto, puesto que el DAG se puede aplicar a todo tipo de data pipelines: procesos ETL, entrenamiento de modelos, etc.

Por último, crear los Data Pipelines con DVC nos abre otra gran puerta: poder realizar el tracking de experimentos desde DVC. Veamoslo.

Cómo hacer tracking de experimentos en DVC

Requisitos para realizar experimentos con DVC

DVC incluye una capa para poder hacer experimentos sencillos. Para ello, el primer requisito es que la estructura de nuestro repositorio debe ser algo como esto:

├── data/
├── metrics.json
├── models/
├── params.yaml  
├── plots/
└── src/

El fichero metrics.json será donde guardemos las métricas de nuestro modelo, tal como lo he hecho en el script anterir. Asimismo, el fichero params.yaml incluye los parámetros que usamos a lo largo de nuestro data pipeline. Este fichero es obligatorio, y también puedes encontrar un ejemplo de cómo usarlo en el apartado anterior.

Además, tal como he indicado anteriormente, para poder realizar el tracking de experimentos en DVC, debemos tener definido nuestro Data Pipeline.

Perfecto, ahora que conocemos cúales son los requisitos para crear un experimento en DVC, veamos cómo podemos crear dichos experimentos.

Cómo crear experimentos en DVC

El funcionamiento de los experimentos en DVC es muy sencillo. Simplemente tenemos que ejecutar el siguiente comando: dvc experiments run --set-param parameter=value. En nuestro caso, tendremos que cambiar tanto el parámetro como el valor.

Para que entiendas mejor el proceso, lo que realmente hace DVC es lo siguiente: como ya tenemos el pipeline definido y los parámetros del pipeline se definen en un fichero a aprte (params.yaml), en vez de usar el parámetro definido en el fichero para ejecutar el pipeline, usará el que nosotros hayamos definido en el experimento.

De esta forma, ejecutará todo el pipeline y guardará los resultados obtenidos en el pipeline, los cuales deben aparecer en el fichero metrics.json.

En mi caso puedo probar a realizar el experimento haciendo predicciones para otra cantidad de valores. Por ejemplo:

dvc experiments run --set-param train.steps=400

Hecho esto, se ejecutará el pipeline usando dicho valor como parámetro del pipeline. Si hemos lanzado varios experimentos, podemos comparar sus resultados ejecutando la secuencia dvc exp show, lo cual devolverá la información de los parámetros y los datos utilizados en dicho experimento, tal como se muestra a continuación:

Experimentos en DVC

Como ves, por defecto DVC incluye información sobre todas las métricas que hemos obtenido, así como los parámetros con los que se ha ejecutado el experimento. De esta forma, podemos ver, de una forma muy sencilla, los diferentex experimentos que nosotros, o el resto del equipo ha desarrollado, los resultados obtenidos y los datasets y ficheros utilizados para llegar a dicho objetivo, lo cual facilita bastante el proceso de experimentación.

Conclusiones

En mi opinión, DVC es una muy buena herramienta para estandarizar el tracking de datos. Además, está construida de tal forma que sea muy parecido al uso de Git, lo cual facilita mucho su uso y reduce mucho la curva de apredizaje.

Respecto al registro de modelos y experimentos, personalmente creo que existen otro tipo de soluciones en el mercado que son mucho más fáciles y potentes, como son Neptune y MLFlow. El primero (neptune), lo recomendaría para organizaciones que no tengan MLEngineers y quieran hacer tracking de metadatos, artefactos, etc. sin complicarse.

Sin embargo, si tu organización cuenta con MLEngineers, seguramente sea más interesante optar por una herramienta como MLFlow, la cual a pesar de ser bastante más compleja de implementar, incluye otro tipo de funcionalidades, como la puesta en producción de los modelos.

De todos modos, DVC es una herramienta muy utilizada en el mundo de MLOps, ya que facilita mucho ciertos procesos que previamente se realizaban manualmente. En este sentido,espero que el post te haya gustado. Si es así, te animo a que te suscribas para estar al tanto de los post que vaya subiendo. ¡Nos vemos en el siguiente!

Blog patrocinado por: