Рубрики
Без рубрики

Руководство инсайдера по алгоритму A* в Python

Алгоритм A* в Python или general-это задача искусственного интеллекта, используемая для поиска путей и обхода графов, поскольку этот алгоритм является гибким.

Автор оригинала: Team Python Pool.

Руководство инсайдера по алгоритму A* в Python

Алгоритм A* в Python или вообще в основном представляет собой задачу искусственного интеллекта, используемую для поиска пути (из точки A в точку B) и обхода графа. Этот алгоритм является гибким и может быть использован в широком диапазоне контекстов. Алгоритм поиска A* использует эвристическую стоимость пути, стоимость начальной точки и конечную точку. Этот алгоритм был впервые опубликован Питером Хартом, Нильсом Нильссоном и Бертрамом Рафаэлем в 1968 году.

Почему Алгоритм A*?

Этот алгоритм является продвинутой формой алгоритма BFS (Поиск по ширине), который сначала ищет более короткий путь, чем более длинные пути. Это полное, а также оптимальное решение для решения задач траектории и сетки.

Optimal – найти наименьшую стоимость от начальной точки до конечной. Полный – Это значит, что он найдет все доступные пути от начала до конца.

Основные понятия А*

Где

g (n): Фактический путь затрат от начального узла до текущего узла.

h ( n): Фактический путь затрат от текущего узла к целевому узлу.

f (n): Фактический путь затрат от начального узла к целевому.

Для реализации алгоритма A* мы должны использовать два массива, а именно OPEN и CLOSE.

ОТКРЫТЬ:

Массив, содержащий узлы, которые были сгенерированы, но еще не были исследованы до сих пор.

CLOSE:

Массив, содержащий узлы, которые исследуются.

Алгоритм

1: Во-первых, поместите начальный узел в OPEN и найдите его значение f (n).

2: Затем удалите узел из OPEN, имеющий наименьшее значение f (n). Если это узел цели, то остановитесь и вернитесь к успеху.

3: Иначе удалите узел из OPEN и найдите всех его преемников.

< strong>4: Найдите значение f (n) всех преемников, поместите их в OPEN и поместите удаленный узел в CLOSE.

5: Goto Step-2.

6: Выход.

Преимущества алгоритма A* в Python

  • Он полностью завершен и оптимален.
  • Это лучшая из всех других техник. Мы используем для решения всех сложных задач именно этот алгоритм.
  • Алгоритм оптимально эффективен, то есть нет другого оптимального алгоритма, который гарантированно расширит меньше узлов, чем A*.

Недостатки алгоритма A* в Python

  • Этот алгоритм является полным, если коэффициент ветвления алгоритма конечен и каждое действие имеет фиксированную стоимость.
  • Быстрое выполнение поиска* сильно зависит от точности эвристического алгоритма, который используется для вычисления h (n), и немного медленнее, чем другие алгоритмы.
  • У него сложные проблемы.

Псевдокод алгоритма A*

let openList equal empty list of nodes
let closedList equal empty list of nodes
put startNode on the openList (leave it's f at zero)
while openList is not empty
    let currentNode equal the node with the least f value
    remove currentNode from the openList
    add currentNode to the closedList
    if currentNode is the goal
        You've found the exit!
    let children of the currentNode equal the adjacent nodes
    for each child in the children
        if child is in the closedList
            continue to beginning of for loop
       .g + distance b/w child and current
        from child to end
       .g + child.h
        if child.position is in the openList's nodes positions
            if child.g is higher than the openList node's g
                continue to beginning of for loop
        add the child to the openList

A* Код алгоритма для графа

Алгоритм* лучше всего подходит для поиска путей из одного места в другое. Он всегда следит за тем, чтобы основанный путь был наиболее эффективным. Это реализация A* на a href=”https://en.wikipedia.org/wiki/Graph_theory”>структура графа href=”https://en.wikipedia.org/wiki/Graph_theory”>структура графа

A* Алгоритм Python Код для графа
A* Алгоритм Python Код для графа
from collections import deque

class Graph:
    def __init__(self, adjac_lis):
       

    def get_neighbors(self, v):
        return self.adjac_lis[v]

    # This is heuristic function which is having equal values for all nodes
    def h(self, n):
        H = {
            'A': 1,
            'B': 1,
            'C': 1,
            'D': 1
        }

        return H[n]

    def a_star_algorithm(self, start, stop):
        # In this open_lst is a lisy of nodes which have been visited, but who's 
        # neighbours haven't all been always inspected, It starts off with the start 
  #node
        # And closed_lst is a list of nodes which have been visited
        # and who's neighbors have been always inspected
       ([start])
       ([])

        # poo has present distances from start to all other nodes
        # the default value is +infinity
        poo = {}
       

        # par contains an adjac mapping of all nodes
        par = {}
       

        while len(open_lst) > 0:
           

            # it will find a node with the lowest value of f() -
            for v in open_lst:
                if n or poo[v] + self.h(v) < poo[n] + self.h(n):
                   ;

            if n:
                print('Path does not exist!')
                return None

            # if the current node is the stop
            # then we start again from start
            if n:
                reconst_path = []

                while par[n]:
                    reconst_path.append(n)
                   [n]

                reconst_path.append(start)

                reconst_path.reverse()

                print('Path found: {}'.format(reconst_path))
                return reconst_path

            # for all the neighbors of the current node do
            for (m, weight) in self.get_neighbors(n):
              # if the current node is not presentin both open_lst and closed_lst
                # add it to open_lst and note n as it's par
                if m not in open_lst and m not in closed_lst:
                    open_lst.add(m)
                   
                   [n] + weight

                # otherwise, check if it's quicker to first visit n, then m
                # and if it is, update par data and poo data
                # and if the node was in the closed_lst, move it to open_lst
                else:
                    if poo[m] > poo[n] + weight:
                       [n] + weight
                       

                        if m in closed_lst:
                            closed_lst.remove(m)
                            open_lst.add(m)

            # remove n from the open_lst, and add it to closed_lst
            # because all of his neighbors were inspected
            open_lst.remove(n)
            closed_lst.add(n)

        print('Path does not exist!')
        return None

ВХОД:

adjac_lis = {
    'A': [('B', 1), ('C', 3), ('D', 7)],
    'B': [('D', 5)],
    'C': [('D', 12)]
}(adjac_lis)
graph1.a_star_algorithm('A', 'D')

ВЫХОД:

Path found: ['A', 'B', 'D']
['A', 'B', 'D']

Объяснение:

В этом коде мы создали класс с именем Graph, где несколько функций выполняют различные операции. Там записано со всеми функциями, какие все операции эта функция выполняет. Затем некоторые условные операторы выполнят необходимые операции, чтобы получить минимальный путь для обхода от одного узла к другому. Наконец, мы получим результат как кратчайший путь для перемещения от одного узла к другому.

Кроме того, Читайте

  • 10 Алгоритмов Машинного Обучения Для Начинающих
  • Как найти Среднее значение списка в Python
  • Реализация алгоритма Дейкстры в Python
  • Как использовать строковый метод Python find() | Python find()
  • Двусвязный список в Python – Расширенная структура данных

Вывод

A* в Python-это мощный и полезный алгоритм со всем потенциалом. Однако она хороша лишь настолько, насколько хороша ее эвристическая функция, которая весьма изменчива, учитывая природу проблемы. Она нашла свое применение в программных системах машинного обучения и поисковой оптимизации для разработки игр.