二维车辆世界

Posted 2020-10-30 一起来看流星雨

无人驾驶汽车-2D世界 [示范]

现在，你将要使用2维网格，而不是1维网格。但是你要做的四件事情，与你在之前的那个1D案例中的四件事情一样：

• 编写一个函数，用于初始化网格中的概率
• 编写一个函数，输出机器人在网格上特定点的概率
• 编写一个函数，用于显示网格的概率（这个函数是为你提供的）
• 编写一个函数，用于更新网格上点的概率

例 ：该示例演示了如何创建2D列表并将新行添加到列表中。

twodlist = []
number_rows = 5

for i in range(number_rows):
    twodlist.append([5, 2, 1, 8])        

print_formatted_list(twodlist)

　　

print out list values with formatting
5, 2, 1, 8
5, 2, 1, 8
5, 2, 1, 8
5, 2, 1, 8
5, 2, 1, 8　　

例 ：对于最后一个例子，这是一个用嵌套for循环创建的2D列表。注意该代码是如何首先创建一个新行，然后将该行添加到2D列表中。

twodlist = []
row = []
number_rows = 5
number_columns = 6

for i in range(number_rows):
    for j in range(number_columns):
        row.append(i)
    twodlist.append(row)
    row = []

print_formatted_list(twodlist)

　

print out list values with formatting
0, 0, 0, 0, 0, 0
1, 1, 1, 1, 1, 1
2, 2, 2, 2, 2, 2
3, 3, 3, 3, 3, 3
4, 4, 4, 4, 4, 4

　　

　

无人驾驶汽车-2D世界

以下是这组练习的几个任务：

• 编写一个函数，用来初始化网格中的概率
• 编写一个函数，输出机器人在网格上特定点的概率
• 编写一个函数，用来显示网格的概率（这个函数是为你提供的）
• 编写一个函数，用来更新网格上的点的概率

这组练习与1D世界中的练习相同。但是现在你需要使用嵌套for循环和嵌套列表，这可能会比较有难度。

练习1

编写一个函数，用来初始化2D网格的概率。请牢记，最初，整个网格的概率是相等的。所有的概率都需要总计为一个概率。

所以，如果你的网格是5×4，你将会有20个空间；与每个空间相关的初始概率将是1/20。

以下是该函数的输入和输出：

输入

• 网格中的行数
• 网格中的列数

输出

• 包含每个网格单元的概率的嵌套列表

def initial_grid(rows, columns):

    grid = []
    row = []
    probability = 1 / (rows * columns)

    for i in range(rows):
        for j in range(columns):
            row.append(probability)
        grid.append(row)
        row = []

    return grid

　　

assert initial_grid(5, 4) == [[0.05, 0.05, 0.05, 0.05],
                              [0.05, 0.05, 0.05, 0.05],
                              [0.05, 0.05, 0.05, 0.05],
                              [0.05, 0.05, 0.05, 0.05],
                              [0.05, 0.05, 0.05, 0.05]]

assert initial_grid(2, 5) == [[0.1, 0.1, 0.1, 0.1, 0.1], 
                              [0.1, 0.1, 0.1, 0.1, 0.1]]

assert initial_grid(2, 2) == [[0.25, 0.25], 
                              [0.25, 0.25]]

print(‘Hooray!‘)

　　

练习 2

编写一个函数，输出机器人在网格上特定点的概率。

以下是该函数的输入和输出：

输入

• 表示为嵌套列表的一个2D网格
• 一个行编号
• 一个列编号

输出

• 输入该行、列的概率

提示

请牢记，第一行第一列中的第一个网格单元是[0][0]而不是[1][1] 。

def probability(grid, row, column):

    return grid[row][column]

　　

assert probability([[.25, .1], 
                    [.45, .2]], 
                   1, 1) == 0.2

assert probability([[.05, .1, .1],
                    [.04, .3, .02],
                    [.01, .02, .02],
                    [.005, .012, .06],
                    [.09, .07, .103]], 3, 2) == 0.06

assert probability([[.05, .1, .1],
                    [.04, .3, .02],
                    [.01, .023, .017],
                    [.005, .012, .06],
                    [.09, .07, .103]], 2, 2) == .017

print(‘You passed all the assertion tests.‘)

　　

 

演示

运行下面的代码单元，从而将该网格的概率可视化。此函数是为你提供的。我们为你提供此代码的原因在于，我们尚未讨论如何在2D世界中以图形方式表示概率分布。

运行下面的代码单元，查看输出值。 该代码显示的是热图。尽管条形图可以表示y轴上的概率，但热图可以用颜色表示概率。

import matplotlib.pyplot as plt
%matplotlib inline

def graph_grid(grid):
    plt.imshow(grid, cmap=‘Greys‘, clim=(0,.1))
    plt.title(‘Heat Map of Grid Probabilities‘)
    plt.xlabel(‘grid x axis‘)
    plt.ylabel(‘grid y axis‘)
    plt.legend()
    plt.show()

　　

grid = [[.05, .1, .1],
        [.04, .3, .02],
        [.01, .023, .017],
        [.005, .012, .06],
        [.09, .07, .103]]

graph_grid(grid)

　　

练习 3

编写一个函数，用来更新网格上的概率。与1D中的示例一样，你的函数将接收一个坐标和更新后的概率。 更新的概率坐标不会有任何特定的顺序；例如，该列表可能包含网格单元格（2,5），然后是网格单元格（1,7）。

下面是该函数的输入和输出。

输入

• 一个二维嵌套列表，包含了机器人位于每个单元格的概率
• 一个嵌套列表，包含了网格单元坐标和新概率

输出

• 一个代表网格的二维嵌套列表，其中包含更新的机器人网格概率

假设你有一个具有以下概率的网格：

grid = [[.05, .1, .1],
        [.04, .3, .02],
        [.01, .023, .017],
        [.005, .012, .06],
        [.09, .07, .103]]

　　你收到的是具有以下值的更新列表

update_list = [
              [[4,2], 0.012],
              [[2,2], 0.108],
              [[0,1], 0.004],
              [[3,0], 0.101]
              ]

　　

目前[4,2]网格单元的概率值为0.103。现在，你将用0.012替换该值。

2,3]网格单元的概率为0.017。

不要被update_list变量吓倒！ 这只是一个嵌套列表，类似于你已经看到的内容。要知道，update_list变量是列表的一个列表。

例如，[4,3]代表第5行第3列中的网格单元，0.012则代表新的概率。

在下一个单元格中，你将通过几种不同的方式来找到一些示例代码，从而访问列表中的值。研究这些示例并使用示例来帮助你编写update_probability（）函数。

嵌套循环示例

# Example of nested lists

update_list = [
              [[4,2], 0.012],
              [[2,2], 0.108],
              [[0,1], 0.004],
              [[3,0], 0.101]
              ]

# Code for accessing the first element in the list
print(update_list[0])
print(update_list[0][0])
print(update_list[0][0][0])
print(update_list[0][0][1])
print(update_list[0][1])

# Output of for loop
print(‘\noutput of for loop‘)
for element in update_list:
    print(element)

print(‘\noutput rows and columns with probability‘)
for element in update_list:
    row, col = element[0]
    probability = element[1]
    print(‘row ‘, row, ‘col ‘, col, ‘probability ‘, probability)

　

完成练习

现在完成这个练习，使用update_list更新网格变量中的概率。

def update_probability(grid, update_list):

for element in update_list:
    x, y = element[0]
    grid[x][y] = element[1]

return grid

　　

　现在，通过运行下面的代码，测试你的结果

grid = [[.05, .1, .1],
        [.04, .3, .02],
        [.01, .023, .017],
        [.005, .012, .06],
        [.09, .07, .103]]

update_list = [
              [[4,2], 0.012],
              [[2,2], 0.108],
              [[0,1], 0.004],
              [[3,0], 0.101]
              ]
update_probability(grid, update_list) 
assert update_probability(grid, update_list) == [[0.05, 0.004, 0.1],
 [0.04, 0.3, 0.02],
 [0.01, 0.023, 0.108],
 [0.101, 0.012, 0.06],
 [0.09, 0.07, 0.012]]

print(‘Nicely done‘)