E-Book, Englisch, 442 Seiten
Reihe: PublishDrive
O'Neal Complete How-To Fundamentals of Machine Learning Systems
1. Auflage 2026
ISBN: 979-8-90498-288-1
Verlag: PublishDrive
Format: EPUB
Kopierschutz: 0 - No protection
A Hands-On Path from First Model to Production for New and Career-Switching Engineers
E-Book, Englisch, 442 Seiten
Reihe: PublishDrive
ISBN: 979-8-90498-288-1
Verlag: PublishDrive
Format: EPUB
Kopierschutz: 0 - No protection
Most machine learning courses stop at a model in a notebook, leaving you unprepared for the work teams actually need. This hands-on guide takes you from your first model to a deployed, monitored ML system you can own with confidence.
Machine learning is one of the most talked-about skills in software engineering, and one of the most badly introduced. Most introductions start with a neural network, spend their time on mathematics, and stop at an accuracy score in a notebook. That leaves a new engineer knowing what a model is, with no idea how to make one useful to anyone else.
Complete How-To Fundamentals of Machine Learning Systems takes a different path. It turns a working Python developer into an engineer who can ship a machine learning system, keep it running, and take responsibility for it over time. Not a researcher, and not a data scientist with a PhD, but an engineer who treats a model like any other component: something with inputs, outputs, a failure mode, and an owner.
Across eleven chapters, you build your first end-to-end ML system early, then learn the mathematical intuitions you actually need, how to work with real data, which models to use and when, and how to evaluate honestly. From there the book turns the notebook into a service with FastAPI and Docker, covers versioning and the ML lifecycle, and teaches monitoring and drift detection. It closes with how ML teams work and a roadmap for what to learn next.
The book assumes Python literacy and nothing else: no statistics beyond the word 'average,' no linear algebra, no prior ML experience. Each chapter ends with a Quick Check and Key Takeaways. Book 1 of the ML Engineer's Journey, it is written for new graduates, career switchers, and junior engineers who want to be the person their team can hand a model to.
Autoren/Hrsg.
Weitere Infos & Material
Introduction
Machine learning is one of the most talked-about skills in software engineering right now, and also one of the most badly introduced. The popular version tends to start with a neural network, spend most of its time on mathematics, and stop somewhere around an accuracy score in a notebook. That version leaves a new engineer knowing roughly what a model is but having no idea how to make one useful to anyone else. This book takes a different path.
The goal here is to turn a working Python developer into an engineer who can ship a machine learning system, keep it running, and take responsibility for it over time. Not a researcher. Not a data scientist with a PhD. An engineer who treats a model the way they treat any other component in a system: something with inputs, outputs, a failure mode, and an owner.
Diagram 0.1, Book Roadmap: The 11-Chapter Ramp
Who This Book Is For
This book was written for a specific person, and there are actually several versions of that person.
The first is the new graduate. You have completed a computer science or data science degree, can write Python confidently, have seen some statistics, and may have built a model or two in a course. But you have never shipped one. The gap between coursework and production has always looked wide and vaguely intimidating, and this book is specifically designed to close it.
The second is the career switcher. You spent years doing something else- web development, DevOps, data analytics, quality assurance, or technical support- and you have decided that machine learning is where you want to go next. You are not starting from zero; you have real engineering instincts and practical experience. What you need is a path that respects those instincts and builds on them rather than pretending you have never written software before.
The third is the junior or mid-level engineer already working adjacent to ML. Maybe you are on a team that includes data scientists, or you have been asked to integrate a model someone else trained, or you have been following tutorials that always seem to stop just before the parts that actually matter at work. This book fills in the gaps that tutorials leave behind.
What all three of these people share is Python literacy. If you can write a function, import a library, read and write files, and follow along when someone shows you a simple script, you have everything this book assumes you have. It does not assume statistics beyond a vague familiarity with the word “average.” It does not assume linear algebra. It does not assume any prior ML experience.
What You Will Be Able to Do
By the time you reach the last page, you will have a set of concrete, practical capabilities. Each of them is the kind of thing a team can actually hand you on your first week.
You will be able to take a tabular dataset, one you have never seen before, and move from raw data to a trained model with an honest performance estimate. You will know how to split data correctly, choose a starting model, evaluate it without cheating, and interpret the numbers you get back in a way that supports real decisions rather than inflated claims.
You will be able to package that model so it can run on a device other than your laptop. You will understand how serialization works, how to wrap a model in a small REST service using FastAPI (a Python web framework designed for fast, lightweight APIs), and how to containerize that service using Docker (a tool that packages your code and all its dependencies into a portable unit that runs the same way everywhere). After Chapters 7 and 8, a model in a notebook is no longer a dead end; it is the beginning of something deployable.
You will be able to add minimum viable monitoring: the basic instrumentation that tells you whether your model is still behaving as it did when you deployed it. You will understand the difference between a model that has stopped working because the data changed and one that has stopped working because the relationships in the world have changed. That distinction has practical consequences for what you do next.
You will also have a mental model of the full lifecycle. Where does data come from? How do teams track experiments and reproduce results? What are the roles on an ML team, and how do they divide up the work? What does good code review look like for ML code? These are the questions that consume most of your time in a real job, and this book addresses them directly.
Diagram 0.2, Reader Journey: From Notebook to Production
What This Book Does Not Promise
Honesty about scope matters, and this book has deliberate limits.
This is not a research book. If your goal is to read ML papers comfortably, run ablation studies, and contribute to the academic literature, you will need to go deeper into mathematics and statistics than this book goes. Chapter 3 gives you the minimum mathematical intuition an engineer needs to make sense of model behavior and read a paper without getting lost, but it stops there intentionally. Research-grade ML practice requires a separate, longer journey.
This is not a deep learning specialty book. Neural networks, transformer architectures, and large language models are covered in Chapters 5 and 11, including what they are, when to use them, and where they fit in the broader landscape. But building and fine-tuning large models is a skill that requires its own book, and this series provides that in Book 2.
This is not a mathematics course. You will see almost no formulas. When mathematical ideas appear, they appear as descriptions of what an operation does rather than how to derive it. The goal is engineering intuition, not proof.
This is also not a shortcut to the title “machine learning engineer” on a resume. That title reflects sustained practice, not reading. This book gives you a foundation that makes the practice coherent and productive. The difference between an engineer who has read this book and one who has not is that the one who has will know what to practice, in what order, and how to evaluate their own progress.
How the Book Is Organized
The eleven chapters follow a deliberate ramp. The first three are accessible to a complete novice. Each subsequent chapter raises the floor a little, adding engineering responsibility and expecting a bit more of the reader. By Chapter 11, you are thinking about the full system, the full team, and the full career arc.
Chapter 1 strips away the hype and gives you a working definition of machine learning. You will learn the difference between supervised, unsupervised, and reinforcement learning; why a model is probabilistic rather than deterministic; and, crucially, when not to use machine learning at all. The last point is at least as important as the first.
Chapter 2 immediately puts everything into motion. Before theory accumulates, you build a complete end-to-end system in a single sitting: raw data, data preparation, model training, honest evaluation, serialization, and a live prediction endpoint. The goal is not sophistication. It is shape. Seeing the whole pipeline once, even in simplified form, gives every subsequent chapter a concrete context to land in.
Chapter 3 presents the minimum viable mathematics for this field. Not a semester of linear algebra. Not a statistics course. Just the handful of ideas- vectors, dot products, probability as a confidence score, the loss landscape- that make model behavior legible to an engineer and allow you to read a paper without completely losing the thread.
Chapter 4 is where the book gets serious about data. Real datasets are messy, biased, and surprisingly dangerous to work with carelessly. You will learn where datasets come from, how to split them correctly, how data leakage silently destroys evaluation results, and why the data on a competition leaderboard behaves nothing like the data flowing through a production system.
Chapter 5 tours the major supervised learning families: linear models, decision trees, random forests, gradient boosting, and neural networks. The emphasis is on fit rather than fashion. You will come away with a practical framework for deciding which model to try first, and what it would take to justify trying something more complex.
Chapter 6 covers evaluation honestly. Cross-validation, metric selection, reading a confusion matrix, understanding precision and recall, and the painful gap between a model’s offline performance and its actual behavior in production. This is the chapter that separates engineers who trust their results from engineers who should not.
Chapter 7 is where the notebook becomes a service. Serialization formats (pickle, joblib, ONNX), input contracts, FastAPI endpoints, health checks, Docker containers, latency tradeoffs, and a minimal deployment path are all here. If Chapter 2 showed you the shape of the pipeline, Chapter 7 shows you how to build the real thing.
Chapter 8 takes on lifecycle, versioning, and reproducibility. Experiment tracking with MLflow (a platform for logging parameters, metrics, and model artifacts), data versioning with DVC (a tool that manages large data files and tracks dataset versions alongside code), and the discipline of tying a specific model artifact to the exact code, data, and configuration that produced it. Reproducibility is not optional; it is the foundation of everything that comes after.
Chapter 9 addresses what happens when a working model quietly stops working. Data drift, concept drift, operational monitoring, alert thresholds, distribution comparisons, and the question of when to...




