DEV Community: Oluwafemi Paul Adeyemi

Why Your Machine Learning Model Performs Well but Fails in Production

Oluwafemi Paul Adeyemi — Mon, 07 Sep 2026 18:03:01 +0000

A machine learning model can achieve 95% accuracy during development and still perform terribly after deployment. This is one of the frustrating realities of machine learning.

You train the model, evaluate it on your test set, see impressive results, and think the hard part is over. Then real users start interacting with it. The predictions become less accurate. Why? Because a model is not trained on “the real world.” It is trained on the data you gave it. And those two things are not always the same. In essence, a machine learning model is an abstraction of reality.

What follows are some reasons why well-performing models may still fail in production.

1. Your training data does not represent production

Suppose you build a model to predict whether a transaction is fraudulent. Your training data might look like this:

Amount	Country	Device	Fraud
500	Nigeria	Mobile	0
1,200	Nigeria	Web	0
9,000	Nigeria	Mobile	1
...	...	...	...

If most of your historical transactions came from mobile users, the model may learn patterns that work particularly well for mobile transactions. But after deployment, suppose the company starts receiving many more transactions from web users. The distribution of the input data has changed. Your model has not suddenly become worse at mathematics. The world it is seeing has changed. This is commonly described as data drift or, more broadly, distribution shift ^[1].

2. Your test set may be too similar to your training data

A model can perform extremely well when the test data resembles the training data too closely. Consider a dataset containing customer records from 2024 and 2025. If you randomly split the entire dataset into training and test sets, records from both years may appear in both sets.

That might be appropriate for some problems. But suppose customer behaviour changes over time. A model trained on randomly mixed historical data may look excellent during evaluation while struggling when asked to predict behaviour in 2026.

For time-dependent problems, how you split the data matters. Sometimes a chronological split is more realistic:

Training: January 2024 – December 2025
Testing: January 2026 – March 2026

The goal is not simply to obtain a high test score. The goal is to create an evaluation that resembles how the model will actually be used.

3. Your preprocessing may not be the same

Imagine that you standardize numerical variables before training. During development, you calculate the mean and standard deviation from the training data. But when the model is deployed, someone implements the preprocessing differently. Perhaps a column is scaled incorrectly. Perhaps missing values are handled differently. Perhaps a categorical variable is encoded using a different mapping. The model itself has not changed. The data entering the model has. This is why preprocessing should normally be treated as part of the machine learning pipeline rather than as a collection of disconnected steps.

With Scikit-Learn, for example, you can combine preprocessing and modelling:

from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("model", model)
])

The pipeline helps ensure that the same transformations are applied consistently.

4. The target can change

Sometimes the problem is not the input data. The meaning of the target variable changes. Imagine a model predicting whether a customer will default on a loan. If the company changes its definition of “default,” historical labels and future labels may no longer represent exactly the same thing. The model is still solving the problem it was trained to solve. But the problem itself has changed. This is sometimes referred to as concept drift ^[2].

5. Production has problems your notebook does not

A model in a notebook only needs to produce predictions. A production system has other requirements. It may need to:

respond quickly;
handle thousands of requests;
deal with missing or unexpected values;
work with changing databases;
maintain consistent preprocessing;
log predictions;
monitor performance.

A model with excellent accuracy but unacceptable response time may still be a failed production system. Machine learning in production is therefore not just about the model. It is about the system surrounding the model.

Summary of the shifts and failures

Reason	What changed?	Drift / Shift classification
1. Training data does not represent production	The distribution of production inputs differs from training data	Data drift / Distribution shift
2. Test set is too similar to training data	Evaluation data does not adequately represent the future/production distribution	Temporal distribution shift (potentially data drift in production)
3. Preprocessing is not the same	The transformation/representation of features changes between training and production	Preprocessing mismatch (can create an input distribution shift)
4. The target changes	The relationship between features and target, or the meaning/distribution of the target, changes	Concept drift
5. Production has problems your notebook does not	System conditions change: latency, missing values, unexpected inputs, infrastructure, etc.	Not necessarily drift/shift — production/system failure

The bigger lesson

A good test score answers a relatively narrow question:

“How well does this model perform on this evaluation data?”

Production asks a much harder question:

“How well does this entire system continue to perform when the real world starts changing?”

That is why a model can have excellent accuracy, precision, recall, or R² during development and still fail after deployment. The solution is not necessarily a more sophisticated algorithm. Sometimes the real problem is data drift, leakage, an unrealistic evaluation strategy, inconsistent preprocessing, changing targets, or poor system design.

The model is only one component. A machine learning model succeeds in production when the assumptions made during development continue to hold when the model meets reality.

References

SQL Window Functions Explained

Oluwafemi Paul Adeyemi — Mon, 07 Sep 2026 17:05:19 +0000

SQL becomes particularly interesting when you stop asking only, “What is the total?” and start asking questions like:

What is each salesperson's total while still seeing every sale?
How does this sale compare with the previous one?
What is this customer's rank within their group?
How much have we sold so far?

These questions are difficult to answer neatly with ordinary aggregation. This is where SQL window functions come in.

The idea behind a window function

Consider a simple "sales" table:

salesperson	sale_date	amount
Alice	2026-01-01	500
Alice	2026-01-03	800
Alice	2026-01-05	300
Bob	2026-01-01	700
Bob	2026-01-04	400

Suppose we want the total sales for each salesperson.

With "GROUP BY":

SELECT
    salesperson,
    SUM(amount) AS total_sales
FROM sales
GROUP BY salesperson;

Output:

salesperson	total_sales
Alice	1,600
Bob	1,100

We get one row per salesperson. That is useful, but something has been lost: the individual transactions.

A window function allows us to calculate across related rows without collapsing those rows. Consider this:

SELECT
    salesperson,
    sale_date,
    amount,
    SUM(amount) OVER (
        PARTITION BY salesperson
    ) AS total_sales
FROM sales;

Output:

salesperson	sale_date	amount	total_sales
Alice	2026-01-01	500	1,600
Alice	2026-01-03	800	1,600
Alice	2026-01-05	300	1,600
Bob	2026-01-01	700	1,100
Bob	2026-01-04	400	1,100

Now every transaction remains visible, but each row also knows the salesperson's total. That is the fundamental idea. GROUP BY reduces rows. Window functions calculate across rows while keeping them.

What does "PARTITION BY" mean?

"PARTITION BY" defines the group of rows over which the calculation operates.

In:

SUM(amount) OVER (
    PARTITION BY salesperson
)

Alice's sales form one window and Bob's sales form another.

It is similar to saying:

“Perform this calculation separately for each salesperson, but do not combine their records into one row.”

You can think of "PARTITION BY" as “divide the data into groups for the calculation.”

What does "ORDER BY" do?

Now suppose the manager wants to know how much each salesperson has sold up to each transaction.

SELECT
    salesperson,
    sale_date,
    amount,
    SUM(amount) OVER (
        PARTITION BY salesperson
        ORDER BY sale_date
    ) AS running_total
FROM sales;

For Alice, the results would conceptually become:

sale_date	amount	running_total
Jan 1	500	500
Jan 3	800	1,300
Jan 5	300	1,600

Here, "ORDER BY" matters because the calculation depends on sequence. Without an ordering, “running total” has no meaningful direction.

Looking at the previous row with "LAG()"

Sometimes we do not need a total. We want to compare the current value with an earlier value. For example, how much did Alice's latest sale change from her previous sale?

SELECT
    salesperson,
    sale_date,
    amount,
    LAG(amount) OVER (
        PARTITION BY salesperson
        ORDER BY sale_date
    ) AS previous_sale
FROM sales;

Output:

salesperson	sale_date	amount	previous_sale
Alice	2026-01-01	500	NULL
Alice	2026-01-03	800	500
Alice	2026-01-05	300	800
Bob	2026-01-01	700	NULL
Bob	2026-01-04	400	700

The first sale for each salesperson has no previous sale, so "LAG()" returns "NULL". This is very useful for questions involving change over time.

You can similarly use "LEAD()" when you want to look forward rather than backward.

Ranking rows

Window functions are also useful for ranking.

SELECT
    salesperson,
    sale_date,
    amount,
    RANK() OVER (
        PARTITION BY salesperson
        ORDER BY amount DESC
    ) AS sale_rank
FROM sales;

Output:

salesperson	sale_date	amount	sale_rank
Alice	2026-01-03	800	1
Alice	2026-01-01	500	2
Alice	2026-01-05	300	3
Bob	2026-01-01	700	1
Bob	2026-01-04	400	2

This ranks each salesperson's transactions from largest to smallest.

There are several ranking functions, including "RANK()", "DENSE_RANK()", and "ROW_NUMBER()". They differ mainly in how they handle ties.

You do not need to memorize all of them immediately. The important idea is that ranking can happen within a window without removing the underlying rows.

Why this matters beyond SQL

Window functions are not just a reporting trick.

For data analysts and machine learning practitioners, they can be useful when creating features such as:

previous transaction amount
number of previous transactions
cumulative customer spending
transaction rank
change from previous observation

For example, "LAG()" can help create a feature representing a customer's previous purchase amount.

But there is an important warning: time-dependent features can cause data leakage if future information accidentally enters the training data.

The fact that SQL can calculate something does not mean it is appropriate for a machine learning model.

The mental model

When you see:

FUNCTION(...) OVER (...)

ask three questions:

What function am I applying?
"SUM", "AVG", "LAG", "RANK", etc.
What rows belong together?
That's usually "PARTITION BY".
Does the order of those rows matter?
If it does, use "ORDER BY".

That's most of the mental model you need to start.

You do not have to master every window function to understand why they are powerful.

The key is simple:

A window function lets SQL look across related rows without losing sight of the current row.

Once that idea clicks, functions such as "SUM() OVER()", "LAG()", "RANK()", and "ROW_NUMBER()" stop looking like mysterious SQL syntax and start looking like different ways of asking questions about a row's context.

Save Our Developers and Engineers — AI Is Stealing Our Jobs

Oluwafemi Paul Adeyemi — Sat, 05 Sep 2026 21:20:21 +0000

Peter was an ML engineer.

For two years, he had worked hard, solved problems, written code, built models, deployed systems, and earned a comfortable living. Like many engineers, he believed his skills had value because what he did required years of learning and experience.

Then his boss discovered an enterprise AI data scientist designed to execute end-to-end ML pipelines.

At first it seemed harmless. Another AI assistant. Another productivity tool. But the more his boss used it, the more he discovered what it could do.

Peter was not immediately worried. After all, engineering was more than writing code.

Or so he thought.

One morning, Peter arrived at work as usual. He greeted the secretary, sat at his desk, and prepared to begin another day.

A few minutes later, the secretary walked toward him with an envelope.

It was a letter.

Peter opened it.

His employment had been terminated.

The reason was painfully simple:

“The machines can now do your work.”

Two years of service had been reduced to a sentence.

The company had not asked what would happen to Peter. It had calculated what Peter's salary cost and what the machine could accomplish for less.

And that is the uncomfortable reality of automation: companies do not experience technological progress emotionally. People do.

Consider something as simple as this:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestRegressor

model = Pipeline([
    ("scaler", StandardScaler()),
    ("regressor", RandomForestRegressor(n_estimators=200))
])

model.fit(X_train, y_train)
predictions = model.predict(X_test)

An AI system can generate code like this in seconds.

But engineering has never been merely about producing lines of code.

Why should the data be standardized? Is there data leakage? Is a random forest appropriate? How should the model be evaluated? What happens when the data distribution changes? Where should the model be deployed? How will failures be detected? Who is responsible when the model produces a wrong prediction?

Even this tiny function looks trivial:

def predict(model, data):
    return model.predict(data)

But what happens when the model begins to drift?

What happens when the input data changes?

What happens when the model confidently produces the wrong answer?

Generating code is not the same as engineering a reliable system.

Yet AI is already moving upward through the software-development ladder.

It generates snippets, functions, modules, tests, documentation, applications, and infrastructure configurations. Increasingly, it can also coordinate these pieces to help construct much larger systems.

That is where the fear comes from.

Automation does not necessarily eliminate an entire profession at once. It eats away at its layers.

A developer who once spent hours writing a function is now spending minutes reviewing AI-generated code. A team that once needed ten engineers for a particular project is now discovering that five can accomplish much of the same work with AI assistance.

And management is already asking the question Peter's boss asked:

Why do we need as many engineers as before?

The problem is even more serious for junior developers.

Entry-level engineers traditionally learned by doing the small tasks that experienced engineers considered repetitive: writing simple functions, fixing minor bugs, creating tests, preparing documentation, and building small applications.

Those are precisely the tasks AI is increasingly good at performing.

The beginner's work is therefore becoming automated before the beginner has had enough time to turn that work into experience.

This creates a troubling contradiction:

Companies want experienced engineers, while automation is reducing some of the opportunities through which engineers gain experience.

Peter understood this only after losing his job.

At first, he was angry. Then he became afraid. Eventually, he realized that fighting AI itself would not bring his job back.

So he adapted.

Peter was already educated. He did not need to start his career from scratch. He needed to redirect what he already knew.

He began learning about large language models, retrieval-augmented generation, AI agents, cloud infrastructure, model serving, AI security, monitoring, and the engineering systems surrounding AI.

He stopped thinking only about how to build a model.

He started learning how to build, deploy, manage, evaluate, secure, and understand AI systems.

He also learned to use AI as part of his own engineering workflow.

That distinction changed everything.

AI can generate.

Peter learned to judge.

AI can suggest an architecture.

Peter learned to determine whether that architecture actually makes sense.

AI can write a model.

Peter learned to understand its assumptions, limitations, failures, and consequences.

He was no longer trying to compete with AI at the tasks AI performed best. He was learning how to work above, around, and alongside those capabilities.

And that gave him something new to offer.

Peter began looking for organizations that needed engineers who could do more than write code—people who could integrate AI into real systems, deploy and monitor those systems, evaluate their outputs, manage their infrastructure, identify their weaknesses, and take responsibility for how they operated.

He eventually found another organization.

The job was different.

Peter was different too.

He had not defeated AI.

He had learned where he could remain valuable in an economy increasingly shaped by it.

That is perhaps the most realistic path for engineers facing automation.

Not pretending that AI cannot replace parts of their work.

Not refusing to use it.

Not simply becoming faster at doing what machines are already becoming good at.

But learning new capabilities, redirecting existing expertise, using AI to multiply their productivity, and finding where those capabilities are needed.

AI is powerful. Pretending otherwise would be foolish.

But perhaps the greater danger is not that AI destroys engineering.

The greater danger is that we allow automation to make us believe that an engineer's value is nothing more than the tasks they currently perform.

Peter lost his old job.

But he did not lose his knowledge, his experience, his ability to reason, or his ability to learn.

His old role disappeared.

His career did not have to.

For every job displaced by AI, there is a Peter who gets laid off. But for every Peter, there is also hope—even in a world where AI is changing the meaning of work.

When the Algorithm Stays the Same but the Code Changes

Oluwafemi Paul Adeyemi — Thu, 03 Sep 2026 21:44:20 +0000

A machine learning algorithm does not belong to a programming language.

Linear regression is still linear regression whether it is implemented in Python, R, JavaScript, or another language. Yet the code used to implement it can look remarkably different.

Why?

The answer lies in the distinction between an algorithm and its implementation. An algorithm describes the procedure or mathematical steps used to solve a problem, while an implementation is the way those steps are translated into instructions that a particular programming language and its libraries can execute. The algorithm therefore represents the underlying idea, whereas the implementation represents one way of putting that idea into practice.

The Algorithm

Consider a simple linear regression model:

y = β₀ + β₁x + ε

The objective is to estimate the parameters β₀ and β₁ so that the model can describe the relationship between the predictor and the response. That mathematical structure does not change because we change programming languages. What changes is how we express the algorithm in code.

The Implementation

In Python, using Scikit-learn:

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(X, y)

predictions = model.predict(X)

In R, the same idea can be expressed using the built-in "lm()" function:

model <- lm(y ~ x, data = data)

predictions <- predict(model)

The syntax is clearly different.

Python uses an object and calls "fit()" and "predict()". R uses a formula interface and the "lm()" function. Yet both are implementing the same fundamental statistical idea: estimating a linear relationship between variables and using that relationship for prediction.

JavaScript can express the same concept through a machine learning library as well:

const model = new LinearRegression();

await model.fit(X, y);

const predictions = model.predict(X);

Once again, the code changes, but the underlying algorithm does not.

What Actually Changes?

When an algorithm crosses programming-language boundaries, several things may change. First is syntax. Each language has its own grammar and conventions. Second is the API. One library may use "fit()" while another uses a different function or method. Third is the data structure. Python may use NumPy arrays, R may use vectors and data frames, while JavaScript may use arrays or typed arrays.

Fourth is the workflow. Libraries can make different design choices about how models are created, trained, evaluated, and used. These differences can make the same algorithm appear unfamiliar when encountered in another language.

What Does Not Change?

The more important question is what remains unchanged. The mathematical formulation remains the same. The statistical objective remains the same. The basic interpretation of the model remains the same.

Changing from Python to R does not transform linear regression into another statistical method. The programming language provides a different way of expressing and using the method. This distinction is important for anyone working across programming-language ecosystems.

If you learn only the API of a particular library, changing languages can feel like starting again. But if you understand the algorithm, its mathematics, its assumptions, and what its outputs mean, learning another implementation becomes much easier.

The code may change its language, syntax, and workflow. The algorithm, however, remains the same. That is the difference between learning a machine learning library and learning machine learning itself.

The Queen of Computer Vision and Her Kingdoms

Oluwafemi Paul Adeyemi — Thu, 03 Sep 2026 20:44:09 +0000

Once upon a time, in the Universe of Machine Learning, on the planet of Computer Vision, there lived a powerful queen named OpenCV.

Her royal palace stood in the Kingdom of C++, where she had ruled for many years. Her court was magnificent: image processing, object detection, feature extraction, video analysis, and many other capabilities surrounded her.

News of the Queen’s benevolence eventually reached three neighbouring kingdoms: Python, R, and JavaScript.

Their citizens desired the benefits of her rule, but there was a problem: the Queen spoke C++.

Python therefore sent an ambassador to the royal court. The ambassador returned with "cv2", allowing OpenCV’s rule to extend into Python territory.

R followed, sending its own emissaries to the Queen’s court. They returned with OpenCV bindings, allowing her capabilities to be accessed from R.

JavaScript also sent emissaries, who returned with OpenCV.js, allowing the Queen to extend her rule into JavaScript territory.

Hence, the Queen’s rule extended beyond the Kingdom of C++, reaching the kingdoms of Python, R, and JavaScript.

Of course, that was merely the medieval version of the story. More seriously, there is an important lesson here: your OpenCV knowledge is transferable.

Once you have learned OpenCV in one language, moving to another does not mean learning Computer Vision from the beginning. The syntax and interfaces may differ, but many of the underlying concepts and operations remain familiar.

Let’s take a look.

OpenCV in Python and R

Suppose we want to read an image and convert it to grayscale.

In C++:

#include <opencv2/opencv.hpp>

int main() {
    cv::Mat image = cv::imread("image.jpg");
    cv::Mat gray;

    cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);

    return 0;
}

In Python:

import cv2

image = cv2.imread("image.jpg")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

In R, the OpenCV package provides an interface to OpenCV:

library(opencv)

image <- ocv_read("image.jpg")
gray <- ocv_gray(image)

The syntax is different, but the task remains the same: read the image and convert it to grayscale.

OpenCV in JavaScript

JavaScript has OpenCV.js, which brings OpenCV to JavaScript applications and the browser.

A similar operation can be performed with the following HTML and JavaScript:

<script async src="opencv.js" type="text/javascript"></script>

let image = cv.imread("image");
let gray = new cv.Mat();

cv.cvtColor(image, gray, cv.COLOR_RGBA2GRAY);

Again, several things are immediately familiar if you already know OpenCV: "imread()", "cvtColor()", and the colour-conversion constants.

Moreover, a number of other kingdoms eventually benefited from the Queen’s rule as well. They include Java, MATLAB, and C#, through various bindings, interfaces, and wrappers that make OpenCV accessible from these languages.

The Queen’s influence, therefore, extends far beyond her original Kingdom of C++.
The same principle applies to many other operations, including resizing, thresholding, filtering, edge detection, and contours.

So, if you have learned OpenCV in one of these languages, changing languages does not necessarily mean beginning your Computer Vision journey again.

The Queen may extend her rule across different kingdoms, but learning her ways in one kingdom gives you a head start in another.

Skrub: A Python Library for Machine Learning with Messy Data

Oluwafemi Paul Adeyemi — Tue, 01 Sep 2026 10:37:40 +0000

When working with machine learning, we often spend more time preparing data than training models. This becomes particularly frustrating when a dataset contains high-cardinality categorical variables, inconsistent strings, or information spread across multiple tables.

Skrub is a relatively lesser-known Python library that tackles exactly this part of the machine-learning workflow.

Install it with:

pip install skrub

Skrub works alongside familiar libraries such as pandas and scikit-learn. Its focus is not on providing another collection of machine-learning algorithms, but on making tabular data easier to represent and use in ML pipelines.

Handling difficult categorical variables

Consider a dataset containing:

company
-------------------------
Microsoft
Microsoft Corp
Microsoft Corporation
MICROSOFT

A conventional categorical encoder can treat these as four unrelated categories. However, the strings contain useful similarities.

Skrub provides "MinHashEncoder", which can transform strings into a fixed-size numerical representation based on their character-level similarities:

from skrub import MinHashEncoder

encoder = MinHashEncoder(n_components=10)

X_encoded = encoder.fit_transform(
    df[["company"]]
)

This can be useful when categorical variables contain many unique values or variations caused by spelling, formatting, abbreviations, or inconsistent data entry.

What about thousands of categories?

Suppose a dataset contains 100,000 product names. One-hot encoding could potentially create an extremely large feature matrix.

Skrub provides alternatives such as "MinHashEncoder" and "GapEncoder". "GapEncoder" is particularly interesting because it can discover latent patterns in categorical strings instead of simply assigning a separate representation to every category.

For example, occupations such as "Data Scientist", "Data Analyst", "Software Engineer", and "Financial Analyst" contain textual patterns that ordinary one-hot encoding does not exploit.

from skrub import GapEncoder

encoder = GapEncoder(n_components=10)

X_encoded = encoder.fit_transform(
    df[["occupation"]]
)

Working with multiple tables

Real-world data is also rarely contained in one clean dataframe. A project may have separate customer, transaction, product, and payment tables.

Skrub includes tools such as "Joiner" and "AggJoiner" for constructing useful features from related tables. This makes it interesting for database-heavy machine-learning projects where feature engineering involves aggregating information across relationships rather than simply transforming individual columns.

Why not just use scikit-learn?

You can—and you probably should.

Skrub is designed to complement the scikit-learn ecosystem rather than replace it. You can use Skrub to prepare or represent difficult tabular data and then pass the resulting features into familiar scikit-learn estimators.

That makes the workflow quite natural:

from sklearn.ensemble import RandomForestRegressor
from skrub import MinHashEncoder

encoder = MinHashEncoder(n_components=20)

X_train_encoded = encoder.fit_transform(
    X_train[["company"]]
)

model = RandomForestRegressor(
    random_state=42
)

model.fit(X_train_encoded, y_train)

The important idea is that feature representation is part of machine learning. A sophisticated model cannot compensate for every weakness in the way raw information is represented.

When is Skrub worth trying?

Skrub is particularly interesting when your data contains:

high-cardinality categorical variables;
messy or inconsistent strings;
company, product, customer, or occupation names;
several related tables;
mixed-type tabular data; or
preprocessing that is becoming difficult to manage with standard encoders.

It is not a replacement for pandas, NumPy, or scikit-learn. Instead, it fills a more specialized gap: turning difficult real-world tables into representations that machine-learning models can work with.

That makes Skrub a useful library to know—even if it isn't yet one of the names that immediately comes to mind when someone says "Python machine learning."

Have you used Skrub in a machine-learning project?

The Numerical Siblings: NumPy and Numba — Different Lives

Oluwafemi Paul Adeyemi — Tue, 01 Sep 2026 10:03:41 +0000

If you work with Python for data science, statistics, machine learning, or scientific computing, you will likely encounter NumPy. But you may not have heard of Numba.

I once developed an algorithm for a descriptor and expected it to run faster than some existing descriptors. Surprisingly, it was actually slower, even though the implementation already made extensive use of NumPy's vectorized operations. I decided to investigate why, and the problem soon became clear: the algorithm performed a large number of repeated numerical operations within loops. Although the individual NumPy operations were optimized, repeatedly calling them from Python introduced considerable overhead, especially as the number of iterations increased. Then I discovered Numba. By using Numba to compile the computationally intensive portions of the algorithm, I was able to reduce much of this overhead, and the same algorithm subsequently became considerably faster. That experience made me curious about the relationship between NumPy and Numba and why they can produce such different performance outcomes.

The names sound remarkably similar, and both are used in numerical computing. So, are NumPy and Numba competing tools? Not at all. Like siblings, they have different roles and live different lives, but their differences are precisely what makes them complementary. NumPy excels at numerical and array operations, while Numba focuses on accelerating computationally intensive Python code.

NumPy

NumPy is a fundamental package for scientific computing in Python. It provides a powerful multidimensional array object, together with a broad collection of routines for efficient numerical operations, including mathematical and logical computations, array reshaping and manipulation, sorting and selection, input and output, discrete Fourier transforms, linear algebra, statistical operations, random simulation, and much more (NumPy Developers, n.d.). Consider a simple use case of NumPy involving a function that accepts a NumPy array and calculates the product of all its elements:

import numpy as np

array = np.array([[2, 3, 4],
                  [5, 6, 7]])

def product_2d(array):
    return np.prod(array)

Numba

Numba, on the other hand, is a Python compiler designed for numerical and array-based functions, allowing computationally intensive applications to be accelerated while keeping the code in Python. It uses the Low Level Virtual Machine (LLVM) compiler infrastructure to generate optimized machine code from Python code. With a few simple annotations, numerical and array-oriented programs can be Just-In-Time (JIT) compiled to achieve performance comparable to code written in C, C++, and Fortran, without requiring a switch to another programming language or Python interpreter (Numba Developers, n.d.).

Numba's key features include on-the-fly generation of machine code, support for both CPU and GPU hardware, and integration with the Python scientific-computing ecosystem through NumPy (Numba Developers, n.d.). A simple example of a Numba-optimized version of the code written earlier is shown below:

import numba

array = np.array([[2, 3, 4],
                  [5, 6, 7]])

@numba.jit
def product_2d(array):
    a, b = array.shape
    product = 1.0

    for i in range(a):
        for j in range(b):
            product *= array[i, j]

    return product

Here, the function retains the familiar Python loop structure, while Numba can compile the numerical operations into optimized machine code. Although no immediate advantage is evident here, using Numba can provide substantial performance improvements when the function involves computationally intensive loops.

Integrating NumPy and Numba

Numba comes in handy when an algorithm requires several custom calculations for each element, involves applying different conditions, updating multiple quantities, or interacting with neighbouring elements. This becomes particularly useful when such operations are repeated over large arrays. For example, consider an operation that repeatedly applies a mathematical transformation to every element of an array.

import numpy as np

array = np.random.rand(1_000_000)

def numpy_version(array):
    result = array.copy()

    for _ in range(10):
        result = np.sin(result) + np.sqrt(result)

    return result

The NumPy implementation is vectorized, but each iteration creates intermediate arrays for the different operations. When the array is very large and the operation is repeated many times, this can increase memory usage and memory traffic. However, Numba could be used to solve this problem.

import numpy as np
import numba

array = np.random.rand(1_000_000)

@numba.njit
def numba_version(array):
    result = array.copy()

    for _ in range(10):
        for i in range(len(result)):
            result[i] = np.sin(result[i]) + np.sqrt(result[i])

    return result

Here, Numba compiles the loops into machine code. Instead of repeatedly constructing intermediate arrays for the vectorized operations, the computation can be performed element by element within the compiled loop.

References

Numba Developers. (n.d.). Overview — Numba 0.64.0dev0 documentation. https://numba.pydata.org/numba-doc/dev/user/overview.html

NumPy Developers. (n.d.). NumPy documentation. https://numpy.org/doc/stable/

Ensemble Models: A Comprehensive Overview

Oluwafemi Paul Adeyemi — Fri, 11 Jul 2025 04:08:27 +0000

Ensemble models are a class of machine learning algorithms that combine the predictions of multiple base models to improve overall performance and robustness. By leveraging the strengths of individual models, ensemble methods can often achieve better results than any single model.

Types of Ensemble Models

Bagging: Bagging involves training multiple instances of the same model on different subsets of the training data. The final prediction is typically made by averaging or voting the predictions of individual models.
Boosting: Boosting involves training models sequentially, with each subsequent model focusing on the errors of the previous model. The final prediction is made by combining the predictions of individual models.
Stacking: Stacking involves training a meta-model to make predictions based on the predictions of multiple base models.

Benefits of Ensemble Models

Improved accuracy: Ensemble models can often achieve better performance than individual models by reducing overfitting and improving generalization.
Robustness: Ensemble models can be more robust to outliers and noisy data by averaging out the predictions of individual models.
Handling complex data: Ensemble models can handle complex data by combining the strengths of individual models.

Popular Ensemble Algorithms

Random Forest: A bagging-based ensemble algorithm that combines multiple decision trees to improve performance and robustness.
Gradient Boosting Machines (GBM): A boosting-based ensemble algorithm that combines multiple weak models to create a strong predictive model.
AdaBoost: A boosting-based ensemble algorithm that combines multiple weak models to create a strong predictive model.

Applications of Ensemble Models

Classification: Ensemble models can be used for classification tasks, such as image classification, text classification, and sentiment analysis.
Regression: Ensemble models can be used for regression tasks, such as predicting continuous outcomes.
Feature selection: Ensemble models can be used for feature selection by evaluating the importance of individual features.

Challenges and Limitations

Computational complexity: Ensemble models can be computationally expensive to train and evaluate.
Overfitting: Ensemble models can suffer from overfitting if the individual models are overfitting to the training data.
Interpretability: Ensemble models can be difficult to interpret due to the complexity of the individual models and the ensemble structure.

Example Python Code

Import necessary libraries
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

#Generate a sample classification dataset
X, y = make_classification(n_samples=1000, n_features=20, n_informative=15, n_redundant=3, random_state=42)

#Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

#Define individual models
model1 = LogisticRegression()
model2 = RandomForestClassifier()
model3 = SVC(probability=True)

#Create an ensemble model using VotingClassifier
ensemble = VotingClassifier(estimators=[('lr', model1), ('rf', model2), ('svm', model3)])

#Train individual models and the ensemble model
model1.fit(X_train, y_train)
model2.fit(X_train, y_train)
model3.fit(X_train, y_train)
ensemble.fit(X_train, y_train)

#Make predictions using individual models and the ensemble model
y_pred1 = model1.predict(X_test)
y_pred2 = model2.predict(X_test)
y_pred3 = model3.predict(X_test)
y_pred_ensemble = ensemble.predict(X_test)

#Evaluate the performance of individual models and the ensemble model
print("Accuracy of Logistic Regression:", accuracy_score(y_test, y_pred1))
print("Accuracy of Random Forest:", accuracy_score(y_test, y_pred2))
print("Accuracy of SVM:", accuracy_score(y_test, y_pred3))
print("Accuracy of Ensemble Model

:", accuracy_score(y_test, y_pred_ensemble))

This code demonstrates the use of ensemble models by combining the predictions of logistic regression, random forest, and support vector machine (SVM) models. The ensemble model is created using the VotingClassifier class from scikit-learn, which combines the predictions of individual models using voting.

Best Practices

Choose the right ensemble method: Select an ensemble method that is suitable for the problem and data.
Select diverse base models: Select base models that are diverse and complementary to improve the performance of the ensemble.
Tune hyperparameters: Tune the hyperparameters of individual models and the ensemble structure to optimize performance.

By following these best practices and understanding the benefits and limitations of ensemble models, practitioners can effectively use ensemble methods to improve the performance and robustness of their machine learning models.

Unsupervised Learning

Oluwafemi Paul Adeyemi — Sat, 27 Jul 2024 00:03:47 +0000

Unsupervised Learning involves a set of algorithm that are used to learn patterns from a data without targets (labels). Unsupervised Learning does not require that each that data point in the dataset be This is Contrarily to Supervised Learning that requires that each data point should have a label, which means that the dataset consists of features and targets.
Basically, in unsupervised learning, the features are not labelled. That means that there is no target to be predicted and there is an interest in finding some patterns in the features. Fundamentally, unsupervised learning involves clustering or dimension reduction. However, there are five types of unsupervised learning. Dridi ^[1] discussed four types of task that can be carried out in unsupervised learning which include: Clustering, association, anomaly detection and autoencoders. But on examination, principal component analysis (pca) and autoencoders are only some approach to carrying out dimensionality reduction which is a task that can be carried out using unsupervised learning:

Clustering

The interest is to put the unlabeled data into categories called clusters, such that objects (data points) in a cluster are more similar than objects in other clusters. A cluster is thus, a collection of objects (data points) with similar characteristics, such objects in these collection are dissimilar to objects in other collections. The types of clustering are: partition, hierarchical, overlapping (fuzzy set) and probabilistic clustering.
a. Partition: Here, an object can belong to one and only one cluster
b. Hierarchical: starts with all the data points as a separate cluster (which means that if the dataset has 1000 data points, then we initially will have 1000 clusters) and then ends with fewer number of clusters, iteratively by taking points that are close by, until the required number of clusters is reached.
c. Overlapping: Each datapoint can belong to two or more clusters with some degree of membership to each cluster.
d. Probabilistic: This method uses some probability to assign data points to clusters.

Types of partitioning clusters

K-means: this algorithm divides a group of data points into non-overlapping clusters using centroids. With an assumption that the clusters are of equal sizes, the joint distribution of features have equal variance, and that there are independent features with similar cluster density^[2]. Basically, K-centroids are chosen and points that are close to each centroid are put in a cluster with the centroid. The measure of closeness is determined by some measure of distance between points, such as the Euclidean distance. Then these two steps written below follow: (a) A new centroid is thereafter obtained for each cluster by finding the average of the points in the cluster, (b) Using the distance measure metric again, points that are close to the centroid are put in same cluster with the new centroid ^[2]
(a) and (b) continue until the difference between the centroids from a preceding iteration and the next iteration (the iteration that immediately follows) is lower than a threshold value.

For small K's computation is usually time saving, but with an increase in K, the computation becomes complex and slower. This algorithm is probably the most popular clustering algorithm in unsupervised learning. There are other variants of this algorithm like the mini-batch k means ^[2]
Mini-Batch-K-Means: This is variant of K-means which uses subsets of the input data which are randomly sample for every iteration; this subsets are called mini-batches. This technique saves computation time and may only have slightly worse results when compared to the traditional K-means^[2].
Bisecting-K-means: This algorithm starts with a single centroid which implies a single cluster for the whole data and then splits each cluster into two until the desired number of clusters is reached^[2].
Mean Shift: Here, instead taking all the centroid at once as in K-means, a centroid is taken, within a circle of radius, r of points, and only points in the radius, r are considered and used to compute a new centroids, and as the centroid shifts, the circle shifts until it converges, which is the birth of the first cluster; then an entirely new centroid is obtained and undergoes the process by which the first cluster was obtained and the process goes on and on until there is the desired number of clusters^[2].

Association

The interest here is to find a defining rule which represents a relationship. E.g If A is connected to B and B is connected to C, then A is connected to B, Customers who purchase item A also purchase item B e.t.c. Association includes:
1. Market basket analysis
2. Customer clustering
3. Price bundling
4. Assortment decisions
5. Cross selling e.t.c^[1]

Anomaly detection

This is concerned with detecting outliers. This is useful in detecting hacked network (by anomaly network traffic), military surveillance, data cleaning and crime detection^[1].

Dimensionality reduction

This can be carried out using pca and autoencoders. Here, the data is reduced to a lower dimension ^[1].

Principal Components Analysis: Principal Components Analysis (pca), is a data reduction technique used when there is multicollinearity between the features. The features are reduced into components using Eigen vectors. The corresponding Eigen values are used to determine the variation in the data. The sum of the Eigen values = trace of variance-covariance matrix which is the total variation in the data. Hence the variation explained by a component = Eigen value of the component/sum of the Eigen values. Pca can be used for facial recognition, image compression, moving recommendation system, and optimizing the power allocation in various communication e.t.c.

Reference

Dridi, S. (2022, April 4). Unsupervised Learning - A Systematic Literature Review. https://doi.org/10.31219/osf.io/kpqr6
Buitinck, L., Louppe, G., Blondel, M., Pedregosa, Fabian, Mueller, A.,Grisel, O., … Ga"el Varoquaux. (2013). API design for machine learning software: experiences from the scikit learn project. In ECML PKDD Workshop: Languages for Data Mining and Machine Learning (pp. 108–122) (Check the Documentation User Guide)

R is Heavily Functional and Classy too

Oluwafemi Paul Adeyemi — Sat, 19 Aug 2023 22:58:25 +0000

I believe that R was primarily made functional because it was intended to be used by Statisticians who are used to functions. For instance, whereas python gives a pandas dataframe object a head method, base R uses a head function to get the first few rows of the dataset been worked on. By base R, it is meant the basic codes, the ground functionalities of R upon which other programs (or packages) can be built.

# Python
data_head = data.head()

# R
data_head = head(data)

This is the case with most of the base R in-built features, however, R still allows for object oriented programming too. Meaning that you can also create classes and create objects from them. But suppose you wanted to make a class, how do you do that?

First, the easiest way to write a class is to use the reference class.

# R
library(methods)

Vehicle = setRefClass("Vehicle", 
  fields = list(
     name = "character", 
     engine = "character", 
     weight = "numeric"
  ), 
  methods = list(
     horn = function(){
        # some codes
     },
     move = function(){
        # some codes
     }
  )
)
car1 = Vehicle(name = "Toyota", engine="s8", weight=45)
# print the name of the vehicle
car1$name
# Let the vehicle horn
car1$horn()
# Let the vehicle move
car1$move()

Another variant of classes in R is the R6 class illustrated below.

# R
library(R6)

Vehicle <- R6Class("Vehicle",
  public = list(
    name = NULL,
    engine = NULL,
    weight = NULL
    initialize = function(name = NA, engine = NA, weight = NA) {
      self$name <- name
      self$engine = engine
      self$weight = weight
      self$horn()
    },
    horn = function(val) {
      # some codes
    move = function() {
      # some codes
    }
  )
)

car1 = Vehicle$new(name = "Toyota", engine="s8", weight=45)
# print the name of the vehicle
car1$name
# Let the vehicle horn
car1$horn()
# Let the vehicle move
car1$move()

I guess you understood that in both cases instead of using the . operator as in data.head() in Python, we are using the $ operator in R: as in car1$name, car1$horn() e.t.c. and that the major differences are that Vehicle$new was used to create a new Vehicle object ( a car named Toyota), a public access modifier was used and an initializer (constructor) was added in the R6 class. while that was not the case with the reference class. An object oriented version of Shiny (for building web apps) called Tidymodules uses the R6 class in its design. See 1 and 2 for more details on the classes available in R.

R may not have the Python, Java, C++, C# e.t.c type of classes, but similar concepts are addressed in its classes. R still very much supports object oriented programming, even though it is heavily functional.

Scikit-Learn, from Python to JavaScript

Oluwafemi Paul Adeyemi — Sat, 19 Aug 2023 22:22:31 +0000

You may have found Scikit-learn to be a great package for your traditional Machine Learning tasks, especially if you are not creating your own implementations of the algorithms you use - going by a good tip in programming, which says: do not reinvent the wheel. Truth be told, you may feel you have a great tool, until you are about to switch to an entirely different programming language. The problem is how do you carry your Scikit-learn tool to another language?

If you are switching to R, there is a way around that: you just need to use a package called Reticulate to link Python and R, and then you can still use your Scikit-learn within R, if you really want to stick to Scikit-learn. But what if you were to switch to JavaScript? Well, fortunately, there are two solutions I can recommend.

1. Scikit.js

It takes very much after its mother, Scikit-learn from Python, except for four basic differences. With reference to the codes below, these differences are: (1) in JavaScript, while every other function takes in positional arguments (as in Python), class constructors take in objects (in the JavaScript code below, object = { fitIntercept: true }). Python, however, allows constructors (initializers) to take in positional arguments.

Python

from sklearn.linear_model import LinearRegression

x = [[3, 2, 5, 7],
     [1, 2, 5, 2], 
     [2, 8, 9, 7]]
y = [45, 32, 52]
model = LinearRegression(fit_intercept = True)
model.fit(x, y)
print(model.coef_)

JavaScript

import * as tf from '@tensorflow/tfjs'
import { LinearRegression, setBackend } from 'scikitjs'
setBackend(tf)

let x = [[3, 2, 5, 7],
         [1, 2, 5, 2], 
         [2, 8, 9, 7]]
let y = [45, 32, 52]
let model = new LinearRegression({ fitIntercept: true })
await model.fit(x, y)
console.log(model.coef)

(2) While camel case is used in JavaScript, underscore case are used in Python: you can see this from the fitIntercept (which is a camel case) and fit_intercept (which is an underscore case) attributes of JavaScript and Python respectively. (3) In JavaScript, there is always an await keyword written before calls to the fit method. Python does not await function calls. This can also be seen in the codes above.
(4) JavaScript demands a new keyword when creating objects while Python does not. This is illustrated in the codes above.

See Scikit.js for more details.

2. Mljs

This package may not offer the exact functionalities of Scikit-learn, however it is easy to see some similarities in fitting of models and prediction as illustrated below:

import SimpleLinearRegression from 'ml-regression-simple-linear';

const x = [[3, 2, 5, 7],
           [1, 2, 5, 2], 
           [2, 8, 9, 7]]
const y = [45, 32, 52]
const model = new SimpleLinearRegression(x, y);
console.log(model.coefficients)

See Mljs package for more details.

SL Classification using Python and R

Oluwafemi Paul Adeyemi — Wed, 09 Aug 2023 13:39:26 +0000

I will be considering the following Supervised Learning classification Algorithms: logistic regression, support vector machine (SVM), k-nearest neighbors(KNN), naive-bayes, decision tree, random forest and extremely randomized trees (also called extraTrees). I will be implementing them in Python and R.

Using Python

I will be using the package called Scikit-Learn which is easy to learn and also friendly to developers who do not major in ML.

First, I import the dataset I want to use - the iris dataset.

from sklearn.datasets import load_iris

Note that if you want to use a dataset that is not built in then you write

import pandas as pd
data = pd.read_csv('filename.csv', sep='symbol')

sep is usually a comma, ',' but it can also be a different symbol. You can do well to investigate the data.

Next, I import the classes that contain the models I want to use.

from sklearn.linear_model import LogisticRegression 
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import MultinomialNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, ExtraTreesClassifier

Finally, I import the function train_test_split used to split a dataset into the training and testing sets and the function cross_val_score used to find a cross validated model accuracy.

from sklearn.model_selection import train_test_split, cross_val_score

Now, I need to obtain the data

data = load_iris()

# You can check the structure of the data
print(data)

Then I separate the data to features (x) and the target (y)

x = data.data
y = data.target

Next, I split the data into the testing and training sets for x and y. I am taking 80% of the original dataset to be the training data and the remaining 20% to be the test data.

x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.8)

Now I can fit the models. Note that the predicted_y is a a one-dimensional numpy array of the predicted values given x_test. Note also that test_accuracy is actually the accuracy of the model's prediction on the basis of the test data while cross_validated_accuracy is the accuracy of the model's prediction based on a number of subsets of the training data (I use 5 subsets of the training data by setting cv = 5 in the cross_validation_accuracy).

1. Logistic Regression

# logistic
lr_model = LogisticRegression(max_iter=500)
lr_model.fit(x_train, y_train)

predicted_y = lr_model.predict(x_test) 
print(predicted_y)

cross_validated_accuracy = cross_val_score(lr_model, X=x_train, y=y_train, cv=5)
print(cross_validated_accuracy)

test_accuracy = lr_model.score(x_test, y_test)
print(round(test_accuracy, 4))

2. SVM

svm_model = SVC()
svm_model.fit(x_train, y_train)

predicted_y = svm_model.predict(x_test)
print(predicted_y)

test_accuracy = svm_model.score(x_test, y_test)
print(round(test_accuracy, 4))

3. KNN

knn_model = KNeighborsClassifier()
knn_model.fit(x_train, y_train)

predicted_y = knn_model.predict(x_test)
print(predicted_y)

test_accuracy = knn_model.score(x_test, y_test)
print(round(test_accuracy, 4))

4. Naive Bayes

nb_model = MultinomialNB()
nb_model.fit(x_train, y_train)

predicted_y = nb_model.predict(x_test)
print(predicted_y)

test_accuracy = nb_model.score(x_test, y_test)
print(round(test_accuracy, 4))

5. Decision Tree

dt_model = DecisionTreeClassifier()
dt_model.fit(x_train, y_train)

predicted_y = dt_model.predict(x_test)
print(predicted_y)

test_accuracy = dt_model.score(x_test, y_test)
print(round(test_accuracy, 4))

6. Random Forest

rf_model = RandomForestClassifier()
rf_model.fit(x_train, y_train)

predicted_y = rf_model.predict(x_test)
print(predicted_y)

test_accuracy = rf_model.score(x_test, y_test)
print(round(test_accuracy, 4))

7. Extremely Randomized Trees

et_model = ExtraTreesClassifier()
et_model.fit(x_train, y_train)

predicted_y = et_model.predict(x_test)
print(predicted_y)

test_accuracy = et_model.score(x_test, y_test)
print(round(test_accuracy, 4))

Using R

The caret package will be used for this purpose. Note that the cross validation accuracy for each model will be displayed when the model is printed.

First, I import the dataset package which contains the iris dataset

library(datasets)

Metrics is a package containing functions that return certain metrics among which is a function called accuracy that returns the accuracy of a model's prediction.

library(Metrics)

and the dataset package

library(datasets)

Note that if you wanted to use a dataset that is not built in then you write

data = read.csv('filename.csv', sep ='symbol')

sep is usually a comma, ',' but it can also be a different symbol. You can do well to investigate the data

Next, I import the caret package which uses a number of other packages (you may not necessarily know) to do stuffs in machine learning.

library(caret)

Now, I need to obtain our data

data = iris

# You can check the structure of the data
print(data)

Using the function createDataPartition, I am taking 80% of the original dataset to be the training data and the remaining 20% to be the test data.

train_index = createDataPartition(y=data$Species, p=0.8, list=FALSE)

Then, I separate the data into training and testing sets.

train_data = data[train_index,]
test_data = data[-train_index,]

Then, I convert the target variable to a factor, because it was initially a string of characters. But after making it a factor, it is discretized.

train_data$Species = factor(train_data$Species)
test_data$Species = factor(test_data$Species)

Next, I control the computational nuance of the train function which I will be using soon.

# The trainControl function uses 5 k_folds for cross validation, hence number = 5
control = trainControl(method = "cv", number=5)

Next, I fit the models. Note that in the train function, preProcess = c("center", "scale") processes the data such that for each variable, the mean is subtracted from each data point due to center and for each variable also, it divides all the data points by the standard deviation due to scale - this means that using preProcess = c("center", "scale") standardizes the data. Note also that tuneLength is actually an integer denoting the amount of granularity in the tuning parameter grid.

Note that the predicted_y is a vector of the predicted values given x_test. Note also that test_accuracy is the actually the accuracy of the model's prediction on the basis of the test data while cross_validated_accuracy is the accuracy of the model's prediction based on some subsets of the training data.

1. Logistic Regression


logistic_model = train(Species ~.,
                       data = train_data,
                       method = "multinom",
                       trControl=control,
                       preProcess = c("center", "scale"),
                       tuneLength = 10)

print(logistic_model)

predicted_y = predict(logistic_model, test_data)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

2. Suport Vector Machine

svm_model = train(Species ~., 
                  data = train_data, 
                  method = "svmLinear",
                  trControl=control,
                  preProcess = c("center", "scale"), 
                  tuneLength = 10)

print(svm_model)

predicted_y = predict(svm_model, test_data)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

3. KNN

knn_model = train(Species ~.,
                  data = train_data, 
                  method = "knn", 
                  trControl=control, 
                  preProcess = c("center", "scale"), 
                  tuneLength = 10)

print(knn_model)

predicted_y = predict(knn_model, test_data)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

4. Naive Bayes

nb_model = train(Species ~.,
                 data = train_data, 
                 method = "nb", 
                 trControl=control, 
                 preProcess = c("center", "scale"),
                 tuneLength = 10)

print(nb_model)

predicted_y = predict(nb_model, test_data)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

5. Decision Tree

decision_tree_model = train(Species ~., 
                            data=train_data,  
                            method = "rpart",
                            trControl=control,  
                            preProcess = c("center", "scale"),
                            tuneLength = 10)

print(decision_tree_model)

predicted_y = predict(decision_tree_model, test_data)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

6. Random Forest

random_forest_model = train(Species ~., 
                            data=train_data,
                            method = "rf",
                            trControl=control,
                            preProcess = c("center", "scale"),
                            tuneLength = 10)

print(random_forest_model)

predicted_y =  predict(random_forest_model, test_data)
print(y_predicted)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

7. Extremely Randomized Trees

et_model = train(Species ~., 
                 data=train_data,
                 method = "ranger",
                 trControl=control,
                 preProcess = c("center", "scale"),
                 tuneLength = 10)

print(et_model)

predicted_y = predict(et_model, test_data)
print(y_predicted)

test_accuracy = accuracy(y_predicted, test_data[, ncol(test_data)])
print(sprintf('Test accuracy = %f', test_accuracy))

And that is it. I think it is super easy to write these codes, if only you see the repetitive patterns in the codes for both Python and R - actually, each language has its own unique pattern. Thanks for reading.
New to R? See:R, beyond Statistical Programming

New to Machine Learning? See:
Introduction to Machine Learning

Not sure which program to use for your ML? See:Best Programming Language for ML