Perceptron Learning and Introduction to Regression

3.1 Perceptron Mathematical Model

3.1.1 Hook

3.1.2 Intuition and Analogy

3.1.3 Formalize — The Mathematical Model

A perceptron receives $N$ input features. They are $x_1,x_2,\dots ,x_N$. Each feature $x_i$ has a weight $w_i$. The weight says how important that feature is. There is also a bias $b$. The bias is an extra offset that shifts the decision boundary.

First, the perceptron computes a weighted sum:

$$z=b+w_1{x}_1+w_2{x}_2+\cdots +w_N{x}_N$$

Some textbooks write $w_0$ instead of $b$ and set a dummy input $x_0=1$. Then the sum becomes compact:

$$z=\sum _{i=0}^N{w}_i{x}_i$$

Second, the perceptron applies a threshold. It compares $z$ to zero:

$$\hat{y}=\{\begin{array}{ll}1& \text{if }z\ge 0\\ 0& \text{if }z<0\end{array}$$

The original perceptron used $+1$ and $-1$ instead of $1$ and $0$:

$$\hat{y}=\{\begin{array}{ll}+1& \text{if }z\ge 0\\ -1& \text{if }z<0\end{array}$$

Both conventions are fine. The key idea does not change.

3.1.4 Symbol Registry

3.1.5 Worked Example — A Tiny Perceptron

3.1.6 Assumptions and Scope

3.1.7 Visual Intuition

Imagine a 2D scatter plot. The X-axis is feature $x_1$, the Y-axis is feature $x_2$. Data points are either circles (class 0) or crosses (class 1). The perceptron draws a straight line through this plane: $w_0+w_1{x}_1+w_2{x}_2=0$. Everything on one side of the line is class 1. Everything on the other side is class 0. The weights determine the angle and position of the line. The bias slides it left or right. Learning means rotating and shifting this line until it splits the circles from the crosses perfectly.

3.1.8 Pitfalls

3.1.9 Student Questions and Answers

3.1.10 Recap and Bridge

Now that you know what a perceptron is, you will see how to pick the right weights to mimic logic gates.

3.1.11 Real-World and Domain Connection

The perceptron was the first hardware implementation of a learning machine. Frank Rosenblatt built it at Cornell in the late 1950s as the "Mark I Perceptron." It was a room-sized machine with 400 photocells connected to neurons via potentiometers (adjustable weights). It could recognize simple patterns like letters. While primitive by today's standards, it proved that machines could learn from data. Modern spam filters, credit card fraud detectors, and medical screening tools all descend from this yes/no decision unit.

3.2 Designing Logic Gates with a Single Perceptron

3.2.1 Hook

3.2.2 Intuition and Analogy

3.2.3 Formalize — AND Gate Weight Design

Start with the AND gate truth table. Each row is a training example:

The perceptron equation with bias $w_0$ (where $x_0=1$): $z=w_0+w_1{x}_1+w_2{x}_2$

Decision rule: if $z\ge 0$, predict 1; if $z<0$, predict 0.

Set up the inequalities for each row:

$$\begin{array}{rlrl}\text{Row 1 (0,0 → 0):}& w_0+w_1\cdot 0+w_2\cdot 0<0& & \Rightarrow w_0<0\\ [4pt]\text{Row 2 (0,1 → 0):}& w_0+w_1\cdot 0+w_2\cdot 1<0& & \Rightarrow w_0+w_2<0\\ [4pt]\text{Row 3 (1,0 → 0):}& w_0+w_1\cdot 1+w_2\cdot 0<0& & \Rightarrow w_0+w_1<0\\ [4pt]\text{Row 4 (1,1 → 1):}& w_0+w_1\cdot 1+w_2\cdot 1\ge 0& & \Rightarrow w_0+w_1+w_2\ge 0\end{array}$$

3.2.4 Worked Example — Verifying the Found Weights

3.2.5 Visual Intuition — The Decision Boundary

Plot the four data points on a 2D plane ($x_1$ on X-axis, $x_2$ on Y-axis):

• (0,0) — label 0
• (0,1) — label 0
• (1,0) — label 0
• (1,1) — label 1 (the only positive case)

Set the weighted sum to zero to get the decision line:

$$-1+0.75x_1+0.75x_2=0\Rightarrow x_1+x_2=\frac{4}{3}\approx 1.33$$

The line cuts through the plane diagonally. The point (1,1) sits above and to the right of the line — so it is classified as 1. The other three points fall below — classified as 0. The line perfectly separates the two classes.

Takeaway: Because the data is linearly separable, one straight line does the job. This is exactly what machine learning tries to do — find patterns intelligently from data.

3.2.6 Assumptions and Scope

3.2.7 Pitfalls

3.2.8 Student Questions and Answers

3.2.9 Recap and Bridge

But solving inequalities by hand does not scale to real data. Next: how to make the perceptron learn weights from examples automatically.

3.2.10 Real-World and Domain Connection

Designing logic gates with perceptrons is more than a classroom exercise. It shows that a neural network can represent Boolean functions — the foundation of all digital computation. In fact, any Boolean function can be built from perceptrons. This requires multiple layers. It is the idea behind the universal approximation theorem. Early AI researchers used perceptrons to model decision-making: if humidity is high AND temperature is above 30°C, trigger irrigation. Modern rule-based expert systems and decision support tools still use this idea. Agriculture, medicine, and industrial control all benefit. But now with learned weights rather than hand-set ones.

3.3 Perceptron Learning Algorithm — Intuition

3.3.1 Hook

3.3.2 Intuition and Analogy

3.3.3 Purpose — Why This Algorithm Exists

3.3.4 Inputs and Outputs

3.3.5 Steps — The Algorithm at a Glance

3.3.6 Trace — Goa Fruit Classification Walkthrough

3.3.7 Quantifying Error

The weight update depends on how far wrong the prediction is. For a single data point:

$$\text{error}=t-\hat{y}$$

If the target is 1 and the prediction is 0: error = +1 (weights should go up). If the target is 0 and the prediction is 1: error = −1 (weights should go down). If they match: error = 0 (no update).

The gradient is the mathematical tool that tells you which direction to adjust each weight. Think of the error as a landscape of hills and valleys. The gradient is the steepest downhill direction. The weight update moves you a small step — of size $\eta$ — in that direction.

When you add up errors across all data points, you get the loss (also called the cost). Minimizing loss is the machine's goal.

3.3.8 Complexity and Cost

A single pass through all $N$ data points is one epoch. Each epoch requires $O(N\cdot d)$ operations where $d$ is the number of features. For linearly separable data, the algorithm converges. But the number of epochs needed can be large for difficult problems. For non-linearly separable data, the algorithm never converges — it oscillates forever.

3.3.9 When to Use and Alternatives

3.3.10 Pitfalls

3.3.11 Student Questions and Answers

3.3.12 Recap and Bridge

Next, you will see this algorithm in action — a full step-by-step worked example on the NOT gate.

3.3.13 Real-World and Domain Connection

The perceptron algorithm was the first practical proof that machines could learn from examples — a milestone in 1958. Today, the same principle of "predict, compare, adjust" powers everything from Netflix recommendations to self-driving car perception. Each time YouTube suggests a video you might like, a variant of this loop runs. The model predicts which videos match your taste. It checks against what you actually watched. Then it updates its internal weights. The perceptron's simple idea — learn from mistakes — scales to systems with billions of parameters.

3.4 Perceptron Learning Algorithm — NOT Gate Worked Example

3.4.1 Hook

3.4.2 Purpose

3.4.3 Inputs and Outputs

3.4.4 Steps — Full Trace

3.4.5 Visual Intuition

Plot this on a 1D line (the $x_1$ axis). Two points: $x_1=0$ (target 1, mark as circle) and $x_1=1$ (target 0, mark as cross). The learned decision boundary is a vertical cut at $x_1=0$. The point at $x_1=0$ falls exactly on the boundary — the algorithm treats $z=0$ as class 1. The point at $x_1=1$ falls to the right, where $z<0$, so it is class 0. Any line between $x_1=0$ and $x_1=1$ would have worked. The algorithm found $x_1=0$, which is one valid answer among many.

3.4.6 Complexity and Cost

This tiny problem converged in 3 epochs with only 3 weight updates. Each epoch visits all 2 data points (4 computations of $z$). Total cost: trivial. But note that the algorithm "wasted" Epoch 1's first point. The initial zero weights happened to classify it correctly. That was just luck. Real problems take many more epochs.

3.4.7 Pitfalls

3.4.8 Student Questions and Answers

3.4.9 Recap and Bridge

Next: how do you know when to stop the algorithm? That is the question of convergence criteria.

3.4.10 Real-World and Domain Connection

The NOT gate example may seem trivial. But it reveals a profound idea. A machine with no prior knowledge — zero weights — can learn a rule purely from examples. This is the foundation of all supervised learning. When a self-driving car learns to detect stop signs, the same loop runs. But now with millions of parameters and millions of examples. The perceptron's three-line update rule was the starting point for all of deep learning.

3.5 Convergence Criteria

3.5.1 Hook

3.5.2 Intuition and Analogy

3.5.3 Formalize — Four Convergence Criteria

3.5.4 Worked Example — Applying Each Criterion

3.5.5 Learning Rate as a Hyperparameter

The learning rate $\eta$ is a hyperparameter — a setting you choose before training begins. It controls the step size of each weight update.

Typical values: between 0.01 and 0.5. Values above 1 rarely work for real datasets because the adjustments become too large and oscillate.

There is no universal rule for picking $\eta$. It does not depend on the application domain. The same rules apply to text, images, and prices alike. For each dataset, you experiment. Try $\eta =0.01$. Try $\eta =0.1$. Try $\eta =0.5$. See which converges fastest and use that value.

In later modules, you will see adaptive learning rates — where $\eta$ changes during training, starting large and shrinking over time.

3.5.6 Assumptions and Scope

3.5.7 Pitfalls

3.5.8 Student Questions and Answers

3.5.9 Recap and Bridge

Now you have seen the perceptron learn. But what happens when you chain many perceptrons together? That requires data flowing in two directions — forward and backward.

3.5.10 Real-World and Domain Connection

Convergence criteria are used in every modern ML training pipeline. When you train a large language model like GPT, the training log shows a "loss curve." This is a plot of error over training steps. Engineers watch this curve to decide when to stop. Flatlining loss means the model is not learning any more — time to stop. In industry, "early stopping" (a form of criterion 3) is one of the most widely used regularization techniques to prevent overfitting. The principles you learn here on a single perceptron scale directly to billion-parameter models.

3.6 Forward and Backward Propagation

3.6.1 Hook

3.6.2 Intuition and Analogy

3.6.3 Formalize — The Two Passes

3.6.4 The Adjustment Process — Step by Step

3.6.5 Trace — A Tiny Two-Layer Network

3.6.6 Visual Intuition

Imagine a multi-story building. Forward propagation: a message goes from the ground floor up each floor to the rooftop. This is the input layer moving through hidden layers to the output. Backward propagation: a correction signal starts at the rooftop and cascades down. It touches every room on every floor. Each room adjusts slightly based on the correction it gets. The building learns the right configuration over many cycles.

3.6.7 Assumptions and Scope

3.6.8 Pitfalls

3.6.9 Student Questions and Answers

3.6.10 Recap and Bridge

Next, you will see a practical implementation — using sklearn's built-in perceptron to classify iris flowers.

3.6.11 Real-World and Domain Connection

Forward-backward training is what makes modern AI possible. Every deep learning breakthrough uses the same engine. AlphaGo beating a Go champion. GPT writing coherent text. Midjourney generating art. All rely on forward pass to produce output and backward pass to assign credit to every weight. Google's 2012 "cat detector" used exactly this two-pass mechanism. It had a network with one billion connections. It learned to recognize cats from YouTube videos. The core idea you are learning now scales directly to those systems.

3.6.12 Symbol Registry

3.7 Using sklearn's Inbuilt Perceptron — Iris Classification

3.7.1 Hook

3.7.2 Purpose

3.7.3 Inputs and Outputs

3.7.4 Steps — Loading, Training, and Predicting

from sklearn import datasets
iris = datasets.load_iris()

# Assume X and y are prepared
# X shape: (150, 2), y values: 0 for setosa, 1 for others

from sklearn.linear_model import Perceptron
model = Perceptron()
model.fit(X, y)

print(model.coef_)        # [[w1, w2]] — the feature weights
print(model.intercept_)   # [w0] — the bias term

prediction = model.predict([[new_x1, new_x2]])

3.7.5 Trace — What Happens Inside fit()

When you call model.fit(X, y), sklearn:

1. Initializes weights to zero
2. Loops through the data points in each epoch
3. For each point: computes the weighted sum, predicts $\hat{y}$, compares with $y$
4. On misclassification: updates weights using the perceptron rule
5. Stops when either all points are correctly classified or max_iter is reached

The Perceptron class can also handle multi-class problems by building multiple binary classifiers internally — one per class pair (one-vs-rest strategy). Each binary classifier has its own set of coefficients.

3.7.6 Visual Intuition

Plot the iris data in a 2D scatter plot with petal length on the X-axis and petal width on the Y-axis. Color the points by species: red for setosa (class 0), blue and green for the other two. The sklearn perceptron draws a straight line through this plane. Setosa points cluster on one side. The other two species cluster on the other side. The line slides between these clusters. This is the same idea as the AND gate and the goa fruit demo. But now with real biological measurements instead of 0s and 1s.

3.7.7 Pitfalls

3.7.8 Student Questions and Answers

3.7.9 Recap and Bridge

Next, you will code the perceptron yourself from scratch in Python — no library shortcuts — to solidify your understanding.

3.7.10 Real-World and Domain Connection

The Iris dataset is one of the most famous datasets in machine learning history, introduced by Ronald Fisher in 1936. It is the "Hello World" of classification. Every ML practitioner has trained on iris at some point. sklearn itself powers thousands of production systems — from recommendation engines to fraud detection pipelines. The Perceptron class is rarely used in production today. Logistic regression and SVMs are more reliable choices. But it serves as the pedagogical entry point for understanding how all linear classifiers work under the hood.

3.8 Coding Perceptron from Scratch — OR Gate

3.8.1 Hook

3.8.2 Purpose

3.8.3 Inputs and Outputs

3.8.4 Steps — The Code Walkthrough

import numpy as np

X = np.array([[0, 0],
              [0, 1],
              [1, 0],
              [1, 1]])
y = np.array([-1, 1, 1, 1])

def initialize_parameters(dim):
    W = np.zeros(dim + 1)  # +1 for bias
    return W

W = initialize_parameters(2)  # W = [w0, w1, w2], all zero

3.8.5 Trace — What Each Line Does

3.8.6 Complexity and Cost

For 4 data points and 3 parameters, each epoch costs 12 multiply-add operations. The algorithm converges in about 5–10 epochs. Total cost: negligible. For real datasets with thousands of features and millions of points, each epoch is expensive. That is why early stopping (checking when the cost flattens) is practically useful.

3.8.7 Pitfalls

3.8.8 Student Questions and Answers

3.8.9 Recap and Bridge

Next, you will see what happens when the data is NOT linearly separable — the famous XOR problem.

3.8.10 Real-World and Domain Connection

Implementing perceptrons from scratch with NumPy is a standard exercise in ML courses worldwide. In industry, you would use frameworks like PyTorch or TensorFlow. But the underlying mechanics — forward pass, loss computation, gradient-based update — are identical. When you debug a PyTorch model and something goes wrong, knowing what happens under the hood lets you fix it. That is the value of coding it yourself. The code you write here is a miniature version of the training loop inside every deep learning framework.

3.9 The XOR Problem — Non-linearly Separable Data

3.9.1 Hook

3.9.2 Intuition and Analogy

3.9.3 Formalize — The XOR Truth Table

3.9.4 Why a Single Perceptron Fails

3.9.5 The Solution — Multi-Layer Perceptron (Intuition)

The fix: use more than one perceptron. Arrange them in layers.

The standard MLP solution for XOR uses:

• Hidden layer with 2 neurons (using a non-linear activation like ReLU or sigmoid)
• Output layer with 1 neuron

The hidden neurons transform the input space so that the transformed points become linearly separable. The output neuron then draws one line in the transformed space. This is the essence of representation learning — learn a new space where the problem becomes simple.

3.9.6 Trace — What Happens When You Try a Single Perceptron on XOR

3.9.7 Visual Intuition

Draw a 2D square with corners at (0,0), (0,1), (1,0), (1,1). Mark (0,0) and (1,1) as red circles (class 0). Mark (0,1) and (1,0) as blue crosses (class 1). Now draw a single straight line. Cut the square any way: vertical, horizontal, diagonal. Always, the line passes through the middle, splitting the square into two halves. Each half contains one red and one blue. This is the geometric proof that XOR is not linearly separable.

Now add a hidden layer. The two hidden neurons transform the square — one neuron pulls (0,0) and (1,1) apart, the other neuron separates (0,1) and (1,0). In the transformed space, the points are arranged in a line, and the output neuron can split them with one cut. The transformation makes a hard problem easy.

3.9.8 Assumptions and Scope

3.9.9 Pitfalls

3.9.10 Student Questions and Answers

3.9.11 Recap and Bridge

With the XOR problem, you have seen the need for deeper architectures. Next, a different direction: instead of classification (yes/no), what if the output is a number? That is regression.

3.9.12 Real-World and Domain Connection

The XOR problem was highlighted by Marvin Minsky and Seymour Papert in their 1969 book Perceptrons. They proved mathematically that single-layer perceptrons could not solve XOR and similar problems. This book contributed to the first "AI winter" — a period of reduced funding and interest in neural networks. It took until the 1980s (with the popularization of backpropagation for multi-layer networks) for the field to recover. Today, every deep neural network owes its existence to the XOR insight. The one recognizing your face in a photo. The one translating your speech. All exist because researchers learned: stack neurons, and the impossible becomes possible.

3.10 Introduction to Regression with Single Perceptron

3.10.1 Hook

3.10.2 Intuition and Analogy

3.10.3 Formalize — Regression vs. Classification

3.10.4 Error Function — Mean Squared Error (MSE)

For classification, you count misclassifications. For regression, you measure how far off the numbers are.

For a single data point, the squared error is:

$$e^2=(t-\hat{y}{)}^2$$

Expanded (since $\hat{y}$ is the weighted sum):

$$e^2=(t-(w_0+w_1{x}_1+\cdots +w_N{x}_N){)}^2$$

For all $N$ data points, the mean squared error (MSE) is:

$$\text{MSE}=\frac{1}{N}\sum _{i=1}^N(t_i-{\hat{y}}_i{)}^2$$

3.10.5 The Objective Function

The machine's goal: find weights that minimize the total loss:

$$\arg \underset{\mathbf{w}}{\min }\sum _{i=1}^N(t_i-{\hat{y}}_i{)}^2$$

This means: search over all possible weight vectors. $\mathbf{w}=(w_0,w_1,\dots ,w_N)$. Pick the one that gives the smallest total squared error.

3.10.6 Weight Update Rule for Regression

The update rule uses the gradient of the MSE. For a single data point:

$$w_i^{\text{(new)}}=w_i^{\text{(old)}}-\eta \cdot (\hat{y}-t)\cdot x_i$$

Note the sign: this uses $(\hat{y}-t)$, not $(t-\hat{y})$. The order is reversed compared to the classification perceptron. Both conventions are equivalent — only the sign of the update flips. The minus sign before $\eta$ means: if $\hat{y}>t$ (overprediction), decrease the weight. If $\hat{y}<t$ (underprediction), increase the weight.

Derivation sketch:

The loss for one point is $L=(t-\hat{y}{)}^2$. By the chain rule:

$$\frac{\partial L}{\partial w_i}=2(t-\hat{y})\cdot \frac{\partial (t-\hat{y})}{\partial w_i}=2(t-\hat{y})\cdot (-x_i)=-2(t-\hat{y})\cdot x_i$$

Some textbooks include a $\frac{1}{2}$ in the loss ($\frac{1}{2}(t-\hat{y}{)}^2$) so that the 2 cancels:

$$\frac{\partial }{\partial w_i}\left[\frac{1}{2}(t-\hat{y}{)}^2\right]=(t-\hat{y})\cdot (-x_i)=-(t-\hat{y})\cdot x_i=(\hat{y}-t)\cdot x_i$$

The weight update $w_i\leftarrow w_i-\eta \cdot \frac{\partial L}{\partial w_i}$ simplifies. It becomes $w_i-\eta \cdot (\hat{y}-t)\cdot x_i$. Whether you include the $\frac{1}{2}$ or not, the algorithm works — it just changes the effective step size.

3.10.7 Worked Example — Salary Prediction

3.10.8 Visual Intuition — The Salary Line

Plot years of experience on the X-axis and salary on the Y-axis. The 3 data points form a loose upward trend. The regression line is the perceptron's prediction. It is the best straight line through these points. It minimizes the average squared vertical distance from each point to the line.

The true relationship (in green) is the target pattern. The predicted line (in red) is the model. The gap between the red line and each green dot is the residual (error). The algorithm tweaks $w_0$ and $w_1$. The intercept $w_0$ sets where the line hits the Y-axis. The slope $w_1$ sets how steep it is. It adjusts both to bring the red line as close as possible to the green points.

3.10.9 Assumptions and Scope

3.10.10 Pitfalls

3.10.11 Student Questions and Answers

3.10.12 Symbol Registry

3.10.13 Recap and Bridge

This concludes the core concepts. The appendices that follow summarize exam guidance and industry applications for everything covered in this lecture.

3.10.14 Real-World and Domain Connection

Linear regression is possibly the most widely used statistical tool in the world. Economists use it to predict GDP growth. Epidemiologists use it to model disease spread. Real estate platforms (Zillow's Zestimate) use regression — trained on millions of home sales — to estimate property values. Weather services predict tomorrow's temperature using regression on atmospheric measurements. Even advanced deep learning models often end with a regression layer. For example, a self-driving car's steering command is a continuous value. It is predicted by a regression head. The single-perceptron regression you learn here is the foundation of all continuous-value prediction in machine learning.

Exam Guidance Summary

Core Concepts to Master

Perceptron model:

• The mathematical structure: weighted sum followed by a threshold (the linear threshold unit).
• Both output conventions — $1/0$ and $+1/-1$ — and when each is used.
• The role of bias: $w_0$ or $b$, learned alongside other weights, shifts the decision boundary.

Logic gate design:

• Set up inequalities for AND, OR, and NOT gates from truth tables.
• Solve for valid weights (any solution satisfying all inequalities is correct).
• Understand why these gates are linearly separable.

Perceptron learning algorithm:

• Be able to work through the algorithm step by step for a given dataset. This is similar to the NOT gate worked example in Section 3.4.
• Know the weight update rule: $w_i^{\text{(new)}}=w_i^{\text{(old)}}+\eta \cdot (t-\hat{y})\cdot x_i$.
• Bias update: same rule with $x_0=1$.

Convergence criteria:

• Four stopping conditions: zero error, maximum iterations, no improvement over consecutive iterations, error reduction below threshold.
• Learning rate $\eta$ is a hyperparameter — determined experimentally, not learned from data.
• Typical learning rate values: 0.01 to 0.5.

Forward and backward propagation:

• Forward pass: input → hidden layers → output → loss.
• Backward pass: loss gradient → back through layers → update every weight.
• Understand the flow conceptually; detailed chain-rule derivations come later.

XOR problem:

• Why XOR is not linearly separable (diagonal classes, no single line works).
• Cost curve oscillates — a diagnostic of non-linearly separable data.
• Solution: multi-layer perceptron with hidden layers.
• Two hidden neurons + one output neuron = XOR solved.

Regression with a single perceptron:

• Skip the threshold — the raw weighted sum is the prediction.
• Mean squared error (MSE): $\frac{1}{N}\sum (t_i-{\hat{y}}_i{)}^2$.
• Weight update for regression: $w_i^{\text{(new)}}=w_i^{\text{(old)}}-\eta \cdot (\hat{y}-t)\cdot x_i$.
• The $\frac{1}{2}$ factor in some loss functions is for derivative convenience — does not affect correctness.

Study Tips

• Practice the NOT gate trace from Section 3.4 until you can do it from memory.
• Design an OR gate from scratch using inequalities — verify your solution.
• Write the perceptron update loop in Python without looking at notes.
• Draw the XOR 2D plot and explain in one sentence why a single line fails.

Key Industry Applications

Tools and Libraries

scikit-learn (sklearn): The most widely used machine learning library in Python. Its Perceptron class (sklearn.linear_model.Perceptron) implements the perceptron learning algorithm with production-grade optimizations. Use it for quick prototyping and baseline models. Shown on the Iris flower dataset in Section 3.7.

NumPy: The foundational numerical computing library for Python. Provides efficient array operations, linear algebra routines, and random number generation. Every perceptron implementation from scratch uses NumPy's vectorized operations. These compute weighted sums and apply updates in bulk. One operation handles all data points at once.

Benchmark Datasets

Iris Flower Dataset: Introduced by Ronald Fisher in 1936. Contains 150 samples across 3 species (setosa, versicolor, virginica) with 4 features (sepal length, sepal width, petal length, petal width). Available directly via sklearn.datasets.load_iris(). Used as a benchmark for classification algorithms. Setosa is linearly separable from the other two species — making it a perfect test case for a single perceptron.

Real-World Regression Applications

The regression techniques introduced in this lecture power these real-world systems:

• House price prediction: Real estate platforms (Zillow, Redfin) use regression to estimate property values. They use features like square footage, location, number of bedrooms, and year built.
• Weather forecasting: Meteorological agencies use regression to predict weather. They forecast temperature, rainfall, and wind speed from historical patterns and satellite data.
• Stock price prediction: Quantitative finance firms use regression to estimate future prices. They use historical trends, trading volume, and market indicators. (Note: financial prediction is hard; simple linear regression is a starting point, not a complete solution.)
• Crop yield prediction: Agricultural technology companies predict harvest quantities from several inputs. Soil composition, rainfall data, temperature patterns, and fertilizer usage. This helps farmers optimize planting and resource allocation.
• Energy consumption forecasting: Utility companies predict electricity demand from several factors. Time of day, temperature, day of week, and seasonal patterns. This enables efficient grid management and reduces waste.

These applications all share the same structure. Features in. Continuous value out. Model trained by minimizing prediction error. The single-perceptron regression you learn here is the simplest version of these production systems.