import random
import matplotlib.pyplot as plt
%matplotlib inline

def dot(u, v):
    # <your code>

def vector_add(u, v):
    # <your code>

def scalar_mult(c, v):
    # <your code>

assert dot([1, 2, 3], [4, 5, 6]) == 32
assert vector_add([1, 2], [3, 4]) == [4, 6]
assert scalar_mult(2, [1, -1, 0.5]) == [2, -2, 1.0]
print('A.1 looks good!')

def squared_error_loss(x, y, w, b):
    z = dot(w, x) + b
    return (y - z) ** 2

def analytic_gradient(x, y, w, b):
    # <your code>, using the formulas you derived in (a)
    return grad_w, grad_b

def numerical_gradient(x, y, w, b, h=1e-5):
    # <your code>, using centered finite differences: (L(param + h) - L(param - h)) / (2 * h)
    return grad_w, grad_b

x_test = [1.0, -2.0]
y_test = 1.0
w_test = [0.3, -0.1]
b_test = 0.2

ga_w, ga_b = analytic_gradient(x_test, y_test, w_test, b_test)
gn_w, gn_b = numerical_gradient(x_test, y_test, w_test, b_test)

print('analytic gradient:', ga_w, ga_b)
print('numeric  gradient:', gn_w, gn_b)

for a, n in zip(ga_w, gn_w):
    assert abs(a - n) < 1e-3, 'gradient w.r.t. w does not match — recheck your derivation'
assert abs(ga_b - gn_b) < 1e-3, 'gradient w.r.t. b does not match — recheck your derivation'
print('A.2 looks good!')

def mean(values):
    # <your code>

def variance(values):
    # <your code>

def standardize(values):
    """Return a new list with each value converted to a z-score,
    using this list's own mean and variance."""
    # <your code>

vals = [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]
assert abs(mean(vals) - 5.0) < 1e-9
assert abs(variance(vals) - 4.0) < 1e-9
z = standardize(vals)
assert abs(mean(z)) < 1e-9
assert abs(variance(z) - 1.0) < 1e-9
print('A.3 looks good!')

# Fetch the dataset if it's not already sitting next to this notebook
# (e.g. when running in Google Colab).
import os
import urllib.request

DATA_URL = "https://raw.githubusercontent.com/AdaptInfer/dgm-fall-2026/main/assets/hw/hw1/dataset.csv"
if not os.path.exists("dataset.csv"):
    urllib.request.urlretrieve(DATA_URL, "dataset.csv")

raw_features = []
labels = []

with open('./dataset.csv', 'r') as f:
    next(f)  # skip header: refractive_index,inclusion_density,label
    for line in f:
        line = line.strip()
        if not line:
            continue
        values = line.split(',')
        raw_features.append([float(values[0]), float(values[1])])
        labels.append(int(values[2]))

print(len(raw_features), len(labels))

col0 = [row[0] for row in raw_features]
col1 = [row[1] for row in raw_features]

col0_std = standardize(col0)
col1_std = standardize(col1)

features = [[a, b] for a, b in zip(col0_std, col1_std)]

random.seed(453)

idx = list(range(len(features)))
random.shuffle(idx)

X_train = [features[i] for i in idx[:100]]
y_train = [labels[i] for i in idx[:100]]
X_test = [features[i] for i in idx[100:]]
y_test = [labels[i] for i in idx[100:]]

plt.scatter([x[0] for x, yi in zip(X_train, y_train) if yi == 0],
            [x[1] for x, yi in zip(X_train, y_train) if yi == 0],
            label='synthetic (0)', marker='o')

plt.scatter([x[0] for x, yi in zip(X_train, y_train) if yi == 1],
            [x[1] for x, yi in zip(X_train, y_train) if yi == 1],
            label='genuine (1)', marker='s')

plt.title('Training set (standardized features)')
plt.xlabel('refractive index (standardized)')
plt.ylabel('inclusion density (standardized)')
plt.legend()
plt.show()

class Perceptron():
    def __init__(self, num_features):
        self.weights = # <your code>
        self.bias = # <your code>
        self.best_weights = list(self.weights)
        self.best_bias = self.bias
        self.best_errors = float('inf')

    def net_input(self, x):
        # <your code>, using dot()

    def activation(self, z):
        # <your code>

    def predict(self, x, use_pocket=False):
        if use_pocket:
            z = # <your code>: same idea as net_input, but using self.best_weights/self.best_bias
        else:
            z = self.net_input(x)
        return self.activation(z)

    def fit(self, X, y, epochs):
        error_history = []
        for e in range(epochs):
            errors = 0
            for xi, yi in zip(X, y):
                # <your code> to compute the prediction and update self.weights/self.bias
                # (hint: vector_add/scalar_mult from Part A.1 are exactly the tools for this)
                # <your code> to count this example as an error if the prediction was wrong
            error_history.append(errors)
            # <your code> to update self.best_weights/self.best_bias/self.best_errors
            # if this epoch's weights are the best seen so far
        return error_history

    def evaluate(self, X, y, use_pocket=False):
        # <your code> to compute prediction accuracy, optionally using the pocketed weights
        return accuracy

ppn = Perceptron(num_features=2)
error_history = ppn.fit(X_train, y_train, epochs=10)

print('final weights:', ppn.weights, 'final bias:', ppn.bias)
print('pocket weights:', ppn.best_weights, 'pocket bias:', ppn.best_bias, 'pocket errors:', ppn.best_errors)

##########################
### Learning curve
##########################

plt.plot(range(1, len(error_history) + 1), error_history, marker='o')
plt.title('Perceptron learning curve')
plt.xlabel('epoch')
plt.ylabel('number of misclassifications')
plt.show()

# <your code>
print('Train set accuracy (final):  %.2f%%' % (train_acc_final * 100))
print('Test set accuracy (final):   %.2f%%' % (test_acc_final * 100))

# <your code>
print('Train set accuracy (pocket): %.2f%%' % (train_acc_pocket * 100))
print('Test set accuracy (pocket):  %.2f%%' % (test_acc_pocket * 100))

##########################
### 2D Decision Boundary
##########################

def boundary_points(w, b, x_range):
    # The decision boundary is where net_input(x) = w[0]*x0 + w[1]*x1 + b = 0
    # (the same net_input you implemented in the Perceptron class above).
    # Solve that equation for x1 in terms of x0:
    x0_vals = list(x_range)
    x1_vals = # <your code>: for each x0 in x0_vals, the x1 with w[0]*x0 + w[1]*x1 + b == 0
    return x0_vals, x1_vals

x0_range = [min(x[0] for x in features) - 0.5, max(x[0] for x in features) + 0.5]
bx, by = boundary_points(ppn.weights, ppn.bias, x0_range)

fig, axes = plt.subplots(1, 2, figsize=(10, 4), sharex=True, sharey=True)

for ax, X_set, y_set, title in [(axes[0], X_train, y_train, 'Training set'),
                                 (axes[1], X_test, y_test, 'Test set')]:
    ax.scatter([x[0] for x, yi in zip(X_set, y_set) if yi == 0],
               [x[1] for x, yi in zip(X_set, y_set) if yi == 0],
               label='synthetic (0)', marker='o')
    ax.scatter([x[0] for x, yi in zip(X_set, y_set) if yi == 1],
               [x[1] for x, yi in zip(X_set, y_set) if yi == 1],
               label='genuine (1)', marker='s')
    ax.plot(bx, by, 'k-', label='decision boundary')
    ax.set_title(title)
    ax.set_xlabel('refractive index (standardized)')
    ax.legend()

axes[0].set_ylabel('inclusion density (standardized)')
plt.tight_layout()
plt.show()

How to Submit¶

HW 1: Math Foundations + the Perceptron Algorithm in "Just" Python (50 pts)¶

Important!¶

0) Imports¶

Part A: Statistics, Linear Algebra, and Calculus Warm-Up (15 pts)¶

A.1) Linear algebra: vector operations (5 pts)¶

A.2) Calculus: hand-derived vs. numerical gradients (5 pts)¶

A.3) Statistics: mean, variance, and standardization (5 pts)¶

Part B: The Perceptron Algorithm in "Just" Python (35 pts)¶

1) Loading the dataset¶

2) Defining the Perceptron model¶

3) Training the Perceptron¶

4) Learning curve¶

5) Evaluating the model¶

6) Decision boundary¶