7.8
Es wurde ein Prozess hinzugefügt, der die PC-Umgebung automatisch mit gethostname () ermittelt und GPU für die iMac-Umgebung und GPU für die Google Colab-Umgebung verwendet.
import socket
host = socket.gethostname()
#IP-Adresse abrufen
# iMac : xxxxxxxx
# Lenovo : yyyyyyyy
# google colab :zufällig
if host == 'xxxxxxxx':
gpu_en = 0
elif host == 'yyyyyyyy':
gpu_en = 0
else:
gpu_en = 1
if gpu_en == 1:
from chainer import cuda, Variable
if gpu_en == 1:
model.to_gpu()
if gpu_en == 1:
return(Variable(cuda.to_gpu(np.array(mini_batch_data, dtype=np.float32))),
Variable(cuda.to_gpu(np.array(mini_batch_move, dtype=np.int32))))
elif gpu_en == 0:
return np.array(mini_batch_data, dtype=np.float32), np.array(mini_batch_move, dtype=np.int32)
Da die Erstellung von Gurken mit Google Colab langsam ist, trat nach der Erstellung der iMac-Seitengurken beim Versuch, die Gurkendatei mit Colab zu lesen und zu trainieren, ein Fehler auf, der das Protokoll nicht unterstützt. Die Ursache ist wie folgt. pickle unterstützt Protokoll 5 mit Python 3.8 und höher. iMac ist Python 3.8.2 colab ist Python 3.6.9 Pickle.dump (positions_train, f, pickle.HIGHEST_PROTOCOL) auf dem iMac erstellt eine Protokoll-5-Pickle-Datei. Wenn ich versuche, mit Colab mithilfe dieser Pickle-Datei zu lernen, wird die Fehlermeldung angezeigt, dass das Protokoll nicht unterstützt wird und Colab es nicht lesen kann. Wenn Sie pickle.HIGHEST_PROTOCOL löschen, wird eine Pickle-Datei mit dem Standardprotokoll 4 erstellt. Jetzt können Sie es in Colab laden.
train_policy.py
python-dlshogi\train_policy.py
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#Umgebungseinstellung
#-----------------------------
import socket
host = socket.gethostname()
#IP-Adresse abrufen
# iMac : xxxxxxxx
# Lenovo : yyyyyyyy
# google colab :zufällig
if host == 'xxxxxxxx':
gpu_en = 0
elif host == 'yyyyyyyy':
gpu_en = 0
else:
gpu_en = 1
#Weitere Hinweise
#Wenn die Erstellung von Essiggurken in Google Colab langsam ist und Sie Pickle lokal erstellen und in Google Colab laden möchten
#Entfernen Sie die Pickle-Protokoll-Option (machen Sie sie zur Standardeinstellung).
#colab Python ver ist 3.Weil es nicht 8 ist und das höchste Protokoll nicht unterstützt wird.
# pickle.dump(positions_train, f, pickle.HIGHEST_PROTOCOL)Linie
#-----------------------------
import numpy as np
import chainer
if gpu_en == 1:
from chainer import cuda, Variable
from chainer import optimizers, serializers
import chainer.functions as F
from pydlshogi.common import *
from pydlshogi.network.policy import PolicyNetwork
from pydlshogi.features import *
from pydlshogi.read_kifu import *
import argparse
import random
import pickle
import os
import re
import logging
parser = argparse.ArgumentParser()
parser.add_argument('kifulist_train', type=str, help='train kifu list')
parser.add_argument('kifulist_test', type=str, help='test kifu list')
parser.add_argument('--batchsize', '-b', type=int, default=32, help='Number of positions in each mini-batch')
parser.add_argument('--test_batchsize', type=int, default=512, help='Number of positions in each test mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=1, help='Number of epoch times')
parser.add_argument('--model', type=str, default='model/model_policy', help='model file name')
parser.add_argument('--state', type=str, default='model/state_policy', help='state file name')
parser.add_argument('--initmodel', '-m', default='', help='Initialize the model from given file')
parser.add_argument('--resume', '-r', default='', help='Resume the optimization from snapshot')
parser.add_argument('--log', default=None, help='log file path')
parser.add_argument('--lr', default=0.01, type=float, help='learning rate')
parser.add_argument('--eval_interval', '-i', default=1000, type=int, help='eval interval')
args = parser.parse_args()
logging.basicConfig(format='%(asctime)s\t%(levelname)s\t%(message)s',
datefmt='%Y/%m/%d %H:%M:%S', filename=args.log, level=logging.DEBUG)
model = PolicyNetwork() #Selbstgemachtes Modell mit externem Modul
if gpu_en == 1:
model.to_gpu()
optimizer = optimizers.SGD(lr=args.lr) #Erstellen Sie eine Instanz der SGD-Klasse
# optimizer = optimizers.MomentumSGD(lr=args.lr, momentum=0.9) #Erstellen Sie eine Instanz der MomentumSGD-Klasse
optimizer.setup(model)
# Init/Resume
if args.initmodel:
logging.info('Load model from {}'.format(args.initmodel))
serializers.load_npz(args.initmodel, model)
if args.resume:
logging.info('Load optimizer state from {}'.format(args.resume))
serializers.load_npz(args.resume, optimizer)
logging.info('read kifu start')
#Wenn eine Pickle-Datei gespeichert ist, laden Sie die Pickle-Datei
# train data
#Suchen und löschen Sie die Erweiterung der Trainingsspielliste (Listenkörper, nicht den Inhalt der Liste)..Speichern Sie die Zeichenfolge mit pickle in einer Variablen.
train_pickle_filename = re.sub(r'\..*?$', '', args.kifulist_train) + '.pickle'
if os.path.exists(train_pickle_filename):
with open(train_pickle_filename, 'rb') as f: # train_pickle_Was im Dateinamen steht, wird gelesen_Kifu-Ausgangsposition[([piece_bb 15 Elemente], [besetzt 2 Elemente], [pieces_in_Hand 2 Element], [move_1 Element beschriften], [1 Element gewinnen]), (Gleiches Set),... ist die Anzahl der Phasen x die Anzahl der Spiele]
positions_train = pickle.load(f)
logging.info('load train pickle')
else:
positions_train = read_kifu(args.kifulist_train)
# test data
test_pickle_filename = re.sub(r'\..*?$', '', args.kifulist_test) + '.pickle'
if os.path.exists(test_pickle_filename):
with open(test_pickle_filename, 'rb') as f:
positions_test = pickle.load(f)
logging.info('load test pickle')
else:
positions_test = read_kifu(args.kifulist_test)
#Wenn keine Pickle gespeichert ist, speichern Sie den Inhalt der oben gelesenen Variablen in der Pickle-Datei und speichern Sie sie.
if not os.path.exists(train_pickle_filename):
with open(train_pickle_filename, 'wb') as f: #Öffnen Sie eine leere Pickle-Datei
pickle.dump(positions_train, f, pickle.HIGHEST_PROTOCOL) #Legen Sie die Daten in die geöffnete Pickle-Datei.
logging.info('save train pickle')
if not os.path.exists(test_pickle_filename):
with open(test_pickle_filename, 'wb') as f:
pickle.dump(positions_test, f, pickle.HIGHEST_PROTOCOL)
logging.info('save test pickle')
logging.info('read kifu end')
logging.info('train position num = {}'.format(len(positions_train))) #Anzahl der äußersten Elemente von Positionen=Die Anzahl der Phasen wird ausgegeben
logging.info('test position num = {}'.format(len(positions_test)))
# mini batch
def mini_batch(positions, i, batchsize):
mini_batch_data = []
mini_batch_move = []
for b in range(batchsize):
features, move, win = make_features(positions[i + b]) #Für Schleife die äußerste Elementanzahl von Positionen, dh der Aspekt
mini_batch_data.append(features) #Fügen Sie Funktionen für jede Phase hinzu=Richtliniennetzwerk-Eingabedaten
mini_batch_move.append(move) #Fügen Sie den Zug für jede Phase hinzu=Lehrerdaten des Richtliniennetzwerks
if gpu_en == 1:
return(Variable(cuda.to_gpu(np.array(mini_batch_data, dtype=np.float32))),
Variable(cuda.to_gpu(np.array(mini_batch_move, dtype=np.int32))))
elif gpu_en == 0:
return np.array(mini_batch_data, dtype=np.float32), np.array(mini_batch_move, dtype=np.int32)
def mini_batch_for_test(positions, batchsize):
mini_batch_data = []
mini_batch_move = []
for b in range(batchsize):
features, move, win = make_features(random.choice(positions)) #Wählen Sie zufällig aus Positionen
mini_batch_data.append(features)
mini_batch_move.append(move)
if gpu_en == 1:
return(Variable(cuda.to_gpu(np.array(mini_batch_data, dtype=np.float32))),
Variable(cuda.to_gpu(np.array(mini_batch_move, dtype=np.int32))))
elif gpu_en == 0:
return np.array(mini_batch_data, dtype=np.float32), np.array(mini_batch_move, dtype=np.int32)
#↑ Vorbereitung zum Lernen
# #↓ Lernschleife
logging.info('start training')
itr = 0
sum_loss = 0
for e in range(args.epoch):
positions_train_shuffled = random.sample(positions_train, len(positions_train))
# positions_Zug ist[([piece_bb 15 Elemente], [besetzt 2 Elemente], [pieces_in_Hand 2 Element], [move_1 Element beschriften], [1 Element gewinnen]), (Gleiches Set),... ist die Anzahl der Phasen x die Anzahl der Spiele]
# random.sample(a,b)Gibt zufällig das b-Element von a zurück
itr_epoch = 0
sum_loss_epoch = 0
for i in range(0, len(positions_train_shuffled) - args.batchsize, args.batchsize):
#Vorwärtsausbreitung
x, t = mini_batch(positions_train_shuffled, i, args.batchsize) #x: Phasendiagramm=Eingabe, t: bewegen=Lehrerdaten
y = model(x) #Modell ist ein externes Modul und ist ein selbst erstelltes Modell
model.cleargrads() #Gradienteninitialisierung
#Verlustberechnung
loss = F.softmax_cross_entropy(y, t)
#Inverse Fehlerausbreitung
loss.backward() #Berechnen Sie den Gradienten
#Aktualisieren Sie die Parameter mithilfe des Verlaufs
optimizer.update()
itr += 1
sum_loss += loss.data
itr_epoch += 1
sum_loss_epoch += loss.data
#Bewertung in regelmäßigen Abständen (Bewertung_Jedes Intervall ausführen)
# print train loss and test accuracy
if optimizer.t % args.eval_interval == 0: # a %b gibt den Rest von a geteilt durch b zurück. t ist der Aktualisierungsschritt. aktualisieren()Inkrementiert mit.
x, t = mini_batch_for_test(positions_test, args.test_batchsize) # x =Phasendiagramm, t=Bewegung
y = model(x)
logging.info('epoch = {}, iteration = {}, loss = {}, accuracy = {}'.format(
optimizer.epoch + 1, optimizer.t, sum_loss / itr, F.accuracy(y,t).data))
itr = 0
sum_loss = 0
# validate test data
logging.info('validate test data')
itr_test = 0
sum_test_accuracy = 0
for i in range(0, len(positions_test) - args.batchsize, args.batchsize): # positions_Test ist kifulist_aus dem Test lesen_Das Ergebnis von Kifu ersetzen
x, t = mini_batch(positions_test, i, args.batchsize) #Genau das gleiche wie während des Trainings
y = model(x)
itr_test += 1
sum_test_accuracy += F.accuracy(y, t).data
logging.info('epoch = {}, iteration = {}, train loss avr = {}, test accuracy = {}'.format(
optimizer.epoch + 1, optimizer.t, sum_loss_epoch / itr_epoch, sum_test_accuracy / itr_test))
#1 Benachrichtigen Sie den Optimierer, wenn die Epoche beendet ist, um die nächste Epoche zu verarbeiten
optimizer.new_epoch()
#Speichern Sie den Modell- und Optimierungsstatus, nachdem Sie alle Epochen trainiert haben
logging.info('save the model')
serializers.save_npz(args.model, model)
print('save the optimizer')
serializers.save_npz(args.state, optimizer)
Recommended Posts