What a ML-Engineer should know by heart

What a ML-Engineer should know by heart

While no one is expected to know everything by heart, there are certain core concepts, tools, and skills a Machine Learning Engineer should be very familiar with to work effectively. These are the foundational elements that should ideally be well understood and easily accessible mentally without frequent reference to external sources.

1. Core Machine Learning Concepts

  • Supervised, Unsupervised, and Reinforcement Learning:
    • Key differences, use cases, and examples.
  • Common Algorithms and When to Use Them:
    • Linear Regression, Logistic Regression.
    • Decision Trees, Random Forests, Gradient Boosting (e.g., XGBoost, LightGBM, CatBoost).
    • k-Means, DBSCAN (clustering algorithms).
    • Support Vector Machines (SVMs).
    • k-Nearest Neighbors (k-NN).
  • Overfitting vs. Underfitting:
    • How to identify and mitigate (e.g., regularization, dropout, etc.).
  • Bias-Variance Tradeoff.
  • Hyperparameter Tuning:
    • Techniques like Grid Search, Random Search, and Bayesian Optimization.
  • Metrics:
    • Accuracy, Precision, Recall, F1 Score, AUC-ROC, Mean Squared Error (MSE), R² Score.

2. Deep Learning Concepts

  • Neural Network Basics:
    • Feedforward Networks.
    • Backpropagation and Gradient Descent.
  • Common Architectures:
    • CNNs (Convolutional Neural Networks) for images.
    • RNNs (Recurrent Neural Networks) and LSTMs/GRUs for sequences.
    • Transformers (e.g., BERT, GPT) for NLP tasks.
  • Activation Functions:
    • ReLU, Sigmoid, Tanh, Softmax, etc.
  • Regularization Techniques:
    • Dropout, Batch Normalization, Weight Decay.
  • Loss Functions:
    • Cross-Entropy Loss, Mean Squared Error, Hinge Loss.
  • Optimization Algorithms:
    • SGD, Adam, RMSProp, etc.

3. Data Handling and Preprocessing

  • Feature Scaling:
    • Standardization (z-score), Normalization (Min-Max scaling).
  • Handling Missing Data:
    • Imputation techniques, removing rows/columns.
  • Feature Engineering:
    • One-Hot Encoding, Binning, Polynomial Features.
  • Data Splitting:
    • Train-test split, Cross-validation, Stratified sampling.
  • Outlier Detection and Handling.

4. Programming and Frameworks

  • Programming Language Proficiency:
    • Python: Data structures, list comprehensions, generators.
    • Basic understanding of NumPy, Pandas for data manipulation.
  • Machine Learning Frameworks:
    • scikit-learn for traditional ML.
    • TensorFlow and PyTorch for deep learning.
  • Data Visualization:
    • Matplotlib, Seaborn, Plotly.

5. Cloud and Deployment Basics

  • Cloud Platforms:
    • AWS (e.g., SageMaker), Google Cloud Platform (GCP), Azure ML.
  • Model Deployment:
    • Flask/FastAPI for serving models.
    • Basics of Docker for containerization.
    • REST API development.
  • MLOps Concepts:
    • Pipelines, version control for data and models (e.g., DVC, MLflow).
    • Monitoring models in production.

6. Applied Knowledge

  • Natural Language Processing (NLP):
    • Tokenization, embeddings (e.g., Word2Vec, GloVe).
    • Working with pre-trained models like BERT, GPT.
  • Computer Vision:
    • Image preprocessing (e.g., resizing, normalization).
    • Augmentation techniques.
    • Common architectures (ResNet, Inception, EfficientNet).
  • Time-Series Analysis:
    • Moving averages, ARIMA, Seasonal Decomposition.
    • Recurrent networks and transformers for sequential data.

7. Mathematical and Statistical Foundations

  • Linear Algebra:
    • Vectors, matrices, dot products, eigenvalues, eigenvectors.
  • Probability and Statistics:
    • Bayes’ theorem, distributions (normal, binomial, etc.), p-values.
  • Calculus:
    • Derivatives, gradients, chain rule (for backpropagation).
  • Optimization:
    • Convexity, gradient descent concepts.
  • Basics of Information Theory:
    • Entropy, KL divergence.

8. Soft Skills

  • Critical Thinking:
    • Framing problems in a way ML can solve.
  • Communication:
    • Explaining models and results to non-technical stakeholders.
  • Team Collaboration:
    • Working with data engineers, product teams, and DevOps.

9. Things to Know How to Do Quickly (Not Necessarily Memorized)

  • Setting up a machine learning pipeline (data ingestion, preprocessing, model training, evaluation).
  • Writing clean and modular Python code for reproducibility.
  • Debugging ML models (e.g., handling vanishing gradients, identifying data leakage).
  • Efficiently searching for documentation or debugging issues via resources like Stack Overflow, GitHub, and official libraries.

Final Note:

It’s important to distinguish between what you should know by heart and what you should know how to do with some assistance. Machine Learning Engineers should aim to deeply understand foundational concepts and have practical experience in applying them. For the rest, it’s perfectly normal to rely on documentation, online resources, and collaboration with your team.

👤 A Personal Note

As the author of this post, I want to be clear:
I don’t have all the math formulas, derivations, or function signatures memorized — and I don’t need to.

Like many engineers, I rely on documentation, cheat sheets, and notebooks when it comes to specific equations or implementation details. What matters most is that I understand the core concepts, can recognize the right approach for a given problem, and know what questions to ask when something isn’t working.

Having a strong mental model lets me:

  • Spot when something feels off
  • Explain the why behind a technique
  • Build systems that are principled, not just copied from Stack Overflow

Tools change. Syntax evolves. But concepts stick.

That’s the kind of knowledge I believe every ML engineer should aim to carry.

Oliver