Serieninhaltsverzeichnis

Ich habe versucht, Othello AI mit Tensorflow zu erstellen, ohne die Theorie des maschinellen Lernens zu verstehen - Einführung -
Ich habe versucht, Othello AI mit Tensorflow zu machen, ohne die Theorie des maschinellen Lernens zu verstehen ~ Implementierung ~
Ich habe versucht, Othello AI mit Tensorflow zu machen, ohne die Theorie des maschinellen Lernens zu verstehen - Iza Battle-
Ich habe versucht, Othello AI zu machen, nachdem ich versucht hatte, die Theorie des maschinellen Lernens zu verstehen ~ Neustart! ~
Ich habe versucht, Othello AI zu machen, nachdem ich versucht hatte, die Theorie des maschinellen Lernens zu verstehen - Was ist diese Alpha Zero Edition-
[Ich habe versucht, ein neutrales Netzwerk mit Excel aufzubauen, um die Theorie des maschinellen Lernens zu verstehen.

Letztes Mal Fortsetzung ... In diesem Bereich habe ich als Außenseiter "die Theorie des maschinellen Lernens" überhaupt nicht studiert. Ich werde Othellos KI machen. Klicken Sie hier für die Site, auf die verwiesen wird

DQN mit Keras, TensorFlow und OpenAI Gym implementieren ・ Training des neuronalen TensorFlow-Netzwerks zum Spielen des Tic-Tac-Toe-Spiels mit einem einstufigen Q-Learning-Algorithmus.

Grundlagen des verstärkenden Lernens

Ich habe Othellos KI gemacht, ohne "die Theorie des maschinellen Lernens" zu studieren. Ich werde die Mindestkenntnisse zusammenfassen, die zur Implementierung erforderlich sind.

Dateistruktur und Rolle

Die Dateistruktur und die Rolle sind wie folgt. 構成.png --train.py --- KI-Training --Reversi.py --- Othello Game Management --dqn_agent.py --- Verwaltung des KI-Trainings --FightWithAI.py --- Kämpfe mit Benutzern

Gesamtalgorithmus

Der diesmal implementierte DQN-Algorithmus sieht folgendermaßen aus.

Wenn Sie diesen Fluss im Auge behalten, werden Sie verstehen, wovon Sie sprechen und was Sie erklären werden.

Othello Spielspezifikationen

Das Brett wurde für Othello-Spiele und KI-Training verwendet Dies erfolgt unter Verwendung eines zweidimensionalen Arrays mit Nein in der folgenden Abbildung.

`Reversi.py`


self.screen[0～7][0～7]

Die Operation, die AI auswählen kann, besteht darin, die Zahl von 0 bis 63 in der obigen Abbildung auszuwählen.

`Reversi.py`


self.enable_actions[0～63]

KI-Training

Im KI-Training spielten Spieler [0] und Spieler [1] Othello-Schlachten n_epochs = 1000 Mal. Speichern Sie zum Schluss die KI des zweiten Spielers [1].

Belohnung für AI

Wenn Sie das Spiel gewinnen, setzen Sie Belohnung = 1
Sonst Belohnung = 0

Trainingsmethode

Ich werde mit zwei AIs spielen, aber ich muss auch im Zug des Gegners handeln Weil die Geschichte bis zum Ende nicht verbunden ist (Q-Wert wird nicht übertragen)

Beide wirken auf Schritt und Tritt Dieses Mal habe ich beschlossen, "den Übergang in D zu speichern" für alle Zahlen, die getrennt vom Spielfortschritt eingestellt werden können.

`train.py`



#Ziele enthält alle Zahlen, die Sie in diesem Zug setzen können
for tr in targets:
    #Dupliziere den Status Quo
    tmp = copy.deepcopy(env)
    #Aktion
    tmp.update(tr, playerID[i])
    #Urteil beenden
    win = tmp.winner()
    end = tmp.isEnd()
    #Vorstand nach dem Handeln
    state_X = tmp.screen
    #Eine Nummer, die Sie hinterlassen können, nachdem Sie gehandelt haben
    target_X = tmp.get_enables(playerID[i+1])
                       
    #Beide Aktionen
    for j in range(0, len(players)):
        reword = 0
        if end == True:
            if win == playerID[j]:
                #Erhalten Sie 1 Belohnung, wenn Sie gewinnen
                reword = 1
        #Beide "Übergang in D speichern"
        players[j].store_experience(state, targets, tr, reword, state_X, target_X, end)
        players[j].experience_replay()

Der folgende Teil des DQN-Algorithmus wird von dqn_agent.py ausgeführt.

Übergang zu D speichern (, ai, ri, si + 1, terminal)
Beispiel für Mini-Patches (si, ai, ri, si + 1, tarminal), die zufällig von D übergehen
Lehrersignal yi = ri + γmax Q (si + 1, a: θ)
Führen Sie für den Q-Netzwerkparameter θ die Gradientenmethode mit (yi-Q (si, ai; θ)) ^ 2 aus.
Setzen Sie das Zielnetzwerk Q = Q regelmäßig zurück

Ich weiß nicht, warum es ein ganzes Paket der Site ist, auf die ich mich bezog

`dqn_agent.py`


    def store_experience(self, state, targets, action, reward, state_1, targets_1, terminal):
        self.D.append((state, targets, action, reward, state_1, targets_1, terminal))
>>
    def experience_replay(self):
        state_minibatch = []
        y_minibatch = []
>>
        # sample random minibatch
        minibatch_size = min(len(self.D), self.minibatch_size)
        minibatch_indexes = np.random.randint(0, len(self.D), minibatch_size)
>>
        for j in minibatch_indexes:
            state_j, targets_j, action_j, reward_j, state_j_1, targets_j_1, terminal = self.D[j]
            action_j_index = self.enable_actions.index(action_j)
>>
            y_j = self.Q_values(state_j)
>>
            if terminal:
                y_j[action_j_index] = reward_j
            else:
                # reward_j + gamma * max_action' Q(state', action')
                qvalue, action = self.select_enable_action(state_j_1, targets_j_1)
                y_j[action_j_index] = reward_j + self.discount_factor * qvalue
>>
            state_minibatch.append(state_j)
            y_minibatch.append(y_j)
>>
        # training
        self.sess.run(self.training, feed_dict={self.x: state_minibatch, self.y_: y_minibatch})
>>
        # for log
        self.current_loss = self.sess.run(self.loss, feed_dict={self.x: state_minibatch, self.y_: y_minibatch})
>>

Variablennamen	Inhalt
state	Brettoberfläche( = Reversi.screen[0～7][0～7] )
targets	Nummer, die Sie verlassen können
action	Ausgewählte Aktion
reward	Belohnung für Aktion 0-1
state_1	Vorstand nach dem Handeln
targets_1	Eine Nummer, die Sie hinterlassen können, nachdem Sie gehandelt haben
terminal	Spiel endet = Richtig

Implementierung

Im KI-Training spielten Spieler [0] und Spieler [1] Othello-Schlachten n_epochs = 1000 Mal. Speichern Sie zum Schluss die KI des zweiten Spielers [1].

`train.py`


   # parameters
    n_epochs = 1000
    # environment, agent
    env = Reversi()
 
    # playerID    
    playerID = [env.Black, env.White, env.Black]

    # player agent    
    players = []
    # player[0]= env.Black
    players.append(DQNAgent(env.enable_actions, env.name, env.screen_n_rows, env.screen_n_cols))
    # player[1]= env.White
    players.append(DQNAgent(env.enable_actions, env.name, env.screen_n_rows, env.screen_n_cols))

Dieser DQNAgent (env.enable_actions, env.name, env.screen_n_rows, env.screen_n_cols) Teil ist

Wiederholungsspeicher initialisieren D. --Q NetworkQ wird mit einem zufälligen Gewicht θ initialisiert --Initialize Target NetworkQ θ ^ = θ

, Dqn_agent.py macht es.

`dqn_agent.py`


class DQNAgent:
>>
    def __init__(self, enable_actions, environment_name, rows, cols):
        ...Kürzung...
        #Initialisierung des Wiedergabespeichers D.
        self.D = deque(maxlen=self.replay_memory_size)
        ...Kürzung...
>>
    def init_model(self):
        # input layer (rows x cols)
        self.x = tf.placeholder(tf.float32, [None, self.rows, self.cols])
>>
        # flatten (rows x cols)
        size = self.rows * self.cols
        x_flat = tf.reshape(self.x, [-1, size])
>>
        #Initialisieren Sie Q NetworkQ mit dem zufälligen Gewicht θ
        W_fc1 = tf.Variable(tf.truncated_normal([size, size], stddev=0.01))
        b_fc1 = tf.Variable(tf.zeros([size]))
        h_fc1 = tf.nn.relu(tf.matmul(x_flat, W_fc1) + b_fc1)
>>
        #Initialisieren Sie das Zielnetzwerk Q θ^=θ
        W_out = tf.Variable(tf.truncated_normal([size, self.n_actions], stddev=0.01))
        b_out = tf.Variable(tf.zeros([self.n_actions]))
        self.y = tf.matmul(h_fc1, W_out) + b_out
>>
        # loss function
        self.y_ = tf.placeholder(tf.float32, [None, self.n_actions])
        self.loss = tf.reduce_mean(tf.square(self.y_ - self.y))
>>
        # train operation
        optimizer = tf.train.RMSPropOptimizer(self.learning_rate)
        self.training = optimizer.minimize(self.loss)
>>
        # saver
        self.saver = tf.train.Saver()
>>
        # session
        self.sess = tf.Session()
        self.sess.run(tf.initialize_all_variables())

`python`


    for e in range(n_epochs):
        # reset
        env.reset()
        terminal = False

for episode =1, M do

Anfangsbildschirm x1, Vorverarbeitung zum Erstellen des Anfangszustands s1

`python`


        while terminal == False: #Schleife bis zum Ende einer Episode

            for i in range(0, len(players)): 
                
                state = env.screen
                targets = env.get_enables(playerID[i])
                
                if len(targets) > 0:
                    #Wenn es einen Platz gibt, an dem man es irgendwo hinstellen kann

#← Hier werden alle oben genannten Hände "in D gespeichert"

                    #Wähle eine Aktion
                    action = players[i].select_action(state, targets, players[i].exploration)
                    #Handeln Sie
                    env.update(action, playerID[i])

while not terminal --Aktionsauswahl

Aktionsauswahl agent.select_action (state_t, Ziele, agent.exploration) ist Dies erfolgt durch dqn_agent.py.

Aktionsauswahl

Handle zufällig ai -Oder ai = argmax Q (s1, a: θ)

`dqn_agent.py`


    def Q_values(self, state):
        # Q(state, action) of all actions
        return self.sess.run(self.y, feed_dict={self.x: [state]})[0]
>>
    def select_action(self, state, targets, epsilon):
>>    
        if np.random.rand() <= epsilon:
            # random
            return np.random.choice(targets)
        else:
            # max_action Q(state, action)
            qvalue, action = self.select_enable_action(state, targets)
            return action
>>  
    #Die Tafel(state)damit,Platz zum setzen(targets)Gibt den Q-Wert und die Zahl zurück, aus denen der Q-Wert maximiert wird
    def select_enable_action(self, state, targets):
        Qs = self.Q_values(state)
        #descend = np.sort(Qs)
        index = np.argsort(Qs)
        for action in reversed(index):
            if action in targets:
                break 
        # max_action Q(state, action)
        qvalue = Qs[action]       
>>
        return qvalue, action

Führen Sie die Aktion ai aus und beobachten Sie die Belohnung ri, den nächsten Bildschirm xi + 1 und beenden Sie das Urteil tarminal --Verarbeiten und erstellen Sie den nächsten Status si + 1

Speichern Sie schließlich die letztere KI



                #Das Ergebnis der Ausführung der Aktion
                terminal = env.isEnd()     
                              
        w = env.winner()                    
        print("EPOCH: {:03d}/{:03d} | WIN: player{:1d}".format(
                         e, n_epochs, w))


    #Speichern speichert den zweiten Spieler player2.
    players[1].save_model()

Die Quelle ist hier. $ git clone https://github.com/sasaco/tf-dqn-reversi.git

Nächstes Mal informiert Sie über die Battle Edition.

[PYTHON] Ich habe versucht, Othello AI mit Tensorflow zu erstellen, ohne die Theorie des maschinellen Lernens zu verstehen ~ Implementierung ~

Serieninhaltsverzeichnis

Grundlagen des verstärkenden Lernens

Dateistruktur und Rolle

Gesamtalgorithmus

Othello Spielspezifikationen

Reversi.py

Reversi.py

KI-Training

Belohnung für AI

Trainingsmethode

train.py

dqn_agent.py

Implementierung

train.py

dqn_agent.py

python

python

dqn_agent.py

`Reversi.py`

`Reversi.py`

`train.py`

`dqn_agent.py`

`train.py`

`dqn_agent.py`

`python`

`python`

`dqn_agent.py`