Kutatások;
1986-től foglalkoznak a gondolattal. Tudom hogy az interpreteres nyelvek (pl. a PHP, a javascript, vagy a Python) jobban kézre állnak, könnyebb velük írni valamit, ami működik. De mi a helyzet a kód futásának gyorsaságával? Itt jön képbe a C++. A C++ programozási nyelv jól ismert a gyorsaságáról. A legtöbb (közel) valósidejű futást igénylő, vagy párhuzamos architektúrájú programot ebben írják. Az önvezető autók esetében nagyon fontos, hogy a fedélzeti számítógép gyorsan dolgozza fel az autóra szerelt szenzorok adatait, hiszen egy 100 km/h-val haladó autó közel 30 métert tesz meg egy másodperc alatt. Az önvezető autós mérnökök is pontosan ezért használják, hogy kipréseljék a számítógépekből a lehető legnagyobb teljesítményt, mégpedig úgy, hogy a C++ kódot a videókártyán (GPU) futtatják a CPU helyett. Ha ismered a C++ programozási nyelvet, van esélyed.
A ROS-ról pár szó
A Robot Operating System (ROS) egy nyílt forráskódú keretrendszer, amelyet robotika alkalmazások fejlesztésére terveztek. A ROS célja, hogy megkönnyítse a robotok szoftverfejlesztését és integrációját különböző hardverekkel. Főbb funkciói a következők:
Architektúra: A ROS egy moduláris architektúrával rendelkezik, amely lehetővé teszi a fejlesztők számára, hogy különböző összetevőket (úgynevezett "node"-okat") használjanak és kombináljanak, ezzel támogatva a komplex rendszerek létrehozását.
Kommunikáció: A ROS különleges üzenetkezelési rendszert használ, amely lehetővé teszi a különböző node-ok közötti kommunikációt. Ez megkönnyíti az adatok megosztását és az események kezelését.
Eszközök és könyvtárak: A ROS rengeteg előre megírt eszközt és könyvtárat biztosít, amelyek felgyorsítják a fejlesztési folyamatot. Ezek közé tartoznak a szimulátorok, érzékelőkezelők, robot mozgásvezérlő algoritmusok és sok más.
Szimuláció: A ROS-hoz tartozik a Gazebo nevű szimulációs rendszer is, amely lehetővé teszi a robotok tesztelését és fejlesztését virtuális környezetben, mielőtt a valós világban alkalmaznák őket.
Támogatás: A ROS nagy közösséggel rendelkezik, amely aktívan fejleszti és támogatja a platformot, így rengeteg forrást, dokumentációt és példaprojektet találhatunk.
A ROS tehát egy erőteljes eszköz a kutatók és fejlesztők számára, akik robotikai rendszereket akarnak létrehozni, tesztelni és működtetni.
A ROS tökéletes az önvezető autók fejlesztésére, hiszen ezek is tulajdonképpen egyfajta robotok, amelyek emberi beavatkozás nélkül, önállóan képesek döntést hozni. Az egyik ok, amiért a ROS-t önvezető autók fejlesztésére használják, hogy segít a moduláris és az elosztott kódok írásában. Ezen felül a ROS nyílt forráskódú keretrendszer, tehát a leggyakoribb robotikai algoritmusok szabadon felhasználhatóak és módosíthatóak. A robotika területén használt algoritmusok nagy többsége alkalmazható és fontos az önvezető autóknál is, például térkép felépítés, lokalizáció kamera, GPS vagy LiDAR segítségével, útvonal tervezés, akadályok elkerülése.
A CUDA alkalmzása– Compute Unified Device Architecture programozási modul.
A Compute Unified Device Architecture (CUDA) az NVIDIA által kifejlesztett párhuzamos számítási architektúra és programozási modell, amely lehetővé teszi a fejlesztők számára, hogy a grafikus processzorok (GPU) számítási kapacitását kihasználják általános célú számítási feladatokhoz. A CUDA célja, hogy a párhuzamos feldolgozási feladatokat, amelyek hagyományosan CPU-kon valósultak meg, a GPU-kra terelje, amelyek sokkal több párhuzamos szálat képesek kezelni.
A CUDA használatának fő előnyei a következők:
Párhuzamos feldolgozás: A CUDA lehetővé teszi, hogy a fejlesztők párhuzamosan futtassanak feladatokat, így jelentősen felgyorsítva a számítást, különösen olyan alkalmazásokban, mint a tudományos számítások, képfeldolgozás, gépi tanulás és mélytanulás.
Hozzáférés az GPU erőforrásaihoz: A CUDA lehetővé teszi a fejlesztők számára, hogy közvetlenül hozzáférjenek a GPU memóriájához és erőforrásaihoz, így maximalizálva a teljesítményt.
Programozási rugalmasság: A CUDA C/C++ kiterjesztések használatával a programozók a jól ismert nyelveken írhatják meg programjaikat, miközben kihasználják a GPU párhuzamos feldolgozási képességeit.
Széleskörű alkalmazások: A CUDA-t széles körben alkalmazzák a számítógépes tudomány, a mérnöki területek, a gépi tanulás, a képfeldolgozás és sok más területen.
Nagy közösségi támogatás: Mivel a CUDA Népszerű és sok fejlesztő használja, jelentős közösségi támogatás áll rendelkezésre, beleértve a dokumentációt, könyvtárakat és eszközöket.
Összességében a CUDA egy hatékony eszköz a fejlesztők számára, akik szeretnék kihasználni a GPU-k párhuzamos feldolgozási teljesítményét a különböző számítási feladatokhoz.
CUDA – Compute Unified Device Architecture
A processzorok (CPU) kiválóan képesek egymást követő feladatok elvégzésére. Olyan gyorsak, hogy már-már azt az illúziót keltik, mintha több dolgot csinálnának egyszerre. De létezik egy másik feldolgozó-egység, ami még jobban alkalmas a párhuzamos feldolgozásra, a videókártya.
Míg a CPU-k négy, esetleg nyolc magon hajtják végre az utasításokat, a videokártya és a CUDA keretrendszer használatával egyszerre többezer utasítás is végrehajtható. Ennek eddig főleg a számítógépes játékokban volt szerepe, de manapság az önvezető autók is kihasználják ezt a képességet.
Az önvezetéshez használt mesterséges-intelligencia hálók futtatásánál jól jön, ha az autóra szerelt kamerák képét egyszerre képesek feldolgozni. Így nem kell kivárni egy képkocka feldolgozásának a befejezését ahhoz, hogy a többi kamerából ugyanakkor jövő képkockákat is fel tudják dolgozni. A CUDA használata az önvezetési iparágban gyakorlatilag egyeduralkodó, amely egyben a hátrányát is jelenti, hiszen egy cég, az NVIDIA fejleszti és tartja karban.
Létezik egy nyílt forráskódú versenytársa, az OpenCL keretrendszer. Ennek nagy előnye, hogy az NVIDIA grafikus kártyák mellett AMD kártyákkal is használható, hátránya viszont a CUDA-nál nehézkesebb használat.
A gépi látás az a tudományág, ami a képi információk számítógépes feldolgozásával foglalkozik. Gépi tanulással kombinálva önvezetésnél felhasználható például útburkolati jelek, esetleg sebességjelző táblák felismerésére, illetve például az előttünk haladó autó távolságának meghatározására. Egy jellemző gépi látási szoftverfejlesztési munkafolyamat során a szoftvermérnök először Python nyelven ír egy prototípust, amivel a működést már be tudja mutatni, de a sebesség még általában elmarad a kívánttól. Ezt a prototípus kódot aztán újra megírják általában C++ használatával.
Az egyik legelterjedtebb gépi látási szoftverkönyvtár az OpenCV. Az OpenCV-nek önmagában nincs nagy hardverigénye, akár még egy Raspberry Pi-on is futtatható. Még egy óriási pozitívum benne az, hogy bár az Intel fejlesztette eredetileg, de open source, bárki által ingyenesen hozzáférhető és felhasználható, akár üzleti célból is. Az OpenCV-t C++-ban írták, és abban is lehet a legjobban dolgozni vele. A gépi látást sokfelé használják vizuális odometriára, ami a képi információk alapján térbeli pozícionálást jelent. Az önvezetésben a vizuális odometria speciális esete az úgynevezett “egomotion”-számítás, mely az autóra rögzített kamerák elmozdulása alapján képes kiszámolni az autó környezethez vett pozícióját.
Deep Learning
A Deep Learning mindenképpen helyet kell, hogy kapjon egy önvezető autós technológiákat felsorakoztató listában, ez gyakorlatilag a “mesterséges intelligencia”, amely lehetővé teszi, hogy a jármű reagáljon olyan helyzetekre, amelyekkel még sosem találkozott korábban.
Nagy mennyiségű (több tera-, esetleg petabájt) tanítóanyag – többnyire képek, videók – felhasználásával megtanítanak egy algoritmust egy döntés meghozatalára. A mesterséges intelligencia alatt nem egy, mindent megoldó, általános algoritmust kell érteni, hanem külön neurális hálókat (neural network) az egyes részfeladatokra. Ezek lehetnek például klasszifikáló hálók, melyek csoportosítják a látott tárgyakat, vagy “dobozoló” hálók (bounding box network), amelyek felismerik a tárgyak körvonalait.
Egy felismerési feladat esetében a tanítóanyag minden egyes képkockáján kézzel, vagy automatizálva megjelölik azt a tárgyat, amit fel kell ismerni. A deep learning lényege, hogy a tanítási folyamat után az algoritmus egy új, ismeretlen tárggyal találkozva is tudjon önálló, helyes döntést hozni. Ha kellően változatos a tanítóanyag, a felismerés is jó minőségű lesz majd.
Egy önjáró autó vezérlésére szolgáló program általában több összetevőből áll, és többféle technológiát integrál. Az alábbiakban egy alapvető felépítést mutatok be, figyelembe véve, hogy általában szükséges az érzékelők adatait kezelni, a döntéshozatali algoritmusokat végrehajtani és a jármű mozgását irányítani.
1. Érzékelők és adatgyűjtés
Az önjáró autók különböző érzékelőkkel vannak felszerelve, mint például:
Lidar: 3D térképkészítés.
Kamerák: Képek és videó feldolgozása.
Radar: Távolságmérés és sebességvizsgálat.
IMU (Inertial Measurement Unit): Gyorsulás és forgósebesség mérés.
A programnak képesnek kell lennie az érzékelők adatait folyamatosan gyűjteni és feldolgozni.
Lássuk hogy fest C++-ban;
def collect_sensor_data():
lidar_data = get_lidar_data()
camera_data = get_camera_data()
radar_data = get_radar_data()
imu_data = get_imu_data()
return lidar_data, camera_data, radar_data, imu_data
2. Környezet észlelése
Az észlelt információk feldolgozása és a környezet modellezése. Az észlelést gépi tanulási technikákkal, mint például a konvolúciós neurális hálókkal (CNN) végezhetjük.
def perception(lidar_data, camera_data):
objects = detect_objects(lidar_data, camera_data) # Objektumok azonosítása
traffic_signs = detect_traffic_signs(camera_data) # Közlekedési táblák észlelése
return objects, traffic_signs
3. Döntéshozatal
A programnak képesnek kell lennie döntéseket hozni az észlelt információk alapján, mint például: lassítani, gyorsítani, jobbra vagy balra kanyarodni.
def decision_making(objects, traffic_signs):
if "red_light" in traffic_signs:
return "stop"
elif "car_in_front" in objects:
return "slow_down"
else:
return "go_straight"
4. Irányítás vezérlés
A vezérlőrendszer a döntések alapján fogja irányítani az autó különböző rendszereit (pl. gáz, fék, kormányzás).
def control_vehicle(decision):
if decision == "stop":
apply_brakes()
elif decision == "slow_down":
reduce_speed()
elif decision == "go_straight":
maintain_speed()
5. Döntéshozó fő ciklus
Végül, a program egy fő ciklusban fut, amely folyamatosan gyűjti az adatokat, és meghozza a szükséges döntéseket.
def main():
while True:
lidar_data, camera_data, radar_data, imu_data = collect_sensor_data()
objects, traffic_signs = perception(lidar_data, camera_data)
decision = decision_making(objects, traffic_signs)
control_vehicle(decision)
if __name__ == "__main__":
main()
Biztonság
Az önjáró autók fejlesztésekor kiemelt figyelmet kell fordítani a biztonsági protokollokra.
Valós idejű feldolgozás: Az érzékelők adatait valós időben kell feldolgozni, ami speciális programozási technikákat igényel.
Gépi tanulás:
A szofisztikált észlelési és döntéshozatali rendszerekhez gépi tanulásra van szükség.
Tesztelés: Az önjáró autóknál a tesztelés elengedhetetlen a különböző forgatókönyvek és környezetek jelentős variabilitása miatt.
Én így kezdenék hozzá;
Az önjáró autók vezérlése egy rendkívül összetett feladat, amely számos szoftverkomponenst és érzékelőt igényel. Itt egy egyszerűsített példa, amely bemutatja, hogyan lehet egy alapvető önjáró autó vezérlését C++ nyelven modellezni. A példa egy egyszerű algoritmust használ a mozgás irányításához, amely figyelembe veszi az akadályokat.
Ez egy szimulációs program, a koncepció alapja;
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
class Sensor {
public:
// Simulálja az akadályok érzékelését
bool detectObstacle() {
// Véletlenszerűen dönt a visszatérési értékről
return rand() % 2 == 0; // 50% eséllyel ad vissza akadályt
}
};
class Car {
public:
void moveForward() {
std::cout << "Az autó előre halad." << std::endl;
}
void turnLeft() {
std::cout << "Az autó balra fordul." << std::endl;
}
void turnRight() {
std::cout << "Az autó jobbra fordul." << std::endl;
}
void stop() {
std::cout << "Az autó megáll." << std::endl;
}
};
class SelfDrivingCar {
private:
Car car;
Sensor sensor;
public:
void drive() {
while (true) {
if (sensor.detectObstacle()) {
std::cout << "Akadály észlelve!" << std::endl;
avoidObstacle();
} else {
car.moveForward();
}
// Megállítani a ciklust a példa kedvéért
if (shouldStop()) {
car.stop();
break;
}
}
}
private:
void avoidObstacle() {
// Véletlenszerű döntés, hogy balra vagy jobbra fordul
if (rand() % 2 == 0) {
car.turnLeft();
} else {
car.turnRight();
}
}
bool shouldStop() {
// Például: véletlenszerűen megállíthatjuk az autót
return rand() % 10 == 0; // 10% eséllyel megáll
}
};
int main() {
srand(static_cast<unsigned int>(time(0))); // Inicializálja a véletlenszám-generátort
SelfDrivingCar selfDrivingCar;
selfDrivingCar.drive();
return 0;
}
Logikailag;
Sensor osztály: Ez a osztály modellezi az érzékelőt, amely képes észlelni, hogy van-e akadály az úton.
Car osztály: Ez az osztály egyszerű parancsokat tartalmaz a kocsi mozgatására.
SelfDrivingCar osztály: A fő logika itt található. Az autó folyamatosan előre halad, amíg akadályt nem észlel. Amikor akadályt észlel, balra vagy jobbra fordul.
main() függvény: Itt kezdődik a program. Inicializáljuk a véletlenszám-generátort és elindítjuk az önjáró autót.
A gépi tanulást, képfeldolgozást, különböző érzékelőket (mint például lidar, radar, kamerák) és sok más technológiát képzelj hozzá, amiket szintén le kell programozni C++-ban.
A LIDAR (Light Detection and Ranging) egy távoli érzékelési technológia, amely lézersugárzást használ a távolságok mérésére és a térképezésre. A LIDAR rendszerek pulzáló lézersugarakat bocsátanak ki, amelyek visszaverődnek az objektumokról, és a visszatérési időt mérik, hogy meghatározzák a távolságot. Ez az információ lehetővé teszi a háromdimenziós térképek, domborzati modellek és más adatok létrehozását.
A LIDAR-t széles körben használják különböző területeken, például:
Geodézia és térképészet: Földrajzi információs rendszerek (GIS) létrehozása, környezeti elemzések.
Ökológia és biometria: Erdők és növényzet térképezése, az ökoszisztémák vizsgálata.
Összeomlás-horoszkópia: Infrastruktúra, például hidak és útvonalak állapotának ellenőrzése.
Autonóm járművek: A környezet érzékelésére és navigálásra.
A LIDAR technológia jellemzően nagyon pontos adatokat szolgáltat, és képes részletes információkat gyűjteni különböző felületekről és struktúrákról.
Az IMU (Inertial Measurement Unit) egy olyan eszköz, amely a mozgás és az orientáció mérésére szolgál. Általában három fő szenzort tartalmaz: gyorsulásmérőt, giroszkópot és néha mágneses iránytűt is. Ezek a komponensek az alábbi feladatokat látják el:
Gyorsulásmérés: A gyorsulásmérő képes mérni az objektum lineáris gyorsulását, amely segít meghatározni a sebességet és az elmozdulást.
** forgási sebesség mérése**: A giroszkóp képes érzékelni az objektum szögsebességét, hogy megállapítja a test orientációját és forgását.
Irány meghatározása: A mágneses iránytű, ha van, segít a világító irányának meghatározásában, aminek segítségével pontosabb orientációs adatokat nyújt.
AZ IMU-t széles körben alkalmazzák különböző területeken, például:
Repülés: Repülőgépek és drónok navigációjára.
Autóipar: Az önvezető járművek navigációs rendszereiben.
Robotika: Robotok mozgásának és orientációjának vezérlésére.
Mobil eszközök: Okostelefonokban és táblagépekben a képernyő orientációjának és mozgásérzékelésének nyomására.
Játékok: A mozgásérzékelés javítására és interaktív játékélmények létrehozására.
Az IMU által gyűjtött adatok elemzése és feldolgozása elengedhetetlen a precíz navigációhoz és a mozgásvezérléshez a fenti alkalmazásokban.
A TOVÁBBI INFORMÁCIÓK MÁR TITKOSAK!
Nincsenek megjegyzések:
Megjegyzés küldése