und sind einige Domains, die aus gutem Grund zu den Top-Schlagworten der Branche gehören. AI wird bis 2020 2,3 Millionen Arbeitsplätze schaffen, da sein Hauptziel darin besteht, Maschinen die Möglichkeit zu geben, menschliches Verhalten nachzuahmen. Seltsam, nicht wahr? Daher werden wir heute Q Learning, den Baustein des Reinforcement Learning, in der folgenden Reihenfolge diskutieren:
- Was ist Verstärkungslernen?
- Q-Learning-Prozess
- Bellman-Gleichung
- Markov-Entscheidungsprozess
- Q-Learning-Demo: NumPy
Was ist Verstärkungslernen?
Werfen wir einen Blick auf unser tägliches Leben. Wir führen zahlreiche Aufgaben in der Umgebung aus und einige dieser Aufgaben bringen uns Belohnungen, andere nicht. Wir suchen ständig nach verschiedenen Wegen und versuchen herauszufinden, welcher Weg zu Belohnungen führt. Basierend auf unseren Maßnahmen verbessern wir unsere Strategien zur Erreichung der Ziele. Dies, meine Freunde, ist eine der einfachsten Analogien des Reinforcement Learning.
Hauptinteressensbereiche:
- Umgebung
- Aktion
- Belohnung
- Zustand
Reinforcement Learning ist der Zweig des maschinellen Lernens, der es Systemen ermöglicht, aus den Ergebnissen ihrer eigenen Entscheidungen zu lernen. Es löst eine bestimmte Art von Problem, bei dem die Entscheidungsfindung sequentiell erfolgt und das Ziel langfristig ist.
Q-Learning-Prozess
Lassen Sie uns anhand unserer Problemstellung hier verstehen, was Q-Lernen ist. Es wird uns helfen, die Hauptkomponenten einer Verstärkungslernlösung zu definieren, d. H. Agenten, Umgebung, Aktionen, Belohnungen und Zustände.
c ++ Fibonacci-Serie
Automobilfabrik Analogie:
Wir sind in einer Automobilfabrik voller Roboter. Diese Roboter helfen den Fabrikarbeitern, indem sie die für die Montage eines Autos erforderlichen Teile transportieren. Diese verschiedenen Teile befinden sich an verschiedenen Stellen innerhalb des Werks in 9 Stationen. Die Teile umfassen Fahrgestell, Räder, Armaturenbrett, Motor und so weiter. Factory Master hat den Ort, an dem das Chassis installiert wird, als höchste Priorität priorisiert. Schauen wir uns das Setup hier an:
Zustände:
Der Ort, an dem sich ein Roboter in einer bestimmten Instanz befindet, wird als Status bezeichnet. Da es einfach ist, es zu codieren, anstatt es sich mit Namen zu merken. Ordnen wir den Standort Zahlen zu.
Aktionen:
Aktionen sind nichts anderes als die Bewegungen der Roboter an einen beliebigen Ort. Angenommen, ein Roboter befindet sich am Standort L2 und die direkten Standorte, zu denen er sich bewegen kann, sind L5, L1 und L3. Lassen Sie uns dies besser verstehen, wenn wir dies visualisieren:
Belohnung:
Der Roboter erhält eine Belohnung für den direkten Übergang von einem Zustand in einen anderen. Zum Beispiel können Sie L5 direkt von L2 aus erreichen und umgekehrt. In beiden Fällen wird also eine Belohnung von 1 vergeben. Werfen wir einen Blick auf die Belohnungstabelle:
Denken Sie daran, wann der Factory Master den Chassis-Standort priorisiert hat. Es war L7, also werden wir diese Tatsache in unsere Belohnungstabelle aufnehmen. Daher weisen wir am Standort (L7, L7) eine sehr große Nummer zu (in unserem Fall 999).
Bellman-Gleichung
Angenommen, ein Roboter muss von Punkt A nach B gehen. Er wählt den Weg, der eine positive Belohnung bringt. Nehmen wir an, wir geben eine Belohnung in Bezug auf den Platzbedarf, damit es folgt.
Was aber, wenn der Roboter irgendwo dazwischen startet, wo er zwei oder mehr Pfade sehen kann? Der Roboter kann somit keine Entscheidung treffen und dies geschieht hauptsächlich, weil er keine besitzt Erinnerung . Hier kommt die Bellman-Gleichung ins Spiel.
V (s) = max (R (s, a) + & # 120632 V (s '))
Wo:
- s = ein bestimmter Zustand
- a = Aktion
- s '= Zustand, in den der Roboter von s geht
- & # 120632 = Rabattfaktor
- R (s, a) = eine Belohnungsfunktion, die einen Zustand und eine Aktion (a) annimmt und einen Belohnungswert ausgibt
- V (s) = Wert, in einem bestimmten Zustand zu sein
Jetzt hat der Block unter dem Ziel eine Belohnung von 1, was die höchste Belohnung ist. Aber was ist mit dem anderen Block? Hier kommt der Abzinsungsfaktor ins Spiel. Nehmen wir einen Abzinsungsfaktor von 0,9 an und füllen Sie alle Blöcke nacheinander.
Markov-Entscheidungsprozess
Stellen Sie sich vor, ein Roboter befindet sich auf dem orangefarbenen Block und muss das Ziel erreichen. Aber selbst wenn es eine leichte Funktionsstörung gibt, wird der Roboter verwirrt sein, welchen Weg er einschlagen soll, anstatt nach oben zu gehen.
wie man ein Ingenieur für künstliche Intelligenz wird
Wir müssen also den Entscheidungsprozess ändern. Es muss Teilweise zufällig und Teilweise unter der Kontrolle des Roboters . Teilweise zufällig, weil wir nicht wissen, wann der Roboter funktionsunfähig wird, und teilweise unter Kontrolle, weil es immer noch die Entscheidung des Roboters ist. Und dies bildet die Basis für den Markov-Entscheidungsprozess.
Ein Markov-Entscheidungsprozess (MDP) ist ein zeitdiskreter stochastischer Steuerungsprozess. Es bietet einen mathematischen Rahmen für die Modellierung der Entscheidungsfindung in Situationen, in denen die Ergebnisse teilweise zufällig sind und teilweise von einem Entscheidungsträger kontrolliert werden.
Also werden wir unsere ursprüngliche Bellman-Gleichung verwenden und Änderungen daran vornehmen. Was wir nicht wissen, ist der nächste Staat, dh. s ’. Was wir wissen, sind alle Möglichkeiten einer Wende und wir ändern die Gleichung.
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 ’): Wahrscheinlichkeit des Umzugs aus dem Staat s zu s ’ mit Aktion zu
& Sigmas ’P (s, a, s ’) V (s): Zufälligkeitserwartungen des Roboters
V (s) = max (R (s, a) + & # 120632 ((0,8 V (Raum)))))oben)) + (0,1 V (Raum)Nieder) +….))
Kommen wir nun zum Q-Learning. Q-Learning basiert auf der Idee, die Qualität einer Maßnahme zu bewerten, die ergriffen wird, um in einen Zustand zu gelangen, anstatt den möglichen Wert des Zustands zu bestimmen, in den sie verschoben wird.
Dies erhalten wir, wenn wir die Idee einbeziehen, die Qualität von Maßnahmen für den Umzug in einen bestimmten Staat zu bewerten. Aus der aktualisierten Bellman-Gleichung, wenn wir sie entfernen max Komponente nehmen wir nur einen Fußabdruck für mögliche Maßnahmen an, der nichts anderes als der ist Qualität der Aktion.
Q (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) V (s '))
In dieser Gleichung, die die Qualität der Aktion quantifiziert, können wir annehmen, dass V (s) das Maximum aller möglichen Werte von Q (s, a) ist. Ersetzen wir also v (s) durch eine Funktion von Q ().
Q (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) max Q (s ’, a’))
So erstellen Sie ein Objektarray in Java
Wir sind nur einen Schritt näher an unserer endgültigen Gleichung des Q-Lernens. Wir werden eine vorstellen Zeitlicher Unterschied Berechnung der Q-Werte in Bezug auf die Veränderungen in der Umgebung im Laufe der Zeit. Aber wie beobachten wir die Änderung in Q?
TD (s, a) = (R (s, a) + & # 120632 & Sigmas ’P (s, a, s ’) max Q (s ’, a’)) - Q (s, a)
Wir berechnen das neue Q (s, a) mit derselben Formel neu und subtrahieren das zuvor bekannte Q (s, a) davon. Die obige Gleichung lautet also:
Q.t(s, a) = Q.t-1(s, a) + α TDt(s, a)
Q.t(s, a) = Aktueller Q-Wert
Q.t-1(s, a) = Vorheriger Q-Wert
Q.t(s, a) = Q.t-1(s, a) + α (R (s, a) + & # 120632 max Q (s ', a')- -Q.t-1(s, a))
Q Lerndemo: NumPy
Ich werde verwenden NumPy, um zu demonstrieren, wie Q Learning funktioniert.
Schritt 1: Importe, Parameter, Status, Aktionen und Belohnungen
importiere numpy als np gamma = 0,75 # Rabattfaktor alpha = 0,9 # Lernrate location_to_state = {'L1': 0, 'L2': 1, 'L3': 2, 'L4': 3, 'L5': 4, ' L6 ': 5,' L7 ': 6,' L8 ': 7,' L9 ': 8} Aktionen = [0,1,2,3,4,5,6,7,8] Belohnungen = 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]])Schritt 2: Ordnen Sie Indizes Standorten zu
state_to_location = dict ((state, location) für location, state in location_to_state.items ())
Schritt 3: Optimale Route mithilfe des Q-Lernprozesses ermitteln
def get_optimal_route (start_location, end_location): belohnungen_neu = np.kopie (belohnungen) endende_Status = ort_zu_Zustand [end_Lage] belohnungen_neu [endende_Zustand, endende_Zustand] = 999 Q = np.array (np.zeros ([9,9]) # Q- Lernprozess für i in range (1000): # Aufnehmen eines zufälligen Zustands current_state = np.random.randint (0,9) # Python schließt die obere Grenze aus playable_actions = [] # Durchlaufen der neuen Belohnungsmatrix für j in range ( 9): if honor_new [current_state, j]> 0: playable_actions.append (j) # Wähle eine zufällige Aktion, die uns zum nächsten Status führt next_state = np.random.choice (playable_actions) # Berechnung des zeitlichen Unterschieds TD = belohnungsneue [current_state , next_state] + gamma * Q [next_state, np.argmax (Q [next_state,])] - Q [current_state, next_state] # Aktualisieren des Q-Werts unter Verwendung der Bellman-Gleichung Q [current_state, next_state] + = alpha * TD # Initialisieren Sie die optimale Route mit dem Startort route = [start_location] #Initialize next_location mit dem Startort next_location = star t_location # Wir wissen nicht genau, wie viele Iterationen erforderlich sind, um den endgültigen Ort zu erreichen. Daher ist while-Schleife eine gute Wahl für die Iteration während (next_location! = end_location): # Abrufen des Startzustands start_state = location_to_state [start_location] # Holen Sie sich den höchsten Q-Wert für den Startzustand next_state = np.argmax (Q [Starting_state,]) # Wir haben den Index des nächsten Zustands. Aber wir brauchen den entsprechenden Brief. next_location = state_to_location [next_state] route.append (next_location) # Aktualisiere den Startort für die nächste Iteration start_location = next_location return route
Schritt 4: Drucken Sie die Route
print (get_optimal_route ('L1', 'L9'))Ausgabe:
Damit haben wir ein Ende des Q-Learning. Ich hoffe, Sie haben die Arbeitsweise von Q Learning zusammen mit den verschiedenen Abhängigkeiten wie dem zeitlichen Unterschied, der Bellman-Gleichung und vielem mehr kennengelernt.
Edurekas macht Sie mit Techniken wie überwachtem Lernen, unbeaufsichtigtem Lernen und Verarbeitung natürlicher Sprache vertraut. Es umfasst Schulungen zu den neuesten Fortschritten und technischen Ansätzen im Bereich künstliche Intelligenz und maschinelles Lernen wie Deep Learning, grafische Modelle und Reinforcement Learning.