16. AI for Robotics

🧠 What is TensorFlow Lite? TensorFlow Lite is a lightweight version of Google’s TensorFlow framework designed to run machine learning models on embedded devices like Raspberry Pi, Android, and microcontrollers. It’s optimized for speed and small size—ideal for robotics projects where computing power is limited.

⚙️ Step-by-Step: Training a Model

1. Prepare the dataset: Organize your images, audio, or sensor data into class folders.
2. Use TensorFlow or Teachable Machine:
   • Teachable Machine: Train in the browser, then export the .tflite file.
   • TensorFlow: Write a training script using Python and Keras, then convert it.
3. Evaluate accuracy: Use test data to verify your model is not overfitting or biased.

🛠️ Converting Model to TFLite

If you used Python and TensorFlow, you can convert your trained model using:

import tensorflow as tf

model = tf.keras.models.load_model('model_folder')
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

Teachable Machine provides a one-click download of the `.tflite` file, simplifying this step.

💡 Optimizing for Deployment

• Quantization: Reduce model size by converting weights from 32-bit floats to 8-bit integers.
• Pruning: Remove unnecessary parts of the network to make it lighter and faster.
• Batch Size: Use batch size = 1 for real-time predictions on edge devices.

📲 Running TFLite Models on Raspberry Pi or Android

To use the model on hardware:

1. Install TFLite runtime: On Raspberry Pi, use:

   pip install tflite-runtime

2. Load and run inference:

import tflite_runtime.interpreter as tflite
import numpy as np

interpreter = tflite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()

input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Provide input data (e.g., image converted to NumPy array)
input_data = np.array(..., dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)
interpreter.invoke()

output_data = interpreter.get_tensor(output_details[0]['index'])
prediction = np.argmax(output_data)

🔌 Integration with Sensors and Actuators

Once your robot receives the AI prediction (e.g., detects a person or object), you can use that result to control motors, LEDs, or triggers. For example:

• Turn servo to follow a detected object.
• Activate an alert if a specific gesture is recognized.
• Sort objects on a conveyor based on classification.

🧪 Testing in Real Time

• Ensure the model responds fast enough (ideally under 200ms latency).
• Test under various conditions—lighting, noise, and angles.
• Use logs or visual outputs to debug incorrect classifications.

📦 Deployment Tips:

• Always keep a backup model in case updates fail.
• Use version control for your training code and datasets.
• Store model files in accessible locations on the robot's filesystem.

✅ Summary: You now have a trained AI model converted to TensorFlow Lite and deployed on a physical robot. This pipeline—from data collection to prediction—gives your robot the power to make intelligent decisions in real time.