Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7 1-4

TOP PAGE

Chapitre 7 Policy Network

7.1~7.4 policy.py

Signification de 194 filtres

Compte tenu de la couche d'entrée, il y a 104 diagrammes de phase 9x9 (images) (= 104ch). Le nombre de filtres est de 194. Utilisez le premier filtre pour filtrer une image 9x9 par rapport à une image. Faites ceci pour 104 canaux et obtenez 104 images. Combinez 104 images en une seule image. C'est 1ch. Faites de même avec le deuxième filtre. Faites de même pour le 194e filtre. Cela donne 194 images. Autrement dit, le nombre de canaux de sortie est de 194 canaux.

Signification du filtre 1x1

pointwise convolution Le but est de réduire le nombre de dimensions Image du filtre allongé de "1 pixel x 1 pixel x nombre de couches" https://www.robotech-note.com/entry/2017/12/24/191936 Entrée: 1 pixel pour chaque canal de 1 à 192, sortie: 1 valeur de pixel Ceci est effectué pour tous les pixels afin d'obtenir une image à un écran. Faites ceci pour le nombre de canaux de sortie en modifiant les paramètres. Obtenez des images de sortie pour le nombre de canaux de sortie. Après tout, la taille de filtre des 194 filtres ci-dessus n'est que de 1x1 et c'est la même chose.

python-dlshogi\pydlshogi\network\policy.py


#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from chainer import Chain
import chainer.functions as F
import chainer.links as L

from pydlshogi.common import *

ch = 192
class PolicyNetwork(Chain):
#Entrée 104ch
#L'entrée est de 104 diagrammes de phase 9x9.
#Nombre de filtres 194.
#Les valeurs 9x9 filtrées pour chaque canal d'entrée sont ajoutées par les canaux d'entrée et émises comme 1 canal.
#Le nombre de filtres étant de 194, le nombre de canaux de sortie est de 194.
    def __init__(self):
        super(PolicyNetwork, self).__init__()
        with self.init_scope():
            self.l1 = L.Convolution2D(in_channels = 104, out_channels = ch, ksize = 3, pad = 1)
            self.l2 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l3 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l4 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l5 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l6 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l7 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l8 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l9 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l10 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l11 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l12 = L.Convolution2D(in_channels = ch, out_channels = ch, ksize = 3, pad = 1)
            self.l13 = L.Convolution2D(in_channels = ch, out_channels = MOVE_DIRECTION_LABEL_NUM,
                                        ksize = 1, nobias = True)
            #Taille de filtre 1x1 (ksize)=1)Sens de
            #Entrée: 1 pixel pour chaque canal de 1 à 192, sortie: 1 valeur de pixel
            #Ceci est effectué pour tous les pixels afin d'obtenir une image sur un seul écran.
            #Faites ceci pour le nombre de canaux de sortie en modifiant les paramètres.
            #Obtenez des images de sortie pour le nombre de canaux de sortie.
            self.l13_bias = L.Bias(shape=(9*9*MOVE_DIRECTION_LABEL_NUM)) 
            # MOVE_DIRECTION_LABEL_NUM=27. Affiche 20 directions de mouvement et 7 pièces.

    def __call__(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        h3 = F.relu(self.l3(h2))
        h4 = F.relu(self.l4(h3))
        h5 = F.relu(self.l5(h4))
        h6 = F.relu(self.l6(h5))
        h7 = F.relu(self.l7(h6))
        h8 = F.relu(self.l8(h7))
        h9 = F.relu(self.l9(h8))
        h10 = F.relu(self.l10(h9))
        h11 = F.relu(self.l11(h10))
        h12 = F.relu(self.l12(h11))
        h13 = self.l13(h12)
        return self.l13_bias(F.reshape(h13,(-1, 9*9*MOVE_DIRECTION_LABEL_NUM)))
        #La raison pour laquelle la fonction softmax n'est pas décrite dans la sortie est
        #F lors de l'apprentissage.softmax_cross_Pour utiliser la fonction d'entropie.
        #Cette fonction calcule la fonction softmax et l'erreur d'entropie croisée en même temps.

common.py bb_rotate180() Argument: nombre binaire à 81 chiffres. (Un élément de piece_bb et occupé, c'est-à-dire qu'une carte de bits est incluse) Sortie: Inverse 81 chiffres et sorties.

python-dlshogi\pydlshogi\common.py


#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import shogi

#Constante de mouvement
# UP=0、UP_LEFT=1、、、、UP_RIGHT_PROMOTE=Il est défini comme 19.
#Lors de l'utilisation, par exemple, 〇〇=S'il est UP, 0 est affecté à la variable 〇〇.
MOVE_DIRECTION = [
    UP, UP_LEFT, UP_RIGHT, LEFT, RIGHT, DOWN, DOWN_LEFT, DOWN_RIGHT,
    UP2_LEFT, UP2_RIGHT,
    UP_PROMOTE, UP_LEFT_PROMOTE, UP_RIGHT_PROMOTE, LEFT_PROMOTE, RIGHT_PROMOTE,
    DOWN_PROMOTE, DOWN_LEFT_PROMOTE, DOWN_RIGHT_PROMOTE,
    UP2_LEFT_PROMOTE, UP2_RIGHT_PROMOTE
] = range(20)

#Table de conversion
# **_La variable nommée PROMOTE est MOVE_Prédéfini dans DIRECTION.
# UP_PROMOTE=10,・ ・ ・,UP_RIGHT_PROMOTE=Il est défini comme 19.
MOVE_DIRECTION_PROMOTED = [
    UP_PROMOTE, UP_LEFT_PROMOTE, UP_RIGHT_PROMOTE, LEFT_PROMOTE, RIGHT_PROMOTE,
    DOWN_PROMOTE, DOWN_LEFT_PROMOTE, DOWN_RIGHT_PROMOTE,
    UP2_LEFT_PROMOTE, UP2_RIGHT_PROMOTE
]

#Nombre d'étiquettes représentant les mouvements
MOVE_DIRECTION_LABEL_NUM = len(MOVE_DIRECTION) + 7 #7 est le type de pièce

# rotate 180degree
# shogi.I1 est 80, ..., shogi.A9 est égal à 0. En d'autres termes, SQUARES_R180 = [80, 79,・ ・ ・, 1, 0]
SQUARES_R180 = [
    shogi.I1, shogi.I2, shogi.I3, shogi.I4, shogi.I5, shogi.I6, shogi.I7, shogi.I8, shogi.I9,
    shogi.H1, shogi.H2, shogi.H3, shogi.H4, shogi.H5, shogi.H6, shogi.H7, shogi.H8, shogi.H9,
    shogi.G1, shogi.G2, shogi.G3, shogi.G4, shogi.G5, shogi.G6, shogi.G7, shogi.G8, shogi.G9,
    shogi.F1, shogi.F2, shogi.F3, shogi.F4, shogi.F5, shogi.F6, shogi.F7, shogi.F8, shogi.F9,
    shogi.E1, shogi.E2, shogi.E3, shogi.E4, shogi.E5, shogi.E6, shogi.E7, shogi.E8, shogi.E9,
    shogi.D1, shogi.D2, shogi.D3, shogi.D4, shogi.D5, shogi.D6, shogi.D7, shogi.D8, shogi.D9,
    shogi.C1, shogi.C2, shogi.C3, shogi.C4, shogi.C5, shogi.C6, shogi.C7, shogi.C8, shogi.C9,
    shogi.B1, shogi.B2, shogi.B3, shogi.B4, shogi.B5, shogi.B6, shogi.B7, shogi.B8, shogi.B9,
    shogi.A1, shogi.A2, shogi.A3, shogi.A4, shogi.A5, shogi.A6, shogi.A7, shogi.A8, shogi.A9,
]

def bb_rotate_180(bb):
#C'est morceau pour entrer bb_Un élément de bb et un élément d'occupé. Autrement dit, un nombre binaire à 81 chiffres.
    bb_r180 = 0
    for pos in shogi.SQUARES: #SQUARES est la gamme(0, 81)Cette
        if bb & shogi.BB_SQUARES[pos] > 0:
        # BB_LES CARRÉS[0b000 ・ ・ ・ 0001,0b000 ・ ・ ・ 0010,0b000 ・ ・ ・ 0100,・ ・ ・,0b100 ・ ・ ・ 0000].. 81 éléments.
        # &Est l'opérateur de bits AND.
            bb_r180 += 1 << SQUARES_R180[pos]
            # a<<b est un opérateur qui décale le bit de a vers la gauche de b chiffres.
    return bb_r180

features.py make_input_features() Arguments: piece_bb, occupé, pieces_in_hand Sortie: où se trouve la première pièce, la première pièce, la deuxième pièce, la deuxième pièce [(Matrice 9x9), (Matrice 9x9), ... (18 + 4 + 4 + 4 + 4 + 2 + 2), (Matrice 9x9), (Matrice 9x9), ... (18 + 4 + 4 + 4 + 4 + 2 + 2)]

make_input_features_from_board() Sortez piece_bb, busy, pieces_in_hand, tournez avec board comme argument et effectuez make_input_features.

make_output_label() Arguments: move (move_from et move_to), color (first ou second) La couleur est utilisée pour permettre à move_direction d'être utilisé à la fois en premier et en second.

Sortie: move_direction (81 chiffres) + move_to (1 chiffre) Image 81-aire. move_direction est de 81 chiffres, move_to est de 1 chiffre. 81 chiffres ... 27 1 chiffre ・ ・ ・ 9x9

En d'autres termes, le déplacement est converti en une valeur numérique et une sortie. À propos, la valeur numérique de cette sortie est également l'indice de la sortie de NN. Il est utilisé lorsque vous souhaitez extraire l'élément souhaité de la sortie de NN.

make_features() Retirez piece_bb, busy, pieces_in_hand avec position comme argument et effectuez make_input_features.

python-dlshogi\pydlshogi\features.py


#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import numpy as np
import shogi
import copy

from pydlshogi.common import *

def make_input_features(piece_bb, occupied, pieces_in_hand):
    features = []
    for color in shogi.COLORS:
        # board pieces
        for piece_type in shogi.PIECE_TYPES_WITH_NONE[1:]: #PIECE_TYPES_WITH_NONE est la plage(0, 16)Cette
            bb = piece_bb[piece_type] & occupied[color] #Obtenir la position de la pièce côté tour pour chaque pièce (&Est un peu opérateur)
            feature = np.zeros(9*9)
            for pos in shogi.SQUARES: #SQUARES est la gamme(0, 81)Cette
                if bb & shogi.BB_SQUARES[pos] > 0: #BB_LES CARRÉS[0b1, 0b10, 0b100,・ ・ ・,0b1 ・ ・ ・ 0].. 81 éléments.
                    feature[pos] = 1                #Chaque bit de la carte de bits est décomposé en éléments. Par exemple, 1010 ...[1,0,1,0,・ ・ ・]Démonté en.
            features.append(feature.reshape((9, 9))) #Chaque bit de la carte de bits est décomposé en éléments et renvoyé sous forme de matrice 9x9.

        # pieces in hand
        for piece_type in range(1, 8):
            for n in range(shogi.MAX_PIECES_IN_HAND[piece_type]):
            #shogi.MAX_PIECES_IN_HAND est le nombre de pièces dont vous disposez. Index 1~7 ressemble probablement à ceci:
            #shogi.MAX_PIECES_IN_HAND[1] =18: Ayumu
            #shogi.MAX_PIECES_IN_HAND[2] =4: voiture d'encens
            #shogi.MAX_PIECES_IN_HAND[3] =4: Katsura
            #shogi.MAX_PIECES_IN_HAND[4] =4: Argent
            #shogi.MAX_PIECES_IN_HAND[5] =4: ven
            #shogi.MAX_PIECES_IN_HAND[6] =2: Coin
            #shogi.MAX_PIECES_IN_HAND[7] =2: voiture volante
                if piece_type in pieces_in_hand[color] and n < pieces_in_hand[color][piece_type]:
                    feature = np.ones(9*9)
                else:
                    feature = np.zeros(9*9)
                features.append(feature.reshape((9, 9)))

    return features
    #Sortie: où se trouve la première pièce, la première pièce, la deuxième pièce, la deuxième pièce
    # [(Matrice 9x9), 
    # (Matrice 9x9),... est (18 + 4 + 4 + 4 + 4 + 2 + 2), 
    # (Matrice 9x9), 
    # (Matrice 9x9),... est (18 + 4 + 4 + 4 + 4 + 2 + 2)]

def make_input_features_from_board(board): #faire avec le conseil comme argument_input_Faites des fonctionnalités.
    if board.turn == shogi.BLACK:
        piece_bb = board.piece_bb
        occupied = (board.occupied[shogi.BLACK], board.occupied[shogi.WHITE])
        pieces_in_hand = (board.pieces_in_hand[shogi.BLACK], board.pieces_in_hand[shogi.WHITE])
    else:
        piece_bb = [bb_rotate_180(bb) for bb in board.piece_bb]
        occupied = (bb_rotate_180(board.occupied[shogi.WHITE]), bb_rotate_180(board.occupied[shogi.BLACK]))
        pieces_in_hand = (board.pieces_in_hand[shogi.WHITE], board.pieces_in_hand[shogi.BLACK])

    return make_input_features(piece_bb, occupied, pieces_in_hand)


def make_output_label(move, color):
    move_to = move.to_square
    move_from = move.from_square
                #■ Déplacer la classe
                #   from_variable carrée: valeur de la source de mouvement lorsque la surface de la planche est représentée par une valeur numérique comprise entre 0 et 80.
                #Le quotient divisé par 9 est la coordonnée y et le reste est la coordonnée x. La coordonnée xy est 0 origine.
                #   to_variable carrée: comme ci-dessus (destination).
                #
                #coordonnée x
                #   0   1   2   3   4   5   6   7   8
                #
                #0 1 2 3 4 5 6 7 8 0 coordonnées y
                #   9   10  11  12  13  14  15  16  17      1
                #   18  19  20  21  22  23  24  25  26      2
                #   27  28  29  30  31  32  33  34  35      3
                #   36  37  38  39  40  41  42  43  44      4
                #   45  46  47  48  49  50  51  52  53      5
                #   54  55  56  57  58  59  60  61  62      6
                #   63  64  65  66  67  68  69  70  71      7
                #   72  73  74  75  76  77  78  79  80      8

    #S'il est blanc, faites pivoter le tableau
    if color == shogi.WHITE:
        move_to = SQUARES_R180[move_to]
        if move_from is not None: #Lorsque vous déplacez une pièce sur le plateau au lieu de la pièce que vous avez
            move_from = SQUARES_R180[move_from]

    # move direction
    if move_from is not None: #Lorsque vous déplacez une pièce sur le plateau au lieu de la pièce que vous avez
        to_y, to_x = divmod(move_to, 9)
        from_y, from_x = divmod(move_from, 9)
        dir_x = to_x - from_x
        dir_y = to_y - from_y
        if dir_y < 0 and dir_x == 0:
            move_direction = UP
        elif dir_y == -2 and dir_x == -1:
            move_direction = UP2_LEFT
        elif dir_y == -2 and dir_x == 1:
            move_direction = UP2_RIGHT
        elif dir_y < 0 and dir_x < 0:
            move_direction = UP_LEFT
        elif dir_y < 0 and dir_x > 0:
            move_direction = UP_RIGHT
        elif dir_y == 0 and dir_x < 0:
            move_direction = LEFT
        elif dir_y == 0 and dir_x > 0:
            move_direction = RIGHT
        elif dir_y > 0 and dir_x == 0:
            move_direction = DOWN
        elif dir_y > 0 and dir_x < 0:
            move_direction = DOWN_LEFT
        elif dir_y > 0 and dir_x > 0:
            move_direction = DOWN_RIGHT

        # promote
        if move.promotion:
            move_direction = MOVE_DIRECTION_PROMOTED[move_direction]
    else:
        #Propre pièce
        # len(MOVE_DIRECTION)Est 20
        # move.drop_piece_Le type est-il le type de pièce que vous avez placé?
        # -Est-ce que 1 est le nombre?
        move_direction = len(MOVE_DIRECTION) + move.drop_piece_type - 1


    move_label = 9 * 9 * move_direction + move_to
    #Image 81-aire. bouge toi_la direction est de 81 chiffres, déplacer_to est un chiffre de 1.
    #81 chiffres ... 27
    #1 chiffre ・ ・ ・ 9x9

    return move_label

def make_features(position):
    piece_bb, occupied, pieces_in_hand, move, win = position
    features = make_input_features(piece_bb, occupied, pieces_in_hand)

    return(features, move, win)

Recommended Posts

Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 11
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 8
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 10 6-9
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 10
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7 5-7
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 9
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 1-2
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3 ~ 5
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7 9
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 8 5-9
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 8 1-4
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7 8
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7 1-4
Apprentissage en profondeur avec Shogi AI sur Mac et Google Colab
Apprentissage en profondeur avec Shogi AI sur Mac et Google Colab Chapitres 1 à 6
Apprenez avec Shogi AI Deep Learning sur Mac et Google Colab Utilisez Google Colab
Apprentissage en profondeur sur Mac et Google Colab mots appris avec Shogi AI
Apprentissage automatique avec Pytorch sur Google Colab
À propos de l'apprentissage avec Google Colab
Étapes pour créer rapidement un environnement d'apprentissage en profondeur sur Mac avec TensorFlow et OpenCV
Jouez avec Turtle sur Google Colab
Deep Learning from scratch La théorie et la mise en œuvre de l'apprentissage profond appris avec Python Chapitre 3
Installez le sélénium sur votre Mac et essayez-le avec python
Analyse d'images par apprentissage profond à partir de Kaggle et Keras
[AI] Apprentissage métrique profond
Prédire les tags en extrayant des fonctionnalités musicales avec Deep Learning
[Google Colab] Comment interrompre l'apprentissage, puis le reprendre
Reconnaissez votre patron avec Deep Learning et masquez l'écran
Une erreur survenue lors de l'apprentissage de YOLO avec Google Colab
HIKAKIN et Max Murai avec vidéo de jeu en direct et apprentissage en profondeur
Essayez l'apprentissage en profondeur avec TensorFlow
Essayez le Deep Learning avec FPGA
Catalina sur Mac et pyenv
Générez des Pokémon avec Deep Learning
Créez des rendez-vous pour le concours AtCoder sur Google Agenda avec Python et GAS
Erreur et solution lors de l'installation de python3 avec homebrew sur mac (catalina 10.15)
Comment exécuter Jupyter et Spark sur Mac avec des paramètres minimaux
La meilleure façon d'utiliser MeCab et CaboCha avec Google Colab
[Note de lecture] Apprentissage automatique pratique avec Scikit-Learn, Keras et TensorFlow Chapitre 1
Installez lp_solve sur Mac OSX et appelez-le avec python.
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Essayez le Deep Learning avec les concombres FPGA-Select
Identification de la race de chat avec Deep Learning
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
MQTT sur Raspberry Pi et Mac
Faites de l'art ASCII avec l'apprentissage en profondeur
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Essayez l'apprentissage en profondeur avec TensorFlow Partie 2
Présentation d'OpenCV sur Mac avec homebrew
Organisez des plateformes d'apprentissage automatique et d'apprentissage en profondeur
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep learning / Deep learning made from scratch Chapitre 5 Mémo