SG.hu

Minden eddiginél haté­ko­nyabb rendező al­go­rit­must fejlesztettek

A rendezetlen listák csökkenő vagy növekvő sorrendbe rakásának kódja évtizede változatlan, de a Google DeepMind csoportja most javított rajta.

Bárki, aki vett részt egy alapfokú programozási tanfolyamon, valószínűleg látott már rendezési algoritmust. Ez egy olyan kód, amely egy rendezetlen listában növekvő vagy csökkenő sorrendbe helyezi az elemeket. Ez egy érdekes kihívás, mert nagyon sokféleképpen meg lehet csinálni, rengeteg ember nagyon sok időt töltött már azzal hogy kitalálja, hogyan lehet ezt a rendezést a lehető leghatékonyabban elvégezni. A rendezés annyira alapvető, hogy az algoritmusok a legtöbb programozási nyelv szabványos könyvtáraiba be vannak építve. A C++ könyvtár esetében például ehhez a kódhoz több mint egy évtizede nem nyúltak hozzá.

A Google DeepMind MI-csoportja azonban kifejlesztett egy olyan megerősített tanulási eszközt, amely rendkívül optimalizált algoritmusokat képes kifejleszteni anélkül, hogy először emberi kódpéldákon képeznék ki. A trükk az volt, hogy úgy állították be, hogy a programozást játékként kezelje. A DeepMind arról nevezetes, hogy olyan szoftvert fejlesztett ki, amely megtanítja magát játszani. Ez a megközelítés rendkívül hatékonynak bizonyult, olyan különböző játékokat hódított meg, mint a sakk, a Go vagy a StarCraft. Bár a részletek attól függően változnak, hogy éppen melyik játékkal foglalkozik, a szoftver saját magával játszik, és olyan lehetőségeket fedez fel, amelyekkel maximalizálni tudja a pontszámot. Mivel nem az emberek által játszott játékokon képezték ki, a DeepMind rendszer olyan megközelítéseket fedezhet fel, amelyekre az emberek nem gondoltak. Természetesen, mivel mindig saját maga ellen játszik, vannak olyan esetek, amikor olyan vakfoltokat alakított ki, amelyeket az emberek kihasználhatnak.

Ez a megközelítés nagyon fontos a programozás szempontjából. A nagy nyelvi modellek azért tudnak kódot írni, mert rengeteg emberi példát láttak, de emiatt nem valószínű, hogy olyasmit fejlesztenek ki, amit az emberek korábban még nem csináltak. Ha jól ismert algoritmusokat szeretnénk optimalizálni - mint például a rendezési függvények -, akkor egy meglévő emberi kódra alapozva a legjobb esetben is csak egyenértékű teljesítményt érhetünk el. De hogyan lehet rávenni egy mesterséges intelligenciát, hogy egy valóban új megközelítést találjon? A DeepMind emberei ugyanazt a megközelítést választották, mint a sakk és a Go esetében: a kódoptimalizálást játékká alakították. Az AlphaDev rendszer olyan x86-os assembly algoritmusokat fejlesztett ki, amelyek a kód késleltetését pontszámként kezelték, és megpróbálták minimalizálni ezt a pontszámot, miközben biztosították, hogy a kód hiba nélkül fusson végig. A megerősítő tanulás révén az AlphaDev fokozatosan javította a feszes, nagy hatékonyságú kód írásának képességét. A rendszer saját kódpéldákat generált, majd kiértékelte azokat.

Az összetett programokban történő rendezés nagy és tetszőleges elemgyűjteményeket képes kezelni, ez azonban a szabványos könyvtárak szintjén valójában rendkívül specifikus, csak egy vagy néhány helyzetet kezelő függvények nagy gyűjteményéből épül fel. Például külön algoritmusok léteznek három, négy és öt elem rendezésére. És van egy másik függvénykészlet, amely tetszőleges számú elemet képes kezelni egy határértékig. A DeepMind az AlphaDev-et mindegyik függvényre beállította, de ezek nagyon különbözőképpen működnek. Ennek eredményeképpen a kód teljesítménye általában a szükséges utasítások számával skálázódik. Az AlphaDev képes volt egy-egy utasítást lefaragni a sort-3, sort-5 és sort-8 utasításból, és még többet a sort-6 és sort-7 utasításból. Csak egy olyan utasítás volt (sort-4), ahol nem sikerült javítani az emberi kódon. A kód többszöri futtatása tényleges rendszereken azt mutatta, hogy a kevesebb utasítás valóban jobb teljesítményt eredményezett.


A C++ könyvtár meglévő implementációjában a kód egy sor tesztet végez, hogy megállapítsa, hány elemet kell rendezni, és az adott elemszámhoz hívja meg a dedikált rendezőfüggvényt. Az átdolgozott kód ennél sokkal furcsább dolgot tesz. Megvizsgálja, hogy van-e két elem, és szükség esetén egy külön függvényt hív meg a rendezéshez. Ha kettőnél több elem van, akkor a kód az első három elemet hívja meg a rendezéshez. Ha három elem van, akkor a rendezés eredményét adja vissza. Ha azonban négy elemet kell rendezni, akkor speciális kódot futtat, amely rendkívül hatékonyan beilleszti a negyedik elemet a megfelelő helyre a három rendezett elemből álló halmazon belül. Ez furcsa megközelítésnek tűnik, de következetesen felülmúlta a meglévő kódot.

Mivel az AlphaDev valóban hatékonyabb kódot produkált, a csapat szerette volna ezeket visszavinni a szabványos C++ könyvtárába. A probléma itt az volt, hogy a kód nem C++-ban, hanem assembly-ben készült. Így hát visszafelé kellett dolgozniuk, és ki kellett találniuk azt a C++ kódot, amely ugyanazt az assemblyt eredményezi. Miután ez megtörtént, a kódot beépítették, és ezzel több mint egy évtizede először módosították a kód egy részét. Ennek eredményeként a kutatók becslése szerint az AlphaDev kódját most már naponta trilliószor hajtják végre.

Hozzászólások

A témához csak regisztrált és bejelentkezett látogatók szólhatnak hozzá!
Bejelentkezéshez klikk ide
(Regisztráció a fórum nyitóoldalán)
  • NEXUS6 #2
    Azért az ilyen evolutív jellegű, önfejlesztő szoftverekrről kb 15 éve olvastam először. Jó magam azt hittem, hogy az alap algoritmusok tekintetében az ilyen kód-optimalizálási kísérleteken, az ehhez szükséges környezet kifejlesztésén már rég túl vagyunk.
    És ezek után akartunk már vagy 5 éve önvezető autót, meg hasonlókat építeni? LOL.
  • t_robert #1
    Erről most alapvetően két dolog jut az eszembe. Valamikor az őskorban számítógép kezelőként kezdtem dolgozni 1982 és 1987 közt. Egy szobányi számítógépünk volt ami az ESZR R40-es számítógép volt. Nos néha előfordult, hogy rendezni kellett akkoriban nagynak számító állományokat. Ehhez be kellett olvasni az anyagot egy mágnes szalagról. Majd elindult a rendszerbe adott (azt is DOS-nak hívták) rendező segédprogram és 3-4 darab 29 MB-os munka merevlemez feltétele mellett kb. 1-1,5 óra alatt képes volt rendezni az állományt és végül visszaírni egy másik mágnes szalagra. Úgy kb. 130-150 ezer rekordról volt szó. Jó nem röhögni az őskor volt. :) Aztán pár év múlva egy rendszer frissités során kaptunk egy hatékonyabb rendező programot. Ami a CA sort néven futott. Ez jóval hatékonyabb volt már mert képes volt 15-20 perc alatt is ugyanazt a nagy rendezést elvégezni. Nagyon örültünk neki. :)
    A másik emlékem valamikor a 80-as évek második feléhez tartozik, mikor megszereztem magamnak első 8 bites személyi számítógépemet egy Atari 800XL-t ez egy 64 KB-os 8 bites számítógép volt. Nagyjából azt a szintet hozta, amit egy C64-es. Na azon álltam neki kísérletezni pont rendezési algoritmusokkal és azok finomításával. A kitüzött feladat egy 1000 elemű numerikus tömb minnél hatékonyabb lerendezése volt. Persze mivel egy 1,79 Mhz-es 8 bites(motorola 6502) procin futott ráadásul interpreteres Basicban nem volt túl sikeres a projekt. :) Emlékszem az első eredmenyeim valahol a 9000 másodperc környékén voltak. Vagyis 2,5 óra. :) Aztán neki álltam finomitani a programot minden féle trükköt bevetve. javitva a rendezés algoritmusát. a kritikus részeket gépi kódban megirva stb. Végül sikerült eljutni az 8-10 perc futási időig. :) Persze akkoriban nem ismertem még a rekurzív rendezési algoritmust. Vagy nem is létezett még vagy csak én nem ismertem. Értelme mondjuk egyáltalán nem volt a dolognak, de legalább sokat tanultam azért belőle...... :)