NVIDIA Accelerated Data Science

Reproducible work starts with a controlled environment. You check driver and CUDA compatibility, manage Conda environments, run containers, and use git so that a result can be rebuilt later.

• Reading nvidia-smi and CUDA versions
• Conda environments and dependencies
• Docker containers with GPU access
• Driver and CUDA compatibility
• Version control with git
• Writing environment files others can use

You build An environment file and container recipe that rebuilds your analysis on another machine.

Most of the work is getting data ready. You join, clean and reshape tables with cuDF and pandas, read and write Parquet, and deal with class imbalance before it spoils a model.

• Loading data with cuDF
• Joins and merges
• Cleaning and type conversion
• Parquet and file formats
• Engineering new columns
• Handling class imbalance

You build A cleaned, joined and balanced training table prepared on the GPU.

When data outgrows memory, ETL needs structure. You build pipelines with RAPIDS, scale them with Dask or Spark, and pick the tool that matches the size and shape of the data.

• ETL stages and design
• Dask for larger-than-memory data
• Spark with GPU acceleration
• Partitioning and file layout
• Choosing between the tools
• Checking that results match the CPU version

You build An ETL pipeline that runs on a dataset too large for one GPU.

Before modeling, look carefully. You summarize data with statistics, draw plots that reveal structure, test simple hypotheses, and read the patterns and relationships that guide later choices.

• Summary statistics and distributions
• Plots for comparison and correlation
• Hypothesis tests and p-values
• Patterns and relationships between variables
• Telling a signal from noise
• Writing findings up clearly

You build An exploratory report with plots and two tested hypotheses.

Some data has order or connections. You split and forecast time series with irregular timestamps in mind, and analyze network data with graph tools.

• Time-based splitting
• Resampling and irregular timestamps
• Interpolation of gaps
• Forecasting basics
• Building graphs from edge lists
• Network measures with GPU graph tools

You build A forecast on a time series and a network analysis of a graph dataset.

GPU libraries train in minutes what a CPU takes hours to do. You fit cuML and XGBoost models, use cross-validation, read metrics and confusion matrices, and compare models for the task.

• cuML estimators and their pandas-like API
• XGBoost on the GPU
• Cross-validation
• Metrics for classification and regression
• Reading confusion matrices
• Hyperparameter tuning and model comparison

You build Two GPU-trained models compared on one dataset, with metrics and a recommendation.

A workflow you cannot repeat is only a draft. You design pipelines from data to model, select features, spot overfitting and underfitting, and automate the steps so that results are reproducible.

• Pipeline design from data to model
• Feature selection
• Diagnosing overfitting and underfitting
• Automating steps and scheduling runs
• Reproducible seeds and splits
• Testing a pipeline end to end

You build An end-to-end pipeline that retrains a model from raw data with one command.

Once a model exists, it needs records. You track experiments with MLflow, store artifacts, monitor pipelines, and watch a deployed model for drift.

• Experiment tracking with MLflow
• Parameters, metrics and artifacts
• Registering and versioning models
• Monitoring pipelines
• Detecting data and model drift
• Deciding when to retrain

You build A tracked set of experiments with a registered model and a drift check.

Take a dataset through the whole workflow. You set up the environment, prepare and analyze data, train and compare models, track the work, and package everything so it can be repeated.

• Setting up the environment
• Preparing and exploring the data
• Training and comparing models
• Tracking and monitoring
• Packaging for reproducibility

You build A repeatable GPU data science project with tracked experiments and an environment file.