Planificación de ruta - Los algoritmos de búsqueda
Este curso cubre discretos y planificación de trayectoria continua, a pesar de que el mundo real es continuo, pero en muchos casos, hará que el mundo discreta resolver planificación de la trayectoria más fácil y más rápido.
Aprender planificación de trayectorias, hay tres puntos principales a considerar:
- La función de coste y cómo penetraciones humana (como "girar a la derecha, gire a la izquierda más fácil que") en nuestro algoritmo de planificación
- Tratando de encontrar las mejores soluciones y buenas soluciones suficientes y compensaciones relacionadas con la optimalidad
- complejos algoritmos de cálculo en línea y fuera de línea, algoritmos y cómo se calcula la mejor ruta con antelación, evitando en lo posible en el camino
La planificación de la trayectoria objetivo es encontrar la ruta de coste mínimo, las condiciones deben ser dados incluyen: mapa, iniciar ubicación, ubicación de destino, la función de coste.
¿Cómo entender la función de costo?
La función de coste se basa en el comportamiento de conducción segura trade-offs gente, el ejemplo más simple es más conveniente que el giro a la derecha, gire a la izquierda, en la empresa de mensajería planificación de la trayectoria, a menudo se prefiere a girar a la derecha en la carretera, por lo que podemos suponer que el costo de la extrema izquierda a continuación más alta que la derecha., giro a la derecha en el costo desvío intersección de 16, pero menor que el costo total de la curva de la izquierda, el camino óptimo.
algoritmo A-Star
función heurística (función heurística) es una especulación optimista acerca de cuán lejos estamos de la meta. Se utiliza un simple valor heurístico como la distancia euclídea de encontrar un camino hacia la meta.
valor heurístico h (x, y) el resultado es menor que la distancia real, el mejor de los casos es igual a la distancia real. valor G es en realidad esta ubicación tiene que pagar para ir. función heurística f = g + h (x, y ) . como se muestra arriba, el costo se supone que cada etapa es una etapa de la posición S [3,2] es el paso 7, inspiró valor es 4, el costo total de 11, desde la posición S hasta el [4,3] paso 7 es un paso, pero sólo valor heurístico 2, el costo total de 9, para moverse por debajo del punto [3,2] coste, por lo tanto [4,3] para el camino óptimo.
Ejecutar el código:
# -----------
# User Instructions:
#
# Modify the the search function so that it becomes
# an A* search algorithm as defined in the previous
# lectures.
#
# Your function should return the expanded grid
# which shows, for each element, the count when
# it was expanded or -1 if the element was never expanded.
#
# If there is no path from init to goal,
# the function should return the string 'fail'
# ----------
grid = [[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0]]
heuristic = [[9, 8, 7, 6, 5, 4],
[8, 7, 6, 5, 4, 3],
[7, 6, 5, 4, 3, 2],
[6, 5, 4, 3, 2, 1],
[5, 4, 3, 2, 1, 0]]
init = [0, 0]
goal = [len(grid)-1, len(grid[0])-1]
cost = 1
delta = [[-1, 0 ], # go up
[ 0, -1], # go left
[ 1, 0 ], # go down
[ 0, 1 ]] # go right
delta_name = ['^', '<', 'v', '>']
def search(grid,init,goal,cost,heuristic):
# ----------------------------------------
# modify the code below
# ----------------------------------------
closed = [[0 for col in range(len(grid[0]))] for row in range(len(grid))]
closed[init[0]][init[1]] = 1
expand = [[-1 for col in range(len(grid[0]))] for row in range(len(grid))]
action = [[-1 for col in range(len(grid[0]))] for row in range(len(grid))]
x = init[0]
y = init[1]
g = 0
h=heuristic[x][y]
f=g+h
open = [[f,g,h, x, y]]
found = False # flag that is set when search is complete
resign = False # flag set if we can't find expand
count = 0
while not found and not resign:
if len(open) == 0:
resign = True
return "Fail"
else:
open.sort()
open.reverse()
next = open.pop()
x = next[3]
y = next[4]
g = next[1]
expand[x][y] = count
count += 1
if x == goal[0] and y == goal[1]:
found = True
else:
for i in range(len(delta)):
x2 = x + delta[i][0]
y2 = y + delta[i][1]
if x2 >= 0 and x2 < len(grid) and y2 >=0 and y2 < len(grid[0]):
if closed[x2][y2] == 0 and grid[x2][y2] == 0:
g2 = g + cost
h2=heuristic[x2][y2]
f2=g2+h2
open.append([f2,g2,h2, x2, y2])
closed[x2][y2] = 1
for i in range(len(expand)):
print(expand[i])
return expand
search(grid,init,goal,cost,heuristic)
-------------------------------------
result:
[0, -1, -1, -1, -1, -1]
[1, -1, -1, -1, -1, -1]
[2, -1, -1, -1, -1, -1]
[3, -1, 8, 9, 10, 11]
[4, 5, 6, 7, -1, 12]
Area representa ningún obstáculo o -1 para explorar. Trayectoria óptima de 0 a 12 representativa.
vehículo oficial Drapa Urban Challenge Saisitanfu del algoritmo A-estrellas
La programación dinámica (programación dinámica)
La programación dinámica es un algoritmos de computación intensiva, sólo se basa en el punto de destino y el mapa, se puede dar salida desde cualquier lugar para el mejor camino hacia el punto de destino. Tenemos que calcular la estrategia de optimización (Política) con la programación dinámica. En la siguiente figura espectáculos:
En primer lugar, tenemos que entender cuál es la mejor estrategia:
estrategia óptima dará a cada célula una acción determinada, mientras que el valor de la función asignará un valor a cada celda, la celda es igual a la distancia más corta a la diana.
[Volcar imagen no pasa la cadena, la estación de origen puede tener mecanismo de cadena de seguridad, se recomienda guardar la imagen abajo cargado directamente (img-rxBoMvtF-1585271108881) (/ home / hyin / .config / Typora / typora-user-images / imagen-20200307112127182 .png)]
Como el cálculo de la distancia más corta desde el punto cero, el valor de la célula adyacente como una entrada, independientemente de su valor, más alcanzar su valor de coste (que se supone 1), utilizando el valor de la función recursiva se obtiene para cada unidad minimizar el valor de la red, resultando en una política de acción óptimo.
Código :( asume valor inicial de cada celda 99, el valor óptimo calculado por la función de coste)
# ----------
# User Instructions:
#
# Write a function optimum_policy that returns
# a grid which shows the optimum policy for robot
# motion. This means there should be an optimum
# direction associated with each navigable cell from
# which the goal can be reached.
#
# Unnavigable cells as well as cells from which
# the goal cannot be reached should have a string
# containing a single space (' '), as shown in the
# previous video. The goal cell should have '*'.
# ----------
grid = [[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0]]
init = [0, 0]
goal = [len(grid)-1, len(grid[0])-1]
cost = 1 # the cost associated with moving from a cell to an adjacent one
delta = [[-1, 0 ], # go up
[ 0, -1], # go left
[ 1, 0 ], # go down
[ 0, 1 ]] # go right
delta_name = ['^', '<', 'v', '>']
def optimum_policy(grid,goal,cost):
# ----------------------------------------
# modify code below
# ----------------------------------------
value = [[99 for row in range(len(grid[0]))] for col in range(len(grid))]
policy = [['' for row in range(len(grid[0]))] for col in range(len(grid))]
change = True
while change:
change = False
for x in range(len(grid)):
for y in range(len(grid[0])):
if goal[0] == x and goal[1] == y:
if value[x][y] > 0:
value[x][y] = 0
policy[x][y]='*'
change = True
elif grid[x][y] == 0:
for a in range(len(delta)):
x2 = x + delta[a][0]
y2 = y + delta[a][1]
if x2 >= 0 and x2 < len(grid) and y2 >= 0 and y2 < len(grid[0]) and grid[x2][y2] == 0:
v2 = value[x2][y2] + cost
if v2 < value[x][y]:
change = True
value[x][y] = v2
policy[x][y]=delta_name[a]
return policy,value
policy,value=optimum_policy(grid,goal,cost)
for i in range(len(value)):
print(value[i])
for i in range(len(policy)):
print(policy[i])
-----------------------------
results:
[11, 99, 7, 6, 5, 4]
[10, 99, 6, 5, 4, 3]
[9, 99, 5, 4, 3, 2]
[8, 99, 4, 3, 2, 1]
[7, 6, 5, 4, 99, 0]
['v', '', 'v', 'v', 'v', 'v']
['v', '', 'v', 'v', 'v', 'v']
['v', '', 'v', 'v', 'v', 'v']
['v', '', '>', '>', '>', 'v']
['>', '>', '^', '^', '', '*']
Un algoritmo mixta estrellas
Un algoritmo de estrellas es uno de los entornos no estructurados mejor algoritmo (estacionamiento) en un camino de exploración, pero el algoritmo A-estrella es discreta, y el mundo robot necesita continuidad. Así que hemos diseñado un híbrido A-Star base a la ecuación cinemática , de manera que la trayectoria suavizada.
[Volcar imagen no pasa la cadena, la estación de origen puede tener mecanismo de cadena de seguridad, se recomienda guardar la imagen abajo cargado directamente (img-ohkjGoIo-1585271108883) (/ home / hyin / .config / Typora / typora-user-images / imagen-20200314205855006 .png)]
Descrito anteriormente es estructurado entorno de algoritmos de ruta de búsqueda y planificación de movimientos para el medio ambiente estructurado como autopistas, ya que hay muchas reglas específicas y trayectoria de referencia, el algoritmo A-estrella ya no es adecuado.
Para más detalles, por favor refiérase a mi otro artículo: planificación de la trayectoria - proyecto de la autopista de conducción
Linkedin: https://linkedin.com/in/williamhyin
