# The Kaggle Book notebooks: badge replay, GPU chapters, no dependency pin

> PacktPublishing/The-Kaggle-Book is the notebook code behind a printed Kaggle book, laid out as 14 chapter folders with no installable package and no pinned environment. A chapter is run by replaying it from GitHub into Colab or Kaggle, usually with an accelerator, and two README image links still resolve to a different repository name.

**PacktPublishing/The-Kaggle-Book** — Code Repository for The Kaggle Book, Published by Packt Publishing

- Repository: https://github.com/PacktPublishing/The-Kaggle-Book
- Stars: 2,335 · Forks: 467
- Language: Jupyter Notebook
- License: MIT
- Published: 2026-10-13 · Updated: 2026-10-13 · Language: en
- Canonical page: https://hysenlabs.com/projects/packtpublishing-the-kaggle-book

## Fourteen numbered chapter folders hold the book's runnable notebooks

PacktPublishing/The-Kaggle-Book is not a library you install. It is the notebook code that backs a printed book, and the repository description says exactly that: a code repository for The Kaggle Book, published by Packt Publishing. The primary language recorded on GitHub is Jupyter Notebook, which fixes the unit of work as a notebook you open and run top to bottom rather than a module you import. The reader being served is someone aiming at competitive data science on Kaggle, where the book's coverage runs from competition tasks and metrics through validation design into tabular modeling, alongside vision, natural language, simulation and optimization. Interviews with 31 Kaggle Masters and Grandmasters belong to the printed text; no interview material appears in the root listing. MIT is the licence identifier on the repository, so a cell lifted out of a chapter carries no copyleft obligation in a work project.

The root is a flat list, and the chapter directories sit at the same level as the book's artwork:

```text
chapter_01/
chapter_02/
chapter_03/
chapter_04/
chapter_05/
chapter_06/
chapter_07/
chapter_08/
chapter_09/
chapter_10/
chapter_11/
chapter_12/
chapter_13/
chapter_14/
```

There is no packaging file, no install step and no console entry point anywhere in that listing. You clone or fork the tree, then work inside a notebook runtime someone else provides.

## Badges replay each notebook from main into Colab or Kaggle

Execution is delegated to hosted notebooks, and the mechanism is a URL rather than a script. The README table carries four columns: chapter number, chapter title, notebook name, and then one Colab badge and one Kaggle badge per row. Row 05, Competition Tasks and Metrics, resolves to meta_kaggle.ipynb inside chapter_05. Row 06, Designing Good Validation, resolves to adversarial-validation-example.ipynb inside chapter_06. Row 07, Modeling for Tabular Competitions, lists interesting-eda-tsne-umap.ipynb first, then meta-features-and-target-encoding.ipynb and really-not-missing-at-random.ipynb. Both badge targets embed the repository and the main branch in their path, so the platform fetches the file from GitHub at the moment you click. Here are the two URLs from row 06 exactly as given:

```text
https://colab.research.google.com/github/PacktPublishing/The-Kaggle-Book/blob/main/chapter_06/adversarial-validation-example.ipynb
https://kaggle.com/kernels/welcome?src=https://github.com/PacktPublishing/The-Kaggle-Book/blob/main/chapter_06/adversarial-validation-example.ipynb
```

The Kaggle link is a wrapper that passes the GitHub path as its src parameter, which means it serves the upstream copy held at PacktPublishing rather than anything in your fork. If you fork this repository to change a notebook, the badge keeps running the original until you rewrite the link yourself.

## The badge replay and the author's Kaggle kernel are different artifacts

Every row also links to a notebook already published on the author's Kaggle account, for example lucamassaron/adversarial-validation-example, which the README calls the fully working original notebook you can copy and run straight away. That kernel is the real alternative to the badge, and the difference is concrete. A badge replay reproduces code from GitHub onto whichever platform you picked, so inputs have to come from somewhere else. The kernel is one prebuilt notebook with its data already attached, so it produces output where the replay stops. The replay route carries one cost, stated in a single line: you may have to add the necessary data before running it. The root listing supports that warning, since no data directory sits beside the chapter folders. Take the kernel when you want to see the state the authors validated, and take the badge when you intend to change the code.

## Most chapters want a GPU or a TPU, so a laptop is the wrong default

Hardware is the first constraint, and it is stated in one breath: most chapters require a GPU, and even a TPU sometimes, to run in a reasonable amount of time. For that reason the project recommends one of the cloud platforms rather than a local machine, on the grounds that they come pre-installed with CUDA. Two things follow if you insist on running locally. The toolchain becomes your problem, because no file in the root listing names a CUDA version, a driver or an accelerator package. And the failure mode is ugly: a notebook written for a TPU does not raise an error on CPU-only hardware, it simply takes longer than your patience allows, so an evening can disappear before you conclude that the machine is at fault rather than the code.

## No dependency file and no tags leave main as the only version anchor

Nothing in the root listing pins what these notebooks expect to import. There is no requirements file, no environment file and no lockfile, so a reader who rebuilds the stack gets whatever the package index currently serves, and code written against an older API can stop working without any change on your side. The same gap runs along the version axis. The last push landed on 2026-03-02, the repository is not archived, and it publishes no GitHub releases, which means there is no tag to check out when a notebook breaks. main is the only reference point on offer, and it moves under you between one run and the next. The fix costs nothing: when a chapter works, copy that notebook into your own repository and treat the copy as the artifact.

## The README cover image points at a different repository name

Two image links inside the README resolve outside this repository. The cover image and the contributors photo are both fetched from PacktPublishing/Data-Analysis-and-Machine-Learning-with-Kaggle, while every notebook badge in the same document resolves to PacktPublishing/The-Kaggle-Book. Two repository names for one book sit inside one README, and the README does not explain the discrepancy. A reader who clicks the cover lands on an older tree and can reasonably conclude that the notebooks live there instead of here. The alt text and the link target also disagree, since the header above them names the project The Kaggle Book. Only one set of chapter folders exists under PacktPublishing/The-Kaggle-Book in the listing, so read the other path as a stale label rather than a second code tree.

## The badge table opens at chapter 05 while the root holds chapter_01

Fourteen chapter directories run from chapter_01 to chapter_14, but the first row of the notebook table is 05, Competition Tasks and Metrics. No notebook is listed for chapters 01 through 04, and the README does not say why. A reader who counts folders finds more chapters than the table covers, which is a cheap way to lose time hunting for notebooks that were never going to be there. The reverse also holds. Chapter 07 spreads four notebooks under one chapter title, printing the chapter number on the first row and leaving the cell blank on the rest, so 3 of those 4 paths carry no chapter number at all. Read the table rather than the file names, because a notebook name in this tree is a topic, not an index.

## Errata.md and a color plate PDF sit beside the chapter code

Two root entries exist to keep the printed book correct. Errata.md is a corrections file for the text, and the Errata image/ directory holds the figures that belong with those corrections, which matters because a wrong plot inside a book cannot be repaired by pushing a commit. A third entry, 9781801817479_ColorImages.pdf, is a color plate asset rather than code, and the long number in its file name ties it to one specific volume. Together with The_Kaggle_Book.png, cover.png and contributors.jpg, these files make the repository the book's file store as much as its code store:

```text
Errata.md
Errata image/
9781801817479_ColorImages.pdf
cover.png
contributors.jpg
The_Kaggle_Book.png
```

None of them are importable or runnable, so a reader searching the tree for a repair to a broken cell in chapter_06 or chapter_07 will not find one here. If a notebook disagrees with the printed text, the errata file is where a correction would be recorded, but the README does not document how an erratum is opened or how quickly it would be applied.

## Conclusion

The Kaggle Book's repository is a companion notebook library rather than a product, and that decides who should open it. Readers working through the book get runnable code for the arguments that need code, and the Colab or Kaggle badge costs nothing to try. Leave it out of any production dependency list, because nothing here installs. Before spending an evening, run chapter_06 and chapter_07 end to end from the badge, fetch the competition data the README warns you must supply, and copy any notebook you keep into your own repository.

## FAQ

### What is PacktPublishing/The-Kaggle-Book, and who is it for?

It is the runnable notebook code that accompanies a printed book on competitive data science, split across 14 chapter folders from chapter_01 to chapter_14. It serves readers who want to execute the book's examples, and it is not a package you can install.

### How do I run a notebook from The Kaggle Book without a local GPU?

Open the Colab or Kaggle badge in the README table, which reproduces the code from GitHub onto that platform. The project recommends this route because most chapters require a GPU, and sometimes a TPU, and the cloud platforms come pre-installed with CUDA.

### Does the repository include the competition data the notebooks need?

No. The README states that with the badge route you may have to add the necessary data before running, and the root listing holds no data directory. The notebooks on the author's Kaggle account are the ones published with their inputs attached.

### Can I pin a known good version of a notebook from The-Kaggle-Book?

Not from the repository itself. It publishes no GitHub releases, its last push landed on 2026-03-02, and no dependency file pins library versions, so main is the only reference point. Copy a working notebook into your own repository if you need a stable copy.

### Why do some images in The Kaggle Book README lead to another GitHub repository?

The cover image and the contributors photo are fetched from PacktPublishing/Data-Analysis-and-Machine-Learning-with-Kaggle, while the notebook badges resolve to PacktPublishing/The-Kaggle-Book. The README does not explain the mismatch, and only one set of chapter folders exists under the current name.

## Sources

- [Issues](https://github.com/PacktPublishing/The-Kaggle-Book/issues)
- [License: MIT](https://github.com/PacktPublishing/The-Kaggle-Book/blob/main/LICENSE)
- [PacktPublishing/The-Kaggle-Book on GitHub](https://github.com/PacktPublishing/The-Kaggle-Book)
- [README](https://github.com/PacktPublishing/The-Kaggle-Book/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/packtpublishing-the-kaggle-book