Introduction to Machine Learning

What is Machine Learning?

Machine Learning is a part of Artificial Intelligence (AI) that allows computers to learn from data without being told exactly what to do. Instead of writing specific rules for every situation, we show the computer examples, and it figures out the patterns on its own.

Think of it like teaching a child to recognize animals. You don't explain every detail about what makes a cat a cat. Instead, you show them many pictures of cats, and eventually, they learn to recognize cats on their own—even cats they've never seen before.

Formal Definitions

What Machine Learning is NOT

If you download hundreds of books onto your computer, it doesn't automatically become smart. Your computer won't start writing stories or summarizing those books for you. That's just data storage—not learning.

Machine Learning happens when a computer can actually improve at a task by learning from data and experience—without being manually programmed for every scenario.

Types of Machine Learning

There are three main approaches to machine learning, each suited for different kinds of problems:

Understanding with Examples

Supervised Learning Example: Teaching a computer to recognize cats by showing it thousands of images labeled "cat" or "not cat." After training, it can identify cats in new photos.

Unsupervised Learning Example: Giving a computer customer purchase data and letting it discover natural groups—like "budget shoppers" vs "premium buyers"—without telling it what groups to look for.

Reinforcement Learning Example: A robot learning to walk by trying different movements. When it falls, it learns to avoid that action. When it takes a successful step, it reinforces that behavior.

How Machines Learn: A Real Story

Not so long ago, if you had picked up your phone and asked an AI assistant what to do in a certain situation, it would have ignored you—and people might have looked at you like you were crazy. Today, it's completely normal. Technology is growing like never before, and Machine Learning is at the center of this transformation.

The Spam Filter Story

Back in the 1990s, one of the earliest real-world uses of ML was the spam filter. Imagine checking your email back then—your inbox would often be flooded with unwanted messages about fake lottery wins, miracle diets, or suspicious job offers.

Engineers started building systems that could learn to recognize spam patterns based on examples. The key insight was: instead of writing rules like "if email contains the word 'lottery', mark as spam," they let the system learn from actual spam and legitimate emails.

Over time, as users kept marking messages as spam, the system learned to identify new spam even before users had to do anything. That was early machine learning in action.

Breaking Down the Learning Process

Let's understand the spam filter using Mitchell's definition:

Key ML Terminology

Training Set: The collection of examples used to teach the system.

Training Instance (Sample): Each individual example in the training set.

Model: The "brain" of the ML system that does the actual learning and prediction. Think of it as the thing being trained.

Features: The characteristics of the data (like weight, color, word count).

Labels: The categories or values we want to predict (like "spam" or "not spam").

Traditional Programming vs Machine Learning

To truly understand what makes ML special, let's compare it with how we normally program computers.

Why AlphaGo Matters

Traditional AI programs like Deep Blue (which beat chess champion Kasparov) were good at one specific task because humans programmed all the chess rules and strategies. But the game of Go is far too complex for this approach—there are more possible Go positions than atoms in the universe!

AlphaGo, developed by DeepMind, learned to play Go by playing against itself millions of times, improving its strategy without human intervention. It eventually became the world champion, beating the best human players. This showed the true power of machine learning.

Applications of Machine Learning

ML is everywhere in our daily lives. Here are some of the most common applications:

Common Machine Learning Libraries

You don't need to build everything from scratch. These tools make ML accessible to everyone:

PyTorch vs TensorFlow

Both are excellent choices for deep learning, but they have different strengths:

Your First Machine Learning Model

Let's build something real! We'll create a model that can tell apples from oranges based on their weight and color. This takes just a few minutes.

Step 1: Install Scikit-Learn

Open your terminal or use Google Colab and run:

# In terminal
pip install scikit-learn

# In Google Colab
!pip install scikit-learn

Step 2: The Problem

We want to teach a computer to distinguish between apples and oranges:

• Apples tend to be heavier and red

• Oranges tend to be lighter and orange-colored

At first glance, this seems easy. But as you get more fruits with varying sizes and colors, writing rules for every single case becomes impossible. Let's let the machine learn instead!

Step 3: Write the Code

from sklearn import tree

# Step 1: Collect training data
# Features: [weight in grams, color (0 = red, 1 = orange)]
features = [
    [150, 0],  # Apple (heavy, red)
    [170, 0],  # Apple (heavy, red)
    [130, 1],  # Orange (lighter, orange)
    [120, 1],  # Orange (lighter, orange)
]
labels = ["apple", "apple", "orange", "orange"]

# Step 2: Create and train the model
clf = tree.DecisionTreeClassifier()
clf = clf.fit(features, labels)

# Step 3: Make predictions!
print(clf.predict([[160, 0]]))  # Heavy and red → Apple!
print(clf.predict([[115, 1]]))  # Light and orange → Orange!

What Just Happened?

fit() means "find patterns in this data." The model looked at our examples and learned that heavier, red things are apples and lighter, orange things are oranges.

predict() uses what was learned to classify new items. We never wrote any if-else rules—the computer figured them out!

Step 4: Visualize Your Model

You can actually see how the decision tree makes decisions:

from sklearn.tree import plot_tree
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
plot_tree(clf, 
    feature_names=["weight", "color"], 
    class_names=["apple", "orange"],
    filled=True)
plt.show()

Try It Yourself!

• What happens with [140, 1]? (Medium weight, orange color)

• Try [200, 0]—a very heavy red fruit

• Add more training examples and see how predictions change!

Understanding Classifiers

A classifier is a type of ML model that puts things into categories. It's one of the most common types of machine learning.

How Classifiers Work

This process is called supervised learning because we supervise the learning by providing correct answers (labels) during training.

Another Example with Numbers

from sklearn import tree

# Features: [weight, texture (0=smooth, 1=bumpy)]
features = [[140, 1], [130, 1], [150, 0], [170, 0]]
labels = [0, 0, 1, 1]  # 0 = Apple, 1 = Orange

# Train
clf = tree.DecisionTreeClassifier()
clf = clf.fit(features, labels)

# Predict
print(clf.predict([[160, 0]]))  # Output: [1] → Orange

Why This Matters

The beauty of classifiers (and ML in general) is that you don't write rules—the machine learns them. You can solve completely new problems just by changing the training data. The same algorithm that classifies fruits could classify emails, diseases, customer types, or anything else—just with different data!