TinyML Lab: Simple MLP + PCA for STM32 TinyML Deployment with X-Cube-AI Cloud

				
					# -*- coding: utf-8 -*-
"""PCA_STM32.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1uYlPi28C9nDe-cE2WTx2LwzbtbXfOlrj
"""

# --- External Libraries for Embedded Export (Requires pip install) ---
# import onnx
# from skl2onnx import convert_sklearn
# from skl2onnx.common.data_types import FloatTensorType
# from micromlgen import port
# ---------------------------------------------------------------------

pip install micromlgen

pip install skl2onnx

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, ConfusionMatrixDisplay

# --- External Libraries for Embedded Export (Requires pip install) ---
import onnx
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
from micromlgen import port

# 1. Load Data
iris = load_iris()
X = iris.data
y = iris.target
feature_names = iris.feature_names
target_names = iris.target_names

# 2. Standardize the data (Crucial for PCA)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# --- VISUALIZATION: 3D Plot BEFORE PCA (using 3 features) ---
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')

for i, target_name in enumerate(target_names):
    ax.scatter(X[y == i, 0], X[y == i, 1], X[y == i, 2], label=target_name)

ax.set_xlabel(feature_names[0])
ax.set_ylabel(feature_names[1])
ax.set_zlabel(feature_names[2])
ax.set_title(f'Iris Dataset (3 of 4 features) - Pre-PCA')
ax.legend()
plt.tight_layout()
plt.show() # Display the plot
# -------------------------------------------------------------

# 3. Apply PCA: Reduce to 2 Principal Components (PC1 and PC2)
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

# --- VISUALIZATION: 2D Plot AFTER PCA (PC1 and PC2) ---
pca_df = pd.DataFrame(data = X_pca, columns = ['principal component 1', 'principal component 2'])
pca_df['target'] = y

plt.figure(figsize=(8, 6))
target_names_list = [iris.target_names[i] for i in y]

sns.scatterplot(
    x='principal component 1',
    y='principal component 2',
    hue=target_names_list,
    palette=sns.color_palette("tab10", n_colors=3),
    data=pca_df,
    legend="full",
    alpha=0.8
)
plt.title(f'Iris Dataset - Post-PCA (2 Principal Components)')
plt.xlabel(f'Principal Component 1 ({pca.explained_variance_ratio_[0]*100:.1f}%)')
plt.ylabel(f'Principal Component 2 ({pca.explained_variance_ratio_[1]*100:.1f}%)')
plt.grid()
plt.tight_layout()
plt.show() # Display the plot
# --------------------------------------------------------

# The PCA components (eigenvectors) are the core transformation matrix
# needed for real-time inference on the STM32.

# 4. Split Data (using the PCA-transformed data)
X_train, X_test, y_train, y_test = train_test_split(
    X_pca, y, test_size=0.3, random_state=42, stratify=y
)

# 5. Train a Classifier (NEW: Simple Multi-Layer Perceptron/Neural Network)
# This is a small network suitable for embedded systems:
# - Hidden Layer 1: 10 neurons
# - Activation: ReLu (Rectified Linear Unit)
# - Max Iterations: 1000 (to ensure convergence)

mlp = MLPClassifier(
    hidden_layer_sizes=(10,),
    max_iter=1000,
    activation='relu',
    solver='adam',
    random_state=42
)
mlp.fit(X_train, y_train)

# 6. Evaluate
y_pred = mlp.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)

print("--- Results with Simple Neural Network (MLP) ---")
print(f"Classifier Accuracy (on 2D data): {accuracy:.4f}")
print(f"\nExplained Variance Ratio by the 2 Components: {pca.explained_variance_ratio_.sum():.4f}")

# --- VISUALIZATION: Confusion Matrix ---
cm = confusion_matrix(y_test, y_pred)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=target_names)
fig, ax = plt.subplots(figsize=(8, 8))
disp.plot(ax=ax, cmap=plt.cm.Blues)
plt.title("Confusion Matrix for PCA-Reduced Data + MLP")
plt.show() # Display the plot
# -----------------------------------------

# --- EXPORT 1: Neural Network Model to ONNX ---
try:
    # Requires: pip install skl2onnx onnx
    from skl2onnx import convert_sklearn
    from skl2onnx.common.data_types import FloatTensorType

    # Define the input type: 2 input features (PC1, PC2) with float type
    initial_type = [('float_input', FloatTensorType([None, 2]))]

    # Export the MLP model
    onnx_model = convert_sklearn(mlp, initial_types=initial_type, target_opset=13)

    # Save to file
    with open("iris_mlp.onnx", "wb") as f:
        f.write(onnx_model.SerializeToString())
    print("\n✅ Exported MLP model to ONNX format: 'iris_mlp.onnx'")

except ImportError:
    print("\n⚠️ Skipping ONNX export: Install 'skl2onnx' and 'onnx' to enable this feature.")

# --- EXPORT 2: PCA Transformation to C Code using micromlgen ---
try:
    # Requires: pip install micromlgen
    from micromlgen import port

    # Export the PCA object (which is a transformer) to C
    c_code = port(pca, classmap={
        0: 'SETOSA',
        1: 'VERSICOLOR',
        2: 'VIRGINICA'
    })

    # Save to C file (Note: using a standard local path)
    with open('iris_pca_transform.c','w') as f:
        f.write(c_code)

    print("✅ Exported PCA transformation to C format: 'iris_pca_transform.c'")

except ImportError:
    print("\n⚠️ Skipping C export: Install 'micromlgen' to enable this feature.")