Forem: Esther

Upload Large Folders to Cloudflare R2

Esther — Sun, 05 Apr 2026 18:18:40 +0000

Cloudflare R2 object storage has a limitation: the web interface only allows uploading folders containing fewer than 100 files. To upload folders with more than 100 files, you typically need to set up Cloudflare Workers or use the S3 API with custom code.

Rclone makes this process easy.

Step 1 - Install Rclone

Rclone ↗ is a command-line tool for managing files on cloud storage. Rclone works well for uploading multiple files from your local machine or copying data from other cloud storage providers.

brew install rclone

Windows:
Download the installer from rclone.org/install/#windows

Step 2 - Create Cloudflare API Keys

From your Cloudflare R2 dashboard, click the Manage button.
Create a new user API token:

Enter a Token Name (e.g. r2-upload-token)
For Permission, select Object Read & Write
Under Specify buckets, choose the bucket(s) you want to allow access to or allow all.

After creation, you will receive: Access Key ID, Secret Access Token, Endpoint (e.g., https://.r2.cloudflarestorage.com)

⚠️ Save these credentials immediately because you won’t be able to see the secret key again.

Step 3 - Configure Rclone

Run the configuration command:

rclone config

Select new remote
Enter name of new remote (you'll use this later)
Select storage > 4 (Amazon S3 Compliant Storage Providers)
Select provider > 7 (Cloudflare)
env_auth > 1 (Enter AWS credentials in the next step)
Enter access_key_id
Enter secret_access_key
Select region - auto (Leave empty or enter 1)
Enter endpoint
Select No for Edit Advanced Config > n (n for No)
Keep this remote > y
Quit config > q

Step 4: Upload Your Folder

Use the rclone copy command:

rclone copy -vv <local_folder_path> <remote_name>:<bucket_name>/<destination_folder>

Example:

rclone copy -vv /Users/Dev/project/images my-rclone-remote:images/apparels

The -vv flag gives verbose output so you can watch the upload progress. rclone also skips any file that has already been uploaded.

Step 5: Verify the Upload

List the bucket and count the files:

rclone ls <remote_name>:<bucket_name> | wc -l

What MCP Actually Is (And Why It Exists)

Esther — Sat, 21 Mar 2026 19:05:18 +0000

What is MCP?

MCPs are a way to give AI applications the external context/capabilities they need to complete their mission.

Kind of a blanket statement, I know. You're probably wondering: doesn’t RAG already do this? What about tools? And you'd be right to think that, somewhat.

These are all ways to give AI context.

With RAG, you typically embed and store context somewhere if you're not trying to overshoot your context window by just sending an entire PDF to the LLM. This context is then retrieved each time the user makes a query to your app.

Although, realistically, you should have some form of reasoning that decides whether the user's query actually needs additional context because they could literally just be asking your app:

"How are you?" 😭

Anyways, Back to MCPs.

MCPs are more closely related to tools (function calling), but they also support resources, which makes them relevant to RAG-like systems too.

And I’m going to explain why MCP exists with a short example:

The Problem MCP Solves

You have a nice OpenAI agent that does research. This agent makes tool calls to Google Scholar using the Serper API + a bunch of other services.

PS: Serper wraps the Google API because working directly with Google is a nightmare.
Along the way, you realise:

“Ugh, I don't even like OpenAI. Why am I using this?”

Also, they jumped into that deal with the Pentagon, sayonara! ✌🏽 LangChain, here I come.
You read the LangChain docs and realise:

“Dang. I have to rewrite my tools from scratch to fit LangChain’s syntax.”

So now you're rewriting:
- agent logic
- tool logic
Months later, you realise:
- you hate LangChain
- you hate their syntax
- you hate installing 100 packages just to use a new LLM
- you especially hate RunnablePassthrough and those damn pipes | 😭
So now, CrewAI it is 🫠
You read CrewAI docs. And yes, you guessed it. You're rewriting everything again: agents, tools, the whole shebang. Sigh.

At this point, you're probably sick of it all.

Unfortunately, you cannot avoid rewriting your agents when switching platforms (for now).

BUUUUT you can avoid rewriting your tools.

🚀 Enter MCP

MCP stands for Model Context Protocol.

It’s a standard created by Anthropic to ensure that LLMs can connect to external data sources and tools seamlessly.

What this means is:

You can build your tools once (as an MCP server), and any MCP-compatible platform can use them.

No more major rewrites every time you switch frameworks 🎉

MCPs were initially built to give LLMs like Claude (and potentially other models via MCP clients) access to more data sources. But now, they’ve evolved into something much bigger: a standard way for AI agents to access tools and context.

Benefits of MCP

1. Access to a growing ecosystem

With MCP, you get access to a whole ecosystem of tools. Many companies are building MCP servers for their platforms, exposing powerful capabilities.

You can explore them here: https://mcpservers.org/

2. Access to local + external data

MCPs can access both:

external systems (APIs, services)
local data (your machine, private files, internal knowledge bases)

So if you want Claude, ChatGPT, Cursor, or any external agent to access your private local knowledge, MCP is a great option.

3. Structured access to capabilities

MCP doesn’t just give access, it structures it.

Core MCP Concepts

Tools: Tools provide capabilities. They allow AI applications to perform actions on behalf of users.

external APIs that do things

Resources: Resources provide information. They allow AI systems to retrieve structured data and pass it as context to models.

knowledge, documents, data sources

We also have Prompts, but I got tired writing this article so read about it here: https://modelcontextprotocol.io/docs/learn/server-concepts#resources

Important Note

For an agent to use MCP tools, it must support the MCP protocol (i.e., be an MCP client). That said, platforms like CrewAI abstract this away, so you don’t always have to manually set this up but some platforms might not have this capability.

MCP Deployment Types

MCP servers can be:

Local (running on your machine)
Remote (hosted elsewhere)

When MCP first came out, it was heavily tied to Claude and required you to build your own server. Now, there are tons of ready-to-use servers.

Check some here:https://platform.claude.com/docs/en/agents-and-tools/remote-mcp-servers

Most platforms now just ask for an MCP URL, and you’re good to go.

Buuuuut, you can build your own. You don’t have to rely on existing servers. If you need a very specific capability, you can build your own MCP server tailored to your use case.

When It Makes Sense to Use MCP

You’re a large company and want a standardized way to expose platform capabilities
You utilise a lot of tools (this is where MCP really shines)
You want third-party agents to use your tools
You’re building reusable capabilities
You have an ecosystem of agents
You don’t want your tooling layer locked into one platform (👀 OpenAI)

Take your pick 😁.

When It Does NOT Make Sense 🚫

Because it’s “trending.”
You have one agent calling one tool. Please just write your tool yourself. 😭

MCP is for robust systems, not overengineering.

Where MCP Does NOT Help ❌

1. It does NOT standardize agent logic

If you switch platforms, you will still rewrite your agents.That said, with modern AI coding tools, it’s like an hour of work max.

2. Reducing complexity

You now have:

an MCP server
a protocol layer
more moving parts

For small projects, this is overkill.

3. Latency tradeoff

Before:
Agent → Tool

Now:
Agent → MCP → Tool

Congratulations! You just introduced an extra hop. 👏

My Final Thoughts

MCP is not about making agents easier or doing fancy things with LLMs. It’s about making systems reusable, scalable, and interoperable. It's also about giving agents all the tools (pun intended) they need to succeed. You can do some serious analysis by plugging an LLM into internal data.

Now, we wait for Anthropic to release a protocol that standardizes agents too 💀

Motion Detection In OpenCV Explained In-Depth

Esther — Wed, 01 Jan 2025 16:01:15 +0000

TLDR:

Background are the pixels in a frame that remain static over time.

Foreground are the pixels in a frame that keep changing.

For each frame, a log of the pixels are kept.

To detect motion, we compare the current pixels in the current frame with their history.

If there is a massive change in intensity, we can safely call it motion detection.

Background subtraction is a technique used in computer vision to identify moving objects in a video by separating them from the background, basically subtracting an object from the background so they can be tracked independently.

As you probably know, frames are individual pictures or images in a video. A video is made up of many frames shown quickly, one after the other, to create the illusion of movement. Think of frames like pages in a flipbook. When you flip through them fast, they make an animated story.

In background subtraction, each frame of the video is compared to a background model (a static reference image of the scene created at different points in time). Any significant difference between the current frame being shown and the background model is considered as foreground, thus indicating motion or change.

To achieve this, the subtraction approach being used in OpenCV is K-nearest neighbors (KNN). This approach classifies each pixel as background or foreground by looking at the color values of its nearest neighbors (K) in a certain time window (history). If the nearest neighbours are below a certain threshold (which represents the "closeness" you accept), then the pixel is considered to be similar to its historical values, and will be classified as background.
If the distance is large, the pixel will be classified as foreground.

For example, if a pixel has been black (0) for the last 399 frames and suddenly turns white (255) in the current frame:

The algorithm checks the nearest neighbors (the number of nearest neighbors is decided internally by the algorithm) from the 400-frame history.
If all the nearest neighbors are black, the current white pixel will likely be classified as foreground because it's too different from the background model and thus motion is detected through a change in the pixels.

The OpenCV function looks like this:

retval = cv2.createBackgroundSubtractorKNN([, history[, dist2Threshold[, detectShadows]]])

How KNN Works for Background Subtraction:

Keeping a history: For every single pixel in the frame, KNN maintains a history of its previous pixel values. Imagine every single pixel has an array of historical values from past frames. This history acts as a model of what that pixel's intensity should look like if it were part of the background.
Comparing current frame with history: When a new frame is captured, the KNN algorithm checks the intensity value of each pixel and compares it with the stored history of that pixel.

In summary, background subtraction is a simple and effective way to identify moving objects in a scene by comparing each frame to a model of the static background.

Canny Edge Detection

Esther — Tue, 19 Nov 2024 02:40:05 +0000

Edge detection is an image processing technique in computer vision that involves identifying the outline of objects in an image.

Canny edge detection is one of the best techniques for edge detection. It’s designed to detect clean, well-defined edges while reducing noise and avoiding false edges. It uses a double thresholding method to detect edges in an image: a high and a low threshold.

img = cv2.Canny('photo.jpg')
img_edges = cv2.Canny(img, 100, 200)
// 100 is the low threshold
// 200 is the high threshold

The thresholds decide what becomes an edge and what doesn't. To make this decision, we use gradient values:

If a gradient value is above the high threshold, it’s considered a strong edge and added to the edge map. (strong edge)
If it’s below the low threshold, it’s ignored. (non edge)
If it is between the high and low threshold, it is only kept if it is connected to a strong edge. (potential edge)

What are gradient values?

Gradient values are not the raw image values. They are computed numbers derived from the raw image by checking how much the pixel intensity changes in an image. We use gradient values because the raw image values don’t directly tell us where the edges are.

A simple example to illustrate changes in pixel intensity: if two neighboring pixels have very different values (e.g. 50 and 200 and the gradient value is 150), there’s a big change — it might be an edge. But if two neighboring pixels have similar values (e.g. 50 and 52 and the gradient value is 2), there’s little change & very little possibility of being an edge.

After the gradient values are computed, they are then compared against the thresholds to decide what qualifies as a strong edge, a potential edge or a non edge.

How do we know values in between thresholds are connected to a strong edge?

By using a method called edge tracking by hysteresis which decides edges that are connected and should be kept VS discarded. This algorithm works by looking at the 8 neighbors (directly adjacent pixels - top, bottom, left, right, and diagonals) of each potential edge pixel. Any pixel directly or indirectly connected to a strong edge is included in the final result.

How edge tracking works:

   50   80  110   90
   70  250  190  120
   60  180  150   70
   40   60   80   50

Imagine this gradient map above:

After applying thresholds (low = 100, high = 200), the strong edge pixels ( > 200) are immediately kept as edges. Here, only the pixel 250 is marked as a strong edge.

The potential edge pixels (100–200) are 110, 190, 120, 180 and 150. Now that we have a pool of potential edges, we perform edge tracking to decide what gets to stay & what is discarded. The algorithm checks if any of the potential edges are directly or indirectly connected to the strong edge (250).

For example:

190 is a neighbor of 250, it is directly connected to a strong edge so it's kept.
150 is a neighbor of 190, it is indirectly connected to a strong edge so it’s also kept.

Weak edge pixels (< 100) like 80, 90 and the rest are completely ignored, as they are considered noise.They will not be a part of the final image.

How to Build a Telegram Bot in 5 Simple Steps

Esther — Mon, 14 Oct 2024 00:48:49 +0000

Building a Telegram bot might seem difficult, but it’s easier than you think! Whether you want to create a fun chatbot, an information service, or something unique, Telegram’s API provides a flexible framework for developers of all skill levels. In this guide, we’ll walk through the process step-by-step, so by the end, you'll have a fully functioning bot ready to interact with users.

Before we get started, a little introduction on how it works. Telegram bots are powered by the telegram API: https://api.telegram.org/bot<YOUR_BOT_TOKEN>. The bot is a script that queries this API using an HTTPS request. While you can choose to interact with the API directly, libraries make it easier. This guide will be based on a Python library. You can find the API documentation here. Also, you can find the scripts here: Nodejs, Python

Now, let's start this exciting journey of bringing your bot idea to life in just five simple steps!

1. Create a New Bot & Generate Bot Token

The first step in building a Telegram bot is to create one via the Telegram platform.

Open Telegram and search for BotFather, the official Telegram bot for creating and managing bots.
Start a chat with the BotFather and use the command /newbot. It will ask you to choose a name for your bot, provide a unique username.
Once you’ve successfully created your bot, BotFather will provide a Bot Token— this will serve as the authentication key for your bot. Make sure to store this token securely because you’ll need it later to communicate with Telegram's API.

2. Install Dependencies

Now that you have your bot ready, it's time to set up your development environment. Before you install dependencies, you will need to create a virtual environment where the installed dependencies will reside:

   python -m venv <YOUR-VIRTUAL_ENVIRONMENT-NAME>

Next, you’ll need the Python telegram library installed:

Install python-telegram-bot by running this in your terminal:
```
 pip install python-telegram-bot
```

This library provides an easy way to interact with the Telegram Bot API.

3. Write the Code

With your environment set up, it’s time to write the code for your bot:

   from telegram import Update
   from telegram.ext import ApplicationBuilder, CommandHandler, ContextTypes

   # Function that handles /start command
   async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
       await update.message.reply_text('Hello! I am your bot. How can I help you today?')

   def main():
       # Use your bot token here
       application = ApplicationBuilder().token(token).build()

       # Register the /start command
       application.add_handler(CommandHandler("start", start))

       # Run the bot until you send a signal to stop
       application.run_polling()

   if __name__ == '__main__':
       main()

Replace "token" with the bot token you got from BotFather.
The CommandHandler registers the start command and runs the start function each time the command is called.
In this simple example, when a user sends the /start command, the bot replies with a greeting.

4. Test the Bot

Now that the code is ready, it’s time to test your bot.

Run your bot script in your terminal:
```
 python bot.py
```
Open Telegram, search for your bot using the unique username you created, and send the /start command.
The bot should reply with your predefined message: Hello! I am your bot. How can I help you today?

5. Deploy the Bot Code

Now you have a functional bot 🥳. You can build upon this code to add more commands and features depending on the purpose of your bot. Once you’ve tested the bot and are happy with its functionality, it’s time to deploy it so it can run 24/7. There are a few common hosting options such as Heroku, AWS, Azure has a free app service plan.

Ensure the bot is running continuously and can restart automatically if there are errors.

Some Extra Updates That Can Be Made:

Perhaps you'd like to show that the bot is typing just like a regular user, add the command below to the start function:

# Send typing action to user - to show that the bot is typing
    await context.bot.send_chat_action(chat_id=update.effective_chat.id, action=ChatAction.TYPING)

In the previous example, we saw how to respond to commands (words that start with a / like /start), to respond to normal text messages, we need a message handler:

from telegram.ext import MessageHandler
application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))

Have fun building!

Calculating Adaptive Threshold in OpenCV

Esther — Fri, 12 Jul 2024 02:59:27 +0000

Read my article on Thresholding and Binary Images for a better background

Adaptive thresholding is a technique used to convert a grayscale image to a binary image (black and white). The threshold value is calculated for smaller regions (blocks) of the image rather than using a single global threshold value for the entire image.

We can perfom adaptive thresholding in OpenCV using this method:

img = cv2.adaptiveThreshold(src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst])

An explanation of the arguments:

src: The image to be worked on.
maxValue: The maximum value to use with the thresholding type.
adaptiveMethod: The adaptive thresholding method to use. We have the Adaptive_THRESH_MEAN_C and ADAPTIVE_THRESH_GAUSSIAN_C.
thresholdType: The type of thresholding to apply. In this article we use the THRESH_BINARY. Read more about the different threshold types
blockSize: The size of the block to calculate the threshold for.
C: A constant subtracted from the calculated mean. This constant fine-tunes the thresholding.

The Mean Calculation

First, we read the image:

# Read the original image.
img = cv2.imread('test_image.png', cv2.IMREAD_GRAYSCALE)

Let us assume the image translates to these numbers:

[[218 217 216 221 220 220]
 [211 210 210 215 216 216]
 [212 211 211 214 216 216]
 [139 138 137 103 105 105]
 [190 190 190 170 170 170]
 [255 255 255 255 255 255]]

Next, we specify our adaptive thresholding method:

img_thresh_adp = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, 7)

img: This is the image we have translated into numbers using the cv2.imread method.
255: This is the maximum value we are to use after calculations. This means that pixels that are above our result will be set to 255 (white) while the pixels that are below will be set to 0 (black)
cv2.ADAPTIVE_THRESH_MEAN_C: This is the adaptiveThresholding algorithm. This method calculates the threshold for a pixel based on the mean of a certain number of pixels.
cv2.THRESH_BINARY: THRESH_BINARY means that pixels above the threshold value will be set to the maximum value (255), and pixels below the threshold value will be set to 0.
3: This means a 3 x 3 pixel area around each pixel is considered.
7: This means after calculating the mean, we subtract 7 from it.

Step-by-Step Calculation

Block 1 (Top-left corner):

Consider the 3x3 block starting at the top-left corner:

[[218 217 216]
 [211 210 210]
 [212 211 211]]

Mean: (218 + 217 + 216 + 211 + 210 + 210 + 212 + 211 + 211) / 9 = 212.8
Subtract constant from result: 212.8 - 7 = 205.8

Since every single number in block 1 is greater than 205, the numbers are all swapped for 255. Therefore the top left corner becomes this:

[[255 255 255]
 [255 255 255]
 [255 255 255]]

Block 2:

Consider the next 3x3 block:

[[217 216 221]
 [210 210 215]
 [211 211 214]]

Mean: 1925 / 9 = 213.8
Subtract constant: 213.8 - 7 = 206.8

Every single number in this block is greater than 206 so the numbers are all swapped for 255. Therefore the block becomes:

[[255 255 255]
 [255 255 255]
 [255 255 255]]

These calculations would be done row by row on a 3 x 3 basis until we have calculations for each section. If the current numbers are less than the result, we use 0 else we use 255. Also, note that the numbers are swapped for 255 only because that is what was specified as the maximum.

For example, below we have specified a maximum value of 200:

img_thresh_adp = cv2.adaptiveThreshold(img, 200, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, 7)

# Calculating the top left corner block
[[218 217 216]
 [211 210 210]
 [212 211 211]]

# Calculating the mean
Mean: 1916 / 9 = 212.8
Subtract constant: 212.8 - 7 = 205.8

# The result
[[200 200 200]
 [200 200 200]
 [200 200 200]]

The resulting image after will always contain a number between 0 and the maxValue specified.

I hope this clarifies adaptiveThresholding for someone out there!

Binary Images & Image Thresholding

Esther — Fri, 12 Jul 2024 02:52:04 +0000

Thresholding

Thresholding is a simple yet effective technique used in image processing to convert a grayscale image into a binary image. The core idea is to segment the image into two parts (usually 0 - black and 255 - white) based on a specific threshold value. Think of the threshold value as a certain number that must be exceeded (or not) for a certain result.

Thresholding involves setting a threshold value that separates the pixel values of the image into two distinct groups:

Pixels above the threshold: These pixels are usually set to the maximum value (often 255 for white in binary images).
Pixels below or equal to the threshold: These pixels are usually set to the minimum value (often 0 for black in binary images).

Types of Thresholding

1. Global Thresholding: A single global threshold value is applied to the entire image.

Example: Setting all pixel values above 165 to 255 (white) and those below or equal to 165 to 0 (black).

cv2.threshold(img, 165, 255, cv2.THRESH_BINARY)

An image with the following values:
[[103 105 105]
 [211 210 210]
 [212 211 211]
 [139 138 137]]

Would become:
[[0 0 0]
 [255 255 255]
 [255 255 255]
 [0 0 0]]

2. Adaptive Thresholding: The threshold value is determined for smaller regions of the image, allowing for different threshold values in different parts of the image.

Example: Setting all pixel values above the calculated mean to 255 (white) and those below or equal to 165 to 0 (black).

cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, 7)

Read more about how Adaptive Thresholding is calculated.

Adaptive thresholding is useful for images with varying lighting conditions. For each pixel, the best possible value is used which results in a clearer image.

Binary Image

A binary image is a type of image that has only two possible pixel values: 0 and 255. These values represent black and white, respectively. Binary images are used to simplify the analysis of images by reducing the complexity of the data. We use thresholding algorithms to achieve binary images.

Significance of Binary Images

Simplification: It reduces the complexity of an image by converting it to two colors, making it easier to analyze.
Segmentation: In application of object detection, it can help in isolating objects from the background.
Feature Extraction: It is useful for identifying and extracting specific features from an image, such as shapes or edges.

Machine Learning For Beginners

Esther — Wed, 15 May 2024 00:08:27 +0000

What is Machine Learning?

Machine learning is a field in AI that revolves around training software (using large amounts of data) to act, think, and predict information the way humans do. This is why it's called machine learning. The software being trained to make predictions is called a model.

What is a Model?

A machine learning model is a software program that can predict new information based on the data it was trained on. The model consists of an algorithm that helps it make predictions. For a model to start making predictions, it has to be trained. The process of passing a lot of data to the model is called training. After a lot of training, it can begin to predict nearly accurate values. This prediction is called ‘inferencing’.

The training data usually consists of two things: features & labels. The features are the characteristics of the data while the label is the value you want to train the model to be able to predict. In Machine Learning, it is visualized as x and y: features(x), label(y).

Here's a simple example:

To train a model that can predict the number of jacket sales based on weather, we would give the model information such as - The weather measurements for the day e.g temperature, these are the features (x), and the number of jackets sold on each day, these are the labels (y).

To implement in code, it would like this:

//Javascript
const data = [
  {
    temperature: 20, //feature
    jackets sold: 30, //label
  },
  {
    temperature: 36, //feature
    jackets sold: 10, //label
  },
  .......
]

This data is sent to the model, it runs an algorithm and studies the data. To validate what the model has learned, we send more data to evaluate its learning.

How Do We Actually Validate That The Model is Learning & What Data Do We Use?

When training the model, we can send 80% of the training data and keep 20% back for evaluation. After training, we send the evaluation data, the model makes a prediction and how far the prediction is from the correct value determines whether or not the model is learning enough & is ready to make predictions, kind of like a test run. The training data must be not be split in 2 ie 80%, 20%, you can train with entire data & test with fresh data.

Using the previous jacket example, this is what the process would look like:

Input training data on jacket sales 
-> model runs algorithm 
-> algorithm studies relationship between temperature and jacket sales
-> input more jacket data to model to evaluate learning 
-> model predict jacket sales
-> compare predictions with the actual validation data 
-> evaluate false prediction rates using special calculations 
-> start over.

This is an example an algorithm to run the training data on jacket sales.

The model is usually depicted as a function that takes in an input and returns an output: y = f(x)

Training a model is doing this over again with large amounts of data (this can be done with different algorithms). When a model is being trained, it runs a specific algorithm on the data to establish patterns and relationships, after training is over, the model will contain the learned patterns & relationships as well as algorithm configurations. Upon deployment, the model becomes a self-contained system that can process input data on its own without needing to run through an algorithm each time.

As you probably guessed, training a model on bad data will yield incorrect predictions which can be very costly. Data must be clean and pass several checks to produce the desired results.

Types of machine learning

Supervised Machine Learning: This is a form of machine learning where we provide training data consisting of both the features & labels. In this method, we carefully curate the data we provide the model, giving it both attributes and labels to enable it to make predictions of its own.

Types of Supervised Learning
- Regression: This is a form of supervised learning where the model is trained to predict a numeric value. e.g The number of icecreams sold on a given day (label - y) based on weather (feature - x) or the number of shirts (label - y) sold based on salary of buyer (feature - x) etc. This data is passed through an algorithm such as linear regression and the predicted values (called y-hat in math speak ŷ) are compared with the actual values and based on that we understand how far off the model is in it's predictions.
- Classification: This is another form of supervised learning where the model is trained to assign the label being predicted to a class. The "class" here is a terminology to mean grouping and they are predefined e.g If we wanted to predict the species of animals based on body structure, in the training data being passed to the model, we would specify animal features and their species. Based on this, after training, the model when given new data can assign it to a species and predict it as such.
  - Binary Classification: In this type of classification, the model is trained to predict only two classes - true or false. e.g A model that helps to predict if people can afford a certain school(label) based on age, salary, inheritance, parents careers(features). When given data, this model will either respond with a true or false. We can imagine a model such as this is trained on the data of the students that are already in the school. We can use algorithms such as Logistic regression to train for this outcome.
  - Multiclass Classification: In this type of classification, the model predicts input data as belonging to a single or multiple classes. e.g A model that can predict the genre of books (a book can have multiple genres). We can use algorithms such as One-vs-Rest(OVR) & multinomial algorithms to achieve this.
Unsupervised Machine Learning: In unsupervised learning, we provide training data consisting of only features without any labels. In this method, the model itself will start to determine relationships between the features and come up with labels itself. We basically tell the model "figure it out".

Types of Unsupervised Learning
- Clustering: In clustering. the model identifies similarities in the data based on features and starts to group them based on that. It is similar to multiclass classification in the fact that it groups data but the difference is in multiclass, we already know what the classes are based on previous learning but in clustering, we don’t. So we give it a bunch of data and ask it to figure it out and learn on it’s own. e.g We can provide a model a bunch of student data and it will group the data by age, gender, class, tuition, address etc. We can use algorithms such as K-Means clustering for clustering.

This is a really simplified background on machine learning to introduce newbies to the field. There's a lot of technical speak surrounding AI today and I hope this article helps a confused person out there.

Thanks for reading!