This chapter provides a comprehensive introduction to Data Version Control (DVC), a tool essential for data versioning in machine learning. Learners will explore the motivation behind data versioning, understand its differences from code versioning, and experiment with a simple classification problem. They will review basic Git commands, learn about DVC, and practice setting up a repository. The chapter concludes with an overview of DVC’s features and use cases, including versioning data and models, CI/CD for machine learning, experiment tracking, pipelines, and more.

Data Versioning Motivation

Anatomy of a Machine Learning Model

Differences Between Data and Code Versioning

Understanding Hyperparameters

Introduction to DVC

Working with Git CLI

Review DVC CLI

DVC features and use cases

DVC pipelines

CI/CD for machine learning

This chapter delves into the setup of DVC, encompassing aspects such as installation, initialization of the repository, and the utilization of the .dvcignore file. It further navigates through the exploration of DVC cache and staging files, imparting knowledge on how to add and remove files, manage caches, and comprehend the underlying mechanisms using the MD5 hash. The chapter also elucidates on DVC remotes, distinguishing them from Git remotes, and guides you on how to add, list, and modify them. Lastly, it teaches you how to interact with these remotes by pushing and pulling data, checking out specific versions, and fetching data to the cache.

DVC Setup and Initialization

Setting up DVC

.dvcignore Patterns

DVC Cache and Staging Files

Working with DVC Cache

Understanding .dvc Files

Configuring DVC Remotes

Purpose of DVC Remotes

Setup a DVC Remote

Interacting with DVC Remotes

Versioning Data using DVC Remote

Checking out Versioned Data

DVC Configuration and Data Management

This chapter focuses on automating ML pipelines using DVC. Learners create a configuration file containing settings and hyperparameters. They also learn about pipeline visualization using directed acyclic graphs and use commands to describe dependencies, commands, and outputs. Execution of DVC pipelines is covered, including local model training and how Git tracks DVC metadata. Additionally, learners explore metrics and plots tracking in DVC, including how to print metrics, create plot files, and compare metrics and plots across different pipeline stages.

Code organization and refactoring

Understanding parameter files in DVC

preprocess:
  # Add Date as a column to drop
  drop_colnames:
    - ____
  # Add RainTomorrow as target column
  target_column: ____
  categorical_features:
    - Location
    - WindGustDir
    - WindDir9am
    - WindDir3pm
    - RainToday
train_and_evaluate:
  target_column: RainTomorrow
  train_test_split:
    test_size: 0.2
    random_state: 1993
  shuffle: true
  shuffle_random_state: 1993
  # Add 2 as number of estimators for rfc classifier
  rfc_params:
    n_estimators: ____
    max_depth: 2
    random_state: 42
  

preprocess:
  # Add Date as a column to drop
  drop_colnames:
    - Date
  # Add RainTomorrow as target column
  target_column: RainTomorrow
  categorical_features:
    - Location
    - WindGustDir
    - WindDir9am
    - WindDir3pm
    - RainToday
train_and_evaluate:
  target_column: RainTomorrow
  train_test_split:
    test_size: 0.2
    random_state: 1993
  shuffle: true
  shuffle_random_state: 1993
  # Add 2 as number of estimators for rfc classifier
  rfc_params:
    n_estimators: 2
    max_depth: 2
    random_state: 42
  

Write a parameter file

Writing and visualizing DVC pipelines

#!/bin/bash

# Preprocess stage
# Output is processed_data.csv
dvc stage add --force \
-n preprocess_stage \
-p preprocess \
-d raw_data.csv \
-d preprocess.py \
____ \
python3 preprocess.py


# Split stage
# This stage uses parameters from `split` section of params.yaml
dvc stage add --force \
-n split_stage \
____ \
-d processed_data.csv \
-d split.py \
-o train_data.csv \
-o eval_data.csv \
python3 split.py


# Train stage
# This stage generates model.pkl as output
dvc stage add --force \
-n train_stage \
-p train \
-d train_data.csv \
-d train.py \
-o model.pkl \
python3 train.py


# Evaluate stage
# This stage uses model.pkl as one of the input
dvc stage add --force \
-n evaluate_stage \
-p evaluate \
-d eval_data.csv \
____ \
-d evaluate.py \
-o metrics.json \
python3 evaluate.py

#!/bin/bash

# Preprocess stage
# Output is processed_data.csv
dvc stage add --force \
-n preprocess_stage \
-p preprocess \
-d raw_data.csv \
-d preprocess.py \
-o processed_data.csv \
python3 preprocess.py


# Split stage
# This stage uses parameters from `split` section of params.yaml
dvc stage add --force \
-n split_stage \
-p split \
-d processed_data.csv \
-d split.py \
-o train_data.csv \
-o eval_data.csv \
python3 split.py


# Train stage
# This stage generates model.pkl as output
dvc stage add --force \
-n train_stage \
-p train \
-d train_data.csv \
-d train.py \
-o model.pkl \
python3 train.py


# Evaluate stage
# This stage uses model.pkl as one of the input
dvc stage add --force \
-n evaluate_stage \
-p evaluate \
-d eval_data.csv \
-d model.pkl \
-d evaluate.py \
-o metrics.json \
python3 evaluate.py

stages:
  preprocess_stage:
    cmd: python3 preprocess.py
    deps:
    - preprocess.py
    - raw_data.csv
    params:
    - preprocess
    outs:
    - processed_data.csv
  split_stage:
    cmd: python3 split.py
    deps:
    - processed_data.csv
    - split.py
    params:
    - split
    outs:
    - eval_data.csv
    - train_data.csv
  train_stage:
    cmd: python3 train.py
    deps:
    - train.py
    - train_data.csv
    params:
    - train
    outs:
    - model.pkl
  evaluate_stage:
    cmd: python3 evaluate.py
    deps:
    - eval_data.csv
    - evaluate.py
    - model.pkl
    params:
    - evaluate
    outs:
    - metrics.json


Designing a DVC pipeline

stages:
  preprocess:
    cmd: python3 preprocess.py
    deps:
    - preprocess.py
    - raw_data.csv
    params:
    - preprocess
    outs:
    - processed_data.csv
  split:
    cmd: python3 split.py
    deps:
    - processed_data.csv
    - split.py
    params:
    - split
    outs:
    - eval_data.csv
    - train_data.csv
  train:
    cmd: python3 train.py
    deps:
    - train.py
    - train_data.csv
    params:
    - train
    outs:
    - model.pkl
  evaluate:
    cmd: python3 evaluate.py
    deps:
    - eval_data.csv
    - evaluate.py
    - model.pkl
    params:
    - evaluate
    outs:
    - metrics.json


Visualizing a DVC pipeline

Executing DVC pipelines

Options

True

False

DVC pipeline execution concepts

stages:
  preprocess:
    # Run the data preprocessing script
    cmd: python3 preprocess_dataset.py params.yaml raw_dataset/weather.csv processed_dataset/weather.csv
    deps:
    - preprocess_dataset.py
    - raw_dataset/weather.csv
    - utils_and_constants.py
    params:
    - preprocess
    outs:
    - processed_dataset/weather.csv
  train_and_evaluate:
    # Run the model training and evaluation script
    cmd: python3 train_and_evaluate.py params.yaml processed_dataset/weather.csv
    deps:
    - metrics_and_plots.py
    - model.py
    # Specify the preprocessed dataset as a dependency
    - processed_dataset/weather.csv
    - train_and_evaluate.py
    - utils_and_constants.py
    params:
    - train_and_evaluate
    outs:
    - metrics.json
    - confusion_matrix.png


schema: '2.0'
stages:
  preprocess:
    cmd: python3 preprocess_dataset.py params.yaml raw_dataset/weather.csv processed_dataset/weather.csv
    deps:
    - path: preprocess_dataset.py
      md5: c4a584bed44aaee9e5e5d73974d974f8
      size: 4499
    - path: raw_dataset/weather.csv
      md5: e602b116f50269aa781c0c910cd80db9
      size: 2701130
    - path: utils_and_constants.py
      md5: 188614911c472f6b55ebe8b3ff3a0192
      size: 1016
    params:
      params.yaml:
        preprocess:
          drop_colnames:
          - Date
          target_column: RainTomorrow
          categorical_features:
          - Location
          - WindGustDir
          - WindDir9am
          - WindDir3pm
          - RainToday
    outs:
    - path: processed_dataset/weather.csv
      md5: 1dea080f8f73483cabd710f788ba0143
      size: 10501985
  train_and_evaluate:
    cmd: python3 train_and_evaluate.py params.yaml processed_dataset/weather.csv
    deps:
    - path: metrics_and_plots.py
      md5: f3db712083b5c84677d41948f71c54d2
      size: 1658
    - path: model.py
      md5: 928da86a0d41e4543ad5c10034dcebc9
      size: 1615
    - path: processed_dataset/weather.csv
      md5: 1dea080f8f73483cabd710f788ba0143
      size: 10501985
    - path: train_and_evaluate.py
      md5: 9c7bb633a92451eda26df183ef4db7e8
      size: 2351
    - path: utils_and_constants.py
      md5: 188614911c472f6b55ebe8b3ff3a0192
      size: 1016
    params:
      params.yaml:
        train_and_evaluate:
          target_column: RainTomorrow
          train_test_split:
            test_size: 0.2
            random_state: 1993
          shuffle: true
          shuffle_random_state: 1993
          rfc_params:
            n_estimators: 2
            max_depth: 2
            random_state: 42
    outs:
    - path: confusion_matrix.png
      md5: fb816ca1280172bfad3988402cc23902
      size: 17433
    - path: metrics.json
      md5: 1309f5092ba8d530648a071216f62452
      size: 78


Execute a ML model training pipeline

Evaluation: Metrics and plots in DVC

stages:
  preprocess:
    # Run the data preprocessing script
    cmd: python3 preprocess_dataset.py params.yaml raw_dataset/weather.csv processed_dataset/weather.csv
    deps:
    - preprocess_dataset.py
    - raw_dataset/weather.csv
    - utils_and_constants.py
    params:
    - preprocess
    outs:
    - processed_dataset/weather.csv
  train_and_evaluate:
    # Run the model training and evaluation script
    cmd: python3 train_and_evaluate.py params.yaml processed_dataset/weather.csv
    deps:
    - metrics_and_plots.py
    - model.py
    # Specify the preprocessed dataset as a dependency
    - processed_dataset/weather.csv
    - train_and_evaluate.py
    - utils_and_constants.py
    params:
    - train_and_evaluate
    outs:
    - confusion_matrix.png
    - predictions.csv
    metrics:
      - metrics.json:
          cache: false

preprocess:
  drop_colnames:
    - Date
  target_column: RainTomorrow
  categorical_features:
    - Location
    - WindGustDir
    - WindDir9am
    - WindDir3pm
    - RainToday
train_and_evaluate:
  target_column: RainTomorrow
  train_test_split:
    test_size: 0.2
    random_state: 1993
  shuffle: true
  shuffle_random_state: 1993
  rfc_params:
    # Change number of estimators to 3
    n_estimators: 2
    max_depth: 2
    random_state: 42
  

preprocess:
  drop_colnames:
    - Date
  target_column: RainTomorrow
  categorical_features:
    - Location
    - WindGustDir
    - WindDir9am
    - WindDir3pm
    - RainToday
train_and_evaluate:
  target_column: RainTomorrow
  train_test_split:
    test_size: 0.2
    random_state: 1993
  shuffle: true
  shuffle_random_state: 1993
  rfc_params:
    # Change number of estimators to 3
    n_estimators: 3
    max_depth: 2
    random_state: 42

Tracking DVC Metrics

stages:
  preprocess:
    cmd: python3 preprocess_dataset.py params.yaml raw_dataset/weather.csv processed_dataset/weather.csv
    deps:
    - preprocess_dataset.py
    - raw_dataset/weather.csv
    - utils_and_constants.py
    params:
    - preprocess
    outs:
    - processed_dataset/weather.csv
  train_and_evaluate:
    cmd: python3 train_and_evaluate.py params.yaml processed_dataset/weather.csv
    plots:
      # Set the target to the file containing predictions data
      - ____:
          # Write the plot template
          template: ____
          x: predicted_label
          y: true_label
          x_label: 'Predicted label'
          y_label: 'True label'
          title: Confusion matrix
          # Set the cache parameter to store
          # plot data in Git repository
          cache: ____
    deps:
    - metrics_and_plots.py
    - model.py
    - processed_dataset/weather.csv
    - train_and_evaluate.py
    - utils_and_constants.py
    params:
    - train_and_evaluate
    outs:
    - confusion_matrix.png
    metrics:
      - metrics.json:
          cache: false


stages:
  preprocess:
    cmd: python3 preprocess_dataset.py params.yaml raw_dataset/weather.csv processed_dataset/weather.csv
    deps:
    - preprocess_dataset.py
    - raw_dataset/weather.csv
    - utils_and_constants.py
    params:
    - preprocess
    outs:
    - processed_dataset/weather.csv
  train_and_evaluate:
    cmd: python3 train_and_evaluate.py params.yaml processed_dataset/weather.csv
    plots:
      # Set the target to the file containing predictions data
      - predictions.csv:
          # Write the plot template
          template: confusion
          x: predicted_label
          y: true_label
          x_label: 'Predicted label'
          y_label: 'True label'
          title: Confusion matrix
          # Set the cache parameter to store
          # plot data in Git repository
          cache: false
    deps:
    - metrics_and_plots.py
    - model.py
    - processed_dataset/weather.csv
    - train_and_evaluate.py
    - utils_and_constants.py
    params:
    - train_and_evaluate
    outs:
    - confusion_matrix.png
    metrics:
      - metrics.json:
          cache: false


Adding plots to dvc.yaml

Congratulations!

Pipelines in DVC

Delve into Data Version Control (DVC), a tool for managing and versioning ML data. Explore its role in the ML lifecycle, differentiate data versioning from code versioning, and examine DVC’s features and use cases. Learn about DVC setup, including cache management and remotes, and discover its applications in CI/CD, experiment tracking, and pipelines. Automate ML pipelines, emphasizing code modularization, and practice executing them efficiently. Conclude with model evaluation, exploring metric tracking in DVC for informed decision-making.


This course offers a comprehensive introduction to Data Version Control (DVC), a tool designed for efficient management and versioning of machine learning data. You will get an understanding of the machine learning product lifecycle, differentiating data versioning from code versioning and exploring DVC’s features and use cases.

<h2>Exploring DVC features</h2>
You will understand the motivations behind data versioning, the machine learning lifecycle, and DVC’s distinct features and use cases. You will also learn about DVC setup, covering installation, repository initialization, and the .dvcignore file. You will explore DVC cache and staging files, learn to add and remove files, manage caches, and understand the underlying mechanisms. You will learn about DVC remotes, explain the distinction between DVC and Git remotes, add remotes, list them, and modify them. You will learn to interact with remotes, push and pull data, check out specific versions, and fetch data to the cache.

<h2>Automate and evaluate</h2>
You will be motivated to automate ML pipelines, emphasizing modularization of code and the creation of a configuration file. You will be introduced to DVC pipelines as directed acyclic graphs, with hands-on experience in adding stages and their inputs and outputs. You will practice executing these pipelines efficiently to enable different use cases in machine learning model training. The course concludes with a focus on evaluation, showcasing how metrics and plots are tracked in DVC.

Supervised Learning with scikit-learn

Introduction to Git

Explore Data Version Control for ML data management. Master setup, automate pipelines, and evaluate models seamlessly.

Evaluation: Metrics and plots in DVC

Create Your Free Account