My goal for this book was to learn more about how LLMs produce text, and in particular, how they know when to stop. And this book covers it all, with source code you can actually follow. I expecially appreciate the appendices that cover Pytorch and the basics of neural networks. I'm going to buy the next book in this series, on reasoning models, as soon as I'm done with this review.

The book is amazing. Much better than I expected. I was minimally familiar with neural networking techniques (finished 6-months course on Coursera, and by now have forgotten most of it). So, I had a vague idea about forward and backward propagation, remembered such terms as dropout, normalization etc. without actually remembering their meaning. From the Andrew Ng course I remembered the term "transformer" (since he had a few good introductory explanations of it), but by now I completely forgot how it works. My knowledge of Python was very limited (and mostly forgotten). I knew nothing about PyTorch. When I saw the references to the book on Facebook, I decided that it might be helpful for me to recall these concepts, and especially interesting was to learn the concept of transformers and self-attention which I knew belong to the foundation of modern LLMs.

The book exceeded my expectations. It is written in an excellent methodical style. Introduces concepts one by one, helps experimenting with them in the real code. It provided an excellent introduction to PyTorch (in Appendix A, which the author recommended to consume before reading the rest of the book). The introduction is short, not overwhelming the reader with millions potential concepts of the huge ecosystem of Python and PyTorch, and still sufficient for productive consuming the entire book that uses both. All the concepts are defined in easy-to-consume steps, leading eventually to a complete overall understanding of GPT model. I am not naive to think that I can develop LLMs by myself now, but I definitely got more than expected. And enjoyed the material a lot.

I did not use the code from GitHub (by the book's reference). Instead, I meticulously re-entered all the examples from the book's text into several Jupyter Notebooks in VSCode. This way I moved a bit slower but understood material better. Even found a few minor (typo-level) issues in the code.

I am working on an ordinary Surface Book (no GPU), and all examples work instantaneously so far (obviously, it will change when I come to training). I am now in the position after chapter 4: Built the untrained GPT model and cannot wait when I will start training and using it.

Highly recommend the book to everyone who wants to make their hands "dirty" with the AI.

Well written book! Clear explanation on how models like ChatGPT work. Provides an excellent foundation !

Clear Explanations Without Hiding the Hard Parts

What I like most is that it doesn’t treat LLMs like magic. It breaks the process down step by step—from tokenization and embeddings to attention, training, and generation—so I could see how all the pieces connect.

Hands-On Learning That Actually Sticks

The examples make a huge difference. Instead of only reading theory, I was able to follow along and understand how each part works in code. That made concepts like transformers and self-attention feel much less intimidating.

Great for Going Beyond Surface-Level AI

This isn’t just a “what is AI?” book. It helped me understand the mechanics behind modern language models and gave me a much stronger foundation for experimenting on my own.

Challenging, But Worth It

Some sections take focus, but that’s part of why I liked it. It pushes you to really understand the material.

I enjoyed the portion of this book that I read. It offers a practical and focused approach to understanding how large language models are built. I don't like the cover of the book, though.

However, absolute beginners may benefit from complementing it with a comprehensive deep learning resource. Before building an LLM, it helps to understand artificial neural networks, which provide the foundation upon which LLMs are built.

For that purpose, I highly recommend the Deep Learning from Curiosity to Mastery series as a companion. Volume 1 covers the foundations of neural networks, while Volume 2 explains embeddings, attention mechanisms, and Transformers in detail. Those are the foundations of LLM.

Raschka’s book is an excellent specialized resource for building an LLM. For beginners, pairing it with the broader foundation provided by Deep Learning from Curiosity to Mastery can make the concepts easier to understand and connect.

I read the book on Monday, and on Tuesday, I had a fully functional Large Language Model (from Scratch).

I'm a retired carpenter, so anyone can build a Large Language Model from this book.

I used pretraining_simple.py, instruction_finetune.py, and downloaded the OpenAI weights.

I trained the LLM on my own Roof Framing 10 MB dataset. It can correctly answer all the questions in my instruction dataset and in Roof Framing in general. Any questions not related to roof framing are answered in coherent sentences. I wouldn't call them hallucinations, just coherent, unrelated answers.

This book is so-so. I wouldn't buy it again. I wanted to learn how the llm works and how the embedding algorithms are designed. Alternatively, he could have discussed the training algorithm of the llm and how the weighting matrices are determined. Alternatively, he could have discussed how the math by setting the vector spaces relate meanings to words so that an llm can convert that into something intelligible as a response. None of this was done. He presents code for llm and uses python libraries. However, it is a black box. All the discussion varies from 2 extremes of high level generalities and then specific lingo and code for particular abstractions. However, virtually nothing is made concrete. Of course some will disagree, but if I knew how llm's worked, I wouldn't write this book. If I don't understand the details of llm functions and code design with llm, this book wouldn't help much. That being said, if you want some code snippets, you will find some useful ones here.

This is a really amazing book to understand the foundational concepts behind LLMs and NLP. It is very well thought out and organized, while maintaining technical depth. A prior understanding of Python makes it more beneficial. If you want to learn what’s in this book but don’t now Python I’d 100% recommend first completing the free CS50P class from Harvard on EdX.

A great book to start and understand AI.

One of the best books on the subject of AI and LLMs that I’ve come across so far. The author explains the components and inner workings of an LLM perfectly. By the end of the book, you’ll have a clear understanding of how an LLM and a chatbot work internally. The only prerequisites for this book are a basic understanding of how neural networks are structured and some knowledge of vectors and matrices; with these, all the steps and code examples are easy to follow.

I’m already looking forward to the author’s next book on reasoning models.

Contains useful stuff, but the author is very sloppy with numbers, which is very annoying comparing one figure with the next. He often rounds off numbers in a wrong way, especially when they are small ('1') or ('2'). The author prefers printing Python that a LLM can also give me. The structure of the book is not logical. Introduces a loss function without mathematical representation. You will need chatgpt to make shots and let you explain. Even chapter titles are misleading, as chapter 7 'pretraining' - no, it is the first introduction of a specific loss function. Book needs a lot of re-work

There is not even one flow diagram representing the total flow through a LLM

Poor printing quality: paper is so thin so one can see letters from back side while reading front side. Also for some reason main cover is not alligned with the rest of the book.

Overall impression like it was printed at home

İçerik çok güzel ama ben basım kağıdını beğenmedim