บทความ: สอนใช้งาน ESP32-S3 กับ TinyML Machine Learning บนไมโครคอนโทรลเลอร์

// รวม Library ที่จำเป็น
#include <TensorFlowLite.h>
#include <tensorflow/lite/experimental/micro/kernels/micro_ops.h>
#include <tensorflow/lite/experimental/micro/micro_error_reporter.h>
#include <tensorflow/lite/experimental/micro/micro_interpreter.h>
#include <tensorflow/lite/schema/schema_generated.h>
#include <tensorflow/lite/version.h>

// รวมไฟล์โมเดลที่แปลงแล้ว
#include "sin_model_data.h"

// ตั้งค่า Tensor Arena (พื้นที่หน่วยความจำสำหรับโมเดล)
constexpr int kTensorArenaSize = 8 * 1024;
uint8_t tensor_arena[kTensorArenaSize];

// สร้าง Error Reporter
tflite::MicroErrorReporter micro_error_reporter;
tflite::ErrorReporter* error_reporter = µ_error_reporter;

// สร้าง MicroInterpreter
const tflite::Model* model = tflite::GetModel(g_sin_model_data);
static tflite::MicroInterpreter static_interpreter(
    model,
    micro_op_resolver,
    tensor_arena,
    kTensorArenaSize,
    error_reporter
);
TfLiteTensor* input = static_interpreter.input(0);
TfLiteTensor* output = static_interpreter.output(0);

void setup() {
    Serial.begin(115200);
    while (!Serial);
    
    Serial.println("TinyML on ESP32-S3 - Sin Prediction Model");
    
    // ตั้งค่า input tensor
    input->data.f[0] = 0.0;  // ค่า x เริ่มต้น
    
    // ทำการอนุญาตให้โมเดลทำงาน
    if (static_interpreter.AllocateTensors() != kTfLiteOk) {
        Serial.println("Error allocating tensors!");
        return;
    }
}

void loop() {
    // ทดลองค่าต่างๆ ของ x (0 ถึง 2π)
    for (float x = 0; x <= 6.28; x += 0.1) {
        // ตั้งค่า input
        input->data.f[0] = x;
        
        // รันโมเดล
        if (static_interpreter.Invoke() != kTfLiteOk) {
            Serial.println("Error invoking model!");
            return;
        }
        
        // อ่านผลลัพธ์
        float y_pred = output->data.f[0];
        float y_actual = sin(x);
        
        // แสดงผล
        Serial.printf("x: %.2f, Predicted: %.3f, Actual: %.3f, Error: %.3f\n",
                     x, y_pred, y_actual, abs(y_pred - y_actual));
        
        delay(100);
    }
    
    Serial.println("\n--- Test Complete ---\n");
    delay(5000);
}

# train_sin_model.py
import tensorflow as tf
import numpy as np

# สร้างข้อมูลฝึก
X_train = np.linspace(0, 2*np.pi, 100).reshape(-1, 1).astype(np.float32)
y_train = np.sin(X_train).astype(np.float32)

# สร้างโมเดล Neural Network
model = tf.keras.Sequential([
    tf.keras.layers.Dense(16, activation='relu', input_shape=(1,)),
    tf.keras.layers.Dense(16, activation='relu'),
    tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')

# ฝึกโมเดล
model.fit(X_train, y_train, epochs=100, verbose=0)

# แปลงเป็น TensorFlow Lite
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

# บันทึกไฟล์
with open('sin_model.tflite', 'wb') as f:
    f.write(tflite_model)

# แปลงเป็น C array
# xxd -i sin_model.tflite > sin_model_data.h
print("Model trained and saved!")

# การ Quantize โมเดล
def representative_dataset():
    for _ in range(100):
        data = np.random.rand(1, 1).astype(np.float32)
        yield [data]

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8
converter.inference_output_type = tf.int8

quantized_model = converter.convert()