Implementation of Reactive Agent for Autonomous Obstacle Avoidance

Reactive Agent for Autonomous Obstacle Avoidance

In this example, we’ll create a simple reactive agent for a robot that avoids obstacles. The robot will move forward until it detects an obstacle, at which point it will change direction.

Step 1: Define the Environment

We create a 10×10 grid using numpy, where 0 represents an empty cell and 1 represents an obstacle. An obstacle is placed at the position (4, 4). The environment is visualized using matplotlib.

Python

import matplotlib.pyplot as plt
import numpy as np

# Define the environment grid (0 = empty, 1 = obstacle)
grid_size = 10
environment = np.zeros((grid_size, grid_size))
environment[4, 4] = 1  # Adding an obstacle

# Visualize the environment
plt.imshow(environment, cmap='gray')
plt.title('Environment Grid')
plt.show()

Output:

A grayscale image of the 10×10 grid with one obstacle.

Step 2: Create the Perception Module

The PerceptionModule class initializes with the environment and the robot’s position. The perceive method checks for obstacles in the adjacent cells (up, down, left, right). If the cell is on the edge of the grid, it considers that direction as an obstacle.

Python

class PerceptionModule:
    def __init__(self, environment, position):
        self.environment = environment
        self.position = position

    def perceive(self):
        x, y = self.position
        # Check for obstacles in the adjacent cells (up, down, left, right)
        perceptions = {
            'up': self.environment[x-1, y] if x > 0 else 1,
            'down': self.environment[x+1, y] if x < grid_size-1 else 1,
            'left': self.environment[x, y-1] if y > 0 else 1,
            'right': self.environment[x, y+1] if y < grid_size-1 else 1,
        }
        return perceptions

Step 3: Create the Action Selection Module

The ActionSelectionModule contains rules for moving in different directions. The select_action method chooses a direction with no obstacle based on perceptions. If all directions are blocked, it returns (0, 0) indicating no movement.

Python

class ActionSelectionModule:
    def __init__(self):
        self.rules = {
            'up': (-1, 0),
            'down': (1, 0),
            'left': (0, -1),
            'right': (0, 1),
        }

    def select_action(self, perceptions):
        for direction, obstacle in perceptions.items():
            if obstacle == 0:  # No obstacle in this direction
                return self.rules[direction]
        return (0, 0)  # Stay if no clear path

Step 4: Create the Execution Module

The ExecutionModule is responsible for updating the robot’s position based on the chosen action. The execute method updates and returns the new position.

Python

class ExecutionModule:
    def __init__(self, position):
        self.position = position

    def execute(self, action):
        self.position = (self.position[0] + action[0], self.position[1] + action[1])
        return self.position

Step 5: Combine the Modules into a Reactive Agent

The ReactiveAgent class integrates perception, action selection, and execution modules. The step method represents one cycle of perception, action selection, and execution, updating the agent’s position.

Python

class ReactiveAgent:
    def __init__(self, environment, position):
        self.perception = PerceptionModule(environment, position)
        self.action_selection = ActionSelectionModule()
        self.execution = ExecutionModule(position)

    def step(self):
        perceptions = self.perception.perceive()
        action = self.action_selection.select_action(perceptions)
        new_position = self.execution.execute(action)
        self.perception.position = new_position
        return new_position

# Initial position of the robot
initial_position = (0, 0)
agent = ReactiveAgent(environment, initial_position)

# Simulate the agent's movement
positions = [initial_position]
for _ in range(20):  # Move for 20 steps
    new_position = agent.step()
    positions.append(new_position)

# Visualize the agent's path
path = np.zeros_like(environment)
for pos in positions:
    path[pos] = 0.5  # Mark the path

plt.imshow(environment + path, cmap='gray')
plt.title('Robot Path')
plt.show()

Step 6: Simulate and Visualize the Agent’s Movement

The robot starts at the initial position (0, 0). A ReactiveAgent object is created with the initial position and environment. The robot moves for 20 steps, with each step updating the robot’s position and appending it to the positions list. The path taken by the robot is marked on the grid and visualized.

Python

# Initial position of the robot
initial_position = (0, 0)
agent = ReactiveAgent(environment, initial_position)

# Simulate the agent's movement
positions = [initial_position]
for _ in range(20):  # Move for 20 steps
    new_position = agent.step()
    positions.append(new_position)

# Visualize the agent's path
path = np.zeros_like(environment)
for pos in positions:
    path[pos] = 0.5  # Mark the path

plt.imshow(environment + path, cmap='gray')
plt.title('Robot Path')
plt.show()

Output:

A grayscale image of the 10×10 grid showing the path taken by the robot from the initial position.

Detailed Explanation of Outputs:

Environment Grid: Initially displays a 10×10 grid with a single obstacle at position (4, 4). The grid is empty except for this obstacle.
Robot Path: Displays the same grid with the robot’s path overlaid. The path starts at (0, 0) and shows the sequence of cells visited by the robot during its 20 steps.

Key Points:

The PerceptionModule enables the robot to sense obstacles in adjacent cells.
The ActionSelectionModule determines the next move based on the perceived obstacles.
The ExecutionModule updates the robot’s position according to the chosen action.
The ReactiveAgent combines these modules to simulate the robot’s behavior in the environment.
The robot’s path is visualized, showing its movement while avoiding obstacles.

Reactive Agent in AI with Example

Agents are essential in the field of artificial intelligence (AI) because they solve complicated issues, automate processes, and mimic human behavior. A fundamental concept in this discipline is the idea of an agent. An agent is a software entity capable of sensing its environment, deciding what actions to take, and executing those decisions.

In this article, we will provide an extensive overview of reactive agents—quick-thinking and responding members of the AI community. We will explore their design and uses, discussing the fundamental terms, the elements that make up reactive agents, and how they perceive the world, make decisions, and carry out tasks. To ensure this tutorial is professional yet approachable for newcomers, we will also cover the benefits and drawbacks of reactive agents.

Table of Content

Overview of Reactive Agents
Architecture Components of Reactive Agents
Perception Module
Action Selection Module
Execution Module
Reactive Agent for Autonomous Obstacle Avoidance
Implementation of Reactive Agent for Autonomous Obstacle Avoidance
Applications of Reactive Agents
Advantages of Reactive Agents
Limitations of Reactive Agents
Conclusion

Implementation of Reactive Agent for Autonomous Obstacle Avoidance

Step 1: Define the Environment

Step 2: Create the Perception Module

Step 3: Create the Action Selection Module

Step 4: Create the Execution Module

Step 5: Combine the Modules into a Reactive Agent

Step 6: Simulate and Visualize the Agent’s Movement

Detailed Explanation of Outputs:

Key Points:

Reactive Agent in AI with Example

Similar Reads

Contact Us