Intro to Perceptron — 01. Hey there! 👋 Are you scratching your… | by This Mohsin | Jan, 2025

Hey there! 👋 Are you scratching your head trying to understand what the heck a perceptron is? Don’t worry — I was totally lost at first too! Let’s break it down super simple, no fancy math required (okay, maybe just a tiny bit 😉).

Imagine you have a super picky bouncer at a club. This bouncer makes yes/no decisions based on two things:

• How tall you are
• How fashionable your clothes are

That’s basically what a perceptron is! It’s like the world’s simplest AI bouncer that makes yes/no decisions based on the information it gets.

Let’s stick with our bouncer example:

1. Gets Information (Inputs)

• Sees how tall you are (Input 1)
• Checks out your outfit (Input 2)

2. Weighs Things Up (Weights)

• Maybe height is super important to this bouncer (big weight)
• Maybe clothes aren’t as important (small weight)

3. Makes a Decision (Output)

• Let’s you in (1) or keeps you out (0)

It’s that simple! Well… almost. 😅

Let’s teach our perceptron something super basic — the AND rule. It’s like a game where you need BOTH things to be true to win.

Think of it like this:

• Do you have a ticket AND ID? You get in! ✅
• Just a ticket but no ID? Nope! ❌
• Just ID but no ticket? Still nope! ❌
• Neither? Definitely not! ❌

Here’s what this looks like in super simple Python code:

# Don't panic! This is simpler than it looks 😊
import numpy as np  # This is just a tool that helps us with number
class SimplePerceptron:
def __init__(self):
self.weights = [0, 0]  # Start knowing nothing
self.bias = 0          # Like the bouncer's mood that day
def decide(self, input1, input2):
# Add up all the evidence
total = input1 * self.weights[0] + input2 * self.weights[1] + self.bias
# Make a yes/no decision
return 1 if total >= 0 else 0
def train(self, inputs, correct_answers):
# Learn from mistakes!
for x1, x2, target in zip(inputs[0], inputs[1], correct_answers):
guess = self.decide(x1, x2)
if guess != target:  # Oops, made a mistake!
# Adjust the weights to do better next time
self.weights[0] += 0.1 * (target - guess) * x1
self.weights[1] += 0.1 * (target - guess) * x2
self.bias += 0.1 * (target - guess)

Here’s the cool (and not so cool) stuff about perceptrons:

Cool Stuff:

• Super fast at making simple yes/no decisions
• Can learn from its mistakes
• Works great for basic problems

Not So Cool Stuff:

• Can only make simple decisions
• Gets confused by complicated problems
• It’s like a bouncer who can only check two things

Because:

1. It’s like the “Hello World” of AI
2. All the fancy AI stuff today started with this simple idea
3. It helps you understand how computers learn

Want to play with perceptrons? Here’s what you can try:

1. Copy the code above
2. Try teaching it different rules
3. See if you can break it (trust me, it’s not hard 😅)

Think of a perceptron as AI’s first baby step. Sure, modern AI is way more complicated, but it all started here! It’s like learning to crawl before you can walk, run, or do backflips.

So there you have it! A perceptron is just a simple yes/no decision maker that can learn from its mistakes. Not so scary after all, right?

Remember:

• It takes inputs (like our bouncer checking height and clothes)
• Weighs them (decides what’s important)
• Makes a yes/no decision
• Can learn when it messes up

If this got you excited about AI:

• Try playing with the code
• Look up “neural networks” (but maybe take a nap first 😴)
• Share what you learned with your friends!

Drop a comment below if anything’s still fuzzy — we’re all learning here! 😊