def _get_go():
try:
go = Go(board_size=gamedata()['width'])
for x,y,_ in gamedata()['moves']:
go = go.place((x,y))
return go
except:
return Go()
def __init__(self, parent, action, evaluator, conf):
if parent is None:
self.go = Go(board_size=conf.BOARD_SIZE, komi=conf.KOMI)
else:
self.go = Go(copy=parent.go)
if action == conf.PASS:
self.go.pass_()
else:
self.go.play(*divmod(action, conf.BOARD_SIZE))
self.parent = parent
self.children = [None] * conf.NUM_ACTIONS
self.action = action
self.n = np.zeros(conf.NUM_ACTIONS, dtype=np.int)
self.w = np.zeros(conf.NUM_ACTIONS, dtype=np.float32)
self.p, self.v = predict(evaluator, self, conf, random_trans=True)
def __init__(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.str_data = None
self.player_name = {"B": None, "W": None}
self.user_name = None
self.my_color = None
self.opponent_name = None
self.rule = Go()
self.time_data = {"B": None, "W": None}
def setUp(self):
go = Go(size=4)
go[2][2].state = WHITE
go[1][2].state = BLACK
go[3][2].state = BLACK
go[2][1].state = BLACK
go[2][3].state = BLACK
self.small_board_white_surrounded = go
go = Go(size=4)
go[2][2].state = WHITE
go[1][2].state = WHITE
go[3][2].state = WHITE
go[2][1].state = WHITE
go[2][3].state = WHITE
self.small_board_all_white = go
go = Go(size=4)
go[2][2].state = WHITE
go[1][2].state = None
go[3][2].state = BLACK
go[2][1].state = BLACK
go[2][3].state = BLACK
self.small_board_white_almost_surrounded = go
board = [
'| |',
'| |',
'| |',
'| |',
'| BB |',
'| BWWB |',
'| BB |',
'| |',
'| |',
'| |',
'| |',
]
self.big_board_white_captured = parse_board(board)
def sgf_to_npy(sgf_collection):
positions = "abcdefghijklmnopqrs"
game = sgf_collection[0]
black_win = True if game.root.properties["RE"][0] == "B" else False
initial_stones = []
for key, value in game.root.properties:
if key == "AB":
initial_stones.append(value[0])
sim = Go()
if initial_stones:
sim.reset(initial_stones=initial_stones)
else:
sim.reset()
for move in game.rest:
try:
stone_position = move.properties["B"][0]
except KeyError:
stone_position = move.properties["W"][0]
if stone_position == "":
action = 361
else:
x = positions.index(stone_position[0])
y = positions.index(stone_position[1])
action = np.ravel_multi_index((y, x), (19, 19))
sim.step(action)
examples = np.zeros((19, 19, 17, len(sim)), dtype=bool)
actions = np.zeros((362, len(sim)))
for idx in range(len(sim)):
state, action_idx = sim.get_history_step(idx)
examples[:, :, :, idx] = state
actions[action_idx, idx] = 1
results = np.ones(len(sim))
if black_win:
results[1::2] = -1
else:
results[::2] = -1
return examples, actions, results
def play_sgf(sgf: str) -> Optional[Dict]:
try:
board_size = int(SZ(sgf))
except:
raise Exception('Illegal Board Size %s' % SZ(sgf))
if '(;W[' in sgf or '(;B[' in sgf:
raise Exception('Analysis Currently Unsupported')
go = Go(board_size)
black, white = sgf_add_stones(sgf)
print(black, white)
for loc in black:
go._board[loc] = Go.BLACK
for loc in white:
go._board[loc] = Go.WHITE
# print(go)
for p, move in sgf_moves(sgf):
# print(p,move)
go._turn = p
go = go.place(move)
# print(go)
return {
'board': go,
'RE': RE(sgf),
'WR': WR(sgf),
'BR': BR(sgf),
'SZ': SZ(sgf),
}
def __init__(self, worker, client):
super(Lit, self).__init__()
self.worker = worker
self.client = client
from go import Go
from run import Run
#from recent import Recent
#from iciba import Iciba
#from f import F
#lit = Lit([Go(), Run(), Recent(), Iciba()])
plugins = [
Go(worker=worker, client=client),
Run(worker=worker, client=client)
]
lay = QVBoxLayout()
# spacing of search box
lay.setSpacing(0)
lay.setMargin(0)
self.inp = Input(self.act, self)
self.inp.textChanged.connect(self._try_query)
self.completer = Suggest(self.inp)
#self.inp.setCompleter(self.completer)
self.completer.activated[QModelIndex].connect(self.select)
lay.addWidget(self.inp)
self.setLayout(lay)
self._install_plugins(plugins)
self.setWindowFlags(
Qt.FramelessWindowHint
| Qt.Popup
| Qt.WindowStaysOnTopHint
)
self.setWindowTitle('lit')
self.mutex = QMutex()
self.jobs = []
from PyQt5.QtWidgets import QApplication from go import Go import sys app = QApplication([]) myGo = Go() sys.exit(app.exec_())
from flask import Flask
from flask_restful import Resource, Api
from flask_cors import CORS, cross_origin
from go import Go
import logging
go = Go()
app = Flask(__name__)
CORS(app)
app.logger.setLevel(logging.INFO)
api = Api(app)
class Status(Resource):
def get(self):
app.logger.info('* Get called')
return {
'serviceName': 'Gene Ontology Utility Service',
'description': 'GO Util'
}
class Details(Resource):
def get(self, goid):
term = go.getGoDag()[goid]
def run_rounds(opts,args):
def get_cmd_wd(cmd, exec_rel_cwd=False):
''' get the proper working directory from a command line '''
new_cmd = []
wd = None
for i, part in reversed(list(enumerate(cmd.split()))):
if wd == None and os.path.exists(part):
wd = os.path.dirname(os.path.realpath(part))
basename = os.path.basename(part)
if i == 0:
if exec_rel_cwd:
new_cmd.insert(0, os.path.join(".", basename))
else:
new_cmd.insert(0, part)
else:
new_cmd.insert(0, basename)
else:
new_cmd.insert(0, part)
return wd, ' '.join(new_cmd)
def get_cmd_name(cmd):
''' get the name of a bot from the command line '''
for i, part in enumerate(reversed(cmd.split())):
if os.path.exists(part):
return os.path.basename(part)
# this split of options is not needed, but left for documentation
game_options = {
"map": opts.map,
"timebank": opts.loadtime,
"time_per_move": opts.turntime,
"player_names" : args, #opts.player_names,
"scenario": opts.scenario }
if opts.player_seed != None:
game_options['player_seed'] = opts.player_seed
if opts.engine_seed != None:
game_options['engine_seed'] = opts.engine_seed
engine_options = {
"timebank": opts.loadtime,
"time_per_move": opts.turntime,
"player_names" : args, #opts.player_names,
"loadtime": opts.loadtime,
"turntime": opts.turntime,
"ack_turn_zero" : opts.ack_turn_zero,
"map_file": opts.map,
"turns": opts.turns,
"log_replay": opts.log_replay,
"log_stream": opts.log_stream,
"log_input": opts.log_input,
"log_output": opts.log_output,
"log_error": opts.log_error,
"serial": opts.serial,
"strict": opts.strict,
"capture_errors": opts.capture_errors,
"secure_jail": opts.secure_jail,
"end_wait": opts.end_wait }
for round in range(opts.rounds):
# initialize game
game_id = round + opts.game_id
# with open(opts.map, 'r') as map_file:
game_options['map'] = ""# map_file.read()
if opts.engine_seed:
game_options['engine_seed'] = opts.engine_seed + round
game = Go(game_options)
# initialize bots
bots = [get_cmd_wd(arg, exec_rel_cwd=opts.secure_jail) for arg in args]
bot_count = len(bots)
# insure correct number of bots, or fill in remaining positions
if game.num_players != len(bots):
if game.num_players > len(bots) and opts.fill:
extra = game.num_players - len(bots)
for _ in range(extra):
bots.append(bots[-1])
else:
print("Incorrect number of bots for map. Need {0}, got {1}"
.format(game.num_players, len(bots)), file=stderr)
for arg in args:
print("Bot Cmd: {0}".format(arg), file=stderr)
break
bot_count = len(bots)
# move position of first bot specified
if opts.position > 0 and opts.position <= len(bots):
first_bot = bots[0]
bots = bots[1:]
bots.insert(opts.position, first_bot)
# initialize file descriptors
if opts.log_dir and not os.path.exists(opts.log_dir):
os.mkdir(opts.log_dir)
if not opts.log_replay and not opts.log_stream and (opts.log_dir or opts.log_stdout):
opts.log_replay = True
replay_path = None # used for visualizer launch
if opts.log_replay:
if opts.log_dir:
replay_path = os.path.join(opts.log_dir, '{0}.replay'.format(game_id))
engine_options['replay_log'] = open(replay_path, 'w')
if opts.log_stdout:
if 'replay_log' in engine_options and engine_options['replay_log']:
engine_options['replay_log'] = Tee(sys.stdout, engine_options['replay_log'])
else:
engine_options['replay_log'] = sys.stdout
else:
engine_options['replay_log'] = None
if opts.log_stream:
if opts.log_dir:
engine_options['stream_log'] = open(os.path.join(opts.log_dir, '{0}.stream'.format(game_id)), 'w')
if opts.log_stdout:
if engine_options['stream_log']:
engine_options['stream_log'] = Tee(sys.stdout, engine_options['stream_log'])
else:
engine_options['stream_log'] = sys.stdout
else:
engine_options['stream_log'] = None
if opts.log_input and opts.log_dir:
engine_options['input_logs'] = [open(os.path.join(opts.log_dir, '{0}.bot{1}.input'.format(game_id, i)), 'w')
for i in range(bot_count)]
else:
engine_options['input_logs'] = None
if opts.log_output and opts.log_dir:
engine_options['output_logs'] = [open(os.path.join(opts.log_dir, '{0}.bot{1}.output'.format(game_id, i)), 'w')
for i in range(bot_count)]
else:
engine_options['output_logs'] = None
if opts.log_error and opts.log_dir:
if opts.log_stderr:
if opts.log_stdout:
engine_options['error_logs'] = [Tee(Comment(stderr), open(os.path.join(opts.log_dir, '{0}.bot{1}.error'.format(game_id, i)), 'w'))
for i in range(bot_count)]
else:
engine_options['error_logs'] = [Tee(stderr, open(os.path.join(opts.log_dir, '{0}.bot{1}.error'.format(game_id, i)), 'w'))
for i in range(bot_count)]
else:
engine_options['error_logs'] = [open(os.path.join(opts.log_dir, '{0}.bot{1}.error'.format(game_id, i)), 'w')
for i in range(bot_count)]
elif opts.log_stderr:
if opts.log_stdout:
engine_options['error_logs'] = [Comment(stderr)] * bot_count
else:
engine_options['error_logs'] = [stderr] * bot_count
else:
engine_options['error_logs'] = None
if opts.verbose:
if opts.log_stdout:
engine_options['verbose_log'] = Comment(sys.stdout)
else:
engine_options['verbose_log'] = sys.stdout
engine_options['game_id'] = game_id
if opts.rounds > 1:
print('# playgame round {0}, game id {1}'.format(round, game_id))
# intercept replay log so we can add player names
if opts.log_replay:
intcpt_replay_io = StringIO()
real_replay_io = engine_options['replay_log']
engine_options['replay_log'] = intcpt_replay_io
result = run_game(game, bots, engine_options)
# add player names, write to proper io, reset back to normal
if opts.log_replay:
replay_json = json.loads(intcpt_replay_io.getvalue())
replay_json['playernames'] = [get_cmd_name(arg) for arg in args]
real_replay_io.write(json.dumps(replay_json))
intcpt_replay_io.close()
engine_options['replay_log'] = real_replay_io
# close file descriptors
if engine_options['stream_log']:
engine_options['stream_log'].close()
if engine_options['replay_log']:
engine_options['replay_log'].close()
if engine_options['input_logs']:
for input_log in engine_options['input_logs']:
input_log.close()
if engine_options['output_logs']:
for output_log in engine_options['output_logs']:
output_log.close()
if engine_options['error_logs']:
for error_log in engine_options['error_logs']:
error_log.close()
if replay_path:
if opts.nolaunch:
if opts.html_file:
visualizer.visualize_locally.launch(replay_path, True, opts.html_file)
else:
if opts.html_file == None:
visualizer.visualize_locally.launch(replay_path,
generated_path="replay.{0}.html".format(game_id))
else:
visualizer.visualize_locally.launch(replay_path,
generated_path=opts.html_file)
def main():
#TODO delete code from here
go_state_obj = GoStateObject()
from search import DeepLearningSearch
from forward_prop_network import ForwardPropNetwork
import tensorflow as tf
import time
#search_algorithm = DeepLearningSearch()
sess = tf.Session()
#forward_prop_network = ForwardPropNetwork(sess)
import copy
search_algorithm = MontecarloSearch()
go_state_obj = GoStateObject()
args = sys.argv
user = '******'
# NNGS set up
nngs = NNGS()
# connect nngs
nngs.connect_nngs()
# login
nngs.login(user)
# match
if len(args) == 3 and args[2] in ('B', 'W'):
nngs.match(args[1], args[2])
# wait
nngs.nngs_wait()
init_time = time.time()
sum_time = 0
# Go, Player set up
rule = Go()
players = [
Player(0, nngs.player_name['B']),
Player(1, nngs.player_name['W'])
]
players[0].next_player = players[1]
players[1].next_player = players[0]
player = players[0]
#last_opponent_move=None
last_opponent_move = None
while True:
print(rule.print_board(go_state_obj))
if player.player_name == user:
my_start_time = time.time()
(go_state_obj,
move) = search_algorithm.next_move(go_state_obj, player,
1800 - (float(sum_time)),
last_opponent_move)
print("next_move:", move)
#go_state_obj = rule.move_and_return_state(go_state_obj, player, move)
nngs.send_data(move2nngs(move, rule))
my_end_time = time.time()
sum_time = sum_time + my_end_time - my_start_time
print("Sum time" + str(sum_time))
#search_algorithm.thread_close()
else:
z = nngs.nngs_wait()
if z == None:
print("None! None! なん！")
exit(0)
if z < 0: continue
#go_state_obj = rule.move_and_return_state(go_state_obj,player, nngs2move(rule, player, z))
nn_move = nngs2move(rule, player, z)
print(nn_move)
if nn_move == 0 or nn_move == 3:
last_opponent_move = rule._PASS
else:
last_opponent_move = nn_move
go_state_obj = rule.move_and_return_state(
go_state_obj, player, nn_move)
player = player.next_player
nngs.close_nngs()
def test_play_game(self):
go = Go(size=11)
go.play(5, 5)
expected_board = '\n'.join([
'| |', '| |', '| |',
'| |', '| |', '| W |',
'| |', '| |', '| |',
'| |', '| |'
])
self.assertEqual(str(go), expected_board,
'\n' + repr(str(go)) + '\n' + repr(expected_board))
go.play(4, 5)
self.assertEqual(
str(go), '\n'.join([
'| |', '| |', '| |',
'| |', '| B |', '| W |',
'| |', '| |', '| |',
'| |', '| |'
]), str(go))
with self.assertRaises(GoException):
go.play(4, 5)
self.assertEqual(
str(go), '\n'.join([
'| |', '| |', '| |',
'| |', '| B |', '| W |',
'| |', '| |', '| |',
'| |', '| |'
]), str(go))
go.play(3, 5)
expected_board = '\n'.join([
'| |', '| |', '| |',
'| W |', '| B |', '| W |',
'| |', '| |', '| |',
'| |', '| |'
])
self.assertEqual(str(go), expected_board, str(go))
go.play(5, 6)
expected_board = '\n'.join([
'| |', '| |', '| |',
'| W |', '| B |', '| WB |',
'| |', '| |', '| |',
'| |', '| |'
])
self.assertEqual(str(go), expected_board, str(go))
go.play(4, 6)
self.assertEqual(
str(go), '\n'.join([
'| |', '| |', '| |',
'| W |', '| BW |', '| WB |',
'| |', '| |', '| |',
'| |', '| |'
]), str(go))
go.play(5, 4)
self.assertEqual(
str(go), '\n'.join([
'| |', '| |', '| |',
'| W |', '| BW |', '| BWB |',
'| |', '| |', '| |',
'| |', '| |'
]), str(go))
go.play(4, 4)
self.assertEqual(
str(go), '\n'.join([
'| |', '| |', '| |',
'| W |', '| WWW |', '| BWB |',
'| |', '| |', '| |',
'| |', '| |'
]), str(go))
def main():
# TODO delete code from here
go_state_obj = GoStateObject()
from search import DeepLearningSearch
from forward_prop_network import ForwardPropNetwork
import tensorflow as tf
search_algorithm = DeepLearningSearch()
sess = tf.Session()
forward_prop_network = ForwardPropNetwork(sess)
import copy
# search_algorithm=MontecarloSearch()
go_state_obj = GoStateObject()
args = sys.argv
user = '******'
# NNGS set up
nngs = NNGS()
# connect nngs
nngs.connect_nngs()
# login
nngs.login(user)
# match
if len(args) == 3 and args[2] in ('B', 'W'):
nngs.match(args[1], args[2])
# wait
nngs.nngs_wait()
# Go, Player set up
rule = Go()
players = [
Player(0, nngs.player_name['B']),
Player(1, nngs.player_name['W'])
]
players[0].next_player = players[1]
players[1].next_player = players[0]
player = players[0]
last_opponent_move = None
while True:
print(rule.print_board(go_state_obj))
if player.player_name == user:
(go_state_obj,
move) = search_algorithm.next_move(forward_prop_network, sess,
go_state_obj, player,
last_opponent_move)
print("next_move:", move)
# go_state_obj = rule.move_and_return_state(go_state_obj, player, move)
if go_state_obj.turns_num >= 500:
print("over 10 PASS in nngs_client_pass.py")
move = rule._PASS
nngs.send_data(move2nngs(move, rule))
else:
z = nngs.nngs_wait()
if z < 0: continue
nn_move = nngs2move(rule, player, z)
print(nn_move)
if nn_move == 0 or nn_move == 3:
last_opponent_move = rule._PASS
else:
last_opponent_move = nn_move
go_state_obj = rule.move_and_return_state(
go_state_obj, player, nn_move)
player = player.next_player
nngs.close_nngs()
if _move_count() - sent_msgs[-1] > 10 and len(win_probs) > 4:
delta_wp = win_probs[-1] - np.mean(win_probs[-5:-1])
if delta_wp > 0.4 and win_probs[-1] > 0.6:
ogs_api._game_chat(game_id, _winning_msg())
sent_msgs.append(_move_count())
if delta_wp < -0.4 and win_probs[-1] < 0.4:
ogs_api._game_chat(game_id, _losing_msg())
sent_msgs.append(_move_count())
if __name__ == '__main__':
logger = make_logger('debug')
model = Gen_Model().load('Go', '0.1')
def new_player():
return MCTS_Player(model, time_limit=2)
# Initialise TF session
MCTS_Player(model, time_limit=1).get_move(Go())
max_concurrent_games = 0
run_threads = {}
config = yaml.load(open('config.yml', 'r'))
ogs_api = OnlineGoAPI(config['username'], config['password'])
ogs_api.logon()
time.sleep(1)
while True:
time.sleep(5)
play_games = [g for g in ogs_api.gamedata if ogs_api.gamedata[g]['phase'] == 'play']
for game_id in play_games:
if game_id not in run_threads:
logger.info("start thread for %s" % game_id)
# run(game_id, ogs_api, new_player())
threading.Thread(target=run, args=(game_id, ogs_api, new_player(), logger)).start()
# multiprocessing.Process(target=run, args=(game_id, ogs_api, new_player(), logger)).start()
def train(self):
players = [Player(0.0, 'human'), Player(1.0, 'human')]
players[0].next_player = players[1]
players[1].next_player = players[0]
#player = players[0]
rule = Go()
print "starting tf.device(/gpu:0)"
sess = tf.InteractiveSession()
#with tf.device("/gpu:1"):
with tf.variable_scope('policy_auto'):
with tf.device("/gpu:0"):
#5290000=23*23*100*100 88200=21*21*
# データ用可変2階テンソルを用意
x_input = tf.placeholder("float", shape=[None, 7, 361])
# 正解用可変2階テンソルを用意
y_ = tf.placeholder("float", shape=[None, 361])
# 画像を2次元配列にリシェイプ 第1引数は画像数(-1は元サイズを保存するように自動計算)、縦x横、チャネル
x_image = tf.reshape(x_input, [-1, 19, 19, 7])
x_image_pad = tf.pad(x_image, [[0, 0], [2, 2], [2, 2], [0, 0]])
# 畳み込み層のフィルタ重み、引数はパッチサイズ縦、パッチサイズ横、入力チャネル数、出力チャネル数
# 5x5フィルタで100チャネルを出力（入力は白黒画像なので1チャンネル）
W_conv1 = self.weight_variable([5, 5, 7, 75]) #[5,5,6,50]
b_conv1 = self.bias_variable([75]) #[50]
h_conv1 = tf.nn.relu(
self.conv2d(x_image_pad, W_conv1) + b_conv1)
#4次元のpaddingをする
### 2層目 プーリング層
# 2x2のマックスプーリング層を構築
h_pool1 = self.max_pool_2x2(h_conv1)
#次の層の畳み込み処理を行う前に、paddingを実行。
# 3層目 畳み込み層
# パッチサイズ縦、パッチサイズ横、入力チャネル（枚数）、出力チャネル（出力の枚数）
# 3x3フィルタで64チャネルを出力
W_conv2 = self.weight_variable([3, 3, 75, 75]) #[3,3,50,100]
b_conv2 = self.bias_variable([75])
h_conv2 = tf.nn.relu(self.conv2d(h_pool1, W_conv2) + b_conv2)
# 4層目 プーリング層
h_pool2 = self.max_pool_2x2(h_conv2)
#次の層の畳み込み処理を行う前に、paddingを実行。
###5層目 畳み込み層
W_conv3 = self.weight_variable([3, 3, 75, 75])
b_conv3 = self.bias_variable([75])
h_conv3 = tf.nn.relu(self.conv2d(h_pool2, W_conv3) + b_conv3)
### 6層目 プーリング層
h_pool3 = self.max_pool_2x2(h_conv3)
###7層目 畳み込み層
W_conv4 = self.weight_variable([3, 3, 75, 75])
b_conv4 = self.bias_variable([75])
h_conv4 = tf.nn.relu(self.conv2d(h_pool3, W_conv4) + b_conv4)
h_pool4 = self.max_pool_2x2(h_conv4)
W_conv5 = self.weight_variable([3, 3, 75, 75])
b_conv5 = self.bias_variable([75])
h_conv5 = tf.nn.relu(self.conv2d(h_pool4, W_conv5) + b_conv5)
h_pool5 = self.max_pool_2x2(h_conv5)
h_pool6_flat = tf.reshape(h_pool5,
[-1, 23 * 23 * 75]) #29*29*100
weight_fully_connected1 = self.weight_variable(
[23 * 23 * 75, 1000])
bias_fc1 = self.weight_variable([1000])
hiden_fully_connect1 = tf.nn.relu(
tf.matmul(h_pool6_flat, weight_fully_connected1) +
bias_fc1)
# ドロップアウトを指定
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(hiden_fully_connect1, keep_prob)
weight_fully_connected2 = self.weight_variable([1000, 361])
bias_fc2 = self.bias_variable([361])
y_conv = tf.nn.softmax(
tf.matmul(h_fc1_drop, weight_fully_connected2) + bias_fc2)
cross_entropy = -tf.reduce_sum(
y_ * tf.log(tf.clip_by_value(y_conv, 1e-10, 1.0)))
#cross_entropy=tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits=y_conv,labels=y_))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(tf.initialize_all_variables())
saver = tf.train.Saver(self.get_particular_variables('policy_auto'))
# 指定したパス内の全てのファイルとディレクトリを要素とするリストを返す
#自分の環境でのsgf_filesへのパスを書く。
print "y_!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
print y_
tf.summary.scalar("cross_entropy", cross_entropy)
tf.summary.scalar("accuracy", accuracy)
#tf.summary.scalar("accuracy",accuracy)
#tf.summary.scalar("correct_prediction",correct_prediction)
#tf.summary.scalar("train_step",train_step)
#merged = tf.summary.merge_all()
files = os.listdir(os.getcwd() + "/kifu")
init = tf.initialize_all_variables()
xTrain = []
yTrain = []
with tf.Session() as sess:
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter('tensorflow_logs/train',
sess.graph)
test_writer = tf.summary.FileWriter('tensorflow_logs/test',
sess.graph)
sess.run(init) #If it is first time of learning
num = 0
batch_count_num = 0
train_count_num = 0
#saver.restore(sess, './policy_network_1x1_bias')
make_input = MakeInputPlane()
step = 0
ckpt_num = 0
batch_count_sum_all = 0
for _ in xrange(100):
continue_kifu_num = 0
for file_name in files:
continue_kifu_num += 1
if continue_kifu_num < 30000:
continue
step += 1
'''
if continue_kifu_num % 100 == 0:
result = sess.run([merged,cross_entropy], feed_dict=feed_dict(False))
summary_str=result[0]
acc = result[1]
train_writer.add_summary(summary_str,step)
'''
with open("kifu/" + file_name) as f:
go_state_obj = GoStateObject()
try:
collection = sgf.parse(f.read())
flag = False
except:
print "sgf_parse bugs"
continue
try:
#print "通過"
for game in collection:
for node in game:
if flag == False:
flag = True
continue
lists = node.properties.values()
#print lists
internal_lists = lists[0]
position = internal_lists[0]
xpos = self.character_list.index(
position[0])
ypos = self.character_list.index(
position[1])
pos_tuple = (xpos, ypos)
#print xpos,ypos
if node.properties.has_key('B') == True:
current_player = players[0]
elif node.properties.has_key('W') == True:
current_player = players[1]
go_state_obj = rule.move(
go_state_obj, current_player,
pos_tuple)
rule.move(go_state_obj, current_player,
pos_tuple)
#print "move ends"
num += 1
if num > 50:
input_board = make_input.generate_input(
go_state_obj, current_player)
answer_board = make_input.generate_answer(
pos_tuple)
xTrain.append(
self.reshape_board(input_board))
yTrain.append(
self.reshape_answer_board(
answer_board))
#print self.reshape_answer_board(answer_board)
#print self.reshape_answer_board(answer_board)
input_board2 = self.rotate90_input(
input_board)
answer_board2 = self.rotate90_answer(
answer_board)
xTrain.append(
self.reshape_board(input_board2))
yTrain.append(
self.reshape_answer_board(
answer_board2))
input_board3 = self.rotate90_input(
input_board2)
answer_board3 = self.rotate90_answer(
answer_board2)
xTrain.append(
self.reshape_board(input_board3))
yTrain.append(
self.reshape_answer_board(
answer_board3))
input_board4 = self.rotate90_input(
input_board3)
answer_board4 = self.rotate90_answer(
answer_board3)
xTrain.append(
self.reshape_board(input_board4))
yTrain.append(
self.reshape_answer_board(
answer_board4))
input_board5 = self.invert_board_input(
input_board4)
answer_board5 = self.invert_board_answer(
answer_board4)
xTrain.append(
self.reshape_board(input_board5))
yTrain.append(
self.reshape_answer_board(
answer_board5))
input_board6 = self.rotate90_input(
input_board5)
answer_board6 = self.rotate90_answer(
answer_board5)
xTrain.append(
self.reshape_board(input_board6))
yTrain.append(
self.reshape_answer_board(
answer_board6))
input_board7 = self.rotate90_input(
input_board3)
answer_board7 = self.rotate90_answer(
answer_board3)
xTrain.append(
self.reshape_board(input_board7))
yTrain.append(
self.reshape_answer_board(
answer_board7))
input_board8 = self.rotate90_input(
input_board7)
answer_board8 = self.rotate90_answer(
answer_board7)
xTrain.append(
self.reshape_board(input_board8))
yTrain.append(
self.reshape_answer_board(
answer_board8))
num = 0
#xTrain,yTrainの中身を代入する処理をここに書く。
batch_count_num += 1
if (batch_count_sum_all + 101
) % 40 == 0 and batch_count_num == 30:
#print xTrain
print "tensorboard writing!"
#train_step.run(feed_dict={x_input: xTrain, y_: yTrain,keep_prob: 0.5})
summary_str, accuracy_value, cross_entropy_value = sess.run(
[merged, accuracy, cross_entropy],
feed_dict={
x_input: xTrain,
y_: yTrain,
keep_prob: 1.0
})
train_writer.add_summary(
summary_str, step)
train_writer.flush()
#train_writer.add_summary(summary_str[0],step)
print accuracy_value
print str(float(cross_entropy_value))
#print cross_entropy
#train_step.run(feed_dict={x_input: xTrain, y_: yTrain,keep_prob: 0.5})
print summary_str[0]
batch_count_sum_all += 1
batch_count_num = 0
train_count_num += 1
xTrain = []
yTrain = []
print train_count_num
elif batch_count_num == 30:
train_step.run(
feed_dict={
x_input: xTrain,
y_: yTrain,
keep_prob: 0.5
})
#train_accuracy = accuracy.eval(feed_dict={x_input:xTrain, y_: yTrain, keep_prob: 1.0})
batch_count_sum_all += 1
batch_count_num = 0
train_count_num += 1
xTrain = []
yTrain = []
print train_count_num
if train_count_num > 2000:
train_count_num = 0
ckpt_num += 1
print "SAVED!"
saver.save(
sess,
'./Network_Backup/policy_network_relu'
+ str(ckpt_num))
except:
#import traceback
#traceback.print_exc()
f.close()
