és néhány olyan domain, amely az iparág legfontosabb divatszavai közé tartozik, és jó okkal. Az AI 2020-ig 2,3 millió munkahelyet fog teremteni, tekintve, hogy fő célja az, hogy a gépek képesek legyenek utánozni az emberi viselkedést. Furcsa, nem? Tehát ma a Q Learning-et, a megerősítő tanulás építőelemét fogjuk megvitatni a következő sorrendben:
- Mi az a megerősítő tanulás?
- Q-tanulási folyamat
- Bellman-egyenlet
- Markov döntési folyamata
- Q-Learning bemutató: NumPy
Mi az a megerősítő tanulás?
Vessünk egy pillantást a mindennapi életünkre. Számos feladatot végzünk a környezetben, és ezek közül egyesek jutalmat hoznak nekünk, míg mások nem. Folyamatosan keressük a különböző utakat, és megpróbáljuk kideríteni, melyik út jutalmazáshoz vezet, és cselekedeteink alapján javítjuk a célok elérésére vonatkozó stratégiánkat. Ez a barátaim az egyik legegyszerűbb hasonlat a megerősítő tanuláshoz.
Főbb érdeklődési területek:
- Környezet
- Akció
- Jutalom
- Állapot
A megerősítő tanulás a gépi tanulás azon ága, amely lehetővé teszi a rendszerek számára, hogy tanuljanak saját döntéseik eredményeiből. Megold egy adott problémát, ahol a döntéshozatal szekvenciális, és a cél hosszú távú.
Q-tanulási folyamat
Értsük meg, mi a Q tanulás, itt a problémamegállapításunkkal. Ez segít meghatározni a megerősítő tanulási megoldás fő összetevőit, azaz az ügynököket, a környezetet, a cselekvéseket, a jutalmakat és az állapotokat.
rekurzív fibonacci c ++
Autógyári analógia:
Robotokkal töltött autógyárban vagyunk. Ezek a robotok segítenek a gyári dolgozóknak az autó összeállításához szükséges alkatrészek továbbításával. Ezek a különböző részek a gyár különböző helyszínein találhatók, 9 állomáson. Az alkatrészek között van alváz, kerekek, műszerfal, motor és így tovább. A Factory Master a futómű telepítésének helyét prioritásként kezelte. Nézzük meg a beállítást itt:
Államok:
Azt a helyet, ahol a robot egy adott példányban van, állapotának nevezzük. Mivel könnyű kódolni, ahelyett, hogy nevekkel emlékeznénk rá. Térképezzük a helyet a számokhoz.
Műveletek:
A műveletek nem másak, mint a robotok bármely helyre történő mozdulatai. Vegye figyelembe, hogy egy robot az L2 helyen van, és a közvetlen helyek, ahová mozoghat, L5, L1 és L3. Értsük meg ezt jobban, ha ezt vizualizáljuk:
Jutalmak:
Jutalmat kap a robot, amiért közvetlenül halad egyik állapotból a másikba. Például elérheti az L5-öt közvetlenül az L2-ből és fordítva. Tehát mindkét esetben 1-es jutalmat kapunk. Vessünk egy pillantást a jutalom táblázatra:
Ne feledje, amikor a gyári mester elsőbbséget adott az alváz helyének. L7 volt, ezért be fogjuk építeni ezt a tényt a jutalom táblázatunkba. Tehát nagyon nagy számot fogunk rendelni (esetünkben 999-et) az (L7, L7) helyre.
Bellman-egyenlet
Tegyük fel, hogy egy robotnak az A pontról B-re kell haladnia. Meg fogja választani azt az utat, amely pozitív jutalmat eredményez. Tegyük fel, hogy ennek nyomán jutalmat nyújtunk annak követésére.
De mi van akkor, ha a robot valahonnan a kettő közül indul, ahol két vagy több utat lát. A robot így nem tud döntést hozni, és ez elsősorban azért történik, mert nem rendelkezik a memória . Itt jön a képbe a Bellman-egyenlet.
V (s) = max (R (s, a) + & # 120632V (s ’))
Hol:
- s = egy adott állapot
- a = cselekvés
- s '= állapot, amelybe a robot átmegy s-ből
- & # 120632 = diszkont faktor
- R (s, a) = jutalomfüggvény, amely állapotot (állapotokat) és műveletet (a) vesz fel, és jutalomértéket ad ki
- V (s) = egy adott állapotban való lét értéke
Most a rendeltetési hely alatti blokk jutalma 1 lesz, ami a legmagasabb jutalom. De mi van a másik blokkkal? Nos, itt jön be a diszkonttényező. Tegyük fel, hogy 0,9 diszkontfaktor van, és egyesével töltsük ki az összes blokkot.
Markov döntési folyamata
Képzelje el, hogy egy robot a narancssárga blokkon van, és el kell érnie a célt. De még akkor is, ha enyhe diszfunkció van, a robot zavart lesz, hogy melyik utat választja, ahelyett, hogy felmenne.
hogyan kell használni a hatalmakat a java-ban
Tehát módosítanunk kell a döntéshozatali folyamatot. Meg kell Részben véletlenszerű és Részben a robot irányítása alatt . Részben véletlenszerű, mert nem tudjuk, hogy a robot mikor fog működni, és részben ellenőrzés alatt áll, mert ez még mindig a robot döntése. És ez képezi az alapját a Markov-döntési folyamatnak.
A Markov-döntési folyamat (MDP) egy diszkrét időstochasztikus kontrollfolyamat. Matematikai keretet biztosít a döntéshozatal modellezéséhez olyan helyzetekben, amikor az eredmények részben véletlenszerűek, részben pedig egy döntéshozó ellenőrzése alatt állnak.
Tehát az eredeti Bellman-egyenletünket fogjuk használni, és változtatni fogunk benne. Amit nem tudunk, az a következő állapot, azaz. s ’. Amit tudunk, az a fordulás minden lehetősége, és változtassunk az egyenleten.
V (s) = max (R (s, a) + és # 120632 V (s ’))
V (s) = max (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) V (s))
P (s, a, s ’): Az állapotból való elmozdulás valószínűsége s nak nek s ’ cselekvéssel nak nek
& Sigmas ’P (s, a, s ’) V (s): A robot véletlenszerűségének elvárásai
V (s) = max (R (s, a) + & # 120632 ((0,8 V (szobafel)) + (0,1 V (szobale-) +….))
Most térjünk át a Q-tanulásra. A Q-Learning elképzelést vet fel egy állapotba lépéshez szükséges cselekvés minőségének felmérésére, ahelyett, hogy meghatározná az áthelyezett állapot lehetséges értékét.
Ez az, amit kapunk, ha beépítjük azt az elképzelést, hogy felmérjük a cselekvések minőségét egy bizonyos államba való áttérés érdekében. ' A frissített Bellman-egyenletből, ha eltávolítjuk őket max komponens, csak egy lábnyomot feltételezünk a lehetséges cselekvéshez, amely nem más, mint a Minőség az akció.
Q (s, a) = (R (s, a) + és # 120632) & Sigmas ’P (s, a, s ’) V (s))
Ebben az egyenletben, amely számszerűsíti a cselekvés minőségét, feltételezhetjük, hogy V (s) a Q (s, a) összes lehetséges értékének maximuma. Tehát helyettesítsük v (s ’) Q () függvényével.
Q (s, a) = (R (s, a) + és # 120632) & Sigmas ’P (s, a, s ’) max Q (s ’, a’))
sql szerverintegrációs szolgáltatások ssis lépésről lépésre
Csak egy lépés van a Q Learning végső egyenletéhez. Bemutatjuk a Időbeli különbség a Q-értékek kiszámításához, figyelembe véve a környezet időbeli változását. De hogyan figyelhetjük meg a Q változását?
TD (s, a) = (R (s, a) + és # 120632) & Sigmas ’P (s, a, s ’) max Q (s ’, a’)) - Q (s, a)
Ugyanazon képlettel újraszámoljuk az új Q (s) -t, és kivonjuk belőle a korábban ismert Q (s, a) -t. Tehát a fenti egyenlet:
Qt(s, a) = Qt-1(s, a) + α TDts, a)
Qt(s, a) = Aktuális Q-érték
Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 max Q (s ’, a’)-Qt-1(s, a))
Q tanulási bemutató: NumPy
Használni fogom A NumPy bemutatja a Q Learning működését.
1. lépés: Import, paraméterek, állapotok, műveletek és jutalmak
importálja a számot, mint np gamma = 0,75 # Kedvezménytényező alfa = 0,9 # Tanulási arány location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} műveletek = [0,1,2,3,4,5,6,7,8] jutalom = np.array ( [[0,1,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0], [0,1,0,0, 0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,0] , [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0], [0,0,0,0, 1,0,1,0,1], [0,0,0,0,0,0,0,1,0]])2. lépés: Mutassa az indexeket helyekhez
state_to_location = dict ((állam, hely) a helyhez, állapot a location_to_state.items ())
3. lépés: Az optimális útvonal elérése a Q Learning Process használatával
def get_optimal_route (start_location, end_location): jutalom_new = np.copy (jutalmak) end_state = location_to_state [end_location] rewards_new [end_state, end_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- Tanulási folyamat az i tartományban (1000): # Véletlenszerű állapot felvétele current_state = np.random.randint (0,9) # A Python kizárja a felső korlátot játszható_műveletek = [] # A j tartomány új jutalommátrixán keresztül ismétlődve ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Válasszon egy véletlenszerű műveletet, amely a következő állapothoz vezet minket next_state = np.random.choice (playable_actions) # TD időbeli különbség kiszámítása = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # A Q-érték frissítése a Bellman-egyenlet segítségével Q [current_state, next_state] + = alfa * TD # Inicializálja az optimális útvonalat a kiindulási hely útvonala = [start_location] # Kezdje a következő_location kezdő helyet next_location = csillag t_location # Nem tudunk a végső helyre való eljutáshoz szükséges pontos iterációk számáról, így a ciklus jó választás lesz az iterációhoz, miközben (next_location! = end_location): # Hozza le a kezdő állapotot Hozza le a kezdő állapotra vonatkozó legmagasabb Q-értéket next_state = np.argmax (Q [start_state,]) # Megkaptuk a következő állapot indexét. De szükségünk van a megfelelő levélre. next_location = state_to_location [next_state] route.append (next_location) # Frissítse a következő iteráció kiindulási helyét start_location = next_location visszatérő útvonal
4. lépés: Nyomtassa ki az útvonalat
nyomtatás (get_optimal_route ('L1', 'L9'))Kimenet:
Ezzel a Q-Learning végéhez értünk. Remélem, hogy megismerte a Q Learning működését, valamint a különböző függőségeket, például az időbeli különbséget, a Bellman-egyenletet és még sok mást.
Edureka's elsajátítja az olyan technikákban, mint a felügyelt tanulás, a felügyelet nélküli tanulás és a természetes nyelv feldolgozása. Képzést tartalmaz a mesterséges intelligencia és a gépi tanulás legújabb fejleményeiről és technikai megközelítéseiről, például a mély tanulásról, a grafikus modellekről és a megerősítő tanulásról.