Most courses about large language models teach you to call one. This teaches you to build one, and the difference is enormous. Sebastian Raschka takes you from a raw text file to a working GPT style model entirely in PyTorch, and he does it in an order that actually makes sense. You start with tokenization and a data loader, then build the attention mechanism by hand, stack it into transformer blocks, wire up the full architecture, pretrain it on a modest corpus, and finally fine-tune it for a downstream task and for instruction following.
The thing I respect most is that nothing important is skipped or imported from a library to save time. When you reach attention you are not told it is a black box that learns relationships, you implement scaled dot product attention yourself and watch the shapes line up, and after that the whole transformer stops being mysterious. Raschka writes the way a good senior engineer talks, he tells you which choices matter, which are conventions, and where people usually get confused, and the companion GitHub repository is genuinely one of the best maintained I have used, so the code runs rather than rotting against a newer library version. Set your expectations correctly on two points.
First, this assumes you can already write Python comfortably and have at least brushed against PyTorch, if tensors are new to you it will be a slog, and you would do better to spend a week on the basics first. Second, the model you end up with is small on purpose, the goal is understanding rather than a competitive model, so do not come expecting to train something that rivals a real foundation model on your laptop. Neither of those is a flaw, they are the point. If you have spent months wiring up API calls and prompts and you still could not honestly explain what happens inside the model, this is the resource that closes that gap, and it closes it permanently.