AI vs machine learning: why they are not the same thing, and why it matters

Machine learning is one way of doing AI, not another name for it

Here is the whole idea in one sentence. Machine learning is a type of artificial intelligence, but artificial intelligence is not only machine learning. A labrador is a dog, but not every dog is a labrador.

There is a third word you will meet, deep learning. It sits one level further in. Deep learning is a kind of machine learning that uses neural networks with many layers, and the standard textbook on it draws the nesting as circles: artificial intelligence on the outside, machine learning inside it, and deep learning further in.¹

So when someone says "AI", they might mean a chess engine, a set of hand written rules, a route planner or a neural network. When they say "machine learning", they mean one thing only: a system that learns its behaviour from data rather than being told every rule.

That is simple enough in theory. In practice, people mix the two up all the time, and the mix up costs money.

Why the two words get mixed up

Marketing is the main culprit. "AI" sounds grander in a press release than "a statistical model trained on last year's orders". So the label goes on everything, including products whose clever part is a spreadsheet formula.

The press helps it along, because "AI" is the word a general audience recognises. And there is a genuine overlap. Most of the AI people use every day, the spam filter, the product recommendations, the chatbot, is built on machine learning. So in everyday use the two really do sit on top of each other.

The mix up still causes three kinds of trouble. Expectations drift (a model that predicts basket size is not about to become sentient). Projects get scoped wrongly (you may not need "AI" when a few rules would do). And thinking about risk gets muddy, because the two fail in different ways.

Worked example: the "AI powered" recommender

An invented gift shop in Kilkenny is offered an "AI powered recommendation engine" for €400 a month. The owner asks one question: how does it decide what to recommend?

The answer: for each product, it counts which other products appeared in the same orders over the last 90 days and shows the top three. That is useful, and it may well sell more. But it is counting, not learning a model, and a developer could build the same thing on the shop's own order table in a few days. Knowing the difference turns a vague pitch into a price you can compare. If you do want a learned recommender, I walk through building one in custom AI recommendations in Solidus.

What artificial intelligence means

Artificial intelligence is the broad idea of machines carrying out tasks we would call intelligent: reasoning, planning, perceiving, using language, learning.

The law now has a definition too. The EU AI Act defines an AI system as a machine based system, designed to operate with varying levels of autonomy, that may adapt after deployment and that, for explicit or implicit objectives, infers from the input it receives how to generate outputs such as predictions, content, recommendations or decisions that can influence physical or virtual environments (I am paraphrasing Article 3(1) closely).² That wording follows the OECD's definition, updated in November 2023, almost word for word.³

The key word in both is "infers". The Act's own recitals say the techniques that allow inference include machine learning approaches and also logic and knowledge based approaches that reason from encoded knowledge. In other words, the law itself treats machine learning as one route to AI among others.²

The standard textbook makes the same point by its shape. Russell and Norvig's Artificial Intelligence: A Modern Approach has seven parts: artificial intelligence, problem solving, knowledge reasoning and planning, uncertain knowledge and reasoning, machine learning, communicating perceiving and acting, and conclusions. Machine learning is one part of seven.⁴

The field is older than most people think. In 1950 Alan Turing opened his paper "Computing Machinery and Intelligence" with the question "Can machines think?" and proposed replacing it with a test he called the imitation game.⁵ The term "artificial intelligence" itself comes from a 1955 proposal by McCarthy, Minsky, Rochester and Shannon for a summer research project at Dartmouth, built on the conjecture that every aspect of learning or intelligence could in principle be described precisely enough for a machine to simulate it.⁶

Under that umbrella sit very different approaches:

• Rule based systems (expert systems). People write the rules, the software applies them. No learning at all.
• Search and optimisation. The system explores possible answers and picks a good one: chess positions, delivery routes, staff rotas.
• Logic and reasoning. The system draws conclusions from facts. All mammals are warm blooded, a dog is a mammal, so a dog is warm blooded.
• Natural Language Processing (NLP), computer vision and robotics. Areas defined by the problem (language, images, physical action), each of which can use any of the techniques.
• Machine learning. The system learns patterns from examples.

Machine learning is one item on that list. AI is the goal. How you get there, with written rules, search, logic or learning, is a separate question.

Worked example: AI with no learning in it

An invented florist in Galway wants its website to quote a delivery day. The owner writes three rules:

1. If the order is in before 2pm and the Eircode starts with H91, deliver today.
2. If the order is in after 2pm and the Eircode starts with H91, deliver tomorrow.
3. For any other Eircode, deliver in two working days.

An order placed at 11am for an H91 Eircode in the city matches rule one: today. An order at 4pm for the same Eircode matches rule two: tomorrow. An order for Tuam (H54) matches rule three: two working days.

Nothing was learned from data. Every answer can be traced to a rule a person wrote. This is the oldest kind of AI, and for this problem it is the right one. Note that the EU AI Act's recitals say the AI system definition should not cover systems based on rules defined solely by people to execute operations automatically, so in law this florist's rules may not count as AI at all.² I come back to why that matters.

What machine learning means

Machine learning flips the usual way of programming around.

• Traditional programming. You give the computer rules and data. It gives you answers.
• Machine learning. You give the computer data and the answers (examples). It works out the rules.

TensorFlow's own introduction puts it neatly: with traditional programming a programmer specifies the rules, whereas with machine learning the programmer provides examples and the computer learns patterns from the data, "programming with data".⁷

Spam filtering is the classic case. You could write rules: if the email mentions an urgent transfer from a foreign prince, mark it as spam. Spammers change their wording, the rules multiply, and soon nobody can maintain them. With machine learning you instead collect a large number of emails that people have already marked as spam or not spam, and the algorithm finds the patterns itself, including combinations of wording, links and senders that nobody would think to write down.

Worked example: learning a spam signal from counts

An invented accountant in Cork has 1,000 old emails, each already marked by hand: 300 spam, 700 genuine. A short script checks one word, "invoice". It appears in 120 of the spam emails and 35 of the genuine ones.

So of the 155 emails containing "invoice", 120 were spam:

$$\frac{120}{120 + 35} = \frac{120}{155} \approx 0.774$$

Here $120$ is the number of spam emails containing the word, $35$ the number of genuine ones containing it, and $0.774$ the share of "invoice" emails that were spam. Before seeing any word, the chance an email is spam was 300 in 1,000, or 30%. Seeing "invoice" raises it to about 77%. Nobody told the script that "invoice" was suspicious in this inbox. It found that in the data. A real filter does this for thousands of words and signals at once and combines them, but the idea is the same. The probability rules behind it are set out in Foundations: probability.

Notice the catch, too. If the accountant's genuine clients start sending invoices by email, the learned signal goes stale. A model is only as current as its data.

The main kinds of machine learning

There are three main families, and a middle ground.

• Supervised learning. You give labelled examples: these photos are cats, those are dogs. The algorithm learns the mapping from input to label. Linear regression, decision trees, random forests and neural networks are common choices.
• Unsupervised learning. You give data with no labels and ask for structure. "Here are 20,000 customers' purchase histories, group the similar ones." Clustering methods such as k means find the groups without being told what they are.
• Reinforcement learning. The algorithm learns by trial and error, receiving a reward or a penalty for each action. AlphaGo is the famous case, and the detail is worth getting right: it was first trained on thousands of expert human games, then played against versions of itself and used reinforcement learning to improve. It beat Lee Sedol four games to one in Seoul in March 2016.⁸
• Semi supervised learning. A few labelled examples and many unlabelled ones. Useful when labels are expensive, for example when each medical scan needs a specialist to read it.

Worked example: supervised and unsupervised on the same shop

An invented tea shop in Waterford has 5,000 customers.

The supervised question: will this customer buy again within 90 days? The shop has history for last year, so every past customer carries a label, yes or no. A model learns from those labels which patterns (first order size, the product bought, whether they opened the welcome email) go with "yes", and then scores this year's new customers.

The unsupervised question: what kinds of customers do I have? There is no label to learn. A clustering method looks only at order count, average basket and favourite category, and might return three groups: about 600 frequent buyers of loose leaf tea, about 1,400 who order gift boxes in December, and about 3,000 who bought once. The shop never defined those groups. It names them afterwards.

Same data, two different questions, two different kinds of learning.

How a model learns: a regression from scratch

At its core, most machine learning is applied statistics. You look for a mathematical function that maps inputs to an output and still works on data it has never seen.

The simplest model is linear regression. With several inputs it looks like this:

$$\hat{y} = \beta_0 + \beta_1 x_1 + \beta_2 x_2 + \dots + \beta_k x_k$$

Here $\hat{y}$ is the predicted output, $\beta_0$ is the intercept (the prediction when every input is zero), $x_1$ to $x_k$ are the $k$ inputs, and $\beta_1$ to $\beta_k$ are the coefficients, each one saying how much the prediction moves when its input rises by one unit and the others stay put. "Learning" means choosing the $\beta$ values that make the predictions as close as possible to the real outcomes in the training data. The full explanation is in Foundations: regression.

Worked example: predicting house prices in Galway

Suppose a model trained on past house sales in Galway learned these coefficients (they are invented for this example, not real Galway prices): an intercept of €60,000, €1,800 per square metre, €12,000 per bedroom, and minus €500 for every year of the building's age.

For an 85 square metre house with three bedrooms, built 40 years ago:

$$\hat{y} = 60{,}000 + (1{,}800 \times 85) + (12{,}000 \times 3) - (500 \times 40) = 229{,}000$$

Here $\hat{y}$ is the predicted price in euro, $60{,}000$ the intercept, and each bracket a coefficient times its input: $153{,}000$ for the floor area, $36{,}000$ for the bedrooms and $20{,}000$ off for the age. The model predicts €229,000. Nobody typed €1,800 per square metre into it. The algorithm found the coefficients that best fitted the past sales. Real models get far more complex, and a neural network can have millions of coefficients, but the core idea holds: find the function that best explains the data.

The words you will hear

• Training. Feeding the algorithm data so it can set its coefficients. Studying before the exam.
• Validation. Testing the model on data it did not see in training, to check it learned patterns and did not just memorise.
• Features. The inputs. Here: floor area, bedrooms, age.
• Labels. The outputs you want to predict, in supervised learning. Here: the actual sale prices.
• Model. The learned function that turns features into a prediction.
• Hyperparameters. Settings for the learning itself, such as how fast it learns or how complex it may become.
• Overfitting. Learning the training data too well, noise and quirks included. The student who memorised last year's paper.
• Underfitting. A model too simple to catch the real pattern.

Worked example: spotting overfitting

The Galway model is trained on 400 sales and tested on 100 sales it never saw. A very flexible version predicts the 400 training houses to within €3,000 on average, but misses the 100 new ones by €41,000 on average. A plain linear version misses the training houses by €18,000 and the new ones by €20,000.

The flexible one looks better on paper and is worse in use. It memorised the 400 houses. The plain one learned something that carries over. That gap between training error and test error is the whole reason validation exists.

How AI without learning works

Approaches that do not learn from data work quite differently.

Expert systems apply rules that human experts supplied. A diagnosis system might hold thousands of rules of the form "if symptoms A, B and C are present and test X is positive, consider diagnosis Y". The strength is that you can trace exactly why it decided what it decided. The weakness is that someone has to write and maintain every rule.

Search explores the possibilities. A chess engine does not need to learn chess from data. It can look ahead through possible positions and score them, using methods such as minimax, alpha beta pruning or Monte Carlo tree search.

Knowledge representation and reasoning stores facts and draws conclusions. Tell the system that Ballinasloe is in County Galway and County Galway is in Connacht, and it can conclude that Ballinasloe is in Connacht without ever seeing an example.

Worked example: search for a delivery route

The Galway florist from earlier has one van and three drops: A, B and C, starting and ending at the shop. There are $3 \times 2 \times 1 = 6$ possible orders to visit them. The software adds up the driving minutes for each of the six (say 48, 52, 39, 61, 44 and 55) and picks the shortest, 39 minutes.

No data, no learning, just a systematic look at every option. With 12 drops there are 479,001,600 orders, which is why real route planners use cleverer search than trying them all. It is still search, not machine learning.

What each approach cannot do

Knowing the limits tells you which tool to reach for.

Limits of AI in general

• No common sense. Systems lack the background knowledge people take for granted (dropped things fall, people dislike being punched) unless it is built in or learned.
• Narrow scope. Each system does what it was built for. A spam filter cannot play chess.
• Brittleness. Systems can fail in odd ways when the situation is a little different from what they were built for. A driving system trained only on American roads might well struggle with a busy Irish roundabout.
• Understanding is disputed. Large language models are trained to predict text. OpenAI's own report says GPT 4 was pretrained "to predict the next token in a document".⁹ Whether that adds up to understanding is still argued. What is not in doubt is that they can produce fluent, confident text that is wrong.

Limits specific to machine learning

• Data dependency. A model is only as good as its training data. Biased data gives a biased model. Situations missing from the data are handled badly.
• The black box. Complex models, deep neural networks above all, are hard to interpret. That matters wherever a decision about a person must be explained. In Ireland the regulator is the Data Protection Commission (DPC), and the law is the EU GDPR, which gives people a right not to be subject to a decision based solely on automated processing that has legal or similarly significant effects on them, and a right to meaningful information about the logic involved in such a decision.¹⁰ The DPC's guidance on AI warns that relying on a model's outputs without critical human analysis can bring in automated decision making risks, and tells organisations to be transparent with the people whose data they process: what processing they do, how they do it and how those people can exercise their rights.¹¹
• Volume of data. Many techniques need a lot of examples. You cannot train a reliable image classifier on 50 photos.
• Computing cost. Training large models takes serious hardware and energy.
• Poor transfer. A model trained for one task usually cannot do another without retraining.
• Adversarial inputs. Carefully crafted changes can fool a model. In a well known demonstration, an image of a panda with an imperceptibly small change added was classified as a gibbon with 99.3% confidence.¹²

Limits of rule based AI

• The knowledge bottleneck. Writing rules by hand is slow, and experts often cannot put what they know into words.
• Scale. Thousands of rules interact in ways nobody predicted.
• Rigidity. A situation no rule covers gets no sensible answer. Rules do not generalise from examples.
• Maintenance. When the world changes, every affected rule must be found and changed by hand.

The practical toolkit: models and Python libraries

If you want to work with machine learning yourself, these are the names you will meet.

What "model" means

A model is the learned function that makes the predictions. The word also names the family of algorithm:

• Linear models (linear and logistic regression). Simple and easy to explain. They work well when relationships are roughly straight lines.
• Decision trees. A series of yes or no questions about the features. Easy to read, but prone to overfitting.
• Random forests. Many decision trees voting together. A strong default for tables of business data.
• Support Vector Machines (SVMs). Find the widest boundary between classes.
• Neural networks. Layers of connected nodes, loosely inspired by the brain, able to learn very intricate patterns. The basis of deep learning.
• Convolutional Neural Networks (CNNs). Neural networks built for images, using filters to pick out features at different scales.
• Recurrent Neural Networks (RNNs) and Transformers. Built for sequences such as text. The Transformer, introduced in 2017, uses attention alone instead of recurrence, which makes it faster to train.¹³ It is the T in GPT, and GPT 4 is described by OpenAI as a Transformer based model.⁹

The Python libraries

Python is the common language of machine learning. The main libraries:

NumPy, "the fundamental package for scientific computing with Python".¹⁴ Fast arrays and maths. Almost everything else builds on it.

import numpy as np

data = np.array([1, 2, 3, 4, 5])
mean = np.mean(data)  # 3.0

pandas, an open source data analysis and manipulation tool.¹⁵ Think of a spreadsheet you drive with code. It is where most of the data preparation happens.

import pandas as pd

df = pd.read_csv("house_prices.csv")
average_price = df["price"].mean()

scikit-learn, "Machine Learning in Python": classification, regression, clustering, dimensionality reduction, model selection and preprocessing behind one consistent interface.¹⁶ The place to start, and enough for a great many business problems.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# features: a table of inputs, labels: the known answers
X_train, X_test, y_train, y_test = train_test_split(
    features, labels, test_size=0.2, random_state=42
)
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
predictions = model.predict(X_test)

TensorFlow, an end to end platform for building and deploying machine learning models.⁷ PyTorch, the other main deep learning framework, now governed by the PyTorch Foundation, hosted by the Linux Foundation.¹⁷

Keras, a high level interface for building neural networks. It used to be tied to TensorFlow. Since Keras 3 it runs on JAX, TensorFlow or PyTorch, chosen by a setting.¹⁸

import keras

# X_train, y_train: training inputs and integer class labels (0 to 9)
model = keras.Sequential([
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dense(10, activation="softmax"),
])
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
model.fit(X_train, y_train, epochs=10)

XGBoost, a gradient boosting library designed to be efficient, flexible and portable, and a strong choice for tables of business data.¹⁹

Hugging Face Transformers, a library of model definitions and pretrained models for text, vision, audio and more, for both training and inference.²⁰ spaCy for industrial strength natural language processing in Python.²¹

Where big data fits in

Modern machine learning and big data grew up together, so a word on how they relate.

The US National Institute of Standards and Technology (NIST) defines big data as extensive datasets, primarily in the characteristics of volume, velocity, variety and variability, that need a scalable architecture to store, manipulate and analyse them efficiently. Volume is the size, velocity the rate of flow, variety the mix of sources and types, and variability the change in rate or structure.²²

The relationship runs both ways. Deep learning in particular needs many examples to learn well. And once data runs to billions of rows, nobody can read it by eye, so you need algorithms to find the patterns. Tools such as Apache Spark, whose MLlib is described as "Apache Spark's scalable machine learning library", exist to train models on data spread across many machines.²³

One figure that gets repeated is that machine learning projects spend 80% of their time on data preparation. I could not find a primary source for it. The nearest survey I could verify, Anaconda's 2022 State of Data Science report, put data preparation and cleansing at 38% of data scientists' time, still the largest single share.²⁴ The point stands without the inflated number: cleaning and shaping the data is the bulk of the work, and training the model is often the easy part.

An example: the Waterford tea shop's 5,000 customers and 18,000 orders fit in one spreadsheet. That is not big data by any of the four characteristics, and it does not need Spark, yet it is plenty for the repeat purchase model above. Real machine learning, ordinary sized data.

How AI and machine learning work together

In practice, AI and machine learning are tightly woven, and most AI products are hybrids.

Take a typical voice assistant. Speech recognition turns audio into text, usually with a learned model. Language understanding works out what you meant, again usually learned. Dialogue management, deciding what to do next, can be hand written rules, learned, or both. Then a reply is generated and turned back into speech. The whole thing is AI in the broad sense, and most of its parts are machine learning.

A self driving system is similar. Perception (spotting lanes, signs and people) and prediction (what will that cyclist do) are learned. Planning often mixes learning with classic search and optimisation. Low level control may use traditional control engineering.

So the boundary blurs inside real systems. That makes the distinction the first question to ask about each part, not a useless one.

Worked example: taking apart a shop's chatbot

An invented homeware shop in Limerick runs a chatbot on harbourhome.example. It has three parts:

1. A language model reads the customer's question. Machine learning.
2. If the question is about an order, the bot looks up the order number in the database and reads out the status. Ordinary software.
3. Refunds over €100 always go to a person. A hand written rule.

One "AI chatbot", three different techniques. Part 1 can be wrong in fluent sentences, so it needs testing and limits. Parts 2 and 3 behave exactly as written. Asking which is which tells the owner where the risk actually sits.

Why the distinction still matters

If they are so intertwined, why bother?

Choosing the right approach. Not every problem needs machine learning. A rule based system is often faster to build, easier to maintain, less expensive to run and easier to explain. If you can solve it with a few if statements, you probably should. Machine learning earns its place when the patterns are too complex to write down, or change too often for rules to keep up.

The path reads from the top. The first question is about rules, because rules are the plainer tool. Only when they cannot be written, or will not stay put, does the second question about examples come in. The takeaway: machine learning is the answer to a specific situation, not the default.

Setting expectations. Neither AI nor machine learning is magic. Each has specific strengths and failure modes. Knowing which one you are buying prevents disappointment and wasted budget.

Understanding risk. A learned model inherits the biases of its training data. A rule based system carries the biases of whoever wrote the rules. The failures differ, so the checks should differ too.

Regulation. This one has teeth. As shown above, the EU AI Act defines AI by inference and its recitals exclude systems based solely on rules written by people.² Whether a tool is in scope can depend on how it works inside, not on what the brochure calls it. For the wider picture on using AI safely in a business, see AI in business: the options, the dangers and how to get it right.

Worked example: sorting three tools

An invented recruitment firm in Cork uses three tools and wants to know what each one is:

1. A form that rejects applications without a right to work answer. A written rule. Not machine learning, and likely outside the AI Act's definition.
2. A tool that ranks CVs by predicted fit, trained on past hires. Machine learning. It needs a bias check, because past hiring choices are baked into the labels, and it needs an explanation ready for the candidates it affects.
3. A chatbot that answers questions about the firm's opening hours from a fixed list. Rules dressed as conversation, unless it uses a language model, in which case part of it learns and can be wrong.

Three tools, all sold as "AI". Only one of them is clearly machine learning, and that one carries the most risk.

The questions that cut through the label

Artificial intelligence is the big picture: machines that do things we would call intelligent. It has been a field of study since the 1950s and covers many approaches.

Machine learning is one of those approaches: systems that learn patterns from data instead of following rules a person wrote. It has come to dominate because it works, because data is plentiful and because computing power has grown.

The two are used as synonyms because machine learning is now so central to AI. Next time someone says "AI", ask four questions:

1. Is it learning from data, or following rules someone wrote?
2. If it learns, what data, and how current is it?
3. How was it tested on cases it had not seen?
4. When it is wrong, how would anyone know, and who can explain the decision?

Those questions cut through the hype and get to what is actually happening under the bonnet. And that matters, because these systems increasingly decide what we see online, whether a loan is approved and which CV gets read.

Footnotes

1. Ian Goodfellow, Yoshua Bengio and Aaron Courville, Deep Learning, MIT Press, 2016, chapter 1, https://www.deeplearningbook.org/

2. Regulation (EU) 2024/1689 (Artificial Intelligence Act), Article 3(1) and Recital 12, Official Journal of the European Union, 12 July 2024, EUR-Lex, https://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri=OJ:L_202401689

3. Stuart Russell, Karine Perset and Marko Grobelnik, Updates to the OECD's definition of an AI system explained, OECD.AI, 29 November 2023, https://oecd.ai/en/wonk/ai-system-definition-update

4. Stuart Russell and Peter Norvig, Artificial Intelligence: A Modern Approach, 4th edition, Global Edition, Pearson, 2024, https://www.pearson.com/en-gb/subject-catalog/p/artificial-intelligence-a-modern-approach-global-edition/P200000004498/9781292401133

5. A. M. Turing, Computing Machinery and Intelligence, Mind, volume LIX, issue 236, pages 433 to 460, October 1950, https://academic.oup.com/mind/article/LIX/236/433/986238

6. J. McCarthy, M. L. Minsky, N. Rochester and C. E. Shannon, A Proposal for the Dartmouth Summer Research Project on Artificial Intelligence, 31 August 1955, https://www-formal.stanford.edu/jmc/history/dartmouth/dartmouth.html

7. TensorFlow, Why TensorFlow, accessed November 2026, https://www.tensorflow.org/about

8. Google DeepMind, AlphaGo, accessed November 2026, https://deepmind.google/research/breakthroughs/alphago/

9. OpenAI, GPT-4 Technical Report, arXiv:2303.08774, 2023, https://arxiv.org/abs/2303.08774

10. Regulation (EU) 2016/679 (General Data Protection Regulation), Articles 13(2)(f), 15(1)(h) and 22(1), Official Journal of the European Union, 4 May 2016, EUR-Lex, https://eur-lex.europa.eu/legal-content/EN/TXT/HTML/?uri=CELEX:32016R0679

11. Data Protection Commission, AI, Large Language Models and Data Protection, DPC, 18 July 2024, https://www.dataprotection.ie/en/dpc-guidance/blogs/AI-LLMs-and-Data-Protection

12. Ian J. Goodfellow, Jonathon Shlens and Christian Szegedy, Explaining and Harnessing Adversarial Examples, arXiv:1412.6572, 2014, figure 1, https://arxiv.org/abs/1412.6572

13. Ashish Vaswani and others, Attention Is All You Need, arXiv:1706.03762, 2017, https://arxiv.org/abs/1706.03762

14. NumPy, project home page, accessed November 2026, https://numpy.org/

15. pandas, project home page, accessed November 2026, https://pandas.pydata.org/

16. scikit-learn, Machine Learning in Python, accessed November 2026, https://scikit-learn.org/stable/

17. PyTorch Foundation, About the PyTorch Foundation, accessed November 2026, https://pytorch.org/foundation/

18. Keras, Introducing Keras 3, accessed November 2026, https://keras.io/keras_3/

19. XGBoost documentation, accessed November 2026, https://xgboost.readthedocs.io/en/stable/

20. Hugging Face, Transformers documentation, accessed November 2026, https://huggingface.co/docs/transformers/index

21. spaCy, Industrial-strength Natural Language Processing in Python, accessed November 2026, https://spacy.io/

22. Wo L. Chang and Nancy Grady, NIST Big Data Interoperability Framework: Volume 1, Definitions, NIST Special Publication 1500-1r2, Version 3, October 2019, https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.1500-1r2.pdf

23. Apache Spark, MLlib, accessed November 2026, https://spark.apache.org/mllib/

24. Sean Michael Kerner, What are data scientists' biggest concerns? The 2022 State of Data Science report has the answers, VentureBeat, 14 September 2022, https://venturebeat.com/ai/what-are-data-scientists-biggest-concerns-the-2022-state-of-data-science-report-has-the-answers