Vehicle AI: A Comprehensive Guide to Autonomous Driving

1import numpy as np
2
3def simple_path_planning(start, goal, obstacles):
4    """A very basic path planning algorithm."""
5    path = [start]
6    current = start
7    while current != goal:
8        # Find the closest point to the goal that is not an obstacle
9        next_point = None
10        min_distance = float('inf')
11        for i in range(max(0, current[0]-1), min(10, current[0]+2)):
12            for j in range(max(0, current[1]-1), min(10, current[1]+2)):
13                if (i, j) not in obstacles:
14                    distance = np.sqrt((i - goal[0])**2 + (j - goal[1])**2)
15                    if distance < min_distance:
16                        min_distance = distance
17                        next_point = (i, j)
18        if next_point is None:
19            return None  # No path found
20        path.append(next_point)
21        current = next_point
22    return path
23
24# Example usage
25start = (1, 1)
26goal = (8, 8)
27obstacles = [(3, 3), (4, 3), (5, 3), (6, 6)]
28
29path = simple_path_planning(start, goal, obstacles)
30if path:
31    print("Path found:", path)
32else:
33    print("No path found.")
34

1import numpy as np
2import random
3
4class SimpleLaneKeepingAgent:
5    def __init__(self, learning_rate=0.1, discount_factor=0.9, epsilon=0.1):
6        self.q_table = {}
7        self.learning_rate = learning_rate
8        self.discount_factor = discount_factor
9        self.epsilon = epsilon
10
11    def get_action(self, state):
12        if random.random() < self.epsilon:
13            return random.choice(['left', 'right', 'straight'])
14        else:
15            if state in self.q_table:
16                return max(self.q_table[state], key=self.q_table[state].get)
17            else:
18                return random.choice(['left', 'right', 'straight'])
19
20    def learn(self, state, action, reward, next_state):
21        if state not in self.q_table:
22            self.q_table[state] = {'left': 0, 'right': 0, 'straight': 0}
23
24        if next_state not in self.q_table:
25            self.q_table[next_state] = {'left': 0, 'right': 0, 'straight': 0}
26
27        old_value = self.q_table[state][action]
28        next_max = max(self.q_table[next_state].values())
29
30        new_value = (1 - self.learning_rate) * old_value + self.learning_rate * (reward + self.discount_factor * next_max)
31        self.q_table[state][action] = new_value
32
33# Simplified environment
34def step(state, action):
35    # Example: state is the lane offset (negative is left, positive is right)
36    # Simplified reward: stay in the lane!
37    if action == 'left':
38        next_state = state - 1
39    elif action == 'right':
40        next_state = state + 1
41    else:
42        next_state = state
43
44    if abs(next_state) > 2:  # Out of lane
45        reward = -1
46    else:
47        reward = 0
48
49    return next_state, reward
50
51# Example training loop
52agent = SimpleLaneKeepingAgent()
53state = 0  # Starting in the center of the lane
54
55for _ in range(1000):
56    action = agent.get_action(state)
57    next_state, reward = step(state, action)
58    agent.learn(state, action, reward, next_state)
59    state = next_state
60
61print("Trained agent (Q-table):")
62print(agent.q_table)
63