Debugging?

What went wrong? Where? How to fix?

Debugging Questions beyond Interpretability

• Can we reproduce the problem?
• What were the inputs to the model?
• Which exact model version was used?
• What data was the model trained with?
• What learning code (cleaning, feature extraction, ML algorithm) was the model trained with?
• Where does the data come from? How was it processed and extracted?
• Were other models involved? Which version? Based on which data?
• What parts of the input are responsible for the (wrong) answer? How can we fix the model?

Breakout Discussion: Movie Predictions

Assume you are receiving complains that a child gets mostly recommendations about R-rated movies

• Could you identify the problematic recommendation(s)?
• Could you identify the model that caused the prediction?
• Could you identify the training code and data that learned the model?
• Could you identify what training data or infrastructure code "caused" the recommmendations?

Data Provenance

• Track origin of all data
  • Collected where?
  • Modified by whom, when, why?
  • Extracted from what other data or model or algorithm?
• ML models often based on data drived from many sources through many steps, including other models

Excursion: Provenance Tracking in Databases

• Whenever value is changed, record:
  • who changed it
  • time of change
  • history of previous values
  • possibly also justifcation of why
• Embedded as feature in some databases, can also be added in business logic
• Immutable data storage keeps history

Tracking Data Lineage

• Document all data sources
• Model dependencies and flows
• Ideally model all data and processing code
• Avoid "visibility debt"
• Advanced: Use infrastructure to automatically capture/infer dependencies and flows (e.g., Goods paper)

Feature Provenance

• How are features extracted from raw data
  • during training
  • during inference
• Has feature extraction changed since the model was trained?

Example?

Good Practice: Feature Store

• Excapsulate feature extraction as functions
• Store centrally for reuse
• Use version control
• Use same feature code in training and inference code
• Advanced: Immutable features -- never change existing features, just add new ones (e.g., creditscore, creditscore2, creditscore3)

Model Provenance

• How was the model trained?
• What data? What library? What hyperparameter? What code?
• Ensemble of multiple models?

Recall: Model Chaining

automatic meme generator

Recall: ML Models for Feature Extraction

self driving car

Summary: Provenance

• Data provenance
• Feature provenance
• Model provenance

How to Version Large Datasets?

(movie ratings, movie metadata, user data?)

Recall: Event Sourcing

• Append only databases
• Record edit events, never mutate data
• Compute current state from all past events, can reconstruct old state
• For efficiency, take state snapshots
• Similar to traditional database logs

createUser(id=5, name="Christian", dpt="SCS")
updateUser(id=5, dpt="ISR")
deleteUser(id=5)

Versioning Datasets

• Store copies of entire datasets (like Git)
• Store deltas between datasets (like Mercurial)
• Offsets in append-only database (like Kafka offset)
• History of individual database records (e.g. S3 bucket versions)
  • some databases specifically track provenance (who has changed what entry when and how)
  • specialized data science tools eg Hangar for tensor data
• Version pipeline to recreate derived datasets ("views", different formats)
  • e.g. version data before or after cleaning?
• Often in cloud storage, distributed
• Checksums often used to uniquely identify versions
• Version also metadata

Aside: Git Internals

Versioning Models

Versioning Models

• Usually no meaningful delta, versioning as binary objects
• Any system to track versions of blobs

Versioning Pipelines

Versioning Dependencies

• Pipelines depend on many frameworks and libraries
• Ensure reproducable builds
  • Declare versioned dependencies from stable repository (e.g. requirements.txt + pip)
  • Optionally: commit all dependencies to repository ("vendoring")
• Optionally: Version entire environment (e.g. Docker container)
• Avoid floating versions
• Test build/pipeline on independent machine (container, CI server, ...)

ML Versioning Tools (see MLOps)

• Tracking data, pipeline, and model versions
• Modeling pipelines: inputs and outputs and their versions
  • explicitly tracks how data is used and transformed
• Often tracking also metadata about versions
  • Accuracy
  • Training time
  • ...

Example: DVC

dvc add images
dvc run -d images -o model.p cnn.py
dvc remote add myrepo s3://mybucket
dvc push

• Tracks models and datasets, built on Git
• Splits learning into steps, incrementalization
• Orchestrates learning in cloud resources

https://dvc.org/

DVC Example

stages:
  features:
    cmd: jupyter nbconvert --execute featurize.ipynb
    deps:
      - data/clean
    params:
      - levels.no
    outs:
      - features
    metrics:
      - performance.json
  training:
    desc: Train model with Python
    cmd:
      - pip install -r requirements.txt
      - python train.py --out ${model_file}
    deps:
      - requirements.txt
      - train.py
      - features
    outs:
      - ${model_file}:
          desc: My model description
    plots:
      - logs.csv:
          x: epoch
          x_label: Epoch
    meta: 'For deployment'
    # User metadata and comments are supported

MLflow, ModelDB, Neptune, TensorBoard, Weights & Biases, Comet.ml

• Instrument pipeline with logging statements
• Track individual runs, hyperparameters used, evaluation results, and model files

ModelDB Example

from verta import Client
client = Client("http://localhost:3000")

proj = client.set_project("My first ModelDB project")
expt = client.set_experiment("Default Experiment")

# log the first run
run = client.set_experiment_run("First Run")
run.log_hyperparameters({"regularization" : 0.5})
run.log_dataset_version("training_and_testing_data", dataset_version)
model1 = # ... model training code goes here
run.log_metric('accuracy', accuracy(model1, validationData))
run.log_model(model1)

# log the second run
run = client.set_experiment_run("Second Run")
run.log_hyperparameters({"regularization" : 0.8})
run.log_dataset_version("training_and_testing_data", dataset_version)
model2 = # ... model training code goes here
run.log_metric('accuracy', accuracy(model2, validationData))
run.log_model(model2)

Google's Goods

• Automatically derive data dependencies from system log files
• Track metadata for each table
• No manual tracking/dependency declarations needed
• Requires homogeneous infrastructure
• Similar systems for tracking inside databases, MapReduce, Sparks, etc.

Aside: Versioning in Notebooks with Verdant

• Data scientists usually do not version notebooks frequently
• Exploratory workflow, copy paste, regular cleaning

From Model Versioning to Deployment

• Decide which model version to run where
  • automated deployment and rollback (cf. canary releases)
  • Kubernetis, Cortex, BentoML, ...
• Track which prediction has been performed with which model version (logging)

Logging and Audit Traces

• Version everything
• Record every model evaluation with model version
• Append only, backed up

Key goal: If a customer complains about an interaction, can we reproduce the prediction with the right model? Can we debug the model's pipeline and data? Can we reproduce the model?

<date>,<model>,<model version>,<feature inputs>,<output>
<date>,<model>,<model version>,<feature inputs>,<output>
<date>,<model>,<model version>,<feature inputs>,<output>

Logging for Composed Models

Ensure all predictions are logged

Discussion

What to do in movie recommendation scenarios? And how?

Definitions

• Reproducibility: the ability of an experiment to be repeated with minor differences from the original experiment, while achieving the same qualitative result
• Replicability: ability to reproduce results exactly, achieving the same quantitative result; requires determinism
• In science, reproducing results under different conditions are valuable to gain confidence
  • "conceptual replication": evaluate same hypothesis with different experimental procedure or population
  • many different forms distinguished "... replication" (e.g. close, direct, exact, independent, literal, nonexperiemental, partial, retest, sequential, statistical, varied, virtual)

Practical Reproducability

• Ability to generate the same research results or predictions
• Recreate model from data
• Requires versioning of data and pipeline (incl. hyperparameters and dependencies)

Nondeterminism

• Some machine learning algorithms are nondeterministic
  • Recall: Neural networks initialized with random weights
  • Recall: Distributed learning
• Many notebooks and pipelines contain nondeterminism
  • Depend on snapshot of online data (e.g., stream)
  • Depend on current time
  • Initialize random seed
• Different library versions installed on the machine may affect results
• (Inference for a given model is usually deterministic)

Recommendations for Reproducibility

• Version pipeline and data (see above)
• Document each step
  • document intention and assumptions of the process (not just results)
  • e.g., document why data is cleaned a certain way
  • e.g., document why certain parameters chosen
• Ensure determinism of pipeline steps (-> test)
• Modularize and test the pipeline
• Containerize infrastructure -- see MLOps

Orchestrating Multiple Models

• Try different modeling approaches in parallel
• Pick one, voting, sequencing, metamodel, or responding with worst-case prediction

Chasing Bugs

• Update, clean, add, remove data
• Change modeling parameters
• Add regression tests
• Fixing one problem may lead to others, recognizable only later