AI人工智能原理与Python实战：22. 人工智能在自动驾驶领域的应用

    import cv2
    
    # 读取图像
    
    # 转换为灰度图像
    # cv2.IMREAD_GRAYSCALE：读取灰度图像
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # 二值化处理
    # cv2.THRESH_BINARY：二值化阈值
    ret, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # 显示图像
    cv2.imshow('binary', binary)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    from sklearn import svm
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import accuracy_score
    
    # 加载数据
    X = [[0, 0], [1, 1]]
    y = [0, 1]
    
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # 创建SVM模型
    model = svm.SVC()
    
    # 训练模型
    model.fit(X_train, y_train)
    
    # 预测结果
    y_pred = model.predict(X_test)
    
    # 计算准确率
    accuracy = accuracy_score(y_test, y_pred)
    print('Accuracy:', accuracy)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import numpy as np
    
    # 定义环境信息
    map = np.array([
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]
    ])
    
    # 定义起点和终点
    start = (0, 0)
    end = (4, 4)
    
    # 定义障碍物
    obstacles = [(1, 1), (2, 2), (3, 3)]
    
    # 定义A*算法
    def a_star(map, start, end):
    # 初始化开始位置和闭包集合
    open_set = {start}
    closed_set = set()
    g_score = {start: 0}
    f_score = {start: heuristic(start, end)}
    previous = {start: None}
    
    # 遍历环境信息
    while open_set:
        # 选择最小f_score的节点
        current = min(open_set, key=lambda node: f_score[node])
    
        # 如果当前节点是终点，则返回路径
        if current == end:
            path = []
            while previous[current]:
                path.append(current)
                current = previous[current]
            return path
    
        # 从开始集合中移除当前节点
        open_set.remove(current)
        closed_set.add(current)
    
        # 获取当前节点的邻居节点
        neighbors = get_neighbors(current, map, obstacles)
    
        # 遍历邻居节点
        for neighbor in neighbors:
            # 计算曼哈顿距离
            neighbor_g_score = g_score[current] + 1
    
            # 如果邻居节点不在闭包集合中，并且曼哈顿距离更小，则更新邻居节点的g_score、f_score和前驱节点
    
            if neighbor not in closed_set and neighbor_g_score < g_score.get(neighbor, float('inf')):
                g_score[neighbor] = neighbor_g_score
                f_score[neighbor] = neighbor_g_score + heuristic(neighbor, end)
                previous[neighbor] = current
    
    # 如果没有找到路径，则返回None
    return None
    
    # 定义曼哈顿距离
    def heuristic(a, b):
    return abs(a[0] - b[0]) + abs(a[1] - b[1])
    
    # 定义获取邻居节点的函数
    def get_neighbors(node, map, obstacles):
    x, y = node
    neighbors = [(x + dx, y + dy) for dx, dy in [(1, 0), (-1, 0), (0, 1), (0, -1)]]
    neighbors = [(x, y) for x, y in neighbors if 0 <= x < map.shape[0] and 0 <= y < map.shape[1] and map[x, y] == 0]
    neighbors = [(x, y) for x, y in neighbors if (x, y) not in obstacles]
    return neighbors
    
    # 获取路径
    path = a_star(map, start, end)
    print(path)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    import numpy as np
    
    # 定义环境信息
    map = np.array([
    [0, 0, 0, 0, 0],
    [0, 0, 1, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]
    ])
    
    # 定义起点和终点
    start = (0, 0)
    end = (4, 4)
    
    # 定义PID参数
    P = 1
    I = 0
    D = 0
    
    # 定义PID控制函数
    def pid_control(error, dt):
    integral = I * np.sum(error)
    derivative = D * (error - np.mean(error)) / dt
    control = P * error + integral + derivative
    return control
    
    # 定义控制系统的主函数
    def control_system():
    # 初始化错误和时间差
    error = end[0] - start[0]
    dt = 0
    
    # 遍历环境信息
    while True:
        # 计算当前位置
        current_x = start[0] + error * dt
    
        # 如果当前位置大于终点的x坐标，则更新错误和时间差
        if current_x > end[0]:
            error = end[0] - current_x
            dt += 1
    
        # 如果当前位置小于终点的x坐标，则更新错误和时间差
        elif current_x < end[0]:
            error = current_x - end[0]
            dt += 1
    
        # 如果当前位置等于终点的x坐标，则退出循环
        else:
            break
    
        # 计算PID控制输出
        control = pid_control(error, dt)
    
        # 更新当前位置
        start = (start[0] + control, start[1])
    
    # 返回控制输出
    return control
    
    # 获取控制输出
    control = control_system()
    print(control)
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读