Membina sistem navigasi dron menggunakan algoritma matplotlib dan A*

Pernahkah anda terfikir bagaimana dron menavigasi melalui persekitaran yang kompleks? Dalam blog ini, kami akan mencipta sistem navigasi dron mudah menggunakan Python, Matplotlib dan algoritma A*. Pada akhirnya, anda akan mempunyai sistem kerja yang menggambarkan dron menyelesaikan labirin!

Apa yang Anda Akan Pelajari

1. Istilah AI asas seperti "ejen" dan "persekitaran."
2. Cara mencipta dan menggambarkan labirin dengan Python.
3. Cara algoritma A* berfungsi untuk menyelesaikan masalah navigasi.
4. Cara melaksanakan dan menggambarkan laluan dron.

Pengenalan

Untuk membina sistem navigasi dron kami, kami memerlukan perkara berikut:

1. Ejen: Drone ?.
2. Laluan: Maze 2D yang akan dilalui dron ?️.
3. Algoritma carian: Algoritma A* ⭐.

Tetapi pertama, mari kita semak beberapa istilah AI asas untuk mereka yang baharu.

Syarat AI Utama

• Agen: Entiti (seperti dron kami) yang melihat persekitarannya (maze) dan mengambil tindakan untuk mencapai matlamat (mencapai penghujung labirin).
• Persekitaran: Dunia tempat ejen beroperasi, di sini diwakili sebagai labirin 2D.
• Heuristik: Peraturan praktikal atau anggaran yang digunakan untuk membimbing carian (seperti mengukur jarak ke matlamat).

Reka Bentuk Sistem

Don kami akan menavigasi maze 2D. Maze akan terdiri daripada:

• Tembok (kawasan tidak boleh dilalui diwakili oleh 1s).
• Laluan (ruang terbuka diwakili oleh 0s).

Objektif dron:

1. Elakkan dinding.?
2. Sampai penghujung jalan.?

Begini rupa labirin itu:

Langkah 1: Sediakan Maze

Import Perpustakaan Diperlukan

Mula-mula, pasang dan import perpustakaan yang diperlukan:

import matplotlib.pyplot as plt
import numpy as np
import random
import math
from heapq import heappop, heappush

Tentukan Dimensi Maze

Mari tentukan saiz labirin:
ular sawa
LEBAR, TINGGI = 22, 22

Tetapkan Arah dan Berat

Dalam navigasi dunia sebenar, pergerakan ke arah yang berbeza boleh mempunyai kos yang berbeza-beza. Contohnya, bergerak ke utara mungkin lebih sukar daripada bergerak ke timur.

DIRECTIONAL_WEIGHTS = {'N': 1.2, 'S': 1.0, 'E': 1.5, 'W': 1.3}
DIRECTIONS = {'N': (-1, 0), 'S': (1, 0), 'E': (0, 1), 'W': (0, -1)}

Memulakan Grid Maze

Kita mulakan dengan grid yang dipenuhi dengan dinding (1s):

import matplotlib.pyplot as plt
import numpy as np
import random
import math
from heapq import heappop, heappush

The numpy. fungsi ones() digunakan untuk mencipta tatasusunan baharu bagi bentuk dan jenis tertentu, diisi dengan satu... berguna dalam memulakan tatasusunan dengan nilai lalai.

Langkah 2: Mengukir Maze

Sekarang mari kita tentukan fungsi yang akan "mengukir" laluan dalam mez anda yang kini dimulakan dengan hanya dinding

DIRECTIONAL_WEIGHTS = {'N': 1.2, 'S': 1.0, 'E': 1.5, 'W': 1.3}
DIRECTIONS = {'N': (-1, 0), 'S': (1, 0), 'E': (0, 1), 'W': (0, -1)}

Tentukan Titik Mula dan Tamat

maze = np.ones((2 * WIDTH + 1, 2 * HEIGHT + 1), dtype=int)

Langkah 3: Memvisualisasikan Maze

Gunakan Matplotlib untuk memaparkan maze:

def carve(x, y):
    maze[2 * x + 1, 2 * y + 1] = 0  # Mark current cell as a path
    directions = list(DIRECTIONS.items())
    random.shuffle(directions)  # Randomize directions

    for _, (dx, dy) in directions:
        nx, ny = x + dx, y + dy
        if 0 <= nx < WIDTH and 0 <= ny < HEIGHT and maze[2 * nx + 1, 2 * ny + 1] == 1:
            maze[2 * x + 1 + dx, 2 * y + 1 + dy] = 0
            carve(nx, ny)

carve(0, 0)  # Start carving from the top-left corner

Langkah 4: Menyelesaikan Maze dengan A*

Algoritma A* mencari laluan terpendek dalam maze berwajaran menggunakan gabungan kos laluan dan heuristik.

Takrifkan Heuristik

Kami menggunakan jarak Euclidean sebagai heuristik kami:

start = (1, 1)
end = (2 * WIDTH - 1, 2 * HEIGHT - 1)
maze[start] = 0
maze[end] = 0

A* Pelaksanaan Algoritma

fig, ax = plt.subplots(figsize=(8, 6))
ax.imshow(maze, cmap='binary', interpolation='nearest')
ax.set_title("2D Maze")
plt.show()

Langkah 5: Visualisasikan Penyelesaian

Kami mempunyai labirin tetapi anda masih belum dapat melihat laluan dron itu.
Mari kita bayangkan laluan dron:

def heuristic(a, b):
    return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)

Kesimpulan

Tahniah! ? Anda telah membina sistem navigasi dron yang berfungsi:

• Menghasilkan labirin 2D.
• Selesaikannya menggunakan algoritma A*.
• Membayangkan laluan terpendek.

Langkah Seterusnya

1. Percubaan dengan saiz dan berat labirin yang berbeza.
2. Cuba heuristik lain seperti jarak Manhattan.
3. Visualkan labirin 3D untuk lebih kerumitan!

Jangan ragu untuk berkongsi keputusan anda atau bertanya soalan dalam ulasan di bawah.
Ke infiniti dan seterusnya ?

Atas ialah kandungan terperinci Membina sistem navigasi dron menggunakan algoritma matplotlib dan A*. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!