Q Learning: Vše, co potřebujete vědět o Reinforcement Learning

Tento článek poskytuje podrobné a komplexní znalosti Q-Learningu prostřednictvím krásné analogie Reinforcement Learning prostřednictvím kódu Pythonu.

a je několik domén, které patří k nejlepším módním slovům v oboru, a to z dobrého důvodu. AI do roku 2020 vytvoří 2,3 milionu pracovních míst, přičemž jejím hlavním cílem je umožnit strojům napodobovat lidské chování. Zvláštní, že? Dnes tedy budeme diskutovat o Q Learning, základním kameni Reinforcement Learning, v následujícím pořadí:

Co je Posílení učení?

Pojďme se podívat na náš každodenní život. V prostředí provádíme řadu úkolů a některé z nich nám přinášejí odměny, zatímco jiné ne. Neustále hledáme různé cesty a snažíme se zjistit, která cesta povede k odměnám, a na základě našich akcí vylepšujeme naše strategie pro dosažení cílů. Tohle jsou moji přátelé jednou z nejjednodušších analogií Reinforcement Learning.





Klíčové oblasti zájmu:

  • životní prostředí
  • Akce
  • Odměna
  • Stát

posilování učení - q učení



Reinforcement Learning je odvětví strojového učení, které systémům umožňuje učit se z výsledků jejich vlastních rozhodnutí. Řeší určitý druh problému, kde je rozhodování postupné a cíl je dlouhodobý.

Proces Q-učení

Pojďme pochopit, co je Q učení, s naším prohlášením o problému zde. Pomůže nám to definovat hlavní komponenty řešení pro posílení učení, tj. Agenty, prostředí, akce, odměny a stavy.

Analogie automobilové továrny:



Jsme v automobilové továrně plné robotů. Tito roboti pomáhají pracovníkům továrny přepravou nezbytných dílů potřebných k sestavení automobilu. Tyto různé části jsou umístěny na různých místech v továrně na 9 stanicích. Součásti zahrnují podvozek, kola, palubní desku, motor atd. Factory Master upřednostnil místo, kde se instaluje šasi, jako nejvyšší prioritu. Podívejme se na nastavení zde:

Státy:

vzestupně c ++

Místo, kde je robot přítomen v konkrétní instanci, se nazývá jeho stav. Protože je snadné jej kódovat, než si jej pamatovat jmény. Pojďme namapovat polohu na čísla.

Akce:

Akce nejsou nic jiného než pohyby robotů na jakékoli místo. Zvažte, že robot je na místě L2 a přímá místa, do kterých se může pohybovat, jsou L5, L1 a L3. Pochopme to lépe, když si to představíme:

Odměny:

Za přechod přímo z jednoho státu do druhého bude robot odměněn. Například můžete dosáhnout L5 přímo z L2 a naopak. V obou případech tedy bude poskytnuta odměna 1. Podívejme se na tabulku odměn:

Pamatujte, kdy Factory Master určil prioritu umístění podvozku. Byla to L7, takže tuto skutečnost začleníme do naší tabulky odměn. Přiřadíme tedy velmi velké číslo (v našem případě 999) na místo (L7, L7).

Bellmanova rovnice

Nyní předpokládejme, že robot musí přejít z bodu A do bodu B. Zvolí cestu, která přinese pozitivní odměnu. Z tohoto důvodu poskytujeme odměnu, pokud jde o stopu, aby mohla následovat.

Ale co když robot začne odněkud mezi tím, kde vidí dvě nebo více cest. Robot tak nemůže učinit rozhodnutí a to se děje především proto, že nemá Paměť . To je místo, kde přichází do obrazu Bellmanova rovnice.

V (s) = max (R (s, a) + & # 120632V (s))

obrácení čísla v Javě

Kde:

  • s = konkrétní stav
  • a = akce
  • s '= stav, do kterého robot přejde ze s
  • & # 120632 = faktor slevy
  • R (s, a) = funkce odměny, která bere stav (y) a akci (a) a vydává hodnotu odměny
  • V (s) = hodnota pobytu v určitém stavu

Blok pod cílem nyní bude mít odměnu 1, což je nejvyšší odměna. Ale co ten druhý blok? Tady přichází faktor slevy. Předpokládejme faktor slevy 0,9 a postupně vyplňme všechny bloky.

Markovův rozhodovací proces

Představte si, že robot je na oranžovém bloku a potřebuje dosáhnout cíle. Ale i když dojde k mírné dysfunkci, robot bude zmatený, kterou cestou se má vydat, než aby šel nahoru.

Musíme tedy upravit rozhodovací proces. Musí Částečně náhodné a Částečně pod kontrolou robota . Částečně náhodně, protože nevíme, kdy bude robot nefunkční, a částečně pod kontrolou, protože je to stále rozhodnutí robota. A to tvoří základ Markovského rozhodovacího procesu.

Markovův rozhodovací proces (MDP) je diskrétní časově stochastický kontrolní proces. Poskytuje matematický rámec pro modelování rozhodování v situacích, kdy jsou výsledky částečně náhodné a částečně pod kontrolou rozhodovatele.

Použijeme tedy naši původní Bellmanovu rovnici a provedeme v ní změny. To, co nevíme, je další stav, tj. s “. Víme, že jsou všechny možnosti otočení a pojďme změnit rovnici.

V (s) = max (R (s, a) + & # 120632 V (s))

V (s) = max (R (s, a) + & # 120632 & Sigmas 'P (s, a, s) V (s))

P (s, a, s): Pravděpodobnost přesunu ze stavu s na s ' s akcí na

& Sigmas 'P (s, a, s) V (s): Očekávání náhody robota

V (s) = max (R (s, a) + & # 120632 ((0,8 V (pokojnahoru)) + (0,1 V (pokojdolů) +….))

Nyní přejdeme k Q Learning. Q-Learning představuje spíše myšlenku hodnocení kvality akce, která je přijata k přesunu do stavu, než stanovení možné hodnoty stavu, do kterého je přesunuta.

Toho se dočkáme, pokud začleníme myšlenku hodnocení kvality akcí pro přechod do určitého stavu. Z aktualizované Bellmanovy rovnice, pokud je odstraníme max komponenta, předpokládáme pouze jednu stopu pro možnou akci, což není nic jiného než Kvalitní akce.

Q (s, a) = (R (s, a) + & # 120632 & Sigmas 'P (s, a, s) V (s))

V této rovnici, která kvantifikuje kvalitu akce, můžeme předpokládat, že V (s) je maximum ze všech možných hodnot Q (s, a). Pojďme tedy nahradit v (s) funkcí Q ().

Q (s, a) = (R (s, a) + & # 120632 & Sigmas 'P (s, a, s) max Q (s ‘, a‘))

Jsme jen o krok blízko naší finální Rovnice Q učení. Chystáme se zavést Časový rozdíl vypočítat hodnoty Q s ohledem na změny v prostředí v průběhu času. Jak ale můžeme pozorovat změnu Q?

c ++ jde třídit

TD (s, a) = (R (s, a) + & # 120632 & Sigmas 'P (s, a, s) max Q (s ‘, a‘)) - Q (s, a)

Přepočítáme nové Q (s, a) se stejným vzorcem a od něj odečteme dříve známé Q (s, a). Výše uvedená rovnice se tedy stává:

Qt(s, a) = Qt-1(s, a) + α TDt(s, a)

Qt(s, a) = Aktuální hodnota Q.

Qt-1(s, a) = Předchozí Q-hodnota

Qt(s, a) = Qt-1(s, a) + α (R (s, a) + & # 120632 max Q (s, a))-Qt-1(s, a))

Demo Q Learning: NumPy

Budu používat NumPy předvést, jak Q Learning funguje.

Krok 1: Importy, parametry, stavy, akce a odměny

import numpy jako np gamma = 0,75 # faktor slevy alfa = 0,9 # rychlost učení location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} akce = [0,1,2,3,4,5,6,7,8] odměny = 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]])

Krok 2: Mapování indexů na místa

state_to_location = dict ((state, location) for location, state in location_to_state.items ())

Krok 3: Získejte optimální trasu pomocí procesu učení Q.

def get_optimal_route (start_location, end_location): rewards_new = np.copy (odměny) ends_state = location_to_state [end_location] rewards_new [ends_state, ends_state] = 999 Q = np.array (np.zeros ([9,9])) # Q- Proces učení pro i v rozsahu (1000): # Vyzvednutí náhodného stavu current_state = np.random.randint (0,9) # Python vylučuje horní hranici playable_actions = [] # Iterace novou maticí odměn pro j v rozsahu ( 9): if rewards_new [current_state, j]> 0: playable_actions.append (j) # Vyberte náhodnou akci, která nás povede k dalšímu stavu next_state = np.random.choice (playable_actions) # Computing Temporal Difference TD = rewards_new [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Aktualizace Q-hodnoty pomocí Bellmanovy rovnice Q [current_state, next_state] + = alpha * TD # Inicializujte optimální trasu s výchozím umístěním route = [start_location] #Initialize next_location s výchozím umístěním next_location = hvězda t_location # Nevíme o přesném počtu iterací potřebných k dosažení konečného umístění, a proto bude smyčka while dobrou volbou pro iteraciing while (next_location! = end_location): # Načíst počáteční stav starting_state = location_to_state [start_location] # Načtěte nejvyšší hodnotu Q týkající se počátečního stavu next_state = np.argmax (Q [starting_state,]) # Získali jsme index dalšího stavu. Ale potřebujeme odpovídající písmeno. next_location = state_to_location [next_state] route.append (next_location) # Aktualizujte výchozí umístění pro další iteraci start_location = next_location zpáteční trasa

Krok 4: Tisk trasy

print (get_optimal_route ('L1', 'L9'))

Výstup:

Tímto jsme ukončili Q-Learning. Doufám, že jste poznali fungování Q Learning spolu s různými závislostmi, jako jsou časový rozdíl, Bellmanova rovnice a další.

Edureka vám umožní ovládat techniky, jako je supervidované učení, nekontrolované učení a zpracování přirozeného jazyka. Zahrnuje školení o nejnovějších pokrokech a technických přístupech v oblasti umělé inteligence a strojového učení, jako je Deep Learning, Graphical Models a Reinforcement Learning.