Lesson 27: Machine Learning & AI Integration

By the end of this lesson, you will:

• • Understand basic machine learning concepts and terminology
• • Implement simple decision trees for robot behavior
• • Create adaptive behavior systems using sensor feedback
• • Build pattern recognition systems for autonomous navigation

Key Concepts:

• • Supervised vs unsupervised learning
• • Decision trees and classification
• • Reinforcement learning basics
• • Neural network fundamentals

1. Supervised Learning

Learning from labeled examples. Like teaching a robot to recognize objects by showing it thousands of labeled images.

Example: Training a robot to identify red vs blue objects using camera data

2. Unsupervised Learning

Finding hidden patterns in data without labels. Like discovering that certain sensor readings always occur together.

Example: Grouping similar driving patterns or obstacle types

3. Reinforcement Learning

Learning through trial and error with rewards and penalties. Like training a robot to navigate by rewarding successful paths.

Example: Robot learns optimal driving strategies through practice

Example: Obstacle Avoidance Decision Tree

Distance Sensor Reading < 20cm?
├─ YES: Is object on the left?
│  ├─ YES: Turn right
│  └─ NO: Turn left
└─ NO: Is path clear ahead?
   ├─ YES: Move forward
   └─ NO: Scan for best path

// Intelligent Obstacle Avoidance with Decision Tree
int frontDistance, leftDistance, rightDistance;

void intelligentNavigation() {
  // Gather sensor data
  frontDistance = getUltrasonicDistance(FRONT_SENSOR);
  leftDistance = getUltrasonicDistance(LEFT_SENSOR);
  rightDistance = getUltrasonicDistance(RIGHT_SENSOR);
  
  // Decision tree implementation
  if (frontDistance < 20) {
    // Obstacle detected ahead
    if (leftDistance > rightDistance) {
      // More space on left
      if (leftDistance > 30) {
        turnLeft();
        Serial.println("Decision: Turn left (clear path)");
      } else {
        reverseAndTurn();
        Serial.println("Decision: Reverse and reassess");
      }
    } else {
      // More space on right or equal
      if (rightDistance > 30) {
        turnRight();
        Serial.println("Decision: Turn right (clear path)");
      } else {
        reverseAndTurn();
        Serial.println("Decision: Reverse and reassess");
      }
    }
  } else if (frontDistance < 50) {
    // Obstacle approaching - slow down
    moveForwardSlow();
    Serial.println("Decision: Proceed with caution");
  } else {
    // Clear path ahead
    moveForward();
    Serial.println("Decision: Full speed ahead");
  }
}

Simple Learning Algorithm Example:

// Adaptive obstacle avoidance
int successfulMoves[4] = {0, 0, 0, 0}; // forward, left, right, back
int totalAttempts[4] = {0, 0, 0, 0};

void adaptiveMove() {
  int bestMove = 0;
  float bestSuccessRate = 0;
  
  // Find the move with highest success rate
  for (int i = 0; i < 4; i++) {
    if (totalAttempts[i] > 0) {
      float successRate = (float)successfulMoves[i] / totalAttempts[i];
      if (successRate > bestSuccessRate) {
        bestSuccessRate = successRate;
        bestMove = i;
      }
    }
  }
  
  executeMove(bestMove);
  updateLearning(bestMove);
}

Simple Pattern Detection:

// Pattern recognition for navigation
int sensorHistory[10];
int historyIndex = 0;

bool detectWallPattern() {
  // Look for consistent wall detection pattern
  int wallCount = 0;
  for (int i = 0; i < 10; i++) {
    if (sensorHistory[i] < 20) { // Wall detected
      wallCount++;
    }
  }
  
  return wallCount > 7; // 70% of readings show wall
}

void updatePattern(int sensorReading) {
  sensorHistory[historyIndex] = sensorReading;
  historyIndex = (historyIndex + 1) % 10;
}

// AI-Powered Obstacle Avoidance System
#include <NewPing.h>

#define TRIGGER_PIN 12
#define ECHO_PIN 11
#define MAX_DISTANCE 200

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);

// Learning variables
float moveSuccess[4] = {0.5, 0.5, 0.5, 0.5}; // forward, left, right, back
int moveAttempts[4] = {1, 1, 1, 1};

void setup() {
  Serial.begin(9600);
  // Initialize motors and sensors
}

void loop() {
  int distance = sonar.ping_cm();
  
  if (distance < 20 && distance > 0) {
    // Obstacle detected - use AI to choose best move
    int bestMove = chooseBestMove();
    executeMove(bestMove);
    
    // Learn from the result
    delay(1000);
    updateLearning(bestMove, wasSuccessful());
  } else {
    moveForward();
  }
  
  delay(100);
}

int chooseBestMove() {
  int bestMove = 0;
  float bestScore = moveSuccess[0];
  
  for (int i = 1; i < 4; i++) {
    if (moveSuccess[i] > bestScore) {
      bestScore = moveSuccess[i];
      bestMove = i;
    }
  }
  
  return bestMove;
}

void updateLearning(int move, bool success) {
  moveAttempts[move]++;
  if (success) {
    moveSuccess[move] = (moveSuccess[move] * (moveAttempts[move] - 1) + 1.0) / moveAttempts[move];
  } else {
    moveSuccess[move] = (moveSuccess[move] * (moveAttempts[move] - 1) + 0.0) / moveAttempts[move];
  }
}

• Transparency: Understanding why AI makes certain decisions
• Bias: Ensuring AI systems are fair and unbiased
• Safety: Implementing fail-safes and human oversight
• Privacy: Protecting user data and maintaining privacy