From Calling Libraries to Understanding ML: Where's the Real Dividing Line?

A Question That Haunts Countless Beginners

Recently, a machine learning learner posed a question on Reddit that struck a deep chord: "At what point did you realize you were actually learning machine learning, and not just calling libraries?"

This question hits at the core anxiety of modern ML learning. With mature frameworks like scikit-learn, PyTorch, and TensorFlow, anyone can train a model in a few lines of code, tweak some parameters, check the accuracy, and get a result that "looks pretty good"—all while having no idea what's happening under the hood.

These three frameworks represent different levels of abstraction within the machine learning toolchain. scikit-learn provides the highest level of encapsulation—users only need to call fit() and predict() to complete the entire workflow from data preprocessing to model evaluation. Its design philosophy is to lower the barrier to entry for traditional ML algorithms (such as SVM, Random Forest, K-Means, etc.) as much as possible. PyTorch and TensorFlow target deep learning scenarios, offering automatic differentiation (autograd) engines and GPU-accelerated computation. PyTorch won the hearts of the academic community with its dynamic computation graph (define-by-run) design, providing a debugging experience close to native Python; TensorFlow, on the other hand, has built a more complete ecosystem for industrial deployment, including production tools like TensorFlow Serving and TensorFlow Lite. It's precisely because these frameworks encapsulate complex details like backpropagation, memory management, and parallel computing behind a few API calls that the widespread phenomenon of "knowing how to call libraries but not understanding the principles" exists.

The poster's confusion is typical: the workflow of training models, tuning parameters, and checking accuracy can be completed without any understanding of the underlying principles. So where exactly is the line between truly "understanding" machine learning and merely "knowing how to use the libraries"?

The Essential Difference Between Library Callers and True Practitioners

Knowing How to Use Libraries vs. Knowing How to Solve Problems

The biggest difference between someone who just calls libraries and someone who truly understands ML is often only revealed when things go wrong.

When your model's accuracy plateaus and stops improving, a library caller can only blindly swap models, add data, or tweak hyperparameters—fumbling around in a black box. Someone who understands the principles, however, will analyze: Is it underfitting or overfitting? Is there a data distribution issue, or was the loss function chosen incorrectly? Are the gradients vanishing or exploding?

In other words, true understanding manifests as diagnostic ability. When a model performs poorly, can you form reasonable hypotheses and know which direction to investigate? That's the real dividing line between a "user" and a "practitioner."

From "It Runs" to "I Know Why"

Many people experience an epiphany moment during practice: one day, you're no longer satisfied with "the code runs and the results look fine," and you start asking "why does this method work" and "what would happen if I did it differently." This kind of proactive curiosity often signals that your learning has entered a deeper level.

Core Concepts That Signal You've Truly Entered Machine Learning

Drawing on the prevailing views of seasoned practitioners in the community, mastery of the following concepts serves as a key indicator of whether someone "truly understands ML."

1. Understanding the Math Behind Gradient Descent

Gradient descent is the engine behind nearly all modern machine learning. Truly understanding it means you grasp that: the loss function is a high-dimensional surface over parameters, the gradient points in the direction of steepest ascent, and we iteratively move in the negative gradient direction to find the minimum.

From a mathematical perspective, this process is rooted in the theory of directional derivatives from multivariable calculus: for a differentiable function f(θ), its gradient ∇f(θ) is a vector pointing in the direction of greatest increase in function value, with its magnitude equal to the maximum directional derivative. In the parameter update rule θ_{t+1} = θ_t - η·∇f(θ_t), η is the learning rate. In practice, virtually no one uses vanilla Batch Gradient Descent (Batch GD); instead, Stochastic Gradient Descent (SGD) or Mini-batch SGD is used, trading noise for computational efficiency. Building on this foundation, researchers have developed a series of adaptive learning rate optimizers: Momentum introduces a momentum term to accelerate convergence and reduce oscillation; Adam (Adaptive Moment Estimation) combines exponential moving averages of first and second moments to automatically adjust the learning rate for each parameter, and has become the most widely used default optimizer in deep learning.

When you understand why a learning rate that's too large causes oscillation and divergence, why one that's too small leads to painfully slow convergence, and why training can get stuck in local optima or saddle points, your intuition about the entire training process undergoes a qualitative shift. At that point, adjusting the learning rate is no longer black magic—it's evidence-based. Understanding the differences between optimizers—for instance, why Adam excels with sparse gradients while SGD with learning rate decay sometimes achieves better generalization on certain tasks—is a crucial step from superstitious tuning to scientific optimization.

2. Truly Understanding the Design Logic of Loss Functions

The loss function determines what the model is "trying to optimize." Why is cross-entropy commonly used for classification instead of mean squared error? Why do certain tasks require custom loss functions? When you can select or design an appropriate loss function based on business objectives, rather than defaulting to whatever the framework provides, you've moved beyond the library-calling level.

To deeply understand this, we need to trace back to the roots of information theory. Cross-entropy originates from information theory: entropy H(p) = -Σp(x)log p(x) measures the uncertainty of a probability distribution, while cross-entropy H(p,q) = -Σp(x)log q(x) measures the average number of bits needed to encode data from distribution p using distribution q. The difference between the two is the KL divergence (Kullback-Leibler Divergence), which measures the "distance" between two distributions. In classification tasks, p is the one-hot distribution of true labels and q is the model's output probability distribution; minimizing cross-entropy is essentially pushing the model's predicted distribution as close as possible to the true distribution. Compared to Mean Squared Error (MSE), cross-entropy's advantage in classification lies in its gradient properties: when the model's prediction is severely off from the true label, cross-entropy produces larger gradients that drive faster learning; MSE, on the other hand, suffers from gradient saturation when Sigmoid outputs approach 0 or 1, leading to extremely slow training. This is a textbook example of why loss function design is not an arbitrary choice but requires deep consideration of task characteristics and optimization dynamics.

3. Deeply Understanding Overfitting and Generalization

Overfitting is arguably the central tension of all ML problems. Truly understanding it goes beyond knowing that "high training accuracy and low test accuracy means overfitting." It means understanding the bias-variance tradeoff, why regularization works, why more data typically alleviates overfitting, and the delicate balance between model capacity and data volume.

The bias-variance tradeoff is one of the most profound insights in statistical learning theory. For any supervised learning model, the expected error on unseen data can be decomposed into three irreducible components: Bias², Variance, and Irreducible Error (Noise). Bias measures systematic deviation—whether the model family itself has sufficient expressive power to capture the true data-generating function; Variance measures the model's sensitivity to training data—how much would predictions change if we used a different training set? Simple models (like linear regression) typically have high bias and low variance, while complex models (like deep neural networks) have low bias and high variance. Regularization techniques (such as L1/L2 regularization, Dropout, and early stopping) essentially trade a small increase in bias for a significant reduction in variance. Notably, modern deep learning has revealed the so-called "Double Descent" phenomenon—when the number of model parameters far exceeds the number of training samples, test error can actually decrease again—posing an intriguing challenge to the classical bias-variance framework and remaining an active area of theoretical research.

Generalization is the ultimate goal of machine learning—making the model perform well on data it has never seen, rather than memorizing the training set.

4. Implementing Core Algorithms from Scratch

Many senior engineers believe that implementing core algorithms from scratch at least once—such as linear regression, logistic regression, or backpropagation for a simple neural network—is an irreplaceable learning experience. When you derive and implement backpropagation by hand and understand how the chain rule propagates gradients between layers, concepts that were once abstract suddenly become concrete and clear.

The Backpropagation algorithm was popularized by Rumelhart, Hinton, and Williams in their seminal 1986 paper, and at its core is a systematic application of the chain rule from calculus. In a multi-layer neural network, the gradient of the loss L with respect to the parameters w of a given layer needs to be propagated backward through all intermediate layers from the output layer. The chain rule tells us: ∂L/∂w = (∂L/∂z_n)·(∂z_n/∂z_{n-1})·...·(∂z_k/∂w), where z_i is the activation of the i-th layer. The elegance of backpropagation lies in the fact that it only requires one forward pass and one backward pass to compute gradients for all parameters, with computational complexity on the same order as the forward pass—far more efficient than the naive approach of computing finite differences for each parameter individually. This also explains why Vanishing Gradients and Exploding Gradients are core challenges in training deep networks: when the chained multiplicative terms are consistently less than 1 or greater than 1, gradients shrink or swell exponentially. Residual connections (ResNet), Batch Normalization, and carefully designed activation functions (such as ReLU replacing Sigmoid) are all architectural innovations developed to mitigate this problem.

You don't need to reinvent the wheel in production, but this process will give you complete transparency into what the framework is hiding from you.

5. Being Able to Read ML Research Papers

When you can read the equations in papers, understand the methodological innovations, and even critically evaluate experimental design, it means you've developed the ability to continuously advance. The frontier moves extremely fast, and being able to acquire knowledge directly from original papers means you can grow without relying on second-hand tutorials.

Common Inefficient Learning Traps for Beginners

The original poster also asked a very practical question: What do beginners spend too much time on that isn't actually important?

Falling Into the Abyss of Mathematical Proofs Too Early

While math is important, many beginners try to master measure theory, functional analysis, and other advanced mathematics right from the start, only to get discouraged and give up. In reality, a solid foundation in linear algebra, calculus, and probability & statistics, combined with intuitive understanding of core algorithms, is sufficient to support most practical work.

These three mathematical pillars each serve distinct yet deeply intertwined roles in machine learning. Linear algebra is the language of representation and computation: data is organized as matrices, model parameters are vectors, each layer in a neural network is essentially a matrix multiplication followed by a nonlinear transformation, and SVD (Singular Value Decomposition) and eigendecomposition have direct applications in PCA dimensionality reduction, recommendation systems, and more. Calculus provides the tools for optimization: gradients, Hessian matrices, and Jacobian matrices form the mathematical foundation for understanding model training dynamics. Probability and statistics provide the framework for modeling uncertainty: Bayesian inference treats model parameters as random variables, and Maximum Likelihood Estimation (MLE) provides a probabilistic interpretation for many loss functions—for instance, MSE corresponds to a Gaussian noise assumption, and cross-entropy corresponds to a Bernoulli distribution. In fact, many seemingly different ML algorithms are unified at the mathematical level: logistic regression is simply maximum likelihood estimation of a linear model under a Bernoulli distribution assumption.

Mathematical depth can be supplemented on-demand when you encounter specific problems—there's no need to pursue comprehensiveness and rigor from the very beginning.

Blindly Chasing the Latest Models

Many newcomers rush to try the latest large models or flashiest architectures while neglecting fundamentals. In reality, understanding how a simple linear model works is more valuable than being able to call a complex model you don't understand. Once the foundations are solid, the cost of learning new models drops dramatically.

Obsessing Over Tools and Environment Configuration

Spending excessive time on framework versions, GPU configurations, and other toolchain minutiae instead of actually understanding modeling approaches is a common misallocation of time. Tools are means, not ends.

Collecting Courses Without Hands-On Practice

The illusion of "bookmarking equals learning" is especially prevalent in ML education. Watching dozens of hours of video and hoarding courses without ever completing a single project from start to finish. Hands-on practice, stumbling through problems yourself—that's the real path to internalizing knowledge.

Conclusion: Understanding Is a Continuous Process

The line between "understanding ML" and "using libraries" is not a binary distinction but a continuous spectrum. You might start by calling libraries, grow through debugging failed projects, deepen your understanding through the epiphany of implementing algorithms from scratch, and ultimately develop your own judgment through reading papers and solving real-world problems.

Perhaps the true signal is this moment: When something goes wrong with your model, you no longer panic and try things randomly, but instead calmly form hypotheses, verify them step by step, and ultimately pinpoint the cause. At that point, you'll realize you're no longer just "using" machine learning—you're truly "doing" machine learning.

Key Takeaways