🎯 About this course

You can already run a Linux machine and write a script. This course teaches you the habits that let a small team trust its numbers and its models: commands that total, join and reshape data and say what they did, a checksum for every file that leaves the team, scripts that are safe to run twice, settings and secrets kept in the right place, a clear reading of a graphics card and its memory, a routine for disks and long jobs, and a model that is versioned, health-checked, released to a few first and rolled back in three commands. Every exercise names who needs it and why, uses a simulated host with a simulated graphics card, and ends with a check of the effective state rather than the command you meant to type.

By the end you will be able to

Use cut, sort, uniq and awk to select, count, total and average the columns of a CSV file, and join and compare text files with join, comm and diff.
Use jq to filter, group and reshape JSON, and use sqlite3 to load a CSV and answer questions with SQL, changing rows safely.
Apply sampling, splitting and compression to files too big to open, and prove that data has not changed with checksums, manifests and dated releases.
Create strict, idempotent, scheduled scripts and keep settings and secrets out of code, logs and version control.
Use nvidia-smi to read the card, tell memory from utilization, find who holds the card memory and free it without harming other jobs.
Analyse the disk, memory and logs of a training host to clean up safely, find the best checkpoint and detect overfitting with a watchdog.
Create versioned model folders with labels and switch, check and roll back a served model with a link, a restart and a health check.
Evaluate a new model version with a canary comparison and a decision rule written first, and record the change.

Curriculum

Topics covered

Data in the shell 5 topics

Entry check: are you ready for data and AI on Linux?
A forty-five minute check of the Linux ideas this course builds on: pipes and fields, exit statuses, counting, picking columns, comparing files and checksums, with a…
CSV and text in the shell: cut, sort, uniq and awk
A CSV file as lines of fields, looking at the shape with head, picking columns with cut, counting by value with sort and uniq -c, and adding up by key, filtering and…
Joining and comparing files: join, paste, comm and diff
Combining two tables on a shared field with join (sorted input), gluing files with paste, comparing sorted lists with comm and its column options, and comparing versions…
JSON with jq: filter, group and reshape
The shape of JSON (objects, arrays, strings, numbers, booleans, null), reading it with jq filters (.field, .[0], .[], length), select and map, groupby and add, raw and…
SQLite from the command line: load, query and change
A SQL database in one file with sqlite3, dot-commands (.tables, .schema, .mode, .headers, .import), loading a CSV, SELECT with WHERE, GROUP BY, ORDER BY, LIMIT and…

Reproducible data work 4 topics

Big files: look, sample, split and compress
Working with files too big to open: size and line count first, head and tail, sampling with shuf while keeping the header, splitting with split -l, compressing with gzip…
Checksums and data versions: prove it has not changed
The SHA-256 checksum as a fingerprint, writing and verifying a manifest with sha256sum and sha256sum -c, what a failed check means, dated release folders, a latest link…
Scripts you can re-run: strict mode, idempotence and cron
Why data scripts fail silently, set -euo pipefail, idempotent design (dated output names, skip if done, temporary file and mv), the grep -c exit-status trap and || true…
Settings and secrets: environment, .env files and permissions
Settings in the environment instead of the code, NAME=value, export and env, loading a .env file with set -a, the rules for secrets (not in version control, mode 600…

GPUs and training hosts 4 topics

Reading nvidia-smi: is the card working?
The nvidia-smi screen (driver and CUDA versions, name, temperature, power, memory usage, utilization, processes), the difference between memory and utilization, asking…
Who holds the GPU memory? Find, ask, stop, check
An out-of-memory error with an occupied card, listing the holders with --query-compute-apps, finding the owner and age on a real machine with ps, asking first, kill…
Disk, memory and datasets on a training host
No space left on device during a run, df -h and du -sh, finding the biggest folders with du -s, sort -nr and head, cleaning checkpoints safely (identify, delete by exact…
Long jobs and their logs: keep it running, read it, watch it
Jobs that outlive the session (nohup, tmux or screen, a service or a scheduler), a training log of epochs with training and validation loss, finding the best epoch with…

Serving models 3 topics

Model files and versions: folders, labels and the current link
Treating a model as a release: one folder per version that is never edited, a meta.json label (name, version, validation loss, date, data), the current link switched…
Health checks and request logs: is it working, and how well?
Running versus working, a health check with curl -fsS and its exit statuses, a health script that prints a word and sets its status, the request log (time, method, path…
A safe rollout: canary, decision rule and rollback
Why a better offline model can fail on real traffic, a canary release to a small share, comparing error rate and latency from two logs, a decision rule written before…

Infrastructure behind data and AI 4 topics

Storage and data formats: where the data lives
The parts of the storage layer (local disks and file systems, object storage, file formats, databases, backups and snapshots), a card for each, one record followed from…
GPU hosts and drivers: from the script to the card
The parts of a GPU host (the card, the driver, the CUDA runtime and libraries, the container toolkit, power, cooling and the bus), a card for each, version matching of…
Schedulers and pipelines: who starts the job, and who notices
The parts of the scheduling layer (cron and timers, locks, retries and timeouts, the pipeline definition, queues and cluster schedulers, logs and alerts), a card for…
Serving and monitoring: from a request to a person
The parts of the serving and monitoring layer (the model server, the front door, health checks, logs and metrics, alerts and on-call, capacity), a card for each, and one…

Interview ready 2 topics

Interview ready: data in the shell
The questions people really ask about CSV and text tools, joins, JSON with jq, SQL with SQLite, big files, checksums, safe scripts and secrets, with model answers, a…
Interview ready: GPUs, serving and operations
The questions people really ask about GPU memory, checkpoints and overfitting, model versions and rollouts, health checks and request logs, canary releases, schedulers…

Course at a glance

See how this course is built

Where the time goes

Longer spokes mean more hours on that module.

Course roadmap click a step

Try a lesson0 / 3

Sample questions from this course. Your progress is kept only in your browser.

Week by week

Drag the slider, or press play, to walk through the course and see what you will have built by each week.

Week 1 of 8

Wk 1

Welcome to the data host

The entry check and scenes 1 to 4: CSV and text, joins, JSON and SQLite.

Wk 2

Reproducible data work

Scenes 5 to 8: big files, checksums and versions, re-runnable scripts, settings and secrets.

Wk 3

GPUs and training hosts

Scenes 9 to 12: nvidia-smi, freeing the card, disk and memory, long jobs and logs.

Wk 4

Serving models

Scenes 13 to 15: model versions, health checks and request logs, a safe rollout.

Wk 5

Under the hood

Scenes 16 to 19: storage, GPU hosts, schedulers, and serving and monitoring.

Wk 6

Interview ready

Scenes 20 and 21: model answers, timed hands-on tasks and a mock round.

Wk 7

Capstone work session

Build the capstone: the booking data pack and the model service pack.

Wk 8

Capstone review

Present the capstone.

What you'll build

The booking data pack

A folder of dated releases with a checksum manifest, a CSV-to-answers pipeline (awk, jq or SQLite), a strict re-runnable report script with its cron line, and the commands that prove each part.

The training host report

A GPU memory and disk review with the cleanup you did and why, a free-memory check script, a training-log watchdog with its exit status and the best checkpoint chosen by validation loss.

The model service pack

A versioned model folder with labels, a health script, an error-rate and percentile report from the request log, a canary comparison with a decision script, a rollback transcript and a change log.

Why take this course

Answer questions from tables and JSON without a notebook
Keep a GPU host and a model service healthy
Release a model with a way back

You will build

A booking data pack with checksums
A training host report with a watchdog
A model service pack with a rollback

What you can do afterwards

Run a small data and AI host with confidence
Explain your choices, their risks and their numbers
Answer data-platform interview questions with specifics

How to take it

💳 Delivery & fees

One course, four ways to attend. Fees are per course, in rupees excluding 18% GST (the GST-inclusive amount is shown too).Fees are per course, in Canadian dollars, before applicable GST/HST.Fees are per course, in US dollars, before any applicable local taxes. Bulk and institutional volume pricing is available.

Bulk and institutional pricing. Volume discounts are available for institutions, campuses, companies and groups enrolling several learners. Ask for a group quote →

Your fee includes our GPU lab infrastructure — no cloud credits to buy. See how we compare, with sources →

Linux for Data and AI