Python Programming Refresher¶

print("Hello, World!")

# Variables — no type declaration needed
name = "ESP32"          # Python figures out this is a string
temperature = 25.5      # this is a float
count = 42              # this is an integer
is_active = True        # this is a boolean (True/False)

# You can change a variable to a different type (Python is flexible)
x = 10          # x is an integer
x = 3.14        # now x is a float — Python allows this
x = "hello"     # now x is a string — Python allows this too

# Basic types
temperature = 25.5          # float — decimal number
count = 42                  # int — whole number
label = "normal"            # str — text (string)
is_active = True            # bool — True or False

# Type hints (optional but helpful for readability)
temperature: float = 25.5
readings: list[float] = []

# Check the type of a variable
print(type(temperature))    # <class 'float'>
print(type(count))          # <class 'int'>
print(type(label))          # <class 'str'>

# String to number
age_str = "25"
age = int(age_str)          # 25 (now an integer)
price = float("9.99")       # 9.99 (now a float)

# Number to string
msg = "Count: " + str(42)   # "Count: 42"

# Float to int (truncates — does NOT round)
x = int(3.9)               # 3 (not 4!)

# Create a list
temperatures = [22.5, 23.1, 24.0, 25.5, 26.2]

# Access by index (starts at 0, just like C)
first = temperatures[0]     # 22.5
last = temperatures[-1]     # 26.2 (negative index = from the end)

# Slice — get a range
middle = temperatures[1:4]  # [23.1, 24.0, 25.5]
# 1:4 means "from index 1 up to (not including) index 4"

# Modify
temperatures.append(27.0)   # add to end → [22.5, ..., 27.0]
temperatures.insert(0, 21.0)  # insert at index 0
temperatures.remove(24.0)  # remove by value
temperatures.pop()          # remove and return last item

# Length
n = len(temperatures)      # number of items

# List comprehensions — create lists with a formula
celsius = [t for t in temperatures if t > 25.0]
# [25.5, 26.2, 27.0] — only values above 25

fahrenheit = [(t * 9/5) + 32 for t in temperatures]
# Convert every temperature to Fahrenheit

# Create — key-value pairs
sensor_reading = {
    "temperature": 25.5,
    "humidity": 60.0,
    "label": "normal"
}

# Access by key
temp = sensor_reading["temperature"]  # 25.5

# Safe access — returns default if key doesn't exist
pressure = sensor_reading.get("pressure", 1013.25)  # 1013.25

# Add or update
sensor_reading["timestamp"] = 1713427200  # new key
sensor_reading["temperature"] = 26.0      # update existing

# Iterate over all key-value pairs
for key, value in sensor_reading.items():
    print(f"{key}: {value}")

# Check if a key exists
if "temperature" in sensor_reading:
    print("Temperature is present")

# Tuples can't be modified after creation — useful for fixed groupings
point = (3.14, 2.71)
x, y = point  # unpacking — x=3.14, y=2.71

# Common in ML: (features, label)
sample = ([25.5, 60.0], "normal")
features, label = sample

value = 75

# if / elif / else — note the indentation!
if value > 80:
    print("High")
elif value > 50:        # elif = "else if"
    print("Normal")
else:
    print("Low")

# Ternary expression — one-line conditional
status = "hot" if temperature > 30 else "normal"

# for loop — iterate over items in a list
for temp in temperatures:
    print(f"Reading: {temp}°C")

# for with enumerate — when you need the index too
for i, temp in enumerate(temperatures):
    print(f"Sample {i}: {temp}°C")

# for with range — repeat a specific number of times
for epoch in range(50):      # epoch goes from 0 to 49
    print(f"Training epoch {epoch}")

# while loop — repeat while a condition is true
retry_count = 0
while retry_count < 5:
    print(f"Attempt {retry_count}")
    retry_count += 1

# Basic function
def celsius_to_fahrenheit(celsius):
    return (celsius * 9/5) + 32

result = celsius_to_fahrenheit(25.5)  # 77.9

# Function with default arguments
def read_sensor(gpio, samples=10, delay_ms=100):
    readings = []
    for _ in range(samples):
        readings.append(analog_read(gpio))
        time.sleep(delay_ms / 1000)
    return readings

# Call with defaults
data = read_sensor(2)                  # uses defaults: samples=10, delay_ms=100
data = read_sensor(2, samples=20)      # override samples only
data = read_sensor(2, delay_ms=50)     # override delay only

# Multiple return values (tuple unpacking)
def min_max(data):
    return min(data), max(data)

lo, hi = min_max([22.5, 25.5, 26.2])  # lo=22.5, hi=26.2

# Lambda — short anonymous function (useful for sorting/filtering)
readings = [(25.5, "normal"), (35.0, "hot"), (20.0, "cold")]
sorted_readings = sorted(readings, key=lambda x: x[0])  # sort by temperature

device_id = "XIAO-S3-01"
temp = 25.5

# f-strings (preferred — Python 3.6+) — put variable inside {}
print(f"Device {device_id}: {temp:.1f}°C")  # Device XIAO-S3-01: 25.5°C

# Multiple values
print(f"Temp={temp:.1f}, Humidity={humidity:.0f}%")

# Formatting options
print(f"Hex: {255:#04x}")     # 0xff
print(f"Pad: {5:03d}")         # 005
print(f"Percent: {0.85:.0%}")  # 85%

# Read a file line by line
with open("sensor_data.csv", "r") as f:   # "r" = read mode
    header = f.readline().strip().split(",")
    for line in f:
        values = line.strip().split(",")
        temp, hum, label = float(values[0]), float(values[1]), values[2]

# Write to a file
with open("output.csv", "w") as f:        # "w" = write mode (overwrites!)
    f.write("temperature,humidity,label\n")
    for row in dataset:
        f.write(f"{row[0]},{row[1]},{row[2]}\n")

# Using csv module (handles quoting and edge cases properly)
import csv

with open("sensor_data.csv", "r") as f:
    reader = csv.DictReader(f)
    for row in reader:
        temp = float(row["temperature"])
        label = row["label"]

import numpy as np

# Create arrays
data = np.array([22.5, 23.1, 24.0, 25.5, 26.2])
zeros = np.zeros(100)           # 100 zeros
ones = np.ones((3, 4))          # 3×4 matrix of ones
range_arr = np.arange(0, 10, 2) # [0, 2, 4, 6, 8]

# Statistics
mean = np.mean(data)       # 24.26
std = np.std(data)         # standard deviation
minimum = np.min(data)     # 22.5
maximum = np.max(data)     # 26.2

# Normalization (critical for ML — see ML section below)
normalized = (data - np.mean(data)) / np.std(data)

# Min-max scaling (0 to 1)
scaled = (data - np.min(data)) / (np.max(data) - np.min(data))

# Reshape (ML models need specific input shapes)
features = data.reshape(-1, 1)  # column vector: [[22.5], [23.1], ...]

# Boolean indexing — filter data with conditions
hot_readings = data[data > 25.0]  # [25.5, 26.2]

import matplotlib.pyplot as plt

# Line plot — sensor readings over time
temperatures = [22.5, 23.1, 24.0, 25.5, 26.2, 27.0]
plt.plot(temperatures, marker='o')
plt.xlabel("Sample Index")
plt.ylabel("Temperature (°C)")
plt.title("Sensor Readings")
plt.grid(True)
plt.show()

# Training loss curve
epochs = range(1, 51)
loss = [0.8, 0.6, 0.45, 0.35, 0.28]  # your training losses
plt.plot(epochs, loss)
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("Training Progress")
plt.show()

# Scatter plot — feature visualization
plt.scatter(temperatures, humidities, c=labels, cmap='viridis')
plt.xlabel("Temperature (°C)")
plt.ylabel("Humidity (%)")
plt.colorbar(label="Class")
plt.show()

import numpy as np

# Raw sensor data
temperatures = np.array([22.5, 23.1, 24.0, 25.5, 26.2, 35.0, 40.1])
humidity = np.array([45.0, 50.2, 55.0, 60.0, 65.3, 80.0, 90.0])
labels = np.array([0, 0, 0, 0, 0, 1, 1])  # 0=normal, 1=hot

# Step 1: Combine features into a 2D array (samples × features)
X = np.column_stack([temperatures, humidity])
# [[22.5, 45.0], [23.1, 50.2], ...]

# Step 2: Normalize — scale each feature to mean=0, std=1
# Formula: normalized = (value - mean) / standard_deviation
# This transforms values so they're centered around 0 with similar ranges
X_mean = X.mean(axis=0)   # mean of each column
X_std = X.std(axis=0)     # std of each column
X_normalized = (X - X_mean) / X_std

# Before normalization: temperature=40.1, humidity=90.0
# After normalization:  temperature=1.52, humidity=1.38
# Now both features have similar ranges — the model treats them equally!

# Step 3: Split into training and testing sets (80/20)
# CRITICAL: The model must be tested on data it has NEVER seen before
# Otherwise, you're just testing its memorization, not its learning
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
    X_normalized, labels, test_size=0.2, random_state=42
)

print(f"Training samples: {len(X_train)}")  # used to teach the model
print(f"Testing samples: {len(X_test)}")    # used to check if it actually learned

# A single neuron doing its calculation
temperature = 35.5
humidity = 85.0
weight1 = 0.8     # temperature is important
weight2 = 0.3     # humidity is less important
bias = -15.0      # baseline offset

# Step 1: Weighted sum
weighted_sum = (temperature * weight1) + (humidity * weight2) + bias
# = (35.5 × 0.8) + (85.0 × 0.3) + (-15.0)
# = 28.4 + 25.5 - 15.0
# = 38.9

# Step 2: Apply activation function (ReLU)
output = max(0, weighted_sum)  # ReLU: if negative, output 0; if positive, pass through
# = max(0, 38.9) = 38.9

# This neuron says: "Yes, this is hot!" (large positive output)

import numpy as np

# ReLU — the most popular activation function
def relu(x):
    return max(0, x)

print(relu(-5))   # 0   (negative → blocked)
print(relu(0))    # 0   (zero → zero)
print(relu(3.7))  # 3.7 (positive → passed through)

# Sigmoid — for binary classification (yes/no)
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

print(sigmoid(-5))   # 0.007  (very unlikely)
print(sigmoid(0))    # 0.5    (50/50 — not sure)
print(sigmoid(5))   # 0.993  (very likely)

# Softmax — for multi-class classification (pick one of many)
def softmax(x):
    exp_x = np.exp(x - np.max(x))  # subtract max for numerical stability
    return exp_x / exp_x.sum()

logits = np.array([2.0, 5.0, 1.0])  # raw scores for [normal, hot, humid]
probs = softmax(logits)
print(probs)  # [0.04, 0.93, 0.03] → 93% chance it's "hot"

# The Adam optimizer automatically adjusts the learning rate — you rarely need to change it
model.compile(
    optimizer='adam',  # Adam = Adaptive Moment Estimation — smart learning rate
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

import tensorflow as tf
from tensorflow import keras
import numpy as np

# Define a simple neural network
model = keras.Sequential([
    # Input layer + first hidden layer
    # Dense = fully connected (every input connects to every neuron)
    # 16 = number of neurons
    # relu = activation function (most common for hidden layers)
    # input_shape=(2,) = 2 input features (temperature, humidity)
    keras.layers.Dense(16, activation='relu', input_shape=(2,)),

    # Second hidden layer — 8 neurons
    keras.layers.Dense(8, activation='relu'),

    # Output layer — 3 neurons (one per class: normal, hot, humid)
    # softmax = converts outputs to probabilities that sum to 1.0
    keras.layers.Dense(3, activation='softmax')
])

# Print a summary of the model
model.summary()

model.compile(
    optimizer='adam',                          # How to update weights (adam is the best default)
    loss='sparse_categorical_crossentropy',     # How to measure error (for integer labels)
    metrics=['accuracy']                        # What to track during training
)

# Train the model
history = model.fit(
    X_train,               # input features (normalized)
    y_train,               # correct labels
    epochs=50,             # number of complete passes through the data
    batch_size=32,         # examples per gradient update
    validation_split=0.2   # use 20% of training data to monitor overfitting
)

# Plot training progress
import matplotlib.pyplot as plt
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()

# Evaluate on test data (data the model has never seen)
loss, accuracy = model.evaluate(X_test, y_test)
print(f"Test Accuracy: {accuracy:.2%}")

# Make a prediction on new data
new_reading = np.array([[25.5, 60.0]])  # temperature, humidity (normalized!)
prediction = model.predict(new_reading)
# prediction = [[0.05, 0.90, 0.05]] → 90% chance it's class 1

predicted_class = np.argmax(prediction)  # 1 (the class with highest probability)
class_names = ["normal", "hot", "humid"]
print(f"Prediction: {class_names[predicted_class]}")

# Convert to TFLite with INT8 quantization
# INT8 = 8-bit integers → much smaller model, faster inference on ESP32

# Step 1: Create a representative dataset generator
# This provides sample inputs so the converter can calibrate the quantization
def representative_dataset():
    for i in range(len(X_train)):
        yield [X_train[i:i+1].astype(np.float32)]

# Step 2: Configure the converter
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]  # enable quantization
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8    # input will be int8 on ESP32
converter.inference_output_type = tf.int8   # output will be int8 on ESP32

# Step 3: Convert and save
tflite_model = converter.convert()
with open("model.tflite", "wb") as f:
    f.write(tflite_model)

print(f"Model size: {len(tflite_model)} bytes")
# Typically 2-5 KB for a small model — fits easily on ESP32!

%matplotlib inline    # show plots inside the notebook
!pip install tensorflow  # run shell command
%%timeit             # time a cell's execution

import serial
import csv

# Open serial port
ser = serial.Serial('/dev/ttyUSB0', 115200, timeout=1)

# Read and parse lines
dataset = []
with open("sensor_log.csv", "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["timestamp", "temperature", "humidity", "label"])

    while True:
        line = ser.readline().decode('utf-8').strip()
        if not line:
            continue

        # Parse: "1713427200,25.5,60.0,normal"
        parts = line.split(",")
        if len(parts) == 4:
            timestamp, temp, hum, label = parts
            writer.writerow([timestamp, temp, hum, label])
            dataset.append((float(temp), float(hum), label))

ser.close()