Programs›🌿 AI Sprouts›Lessons›Algorithms Explained — The Recipes of AI

🧮

AI Sprouts • Beginner⏱️ 30 min read

Algorithms Explained — The Recipes of AI

From Data to Decisions 👋

In the previous lesson, you learned that data is the fuel of AI. But fuel alone doesn't drive a car — you need an engine. In AI, that engine is called an algorithm.

By the end of this lesson, you'll understand three fundamental algorithms and know when to use each one.

Data goes in, the algorithm processes it, predictions come out — An algorithm transforms raw data into useful predictions

What is an Algorithm? 🤔

An algorithm is simply a set of step-by-step instructions to solve a problem.

You already follow algorithms every day:

🍳 A cooking recipe — "Heat oil, add onions, stir for 3 minutes..."
🗺️ Directions to school — "Walk north, turn left at the park, cross the bridge..."
🔢 Long division — A step-by-step process you learned in maths class

In AI, algorithms are the step-by-step instructions a computer follows to find patterns in data and make predictions.

🤔

Think about it:

Think about how you decide what to wear each morning. You probably check the weather, think about your plans, consider what's clean — that's an algorithm! You follow a series of steps (even if unconsciously) to reach a decision. AI algorithms do the same thing, just with data instead of gut feelings.

Algorithm 1: Decision Trees 🌳

A decision tree is one of the most intuitive algorithms in AI. It makes decisions by asking a series of yes/no questions — just like the game "20 Questions."

How it works

Imagine you're deciding whether to play outside:

Is it raining?
├── Yes → Stay inside 🏠
└── No → Is it above 15°C?
    ├── Yes → Play outside! ⚽
    └── No → Wear a jacket and play outside 🧥

That's a decision tree! Each node asks a question, each branch follows an answer, and each leaf gives a final decision.

A real ML example

Suppose we want to predict whether someone will buy a product:

Age greater than 25?
├── Yes → Has bought before?
│   ├── Yes → WILL BUY ✅ (95% confidence)
│   └── No → Price under £20?
│       ├── Yes → WILL BUY ✅ (70% confidence)
│       └── No → WON'T BUY ❌ (80% confidence)
└── No → Student discount available?
    ├── Yes → WILL BUY ✅ (60% confidence)
    └── No → WON'T BUY ❌ (75% confidence)

Why decision trees are great

✅ Easy to understand — you can literally draw them on paper
✅ Explainable — you can trace exactly why a decision was made
✅ Work with both numbers and categories — age (number) or colour (category)

When they struggle

❌ Can overfit — memorise the training data instead of learning general patterns
❌ A single tree can be inaccurate on complex problems
❌ Small changes in data can create a completely different tree

🤯

Random Forests — one of the most powerful ML algorithms — simply combine hundreds of decision trees and let them "vote" on the answer. It's like asking 500 people for directions and going with the majority. This simple idea dramatically improves accuracy!

Algorithm 2: K-Nearest Neighbors (KNN) 🏘️

KNN is the "ask your neighbors" algorithm. Its logic is beautifully simple: things that are similar tend to be close together.

The intuition

Imagine you move to a new city and want to find a good restaurant. What do you do? You ask your nearest neighbors for recommendations! If 3 out of 5 neighbors recommend Italian food, you'd probably try Italian.

KNN works exactly the same way:

Take a new, unknown data point
Find the K closest data points in the training data (K is a number you choose)
Let those neighbors vote on the answer
Go with the majority

A visual example

Imagine a graph with red dots (cats) and blue dots (dogs), based on weight and height:

Height
  |   🔴  🔴
  |  🔴  ❓  🔴      ← What is ❓?
  |    🔴   🔵
  |  🔵  🔵
  |   🔵   🔵  🔵
  +----------------→ Weight

If K=3, we find the 3 nearest neighbors to ❓. If 2 are red (cat) and 1 is blue (dog), we predict: cat! 🐱

Choosing K

K too small (e.g., K=1) → Sensitive to noise — one weird data point changes everything
K too large (e.g., K=100) → Too general — distant points that aren't really relevant get a vote
Sweet spot → Usually K=3, 5, or 7 works well. Always use an odd number to avoid ties!

from sklearn.neighbors import KNeighborsClassifier

# Create and train a KNN model with K=5
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# Predict on new data
prediction = knn.predict(X_test)
print(f"Accuracy: {knn.score(X_test, y_test):.2%}")

💡

KNN is a "lazy learner" — it doesn't actually learn anything during training! It just memorises all the data and does the real work at prediction time by calculating distances. This makes training instant but predictions slow on large datasets.

Algorithm 3: Linear Regression 📈

Linear regression is the art of fitting a line through data points. It's used when you want to predict a number (not a category).

The intuition

Think about this: the more hours you study, the higher your test score tends to be. If you plotted this on a graph, you'd see data points trending upward. Linear regression draws the best-fitting line through those points.

Score
100 |                    *   *
 80 |              *  *
 60 |        *  *
 40 |     *
 20 |  *
    +-------------------------→ Hours studied

The line lets you predict: "If I study for 7 hours, I'll probably score around 85."

The equation

Every line can be described as:

y = mx + b

y = what we're predicting (test score)
x = input feature (hours studied)
m = slope (how steep the line is)
b = intercept (where the line crosses the y-axis)

The algorithm finds the best values for m and b so the line is as close as possible to all the data points.

from sklearn.linear_model import LinearRegression
import numpy as np

# Study hours and test scores
hours = np.array([1, 2, 3, 4, 5, 6, 7, 8]).reshape(-1, 1)
scores = np.array([20, 35, 45, 55, 65, 75, 82, 90])

# Fit the model
model = LinearRegression()
model.fit(hours, scores)

# Predict score for 5.5 hours of study
predicted = model.predict([[5.5]])
print(f"Predicted score for 5.5 hours: {predicted[0]:.1f}")
print(f"Slope (m): {model.coef_[0]:.2f}")
print(f"Intercept (b): {model.intercept_:.2f}")

When linear regression works — and when it doesn't

✅ Great when the relationship is roughly a straight line
✅ Fast, simple, and easy to interpret
❌ Terrible when the relationship is curved or complex
❌ Sensitive to outliers — one extreme point can tilt the whole line

When to Use Which Algorithm? 🧭

| Question | Decision Tree | KNN | Linear Regression | |----------|:---:|:---:|:---:| | Predicting a category (cat/dog)? | ✅ | ✅ | ❌ | | Predicting a number (price, score)? | ✅ | ✅ | ✅ | | Need to explain the decision? | ✅✅ | ❌ | ✅ | | Have a very large dataset? | ✅ | ❌ | ✅ | | Relationship is a straight line? | ❌ | ❌ | ✅✅ | | Don't know the relationship shape? | ✅ | ✅ | ❌ |

🤔

Think about it:

There's no single "best" algorithm. The right choice depends on your data, your problem, and what you need. A doctor diagnosing diseases might prefer a decision tree because it can explain why it made a diagnosis. A weather app predicting temperature might use linear regression because the relationship with historical data is roughly linear.

Interactive: Build a Movie Recommender 🎬

Let's build a simple decision tree for recommending films! Think about how you choose films:

Do you want something funny?
├── Yes → Do you like animated films?
│   ├── Yes → Watch "Inside Out 2" 🎭
│   └── No → Do you want something family-friendly?
│       ├── Yes → Watch "Home Alone" 🏠
│       └── No → Watch "The Grand Budapest Hotel" 🏨
└── No → Do you like action?
    ├── Yes → Do you prefer superheroes?
    │   ├── Yes → Watch "Spider-Man: Across the Spider-Verse" 🕷️
    │   └── No → Watch "Top Gun: Maverick" ✈️
    └── No → Do you want a true story?
        ├── Yes → Watch "Hidden Figures" 🚀
        └── No → Watch "Interstellar" 🌌

Try this yourself: Add more branches! What about genre, mood, length, or language? Every question you add makes the tree more personalised. This is exactly how recommendation algorithms start — simple rules that get refined with data.

# A simple decision tree in code
def recommend_movie(funny, animated, action, superhero, true_story):
    if funny:
        if animated:
            return "Inside Out 2 🎭"
        else:
            return "The Grand Budapest Hotel 🏨"
    else:
        if action:
            if superhero:
                return "Spider-Man: Across the Spider-Verse 🕷️"
            else:
                return "Top Gun: Maverick ✈️"
        else:
            if true_story:
                return "Hidden Figures 🚀"
            else:
                return "Interstellar 🌌"

# Try it!
print(recommend_movie(funny=False, animated=False,
                      action=True, superhero=True,
                      true_story=False))
# Output: Spider-Man: Across the Spider-Verse 🕷️

Quick Recap 🎯

An algorithm is a step-by-step procedure for solving a problem
Decision trees ask yes/no questions to reach a decision — explainable and visual
KNN classifies by asking the K nearest neighbors to vote — simple but lazy
Linear regression fits a line through data to predict numbers — fast but limited to linear relationships
No algorithm is universally best — choose based on your data and problem
Real AI systems often combine multiple algorithms for better results

What's Next? 🚀

You've now met three classic algorithms. In the next lesson, we'll explore neural networks — the powerful, brain-inspired algorithms behind modern AI breakthroughs like ChatGPT, image generation, and self-driving cars. Get ready to think in layers! 🧠

Lesson 2 of 30 of 3 completed

←Datasets and Data — The Fuel of AI Introduction to Neural Networks — How AI Thinks in Layers→