Teaching Robots to Learn and Make Smart Decisions
Machine learning is like teaching a robot to get better at tasks by showing it lots of examples. Instead of programming every possible situation, we let the robot learn patterns from data and make its own decisions based on what it has seen before.
Humans are naturally good at recognizing patterns - like knowing it might rain when you see dark clouds. Machine learning helps robots do the same thing with sensor data, finding patterns that help them make good decisions.
To teach a robot, we collect lots of examples (called training data). For instance, if we want a robot to recognize obstacles, we show it thousands of pictures labeled "obstacle" or "safe path" until it learns to tell the difference.
// Simple pattern recognition for robot behavior
class SimplePatternLearner {
private:
struct DataPoint {
float sensorValue;
bool shouldTurn; // true = turn, false = go straight
};
static const int MAX_DATA = 50;
DataPoint trainingData[MAX_DATA];
int dataCount = 0;
public:
// Add a training example
void addTrainingExample(float sensor, bool correctAction) {
if (dataCount < MAX_DATA) {
trainingData[dataCount].sensorValue = sensor;
trainingData[dataCount].shouldTurn = correctAction;
dataCount++;
}
}
// Make a prediction based on learned patterns
bool predictAction(float currentSensor) {
// Find the closest training example
float closestDistance = 1000;
bool bestAction = false;
for (int i = 0; i < dataCount; i++) {
float distance = abs(currentSensor - trainingData[i].sensorValue);
if (distance < closestDistance) {
closestDistance = distance;
bestAction = trainingData[i].shouldTurn;
}
}
return bestAction;
}
// Simple confidence measure
float getConfidence(float currentSensor) {
// Count how many similar examples we have
int similarCount = 0;
for (int i = 0; i < dataCount; i++) {
if (abs(currentSensor - trainingData[i].sensorValue) < 5) {
similarCount++;
}
}
return (float)similarCount / dataCount;
}
}; Decision-making algorithms help robots choose the best action from several options. This is like having a set of rules that help the robot think through different choices and pick the one most likely to succeed.
A decision tree is like a flowchart that asks yes/no questions to reach a decision. For example: "Is there an obstacle ahead?" → Yes → "Is it closer than 20cm?" → Yes → "Turn left"
We can give each possible action a score based on how good we think it is. The robot then chooses the action with the highest score. This is like rating different paths from 1-10 and always taking the best-rated path.
// Simple decision making for robot navigation
class SmartDecisionMaker {
private:
struct ActionScore {
String actionName;
float score;
};
public:
// Evaluate different movement options
String chooseBestAction(float frontDistance, float leftDistance, float rightDistance) {
ActionScore options[4];
// Option 1: Go forward
options[0].actionName = "forward";
options[0].score = calculateForwardScore(frontDistance);
// Option 2: Turn left
options[1].actionName = "left";
options[1].score = calculateTurnScore(leftDistance);
// Option 3: Turn right
options[2].actionName = "right";
options[2].score = calculateTurnScore(rightDistance);
// Option 4: Back up
options[3].actionName = "backward";
options[3].score = 1.0; // Always low priority
// Find the best option
String bestAction = "stop";
float bestScore = 0;
for (int i = 0; i < 4; i++) {
if (options[i].score > bestScore) {
bestScore = options[i].score;
bestAction = options[i].actionName;
}
}
return bestAction;
}
private:
float calculateForwardScore(float distance) {
// Higher score for more distance
if (distance > 50) return 10.0;
if (distance > 30) return 7.0;
if (distance > 15) return 3.0;
return 0.0; // Too close, don't go forward
}
float calculateTurnScore(float distance) {
// Moderate score for turning
if (distance > 25) return 8.0;
if (distance > 15) return 5.0;
return 2.0;
}
// Learn from outcomes to improve future decisions
void updateScores(String lastAction, bool wasSuccessful) {
// This would adjust our scoring based on results
if (wasSuccessful) {
Serial.println("Good choice: " + lastAction);
} else {
Serial.println("Need to improve: " + lastAction);
}
}
}; Adaptive learning means the robot continues to improve its performance as it gains more experience. Like how you get better at video games the more you play, robots can get better at their tasks through practice and feedback.
A feedback loop is when the robot checks if its actions worked well and uses that information to make better decisions next time. If turning left worked well in a situation, it's more likely to turn left in similar situations.
The robot keeps track of what happened in different situations and what actions worked best. This creates a "memory" of experiences that helps guide future decisions, making the robot smarter over time.
// Adaptive learning system for robot behavior
class AdaptiveLearner {
private:
struct Experience {
float situation[3]; // sensor readings
String action; // what we did
float result; // how well it worked (0-10)
};
static const int MAX_EXPERIENCES = 100;
Experience memory[MAX_EXPERIENCES];
int experienceCount = 0;
// Performance tracking
float actionSuccess[4] = {5.0, 5.0, 5.0, 5.0}; // forward, left, right, back
public:
// Learn from a completed action
void learnFromExperience(float sensors[3], String action, float outcome) {
// Store the experience
if (experienceCount < MAX_EXPERIENCES) {
for (int i = 0; i < 3; i++) {
memory[experienceCount].situation[i] = sensors[i];
}
memory[experienceCount].action = action;
memory[experienceCount].result = outcome;
experienceCount++;
}
// Update action success rates
updateActionSuccess(action, outcome);
}
// Make smarter decisions based on experience
String makeSmartDecision(float currentSensors[3]) {
// Find similar past situations
float bestScore = 0;
String bestAction = "forward";
String actions[] = {"forward", "left", "right", "backward"};
for (int a = 0; a < 4; a++) {
float score = predictActionSuccess(currentSensors, actions[a]);
if (score > bestScore) {
bestScore = score;
bestAction = actions[a];
}
}
return bestAction;
}
private:
void updateActionSuccess(String action, float outcome) {
int actionIndex = getActionIndex(action);
if (actionIndex >= 0) {
// Gradually update success rate
actionSuccess[actionIndex] = (actionSuccess[actionIndex] * 0.9) + (outcome * 0.1);
}
}
float predictActionSuccess(float sensors[3], String action) {
// Look for similar situations in memory
float totalScore = 0;
int similarCount = 0;
for (int i = 0; i < experienceCount; i++) {
if (memory[i].action == action) {
// Check if situation is similar
float similarity = calculateSimilarity(sensors, memory[i].situation);
if (similarity > 0.7) { // 70% similar
totalScore += memory[i].result;
similarCount++;
}
}
}
if (similarCount > 0) {
return totalScore / similarCount;
} else {
// No similar experience, use general action success
return actionSuccess[getActionIndex(action)];
}
}
float calculateSimilarity(float sensors1[3], float sensors2[3]) {
float totalDiff = 0;
for (int i = 0; i < 3; i++) {
totalDiff += abs(sensors1[i] - sensors2[i]);
}
// Convert difference to similarity (0-1)
return max(0.0, 1.0 - (totalDiff / 300.0));
}
int getActionIndex(String action) {
if (action == "forward") return 0;
if (action == "left") return 1;
if (action == "right") return 2;
if (action == "backward") return 3;
return -1;
}
}; Build a robot that learns to navigate better over time by remembering what works and what doesn't in different situations.
Topic: AI in Everyday Life
Research and write a one-page report on how machine learning is used in one of these areas: