# =============================================================================# PART 4: THE PERCEPTRON - SETUP# ============================================================================= import numpy as npimport matplotlib.pyplot as pltfrom IPython.display import display, clear_output # Try to import ipywidgets for interactive featurestry:    import ipywidgets as widgets    WIDGETS_AVAILABLE = Trueexcept ImportError:    WIDGETS_AVAILABLE = False    print("Note: ipywidgets not installed. Interactive features will be limited.") # Set up matplotlib stylestyle_options = ['seaborn-v0_8-whitegrid', 'seaborn-whitegrid', 'ggplot', 'default']for style in style_options:    try:        plt.style.use(style)        break    except OSError:        continue plt.rcParams['figure.figsize'] = [10, 6]plt.rcParams['font.size'] = 12np.random.seed(42)  # For reproducible random numbers # =============================================================================# RECREATE OUR CANONICAL LINE IMAGES (from Parts 1-3)# ============================================================================= # Vertical line: bright pixels in the middle columnvertical_line = np.array([    [0, 1, 0],    [0, 1, 0],    [0, 1, 0]]) # Horizontal line: bright pixels in the middle rowhorizontal_line = np.array([    [0, 0, 0],    [1, 1, 1],    [0, 0, 0]]) # Flattened versions (9 pixels as a 1D array)vertical_flat = vertical_line.flatten()horizontal_flat = horizontal_line.flatten() print("Setup complete!")print("="*60)print("\nOur canonical images (as 3x3 matrices):")print(f"\nVertical Line:            Horizontal Line:")print(f"  {vertical_line[0]}                 {horizontal_line[0]}")print(f"  {vertical_line[1]}                 {horizontal_line[1]}")print(f"  {vertical_line[2]}                 {horizontal_line[2]}")print(f"\nAs flattened vectors (9 pixels):")print(f"  Vertical:   {vertical_flat}")print(f"  Horizontal: {horizontal_flat}")

# =============================================================================# DATASET GENERATOR: Create V/H Line Examples On-The-Fly# ============================================================================= def generate_line_dataset(n_samples=100, noise_level=0.0, seed=None):    """    Generate a dataset of vertical and horizontal line images.        Parameters:    -----------    n_samples : int        Total number of samples (will be split evenly between V and H)    noise_level : float (0.0 to 0.5)        Amount of random noise to add (0.0 = clean, 0.3 = noisy)    seed : int or None        Random seed for reproducibility        Returns:    --------    X : numpy array of shape (n_samples, 9)        Flattened 3x3 images    y : numpy array of shape (n_samples,)        Labels: 1 for vertical, 0 for horizontal    """        if seed is not None:        np.random.seed(seed)        X = []  # Will hold all images (as flattened arrays)    y = []  # Will hold all labels        # Generate n_samples/2 vertical lines and n_samples/2 horizontal lines    for i in range(n_samples):                if i < n_samples // 2:            # ----- VERTICAL LINE (label = 1) -----            # Pick a random column (0, 1, or 2) for variety            col = np.random.randint(0, 3)                        # Create blank 3x3 image            image = np.zeros((3, 3))                        # Fill the chosen column with 1s            image[:, col] = 1                        # Add noise if requested            if noise_level > 0:                image = image + np.random.randn(3, 3) * noise_level                image = np.clip(image, 0, 1)  # Keep values in [0, 1]                        X.append(image.flatten())            y.append(1)  # Label: Vertical                    else:            # ----- HORIZONTAL LINE (label = 0) -----            # Pick a random row (0, 1, or 2) for variety            row = np.random.randint(0, 3)                        # Create blank 3x3 image            image = np.zeros((3, 3))                        # Fill the chosen row with 1s            image[row, :] = 1                        # Add noise if requested            if noise_level > 0:                image = image + np.random.randn(3, 3) * noise_level                image = np.clip(image, 0, 1)                        X.append(image.flatten())            y.append(0)  # Label: Horizontal        # Convert to numpy arrays    X = np.array(X)    y = np.array(y)        # Shuffle the dataset (so V and H are mixed, not grouped)    shuffle_idx = np.random.permutation(n_samples)    X = X[shuffle_idx]    y = y[shuffle_idx]        return X, y print("Dataset generator function created!")print("="*60)

# =============================================================================# GENERATE AND VISUALIZE OUR DATASET# ============================================================================= # Generate 20 clean examples for visualizationX_small, y_small = generate_line_dataset(n_samples=20, noise_level=0.0, seed=42) print("DATASET GENERATED!")print("="*60)print(f"\nDataset shape: X = {X_small.shape}, y = {y_small.shape}")print(f"  - {X_small.shape[0]} total samples")print(f"  - Each sample has {X_small.shape[1]} features (3x3 = 9 pixels)")print(f"\nLabel distribution:")print(f"  - Vertical lines (y=1): {np.sum(y_small == 1)} samples")print(f"  - Horizontal lines (y=0): {np.sum(y_small == 0)} samples") # Show first few samplesprint("\n" + "="*60)print("FIRST 6 SAMPLES:")print("="*60) for i in range(6):    image = X_small[i].reshape(3, 3)    label = y_small[i]    label_name = "VERTICAL" if label == 1 else "HORIZONTAL"    print(f"\nSample {i}: Label = {label} ({label_name})")    print(f"  {image[0]}")    print(f"  {image[1]}")    print(f"  {image[2]}")

# =============================================================================# VISUALIZE SAMPLE IMAGES FROM OUR DATASET# ============================================================================= # Show a grid of 10 sample imagesfig, axes = plt.subplots(2, 5, figsize=(12, 5)) for i, ax in enumerate(axes.flat):    image = X_small[i].reshape(3, 3)    label = y_small[i]    label_name = "VERTICAL" if label == 1 else "HORIZONTAL"        ax.imshow(image, cmap='Blues', vmin=0, vmax=1)    ax.set_title(f"{label_name}\n(y={label})", fontsize=10)    ax.axis('off')        # Add grid lines    for j in range(4):        ax.axhline(j - 0.5, color='gray', linewidth=0.5)        ax.axvline(j - 0.5, color='gray', linewidth=0.5) plt.suptitle('Sample Images from Our Generated Dataset', fontsize=14, fontweight='bold')plt.tight_layout()plt.show() print("\nNotice: The lines can appear in different positions (left/center/right columns,")print("top/center/bottom rows). This variety makes our dataset more realistic!")

# =============================================================================# THE FORWARD PASS: Step-by-Step Walkthrough# ============================================================================= # Define the sigmoid activation function (from Part 3)def sigmoid(z):    """Sigmoid activation: squashes any value to range (0, 1)."""    return 1 / (1 + np.exp(-z)) # Let's use our canonical vertical line as the inputx = vertical_flat.copy() # Create some random weights (as if the Perceptron is untrained)np.random.seed(123)  # For reproducibilityw = np.random.randn(9) * 0.5  # 9 random weightsb = np.random.randn() * 0.1    # 1 random bias print("="*70)print("FORWARD PASS: Step-by-Step with Real Numbers")print("="*70) # ----- STEP 1: Receive Input -----print("\n┌─────────────────────────────────────────────────────────────────────┐")print("│ STEP 1: Receive Input                                               │")print("└─────────────────────────────────────────────────────────────────────┘")print(f"\nInput image (as 3x3 grid):")print(f"  {x.reshape(3,3)[0]}")print(f"  {x.reshape(3,3)[1]}")print(f"  {x.reshape(3,3)[2]}")print(f"\nFlattened input vector x:")print(f"  x = {x}") # ----- STEP 2: Weighted Sum (Dot Product) -----print("\n┌─────────────────────────────────────────────────────────────────────┐")print("│ STEP 2: Weighted Sum (Dot Product)                                  │")print("└─────────────────────────────────────────────────────────────────────┘")print(f"\nWeights vector w:")print(f"  w = [{', '.join([f'{wi:.3f}' for wi in w])}]") # Show element-wise multiplicationprint(f"\nElement-wise products (x[i] × w[i]):")products = x * wprint(f"  = [{', '.join([f'{p:.3f}' for p in products])}]") # Sum the productsdot_product = np.sum(products)print(f"\nSum of products (the dot product):")print(f"  w · x = {dot_product:.4f}") # ----- STEP 3: Add Bias -----print("\n┌─────────────────────────────────────────────────────────────────────┐")print("│ STEP 3: Add Bias                                                    │")print("└─────────────────────────────────────────────────────────────────────┘")print(f"\nBias value:")print(f"  b = {b:.4f}")print(f"\nPre-activation value z:")z = dot_product + bprint(f"  z = (w · x) + b")print(f"  z = {dot_product:.4f} + {b:.4f}")print(f"  z = {z:.4f}") # ----- STEP 4: Apply Activation -----print("\n┌─────────────────────────────────────────────────────────────────────┐")print("│ STEP 4: Apply Activation (Sigmoid)                                  │")print("└─────────────────────────────────────────────────────────────────────┘")print(f"\nApplying sigmoid to z = {z:.4f}:")y_hat = sigmoid(z)print(f"  ŷ = sigmoid(z) = 1 / (1 + e^(-z))")print(f"  ŷ = 1 / (1 + e^(-{z:.4f}))")print(f"  ŷ = {y_hat:.4f}") # ----- FINAL RESULT -----print("\n" + "="*70)print("FORWARD PASS COMPLETE!")print("="*70)print(f"\nFinal output: ŷ = {y_hat:.4f}")print(f"\nInterpretation: The Perceptron is {y_hat*100:.1f}% confident this is a VERTICAL line.")print(f"\nPrediction: {'VERTICAL (y=1)' if y_hat >= 0.5 else 'HORIZONTAL (y=0)'}")print(f"Actual label: VERTICAL (y=1)")print(f"{'✓ Correct!' if y_hat >= 0.5 else '✗ Wrong!'}")

# =============================================================================# THE PERCEPTRON CLASS: Clean, Reusable Implementation# ============================================================================= class Perceptron:    """    A single-layer Perceptron for binary classification.        This is the simplest possible neural network - just one neuron!        Attributes:        n_inputs (int): Number of input features (9 for our 3x3 images)        weights (array): One weight per input feature        bias (float): The threshold/offset term    """        def __init__(self, n_inputs):        """        Initialize the Perceptron with random weights and bias.                Parameters:            n_inputs: Number of input features (pixels in our image)        """        # Random weights, small values centered around 0        self.weights = np.random.randn(n_inputs) * 0.1                # Bias starts at 0        self.bias = 0.0                # Store for reference        self.n_inputs = n_inputs                # Storage for debugging/visualization        self.last_z = None    # Pre-activation value        self.last_output = None  # Final output        def forward(self, x):        """        Compute the forward pass - make a prediction.                Parameters:            x: Input array (can be 2D image or 1D flattened)                Returns:            float: Probability between 0 and 1        """        # Ensure x is a 1D array        x = np.array(x).flatten()                # STEP 1 & 2: Weighted sum + bias        # Formula: z = w · x + b        self.last_z = np.dot(self.weights, x) + self.bias                # STEP 3: Apply sigmoid activation        # Formula: output = 1 / (1 + e^(-z))        self.last_output = 1 / (1 + np.exp(-self.last_z))                return self.last_output        def predict(self, x):        """        Make a binary prediction (0 or 1).                Parameters:            x: Input array                Returns:            int: 0 (horizontal) or 1 (vertical)        """        probability = self.forward(x)        return 1 if probability >= 0.5 else 0        def __repr__(self):        return f"Perceptron(inputs={self.n_inputs})"  # Create our Perceptron!print("="*60)print("PERCEPTRON CLASS CREATED!")print("="*60) # Instantiate a Perceptron for 9 inputs (3x3 = 9 pixels)perceptron = Perceptron(n_inputs=9) print(f"\nOur Perceptron: {perceptron}")print(f"\nInitial weights (random, untrained):")print(f"  Shape: {perceptron.weights.shape}")print(f"  Values: [{', '.join([f'{w:.3f}' for w in perceptron.weights])}]")print(f"\nInitial bias: {perceptron.bias}")print("\nThe Perceptron is ready, but completely UNTRAINED!")print("Its weights are random - it doesn't know what a vertical line looks like.")

# =============================================================================# TESTING THE UNTRAINED PERCEPTRON ON OUR CANONICAL EXAMPLES# ============================================================================= print("="*70)print("TESTING UNTRAINED PERCEPTRON")print("="*70) # Test on our canonical vertical lineprint("\n┌─────────────────────────────────────────────────────────────────────┐")print("│ Test 1: VERTICAL LINE                                               │")print("└─────────────────────────────────────────────────────────────────────┘")print(f"\nImage (3x3):")print(f"  {vertical_line[0]}")print(f"  {vertical_line[1]}")print(f"  {vertical_line[2]}") prob_vertical = perceptron.forward(vertical_flat)pred_vertical = perceptron.predict(vertical_flat)actual_vertical = 1 print(f"\nForward pass calculation:")print(f"  z = w · x + b = {perceptron.last_z:.4f}")print(f"  output = sigmoid(z) = {prob_vertical:.4f}")print(f"\nPrediction: {pred_vertical} ({'VERTICAL' if pred_vertical == 1 else 'HORIZONTAL'})")print(f"Actual:     {actual_vertical} (VERTICAL)")print(f"Result:     {'CORRECT!' if pred_vertical == actual_vertical else 'WRONG!'}") # Test on our canonical horizontal lineprint("\n┌─────────────────────────────────────────────────────────────────────┐")print("│ Test 2: HORIZONTAL LINE                                             │")print("└─────────────────────────────────────────────────────────────────────┘")print(f"\nImage (3x3):")print(f"  {horizontal_line[0]}")print(f"  {horizontal_line[1]}")print(f"  {horizontal_line[2]}") prob_horizontal = perceptron.forward(horizontal_flat)pred_horizontal = perceptron.predict(horizontal_flat)actual_horizontal = 0 print(f"\nForward pass calculation:")print(f"  z = w · x + b = {perceptron.last_z:.4f}")print(f"  output = sigmoid(z) = {prob_horizontal:.4f}")print(f"\nPrediction: {pred_horizontal} ({'VERTICAL' if pred_horizontal == 1 else 'HORIZONTAL'})")print(f"Actual:     {actual_horizontal} (HORIZONTAL)")print(f"Result:     {'CORRECT!' if pred_horizontal == actual_horizontal else 'WRONG!'}")

# =============================================================================# TESTING ON THE FULL DATASET: Calculate Accuracy# ============================================================================= # Generate a larger dataset for proper testingX_test, y_test = generate_line_dataset(n_samples=100, noise_level=0.0, seed=99) print("="*70)print("FULL DATASET EVALUATION")print("="*70)print(f"\nDataset: {len(y_test)} samples ({sum(y_test)} vertical, {len(y_test) - sum(y_test)} horizontal)") # Make predictions on all samplespredictions = []correct = 0 for i in range(len(X_test)):    pred = perceptron.predict(X_test[i])    predictions.append(pred)    if pred == y_test[i]:        correct += 1 accuracy = correct / len(y_test) * 100 # Display results table (first 10 samples)print("\n" + "-"*70)print("FIRST 10 PREDICTIONS:")print("-"*70)print(f"{'Sample':<8} {'Actual':<12} {'Predicted':<12} {'Result':<10}")print("-"*70) for i in range(10):    actual_name = "VERTICAL" if y_test[i] == 1 else "HORIZONTAL"    pred_name = "VERTICAL" if predictions[i] == 1 else "HORIZONTAL"    result = "Correct" if predictions[i] == y_test[i] else "WRONG"    symbol = "+" if predictions[i] == y_test[i] else "X"    print(f"  {i:<6} {actual_name:<12} {pred_name:<12} {symbol} {result}") # Summaryprint("\n" + "="*70)print("ACCURACY SUMMARY")print("="*70)print(f"\n  Total samples:  {len(y_test)}")print(f"  Correct:        {correct}")print(f"  Wrong:          {len(y_test) - correct}")print(f"\n  ACCURACY: {accuracy:.1f}%")print(f"\n  Expected (random guessing): ~50%")print(f"  Difference from random: {abs(accuracy - 50):.1f}%") if accuracy > 55:    print("\n  Hmm, slightly better than random - got lucky with the random weights!")elif accuracy < 45:    print("\n  Worse than random! The weights are actually hurting performance.")else:    print("\n  As expected: basically random guessing. The Perceptron is CONFUSED!")

# =============================================================================# VISUALIZING THE PROBLEM: Random Weights vs Ideal Weights# ============================================================================= # What ideal weights for a vertical detector should look likeideal_weights = np.array([    [-1,  2, -1],   # Top row: look for middle    [-1,  2, -1],   # Middle row: look for middle    [-1,  2, -1]    # Bottom row: look for middle]).flatten() * 0.5 # Our actual (random) weightsactual_weights = perceptron.weights # Visualizefig, axes = plt.subplots(1, 3, figsize=(14, 4)) # Plot 1: Random weights (what we have)ax1 = axes[0]weights_grid = actual_weights.reshape(3, 3)im1 = ax1.imshow(weights_grid, cmap='RdBu', vmin=-0.5, vmax=0.5)ax1.set_title('Our Random Weights\n(Untrained)', fontsize=12, fontweight='bold')for i in range(3):    for j in range(3):        ax1.text(j, i, f'{weights_grid[i,j]:.2f}', ha='center', va='center', fontsize=10)plt.colorbar(im1, ax=ax1, label='Weight value') # Plot 2: Ideal weights (what we need)ax2 = axes[1]ideal_grid = ideal_weights.reshape(3, 3)im2 = ax2.imshow(ideal_grid, cmap='RdBu', vmin=-0.5, vmax=0.5)ax2.set_title('Ideal Weights\n(What we need)', fontsize=12, fontweight='bold')for i in range(3):    for j in range(3):        ax2.text(j, i, f'{ideal_grid[i,j]:.2f}', ha='center', va='center', fontsize=10)plt.colorbar(im2, ax=ax2, label='Weight value') # Plot 3: A vertical line (what we're trying to detect)ax3 = axes[2]im3 = ax3.imshow(vertical_line, cmap='Blues', vmin=0, vmax=1)ax3.set_title('Vertical Line\n(What we detect)', fontsize=12, fontweight='bold')for i in range(3):    for j in range(3):        ax3.text(j, i, f'{vertical_line[i,j]}', ha='center', va='center', fontsize=10)plt.colorbar(im3, ax=ax3, label='Pixel value') plt.tight_layout()plt.show() # Show the key insightprint("\nKEY INSIGHT: Why Random Weights Fail")print("="*60)print("""IDEAL weights for vertical detection should have:  - HIGH values in the middle column (where vertical lines are)  - LOW or NEGATIVE values elsewhere Our RANDOM weights have no pattern - they're just noise! The Perceptron doesn't KNOW what vertical lines look like yet.It needs to LEARN the right weights through TRAINING.""")

# =============================================================================# WHAT IF WE HAD IDEAL WEIGHTS? (Sneak Preview)# ============================================================================= print("="*70)print("WHAT IF WE HAD THE RIGHT WEIGHTS? (A Preview)")print("="*70) # Create a new Perceptron and give it ideal weightsideal_perceptron = Perceptron(n_inputs=9)ideal_perceptron.weights = ideal_weights.copy()ideal_perceptron.bias = -1.5  # A good threshold print("\nIdeal weights (as 3x3 grid):")print(f"  {ideal_perceptron.weights.reshape(3,3)[0]}")print(f"  {ideal_perceptron.weights.reshape(3,3)[1]}")print(f"  {ideal_perceptron.weights.reshape(3,3)[2]}")print(f"\nBias: {ideal_perceptron.bias}") # Test on the same datasetcorrect_ideal = 0for i in range(len(X_test)):    if ideal_perceptron.predict(X_test[i]) == y_test[i]:        correct_ideal += 1 accuracy_ideal = correct_ideal / len(y_test) * 100 print("\n" + "-"*70)print("COMPARISON:")print("-"*70)print(f"\n  Random weights accuracy:  {accuracy:.1f}%")print(f"  Ideal weights accuracy:   {accuracy_ideal:.1f}%")print(f"\n  Improvement: +{accuracy_ideal - accuracy:.1f}%") print("\n" + "="*70)print("THE BIG QUESTION:")print("="*70)print("""How do we get from RANDOM weights to IDEAL weights? We don't want to hand-design them (that defeats the purpose!).We want the Perceptron to LEARN them automatically. This is what TRAINING does - and it's the topic of Part 5!""")

# =============================================================================# KNOWLEDGE CHECK - Part 4# ============================================================================= print("KNOWLEDGE CHECK - Part 4: The Perceptron")print("="*60)print("\nAnswer these questions to test your understanding:\n") questions = [    {        "q": "1. What are the steps of a forward pass (in order)?",        "options": [            "A) Activation -> Weighted Sum -> Output",            "B) Weighted Sum -> Add Bias -> Activation -> Output",            "C) Input -> Output -> Activation",            "D) Bias -> Weights -> Sigmoid"        ],        "answer": "B",        "explanation": "The forward pass is: (1) compute weighted sum of inputs, (2) add bias, (3) apply activation function, (4) get output."    },    {        "q": "2. Why does an untrained Perceptron get ~50% accuracy?",        "options": [            "A) Because sigmoid always outputs 0.5",            "B) Because the dataset is unbalanced",            "C) Because random weights give random predictions",            "D) Because the bias is always 0"        ],        "answer": "C",        "explanation": "Random weights have no meaningful pattern, so the Perceptron essentially guesses randomly. For binary classification, random guessing gives ~50% accuracy."    },    {        "q": "3. What does the forward pass output for binary classification?",        "options": [            "A) Always 0 or 1 exactly",            "B) A probability between 0 and 1",            "C) Any real number",            "D) The raw weighted sum"        ],        "answer": "B",        "explanation": "The sigmoid activation squashes the output to a probability between 0 and 1. We then threshold at 0.5 to get a binary prediction."    },    {        "q": "4. For a vertical line detector, where should the weights be highest?",        "options": [            "A) In the corners",            "B) In the middle column",            "C) In the middle row",            "D) Equally everywhere"        ],        "answer": "B",        "explanation": "Vertical lines appear in columns. High weights in the middle column will give high scores when vertical pixels align with them."    },    {        "q": "5. Who invented the Perceptron?",        "options": [            "A) Geoffrey Hinton",            "B) Frank Rosenblatt",            "C) Yann LeCun",            "D) Alan Turing"        ],        "answer": "B",        "explanation": "Frank Rosenblatt invented the Perceptron in 1958 at Cornell. It was the first neural network that could learn!"    }] for q in questions:    print(q["q"])    for opt in q["options"]:        print(f"   {opt}")    print() print("\n" + "="*60)print("Scroll down for answers...")print("="*60)

# =============================================================================# ANSWERS - Knowledge Check Part 4# ============================================================================= print("ANSWERS - Part 4 Knowledge Check")print("="*60) for i, q in enumerate(questions, 1):    print(f"\n{i}. Answer: {q['answer']}")    print(f"   Explanation: {q['explanation']}") print("\n" + "="*60)print("How did you do?")print("  5/5: Perceptron Expert!")print("  4/5: Great understanding!")print("  3/5: Review the sections you missed")print("  <3:  Re-read Part 4 before continuing")print("="*60)