` 101 | * 設定初始的時限並重新計時， ```main time``` 為基本思考時間，```byo time``` 為讀秒思考時間，```byo stones``` 為讀秒內要下的棋手數，僅支援加拿大讀秒（Canadian byo-yomi）規則。 102 | 103 | * `time_left [black|white]

` 104 | * 設定某方剩餘的時限。 105 | 106 | * `analyze [black|white] ` 107 | * 背景分析結果，詳細指令的參數可到[這裡](https://github.com/SabakiHQ/Sabaki/blob/master/docs/guides/engine-analysis-integration.md)查看。 108 | 109 | * `genmove_analyze [black|white] ` 110 | * 讓引擎思考並產生下一手棋到盤面上並在背景送出分析結果，詳細指令的參數可到[這裡](https://github.com/SabakiHQ/Sabaki/blob/master/docs/guides/engine-analysis-integration.md)查看。 111 | 112 | ## 三、其它 KGS 可用指令 113 | 114 | 有些指令在 KGS 上有特殊效果，或是可以提供更多功能，如果有興趣的話，可以優先實作下列指令，指令的參數和效果可到 [GTP 英文文檔](https://www.gnu.org/software/gnugo/gnugo_19.html)查看 115 | 116 | * `final_status_list [alive|dead]` 117 | * 顯示當前盤面的死棋和活棋棋串。GNU Go 還有實做其它種類的判斷，如 ```seki```、 ```white_territory```、 ```black_territory``` 和 ```dame```。 118 | 119 | * `place_free_handicap ` 120 | * 讓引擎自己生成讓子的位置。 121 | 122 | * `set_free_handicap ` 123 | * 使用者告訴電腦讓子的位置。 124 | 125 | * `kgs-genmove_cleanup [black|white]` 126 | * KGS 專用的生成合法手的指令，禁止虛手直到盤面沒有死棋為止，用以清除盤面死棋。 127 | 128 | * `kgs-time_settings ...` 129 | * KGS 專用的時間控制指令，相比原版的多支援 Byo-Yomi 讀秒規則，詳情請看[這裡](https://www.gokgs.com/help/timesystems.html)。 130 | 131 | * `kgs-game_over` 132 | * 當每盤對戰結束，會發出此指令。 133 | -------------------------------------------------------------------------------- /gtp.py: -------------------------------------------------------------------------------- 1 | from sys import stderr, stdout, stdin 2 | from board import Board, PASS, RESIGN, BLACK, WHITE, INVLD 3 | from network import Network 4 | from mcts import Search 5 | from config import BOARD_SIZE, KOMI 6 | from time_control import TimeControl 7 | 8 | class GTP_ENGINE: 9 | def __init__(self, args): 10 | self.args = args 11 | self.board = Board(BOARD_SIZE, KOMI) 12 | self.network = Network(BOARD_SIZE) 13 | self.time_control = TimeControl() 14 | self.network.trainable(False) 15 | self.board_history = [self.board.copy()] 16 | self.last_verbose = str() 17 | 18 | if self.args.weights != None: 19 | self.network.load_pt(self.args.weights) 20 | 21 | # For GTP command "clear_board". Reset the board to the initial state and 22 | # clear the move history. 23 | def clear_board(self): 24 | self.board.reset(self.board.board_size, self.board.komi) 25 | self.board_history = [self.board.copy()] 26 | self.network.clear_cache() 27 | 28 | # For GTP command "genmove". The engine returns the best move and play it. 29 | def genmove(self, color): 30 | # Genrate next move and play it. 31 | c = self.board.to_move 32 | if color.lower()[:1] == "b": 33 | c = BLACK 34 | elif color.lower()[:1] == "w": 35 | c = WHITE 36 | 37 | self.board.to_move = c 38 | search = Search(self.board, self.network, self.time_control) 39 | 40 | # Collect the search verbose for the built-in GUI. 41 | move, self.last_verbose = search.think( 42 | self.args.playouts, 43 | self.args.resign_threshold, 44 | self.args.verbose) 45 | if self.board.play(move): 46 | self.board_history.append(self.board.copy()) 47 | 48 | return self.board.vertex_to_text(move) 49 | 50 | # For GTP command "play". Play a move if it is legal. 51 | def play(self, color, move): 52 | # play move if the move is legal. 53 | c = INVLD 54 | if color.lower()[:1] == "b": 55 | c = BLACK 56 | elif color.lower()[:1] == "w": 57 | c = WHITE 58 | 59 | vtx = None 60 | if move == "pass": 61 | vtx = PASS 62 | elif move == "resign": 63 | vtx = RESIGN 64 | else: 65 | x = ord(move[0]) - (ord('A') if ord(move[0]) < ord('a') else ord('a')) 66 | y = int(move[1:]) - 1 67 | if x >= 8: 68 | x -= 1 69 | vtx = self.board.get_vertex(x,y) 70 | 71 | if c != INVLD: 72 | self.board.to_move = c 73 | if self.board.play(vtx): 74 | self.board_history.append(self.board.copy()) 75 | return True 76 | return False 77 | 78 | # For GTP command "undo". Play the undo move. 79 | def undo(self): 80 | if len(self.board_history) > 1: 81 | self.board_history.pop() 82 | self.board = self.board_history[-1].copy() 83 | 84 | # For GTP command "boardsize". Set a variant board size. 85 | def boardsize(self, bsize): 86 | self.board.reset(bsize, self.board.komi) 87 | self.board_history = [self.board.copy()] 88 | self.network.clear_cache() 89 | 90 | # For GTP command "boardsize". Set a variant komi. 91 | def komi(self, k): 92 | self.board.komi = k 93 | 94 | # For GTP command "time_settings". Set initial time settings and restart it. 95 | # 'main time' is basic thinking time. 96 | # 'byo time' is byo yomi time. 97 | # 'byo stones' is byo yomi stone. 98 | def time_settings(self, main_time, byo_time, byo_stones): 99 | if not main_time.isdigit() or \ 100 | not byo_time.isdigit() or \ 101 | not byo_stones.isdigit(): 102 | return False 103 | 104 | self.time_control.time_settings(int(main_time), int(byo_time), int(byo_stones)) 105 | return True 106 | 107 | # For GTP command "time_left". Set time left value for one side. 108 | def time_left(self, color, time, stones): 109 | c = INVLD 110 | if color.lower()[:1] == "b": 111 | c = BLACK 112 | elif color.lower()[:1] == "w": 113 | c = WHITE 114 | if c == INVLD: 115 | return False 116 | self.time_control.time_left(c, int(time), int(stones)) 117 | return True 118 | 119 | # For GTP command "showboard". Dump the board(stand error output). 120 | def showboard(self): 121 | stderr.write(str(self.board)) 122 | stderr.flush() 123 | 124 | def lz_genmove_analyze(self, color, interval): 125 | c = self.board.to_move 126 | if color.lower()[:1] == "b": 127 | c = BLACK 128 | elif color.lower()[:1] == "w": 129 | c = WHITE 130 | 131 | self.board.to_move = c 132 | search = Search(self.board, self.network, self.time_control) 133 | search.analysis_tag["interval"] = interval/100 134 | 135 | # Collect the search verbose for the built-in GUI. 136 | move, self.last_verbose = search.think( 137 | self.args.playouts, 138 | self.args.resign_threshold, 139 | self.args.verbose) 140 | if self.board.play(move): 141 | self.board_history.append(self.board.copy()) 142 | 143 | return self.board.vertex_to_text(move) 144 | 145 | def lz_analyze(self, color, interval): 146 | c = self.board.to_move 147 | if color.lower()[:1] == "b": 148 | c = BLACK 149 | elif color.lower()[:1] == "w": 150 | c = WHITE 151 | 152 | self.board.to_move = c 153 | search = Search(self.board, self.network, self.time_control) 154 | search.analysis_tag["interval"] = interval/100 155 | 156 | # Collect the search verbose for the built-in GUI. 157 | self.last_verbose = search.ponder( 158 | self.args.playouts * 100, 159 | self.args.verbose) 160 | 161 | class GTP_LOOP: 162 | COMMANDS_LIST = [ 163 | "quit", "name", "version", "protocol_version", "list_commands", 164 | "play", "genmove", "undo", "clear_board", "boardsize", "komi", 165 | "time_settings", "time_left", "lz-genmove_analyze", "lz-analyze" 166 | ] 167 | def __init__(self, args): 168 | self.engine = GTP_ENGINE(args) 169 | self.args = args 170 | self.cmd_id = None 171 | 172 | # Start the main GTP loop. 173 | self.loop() 174 | 175 | def loop(self): 176 | while True: 177 | # Get the commands. 178 | cmd = stdin.readline().split() 179 | 180 | # Get the command id. 181 | self.set_id(cmd) 182 | 183 | if len(cmd) == 0: 184 | continue 185 | 186 | main = cmd[0] 187 | if main == "quit": 188 | self.success_print("") 189 | break 190 | 191 | # Parse the commands and execute it. 192 | self.process(cmd) 193 | 194 | def set_id(self, cmd): 195 | self.cmd_id = None 196 | if len(cmd) == 0: 197 | return 198 | 199 | if cmd[0].isdigit(): 200 | self.cmd_id = cmd.pop(0) 201 | 202 | def process(self, cmd): 203 | # TODO: Support analyze and genmove_analyze commands. 204 | main = cmd[0] 205 | 206 | if main == "name": 207 | self.success_print("dlgo") 208 | elif main == "version": 209 | version = "0.1"; 210 | if self.args.kgs: 211 | self.success_print(version + "\nI am a simple bot. I don't understand the life and death. Please help me to remove the dead strings when the game is end. Have a nice game.") 212 | else: 213 | self.success_print(version) 214 | elif main == "protocol_version": 215 | self.success_print("2") 216 | elif main == "list_commands": 217 | clist = str() 218 | for c in self.COMMANDS_LIST: 219 | clist += c 220 | if c is not self.COMMANDS_LIST[-1]: 221 | clist += '\n' 222 | self.success_print(clist) 223 | elif main == "clear_board": 224 | # reset the board 225 | self.engine.clear_board(); 226 | self.success_print("") 227 | elif main == "play" and len(cmd) >= 3: 228 | # play color move 229 | if self.engine.play(cmd[1], cmd[2]): 230 | self.success_print("") 231 | else: 232 | self.fail_print("") 233 | elif main == "undo": 234 | # undo move 235 | self.engine.undo(); 236 | self.success_print("") 237 | elif main == "genmove" and len(cmd) >= 2: 238 | # genrate next move 239 | self.success_print(self.engine.genmove(cmd[1])) 240 | elif main == "boardsize" and len(cmd) >= 2: 241 | # set board size and reset the board 242 | self.engine.boardsize(int(cmd[1])) 243 | self.success_print("") 244 | elif main == "komi" and len(cmd) >= 2: 245 | # set komi 246 | self.engine.komi(float(cmd[1])) 247 | self.success_print("") 248 | elif main == "showboard": 249 | # display the board 250 | self.engine.showboard() 251 | self.success_print("") 252 | elif main == "time_settings": 253 | if self.engine.time_settings(cmd[1], cmd[2], cmd[3]): 254 | self.success_print("") 255 | else: 256 | self.fail_print("") 257 | elif main == "time_left": 258 | if self.cmd_id is not None: 259 | stdout.write("={}\n".format(self.cmd_id)) 260 | else: 261 | stdout.write("=\n") 262 | stdout.flush() 263 | elif main == "lz-genmove_analyze": 264 | color = "tomove" 265 | interval = 0 266 | if len(cmd) >= 2: 267 | if cmd[1].isdigit(): 268 | interval = cmd[1] 269 | if cmd[2].isdigit(): 270 | color = cmd[1] 271 | interval = cmd[2] 272 | self.success_half('') 273 | m = self.engine.lz_genmove_analyze(color, int(interval)) 274 | stdout.write("play {}\n\n".format(m)) 275 | stdout.flush() 276 | elif main == "lz-analyze": 277 | color = "tomove" 278 | interval = 0 279 | if len(cmd) >= 2: 280 | if cmd[1].isdigit(): 281 | interval = cmd[1] 282 | if cmd[2].isdigit(): 283 | color = cmd[1] 284 | interval = cmd[2] 285 | self.success_half('') 286 | m = self.engine.lz_analyze(color, int(interval)) 287 | stdout.write("\n") 288 | stdout.flush() 289 | else: 290 | self.fail_print("Unknown command") 291 | 292 | def success_half(self, res): 293 | if self.cmd_id is not None: 294 | stdout.write("={} {}\n".format(self.cmd_id, res)) 295 | else: 296 | stdout.write("= {}\n".format(res)) 297 | stdout.flush() 298 | 299 | def success_print(self, res): 300 | if self.cmd_id is not None: 301 | stdout.write("={} {}\n\n".format(self.cmd_id, res)) 302 | else: 303 | stdout.write("= {}\n\n".format(res)) 304 | stdout.flush() 305 | 306 | def fail_print(self, res): 307 | stdout.write("? {}\n\n".format(res)) 308 | stdout.flush() 309 | -------------------------------------------------------------------------------- /gui.py: -------------------------------------------------------------------------------- 1 | from board import Board, PASS, RESIGN, BLACK, WHITE, INVLD, EMPTY 2 | from gtp import GTP_ENGINE 3 | from config import BOARD_SIZE, KOMI 4 | 5 | import time 6 | import argparse 7 | import tkinter as tk 8 | from threading import Thread 9 | from tkinter import scrolledtext 10 | 11 | class GUI_LOOP(GTP_ENGINE): 12 | def __init__(self, args): 13 | super(GUI_LOOP, self).__init__(args) 14 | 15 | self.init_layouts(1200, 800) 16 | 17 | self.window = tk.Tk() 18 | self.window.resizable(0, 0) 19 | self.window.title("Deep Learning of Go") 20 | self.window.geometry("{w}x{h}".format(w=self.width, h=self.height)) 21 | 22 | self.oval_buffer = [None] * self.board.num_intersections 23 | self.text_buffer = [None] * self.board.num_intersections 24 | 25 | self.game_thread = None 26 | self.suspend = False 27 | self.acquire_vtx = None 28 | 29 | self.init_widgets() 30 | self.window.mainloop() 31 | 32 | def init_layouts(self, width, height): 33 | min_width = 800 34 | min_height = 500 35 | self.widgets_offset_base = 30 36 | 37 | 38 | self.width = max(width, min_width) 39 | self.height = max(height, min_height) 40 | 41 | size_base = min(self.width, self.height) 42 | 43 | # Set the canvas size and coordinate. 44 | self.canvas_size = size_base - self.widgets_offset_base * 2 # The canvas the always square. 45 | self.canvas_x = self.widgets_offset_base 46 | self.canvas_y = self.widgets_offset_base 47 | 48 | # Set the buttons's coordinates. 49 | buttons_offset_base = self.canvas_x + self.canvas_size + self.widgets_offset_base 50 | self.buttons_x = [buttons_offset_base + 0 * 90, 51 | buttons_offset_base + 1 * 90, 52 | buttons_offset_base + 2 * 90, 53 | buttons_offset_base + 3 * 90] 54 | self.buttons_y = 4 * [self.widgets_offset_base] 55 | 56 | # Set the scrolled text size and coordinate. 57 | self.scrolled_x = self.canvas_x + self.canvas_size + self.widgets_offset_base 58 | self.scrolled_y = 3 * self.widgets_offset_base 59 | 60 | self.scrolled_width = round((self.width - self.scrolled_x - self.widgets_offset_base) / 9) 61 | self.scrolled_height = round((self.height - self.scrolled_y - self.widgets_offset_base) / 18) 62 | 63 | def init_widgets(self): 64 | self.canvas = tk.Canvas(self.window, bg="#CD853F", height=self.canvas_size, width=self.canvas_size) 65 | self.scroll_rext = scrolledtext.ScrolledText(self.window, height=self.scrolled_height, width=self.scrolled_width) 66 | 67 | self.bt_black_start = tk.Button(self.window, text="執黑開始", command=lambda : self.start_new_game(BLACK)) 68 | self.bt_black_start.place(x=self.buttons_x[0], y=self.buttons_y[0]) 69 | 70 | self.bt_white_start = tk.Button(self.window, text="執白開始", command=lambda : self.start_new_game(WHITE)) 71 | self.bt_white_start.place(x=self.buttons_x[1], y=self.buttons_y[1]) 72 | 73 | self.bt_self_play = tk.Button(self.window, text="電腦自戰", command=lambda : self.start_new_game()) 74 | self.bt_self_play.place(x=self.buttons_x[2], y=self.buttons_y[2]) 75 | 76 | self.bt_pass_start = tk.Button(self.window, text="虛手", command=lambda : self.acquire_move(PASS)) 77 | self.bt_pass_start.place(x=self.buttons_x[3], y=self.buttons_y[3]) 78 | 79 | self.draw_canvas(self.canvas_x, self.canvas_y) 80 | self.draw_scroll_text(self.scrolled_x, self.scrolled_y) 81 | 82 | def draw_canvas(self, x, y): 83 | bsize = self.board.board_size 84 | square_size = self.canvas_size / bsize 85 | lower = square_size/2 86 | upper = self.canvas_size - square_size/2 87 | 88 | for i in range(bsize): 89 | offset = i * square_size 90 | self.canvas.create_line(lower ,lower+offset, upper , lower+offset) 91 | self.canvas.create_line(lower+offset ,lower , lower+offset, upper) 92 | self.canvas.place(x=x, y=y) 93 | 94 | def draw_scroll_text(self, x, y): 95 | self.scroll_rext.place(x=x, y=y) 96 | 97 | def insert_scroll_text(self, string): 98 | self.scroll_rext.insert(tk.END, string+'\n') 99 | self.scroll_rext.see(tk.END) 100 | self.scroll_rext.update() 101 | 102 | def reset_canvas(self): 103 | self.clear_board() 104 | self.canvas.delete("all") 105 | self.scroll_rext.delete(1.0, tk.END) 106 | self.draw_canvas(self.canvas_x, self.canvas_y) 107 | self.canvas.bind("", self.scan_move) 108 | self.rect = None 109 | 110 | def draw_stone(self, to_move, rc_pos, move_num=None): 111 | r, c = rc_pos 112 | x, y = self.convert_rc_to_xy(rc_pos) 113 | 114 | bsize = self.board.board_size 115 | square_size = self.canvas_size/bsize 116 | 117 | color_stone = "black" if to_move == BLACK else "white" 118 | color_index = "white" if to_move == BLACK else "black" 119 | color_border = "#696969" if to_move == BLACK else "black" 120 | 121 | 122 | radius = max(square_size/2 - 5, 15) 123 | border = max(round(radius/15), 2) 124 | self.oval_buffer[self.board.get_index(r, c)] = self.canvas.create_oval( 125 | x-radius, y-radius, x+radius, y+radius, 126 | fill=color_stone, outline=color_border, width=border) 127 | if self.rect == None: 128 | offset = max(square_size/2 , 20) 129 | self.rect = self.canvas.create_rectangle(x-offset, y-offset, x+offset, y+offset, outline="#c1005d") 130 | self.rect_xy_pos = (x, y) 131 | else: 132 | rc_pos = self.convert_xy_to_rc((x, y)) 133 | old_x, old_y = self.rect_xy_pos 134 | new_x, new_y = self.convert_rc_to_xy(rc_pos) 135 | dx, dy = new_x-old_x, new_y-old_y 136 | self.canvas.move(self.rect, dx, dy) 137 | self.rect_xy_pos = (new_x, new_y) 138 | 139 | text_size = round(1*square_size/2) 140 | if move_num == None: 141 | move_num = str() 142 | 143 | self.text_buffer[self.board.get_index(r,c)] = self.canvas.create_text(x,y, text=str(move_num), fill=color_index, font=('Arial', text_size)) 144 | self.canvas.update() 145 | 146 | def convert_rc_to_xy(self, rc_pos): 147 | bsize = self.board.board_size 148 | square_size = self.canvas_size/bsize 149 | lower = square_size/2 150 | 151 | r, c = rc_pos 152 | 153 | x = c*square_size + lower 154 | y = r*square_size + lower 155 | return x, y 156 | 157 | def convert_xy_to_rc(self, xy_pos): 158 | bsize = self.board.board_size 159 | square_size = self.canvas_size/bsize 160 | lower = square_size/2 161 | 162 | x, y = xy_pos 163 | r = round((y-lower)/square_size) 164 | c = round((x-lower)/square_size) 165 | return r, c 166 | 167 | def start_new_game(self, color=None): 168 | self.suspend = True # stop the board updating. 169 | 170 | self.acquire_vtx = None 171 | self.turns = ["compute", "compute"] 172 | if color != None: 173 | self.turns[color] = "player" 174 | self.reset_canvas() 175 | self.game_over = False 176 | 177 | if self.game_thread == None: 178 | # Create one game if we don't do it. 179 | self.game_thread = Thread(target=self.process_game,) 180 | self.game_thread.setDaemon(True) 181 | self.game_thread.start() 182 | 183 | self.suspend = False # start the game. 184 | 185 | def process_game(self): 186 | resignd = None 187 | 188 | while True: 189 | # Short sleep in order to avoid busy running. 190 | time.sleep(0.1) 191 | 192 | if self.suspend or self.game_over: 193 | continue 194 | 195 | to_move = self.board.to_move 196 | move_num = self.board.move_num 197 | 198 | if self.turns[to_move] == "compute": 199 | move = self.genmove("black" if to_move == BLACK else "white") 200 | 201 | vtx = self.board.last_move 202 | if move == "resign": 203 | vtx = RESIGN 204 | resignd = to_move 205 | 206 | if move == "pass": 207 | self.insert_scroll_text("電腦虛手") 208 | 209 | if vtx != PASS or vtx != RESIGN: 210 | self.update_canvas(vtx, to_move, move_num+1) 211 | 212 | # Dump the search verbose. 213 | if self.args.verbose: 214 | self.insert_scroll_text(self.last_verbose) 215 | self.acquire_vtx = None 216 | else: 217 | if self.acquire_vtx != None: 218 | if self.acquire_vtx == PASS: 219 | self.board.play(PASS) 220 | self.canvas.delete(self.rect) 221 | else: 222 | self.board.play(self.acquire_vtx) 223 | self.update_canvas(self.acquire_vtx, to_move, move_num+1) 224 | self.acquire_vtx = None 225 | 226 | if resignd != None: 227 | if resignd == BLACK: 228 | self.insert_scroll_text("黑棋投降") 229 | else: 230 | self.insert_scroll_text("白棋投降") 231 | resignd = None 232 | self.game_over = True 233 | self.network.clear_cache() 234 | elif self.board.num_passes >= 2: 235 | score = self.board.final_score() 236 | if abs(score) <= 0.01: 237 | self.insert_scroll_text("和局") 238 | elif score > 0: 239 | self.insert_scroll_text("黑勝{}目".format(score)) 240 | elif score < 0: 241 | self.insert_scroll_text("白勝{}目".format(-score)) 242 | self.game_over = True 243 | self.network.clear_cache() 244 | 245 | def update_canvas(self, vtx, to_move, move_num): 246 | # Update the board canvas. 247 | 248 | r = self.board.get_x(vtx) 249 | c = self.board.get_y(vtx) 250 | self.draw_stone(to_move, (r,c)) 251 | 252 | if self.board.removed_cnt != 0: 253 | curr = len(self.board.history) - 1 254 | post_state = self.board.history[curr-1] 255 | for v in range(len(post_state)): 256 | if self.board.state[v] == EMPTY and post_state[v] != EMPTY: 257 | self.canvas.delete(self.oval_buffer[self.board.vertex_to_index(v)]) 258 | self.canvas.delete(self.text_buffer[self.board.vertex_to_index(v)]) 259 | 260 | def scan_move(self, event): 261 | # Acquire a move after the player click the board. 262 | 263 | x, y = event.x, event.y 264 | r, c = self.convert_xy_to_rc((x, y)) 265 | 266 | if r < 0 or r >= self.board.board_size: 267 | return 268 | 269 | if c < 0 or c >= self.board.board_size: 270 | return 271 | 272 | self.acquire_move(self.board.get_vertex(r,c)) 273 | 274 | def acquire_move(self, vtx): 275 | # Set acquire move if the move is legal. 276 | 277 | if self.board.legal(vtx): 278 | self.acquire_vtx = vtx 279 | -------------------------------------------------------------------------------- /img/alphago_zero_mcts.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/alphago_zero_mcts.jpg -------------------------------------------------------------------------------- /img/dlgo_vs_leela.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/dlgo_vs_leela.gif -------------------------------------------------------------------------------- /img/loss.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/loss.gif -------------------------------------------------------------------------------- /img/loss_plot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/loss_plot.png -------------------------------------------------------------------------------- /img/mcts.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/mcts.png -------------------------------------------------------------------------------- /img/overfitting.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/overfitting.png -------------------------------------------------------------------------------- /img/policy_value.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/policy_value.gif -------------------------------------------------------------------------------- /img/puct.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/puct.gif -------------------------------------------------------------------------------- /img/sabaki-analysis.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/sabaki-analysis.png -------------------------------------------------------------------------------- /img/score_board.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/score_board.png -------------------------------------------------------------------------------- /img/screenshot_sabaki_01.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/screenshot_sabaki_01.png -------------------------------------------------------------------------------- /img/screenshot_sabaki_02.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/screenshot_sabaki_02.png -------------------------------------------------------------------------------- /img/screenshot_sabaki_03.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/screenshot_sabaki_03.png -------------------------------------------------------------------------------- /img/shortcut.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/shortcut.png -------------------------------------------------------------------------------- /img/ucb.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/img/ucb.gif -------------------------------------------------------------------------------- /mcts.py: -------------------------------------------------------------------------------- 1 | from board import Board, PASS, RESIGN, BLACK, WHITE 2 | from network import Network 3 | from time_control import TimeControl 4 | 5 | from sys import stderr, stdout, stdin 6 | import math 7 | import time 8 | import select 9 | 10 | class Node: 11 | C_PUCT = 0.5 # The PUCT hyperparameter. This value should be 1.25 in 12 | # AlphaGo Zero. However our value range is 1 ~ 0, not 1 ~ -1. 13 | # So we rescale this value as 0.5 (LeelaZero use it). 14 | def __init__(self, p): 15 | self.policy = p # The network raw policy from its parents node. 16 | self.nn_eval = 0 # The network raw eval from this node. 17 | 18 | self.values = 0 # The accumulation winrate. 19 | self.visits = 0 # The accumulation node visits. 20 | # The Q value must be equal to (self.values / self.visits) 21 | self.children = dict() # Next node. 22 | 23 | def clamp(self, v): 24 | # Map the winrate 1 ~ -1 to 1 ~ 0. 25 | return (v + 1) / 2 26 | 27 | def inverse(self, v): 28 | # Swap the side to move winrate. 29 | return 1 - v 30 | 31 | def expand_children(self, board: Board, network: Network): 32 | if board.last_move == PASS: 33 | score = board.final_score() 34 | if (board.to_move == BLACK and score > 0) or \ 35 | (board.to_move == WHITE and score < 0): 36 | # Play pass move if we win the game. 37 | self.children[PASS] = Node(1.0) 38 | return 1; 39 | 40 | # Compute the net results. 41 | policy, value = network.get_outputs(board.get_features()) 42 | 43 | for idx in range(board.num_intersections): 44 | vtx = board.index_to_vertex(idx) 45 | 46 | # Remove the all illegal move. 47 | if board.legal(vtx): 48 | p = policy[idx] 49 | self.children[vtx] = Node(p) 50 | 51 | # The pass move is alwaly the legal move. We don't need to 52 | # check it. 53 | self.children[PASS] = Node(policy[board.num_intersections]) 54 | 55 | # The nn eval is side-to-move winrate. 56 | self.nn_eval = self.clamp(value[0]) 57 | 58 | return self.nn_eval 59 | 60 | def remove_superko(self, board: Board): 61 | # Remove all superko moves. 62 | 63 | remove_list = list() 64 | for vtx, _ in self.children.items(): 65 | if vtx != PASS: 66 | next_board = board.copy() 67 | next_board.play(vtx) 68 | if next_board.superko(): 69 | remove_list.append(vtx) 70 | for vtx in remove_list: 71 | self.children.pop(vtx) 72 | 73 | def puct_select(self): 74 | parent_visits = max(self.visits, 1) # The parent visits must great than 1 because we want to get the 75 | # best policy value if it is the first selection. 76 | numerator = math.sqrt(parent_visits) 77 | puct_list = list() 78 | 79 | # Select the best node by PUCT algorithm. 80 | for vtx, child in self.children.items(): 81 | q_value = 0 # init to lose 82 | 83 | if child.visits != 0: 84 | q_value = self.inverse(child.values / child.visits) 85 | 86 | puct = q_value + self.C_PUCT * child.policy * (numerator / (1+child.visits)) 87 | puct_list.append((puct, vtx)) 88 | return max(puct_list)[1] 89 | 90 | def update(self, v): 91 | self.values += v 92 | self.visits += 1 93 | 94 | def get_best_prob_move(self): 95 | gather_list = list() 96 | for vtx, child in self.children.items(): 97 | gather_list.append((child.policy, vtx)) 98 | return max(gather_list)[1] 99 | 100 | def get_best_move(self, resign_threshold): 101 | # Return best probability move if there are no playouts. 102 | if self.visits == 1: 103 | if resign_threshold is not None and \ 104 | self.values < resign_threshold: 105 | return RESIGN 106 | else: 107 | return self.get_best_prob_move() 108 | 109 | # Get best move by number of node visits. 110 | gather_list = list() 111 | for vtx, child in self.children.items(): 112 | gather_list.append((child.visits, vtx)) 113 | 114 | vtx = max(gather_list)[1] 115 | child = self.children[vtx] 116 | 117 | # Play resin move if we think we have already lost. 118 | if resign_threshold is not None and \ 119 | self.inverse(child.values / child.visits) < resign_threshold: 120 | return RESIGN 121 | return vtx 122 | 123 | def to_string(self, board: Board): 124 | # Collect some node information in order to debug. 125 | 126 | out = str() 127 | out += "Root -> W: {:5.2f}%, V: {}\n".format( 128 | 100.0 * self.values/self.visits, 129 | self.visits) 130 | 131 | gather_list = list() 132 | for vtx, child in self.children.items(): 133 | gather_list.append((child.visits, vtx)) 134 | gather_list.sort(reverse=True) 135 | 136 | for _, vtx in gather_list: 137 | child = self.children[vtx] 138 | if child.visits != 0: 139 | out += " {:4} -> W: {:5.2f}%, P: {:5.2f}%, V: {}\n".format( 140 | board.vertex_to_text(vtx), 141 | 100.0 * self.inverse(child.values/child.visits), 142 | 100.0 * child.policy, 143 | child.visits) 144 | return out 145 | 146 | def get_pv(self, board: Board, pv_str): 147 | # Get the best Principal Variation list since this 148 | # node. 149 | if len(self.children) == 0: 150 | return pv_str 151 | 152 | next_vtx = self.get_best_move(None) 153 | next = self.children[next_vtx] 154 | pv_str += "{} ".format(board.vertex_to_text(next_vtx)) 155 | return next.get_pv(board, pv_str) 156 | 157 | def to_lz_analysis(self, board: Board): 158 | # Output the leela zero analysis string. Watch the detail 159 | # here: https://github.com/SabakiHQ/Sabaki/blob/master/docs/guides/engine-analysis-integration.md 160 | out = str() 161 | 162 | gather_list = list() 163 | for vtx, child in self.children.items(): 164 | gather_list.append((child.visits, vtx)) 165 | gather_list.sort(reverse=True) 166 | 167 | if len(gather_list) == 0: 168 | return str() 169 | 170 | i = 0 171 | for _, vtx in gather_list: 172 | child = self.children[vtx] 173 | if child.visits != 0: 174 | winrate = self.inverse(child.values/child.visits) 175 | prior = child.policy 176 | lcb = winrate 177 | order = i 178 | pv = "{} ".format(board.vertex_to_text(vtx)) 179 | out += "info move {} visits {} winrate {} prior {} lcb {} order {} pv {}".format( 180 | board.vertex_to_text(vtx), 181 | child.visits, 182 | round(10000 * winrate), 183 | round(10000 * prior), 184 | round(10000 * lcb), 185 | order, 186 | child.get_pv(board, pv)) 187 | i+=1 188 | out += '\n' 189 | return out 190 | 191 | 192 | 193 | # TODO: The MCTS performance is bad. Maybe the recursive is much 194 | # slower than loop. Or self.children do too many times mapping 195 | # operator. Try to fix it. 196 | class Search: 197 | def __init__(self, board: Board, network: Network, time_control: TimeControl): 198 | self.root_board = board # Root board positions, all simulation boards will fork from it. 199 | self.root_node = None # Root node, start the PUCT search from it. 200 | self.network = network 201 | self.time_control = time_control 202 | self.analysis_tag = { 203 | "interval" : -1 204 | } 205 | 206 | def _prepare_root_node(self): 207 | # Expand the root node first. 208 | self.root_node = Node(1) 209 | val = self.root_node.expand_children(self.root_board, self.network) 210 | 211 | # In order to avoid overhead, we only remove the superko positions in 212 | # the root. 213 | self.root_node.remove_superko(self.root_board) 214 | self.root_node.update(val) 215 | 216 | def _descend(self, color, curr_board, node): 217 | value = None 218 | if curr_board.num_passes >= 2: 219 | # The game is over. Compute the final score. 220 | score = curr_board.final_score() 221 | if score > 1e-4: 222 | # The black player is winner. 223 | value = 1 if color is BLACK else 0 224 | elif score < -1e-4: 225 | # The white player is winner. 226 | value = 1 if color is WHITE else 0 227 | else: 228 | # The game is draw 229 | value = 0.5 230 | elif len(node.children) != 0: 231 | # Select the next node by PUCT algorithm. 232 | vtx = node.puct_select() 233 | curr_board.to_move = color 234 | curr_board.play(vtx) 235 | color = (color + 1) % 2 236 | next_node = node.children[vtx] 237 | 238 | # go to the next node. 239 | value = self._descend(color, curr_board, next_node) 240 | else: 241 | # This is the termainated node. Now try to expand it. 242 | value = node.expand_children(curr_board, self.network) 243 | 244 | assert value != None, "" 245 | node.update(value) 246 | 247 | return node.inverse(value) 248 | 249 | def ponder(self, playouts, verbose): 250 | if self.root_board.num_passes >= 2: 251 | return str() 252 | 253 | analysis_clock = time.time() 254 | interval = self.analysis_tag["interval"] 255 | 256 | # Try to expand the root node first. 257 | self._prepare_root_node() 258 | 259 | for p in range(playouts): 260 | if p != 0 and \ 261 | interval > 0 and \ 262 | time.time() - analysis_clock > interval: 263 | analysis_clock = time.time() 264 | stdout.write(self.root_node.to_lz_analysis(self.root_board)) 265 | stdout.flush() 266 | 267 | rlist, _, _ = select.select([stdin], [], [], 0) 268 | if rlist: 269 | break 270 | 271 | # Copy the root board because we need to simulate the current board. 272 | curr_board = self.root_board.copy() 273 | color = curr_board.to_move 274 | 275 | # Start the Monte Carlo tree search. 276 | self._descend(color, curr_board, self.root_node) 277 | 278 | # Always dump last tree stats for GUI, like Sabaki. 279 | if interval > 0 and \ 280 | self.root_node.visits > 1: 281 | stdout.write(self.root_node.to_lz_analysis(self.root_board)) 282 | stdout.flush() 283 | 284 | out_verbose = self.root_node.to_string(self.root_board) 285 | if verbose: 286 | # Dump verbose to stderr because we want to debug it on GTP 287 | # interface(sabaki). 288 | stderr.write(out_verbose) 289 | stderr.write("\n") 290 | stderr.flush() 291 | 292 | return out_verbose 293 | 294 | def think(self, playouts, resign_threshold, verbose): 295 | # Get the best move with Monte carlo tree. The time controller and max playouts limit 296 | # the search. More thinking time or playouts is stronger. 297 | 298 | if self.root_board.num_passes >= 2: 299 | return PASS, str() 300 | 301 | analysis_clock = time.time() 302 | interval = self.analysis_tag["interval"] 303 | self.time_control.clock() 304 | if verbose: 305 | stderr.write(str(self.time_control)) 306 | stderr.write("\n") 307 | stderr.flush() 308 | 309 | # Prepare some basic information. 310 | to_move = self.root_board.to_move 311 | bsize = self.root_board.board_size 312 | move_num = self.root_board.move_num 313 | 314 | # Compute thinking time limit. 315 | max_time = self.time_control.get_thinking_time(to_move, bsize, move_num) 316 | 317 | # Try to expand the root node first. 318 | self._prepare_root_node() 319 | 320 | for p in range(playouts): 321 | if p != 0 and \ 322 | interval > 0 and \ 323 | time.time() - analysis_clock > interval: 324 | analysis_clock = time.time() 325 | stdout.write(self.root_node.to_lz_analysis(self.root_board)) 326 | stdout.flush() 327 | 328 | if self.time_control.should_stop(max_time): 329 | break 330 | 331 | # Copy the root board because we need to simulate the current board. 332 | curr_board = self.root_board.copy() 333 | color = curr_board.to_move 334 | 335 | # Start the Monte Carlo tree search. 336 | self._descend(color, curr_board, self.root_node) 337 | 338 | # Eat the remaining time. 339 | self.time_control.took_time(to_move) 340 | 341 | # Always dump last tree stats for GUI, like Sabaki. 342 | if interval > 0 and \ 343 | self.root_node.visits > 1: 344 | stdout.write(self.root_node.to_lz_analysis(self.root_board)) 345 | stdout.flush() 346 | 347 | out_verbose = self.root_node.to_string(self.root_board) 348 | if verbose: 349 | # Dump verbose to stderr because we want to debug it on GTP 350 | # interface(sabaki). 351 | stderr.write(out_verbose) 352 | stderr.write(str(self.time_control)) 353 | stderr.write("\n") 354 | stderr.flush() 355 | 356 | return self.root_node.get_best_move(resign_threshold), out_verbose 357 | -------------------------------------------------------------------------------- /network.py: -------------------------------------------------------------------------------- 1 | import torch 2 | import torch.nn as nn 3 | import torch.nn.functional as F 4 | 5 | from config import * 6 | 7 | class FullyConnect(nn.Module): 8 | def __init__(self, in_size, 9 | out_size, 10 | relu=True): 11 | super().__init__() 12 | self.relu = relu 13 | self.linear = nn.Linear(in_size, out_size) 14 | 15 | def forward(self, x): 16 | x = self.linear(x) 17 | return F.relu(x, inplace=True) if self.relu else x 18 | 19 | class ConvBlock(nn.Module): 20 | def __init__(self, in_channels, 21 | out_channels, 22 | kernel_size, 23 | relu=True): 24 | super().__init__() 25 | 26 | assert kernel_size in (1, 3) 27 | self.relu = relu 28 | self.conv = nn.Conv2d( 29 | in_channels, 30 | out_channels, 31 | kernel_size, 32 | padding="same", 33 | bias=True, 34 | ) 35 | self.bn = nn.BatchNorm2d( 36 | out_channels, 37 | eps=1e-5 38 | ) 39 | 40 | nn.init.kaiming_normal_(self.conv.weight, 41 | mode="fan_out", 42 | nonlinearity="relu") 43 | def forward(self, x): 44 | x = self.conv(x) 45 | x = self.bn(x) 46 | return F.relu(x, inplace=True) if self.relu else x 47 | 48 | class ResBlock(nn.Module): 49 | def __init__(self, channels, se_size=None): 50 | super().__init__() 51 | self.with_se=False 52 | self.channels=channels 53 | 54 | self.conv1 = ConvBlock( 55 | in_channels=channels, 56 | out_channels=channels, 57 | kernel_size=3 58 | ) 59 | self.conv2 = ConvBlock( 60 | in_channels=channels, 61 | out_channels=channels, 62 | kernel_size=3, 63 | relu=False 64 | ) 65 | 66 | if se_size != None: 67 | self.with_se = True 68 | self.avg_pool = nn.AdaptiveAvgPool2d(1) 69 | self.squeeze = FullyConnect( 70 | in_size=channels, 71 | out_size=se_size, 72 | relu=True 73 | ) 74 | self.excite = FullyConnect( 75 | in_size=se_size, 76 | out_size=2 * channels, 77 | relu=False 78 | ) 79 | 80 | def forward(self, x): 81 | identity = x 82 | 83 | out = self.conv1(x) 84 | out = self.conv2(out) 85 | 86 | if self.with_se: 87 | b, c, _, _ = out.size() 88 | seprocess = self.avg_pool(out) 89 | seprocess = torch.flatten(seprocess, start_dim=1, end_dim=3) 90 | seprocess = self.squeeze(seprocess) 91 | seprocess = self.excite(seprocess) 92 | 93 | gammas, betas = torch.split(seprocess, self.channels, dim=1) 94 | gammas = torch.reshape(gammas, (b, c, 1, 1)) 95 | betas = torch.reshape(betas, (b, c, 1, 1)) 96 | out = torch.sigmoid(gammas) * out + betas 97 | 98 | out += identity 99 | 100 | return F.relu(out, inplace=True) 101 | 102 | 103 | class Network(nn.Module): 104 | def __init__(self, board_size, 105 | input_channels=INPUT_CHANNELS, 106 | block_size=BLOCK_SIZE, 107 | block_channels=BLOCK_CHANNELS, 108 | policy_channels=POLICY_CHANNELS, 109 | value_channels=VALUE_CHANNELS, 110 | use_se=USE_SE, 111 | use_gpu=USE_GPU): 112 | super().__init__() 113 | 114 | self.nn_cache = {} 115 | 116 | self.block_size = block_size 117 | self.residual_channels = block_channels 118 | self.policy_channels = policy_channels 119 | self.value_channels = value_channels 120 | self.value_layers = 256 121 | self.board_size = board_size 122 | self.spatial_size = self.board_size ** 2 123 | self.input_channels = input_channels 124 | self.use_se = use_se 125 | self.use_gpu = True if torch.cuda.is_available() and use_gpu else False 126 | self.gpu_device = torch.device("cpu") 127 | 128 | if self.use_se: 129 | assert self.residual_channels // 2 == 0, "BLOCK_CHANNELS must be divided by 2." 130 | 131 | self.construct_layers() 132 | if self.use_gpu: 133 | self.gpu_device = torch.device("cuda") 134 | self.to_gpu_device() 135 | 136 | def to_gpu_device(self): 137 | self = self.to(self.gpu_device) 138 | 139 | def construct_layers(self): 140 | self.input_conv = ConvBlock( 141 | in_channels=self.input_channels, 142 | out_channels=self.residual_channels, 143 | kernel_size=3, 144 | relu=True 145 | ) 146 | 147 | # residual tower 148 | self.residual_tower = nn.ModuleList() 149 | for s in range(self.block_size): 150 | se_size = self.residual_channels // 2 if self.use_se else None 151 | self.residual_tower.append( 152 | ResBlock(self.residual_channels, se_size)) 153 | 154 | # policy head 155 | self.policy_conv = ConvBlock( 156 | in_channels=self.residual_channels, 157 | out_channels=self.policy_channels, 158 | kernel_size=1, 159 | relu=True 160 | ) 161 | self.policy_fc = FullyConnect( 162 | in_size=self.policy_channels * self.spatial_size, 163 | out_size=self.spatial_size + 1, 164 | relu=False 165 | ) 166 | 167 | # value head 168 | self.value_conv = ConvBlock( 169 | in_channels=self.residual_channels, 170 | out_channels=self.value_channels, 171 | kernel_size=1, 172 | relu=True 173 | ) 174 | 175 | self.value_fc = FullyConnect( 176 | in_size=self.value_channels * self.spatial_size, 177 | out_size=self.value_layers, 178 | relu=True 179 | ) 180 | self.winrate_fc = FullyConnect( 181 | in_size=self.value_layers, 182 | out_size=1, 183 | relu=False 184 | ) 185 | 186 | def forward(self, planes): 187 | x = self.input_conv(planes) 188 | 189 | # residual tower 190 | for block in self.residual_tower: 191 | x = block(x) 192 | 193 | # policy head 194 | pol = self.policy_conv(x) 195 | pol = self.policy_fc(torch.flatten(pol, start_dim=1, end_dim=3)) 196 | 197 | # value head 198 | val = self.value_conv(x) 199 | val = self.value_fc(torch.flatten(val, start_dim=1, end_dim=3)) 200 | val = self.winrate_fc(val) 201 | 202 | return pol, torch.tanh(val) 203 | 204 | @torch.no_grad() 205 | def get_outputs(self, planes): 206 | # TODO: Limit the NN cache size. 207 | 208 | h = hash(planes.tostring()) 209 | res = self.nn_cache.get(h) # search the NN computation 210 | 211 | if res is not None: 212 | p, v = res 213 | return p, v 214 | 215 | m = nn.Softmax(dim=1) 216 | x = torch.unsqueeze(torch.tensor(planes, dtype=torch.float32), dim=0) 217 | if self.use_gpu: 218 | x = x.to(self.gpu_device) 219 | p, v = self.forward(x) 220 | p, v = m(p).data.tolist()[0], v.data.tolist()[0] 221 | 222 | self.nn_cache[h] = (p, v) # save the NN computation 223 | 224 | return p, v 225 | 226 | def clear_cache(self): 227 | self.nn_cache.clear() 228 | 229 | def trainable(self, t=True): 230 | torch.set_grad_enabled(t) 231 | if t==True: 232 | self.train() 233 | else: 234 | self.eval() 235 | 236 | def save_pt(self, filename): 237 | torch.save(self.state_dict(), filename) 238 | 239 | def load_pt(self, filename): 240 | self.load_state_dict( 241 | torch.load(filename, map_location=self.gpu_device, weights_only=True) 242 | ) 243 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | torch 2 | torchvision 3 | torchaudio 4 | numpy 5 | tk 6 | matplotlib 7 | -------------------------------------------------------------------------------- /sgf.py: -------------------------------------------------------------------------------- 1 | import glob, os, argparse 2 | from board import BLACK, WHITE, EMPTY, INVLD 3 | 4 | class SgfParser: 5 | def __init__(self, sgf_string): 6 | self.history = list() 7 | self.black_player = str() 8 | self.white_player = str() 9 | self.winner = INVLD 10 | self.board_size = None 11 | self.komi = None 12 | self._parse(sgf_string) 13 | 14 | def _process_key_value(self, key, val): 15 | def as_move(m, bsize=self.board_size): 16 | if len(m) == 0 or m == "tt": 17 | return None 18 | x = ord(m[0]) - ord('a') 19 | y = ord(m[1]) - ord('a') 20 | y = bsize - 1 - y 21 | return (x, y) 22 | 23 | if key == "SZ": 24 | self.board_size = int(val) 25 | elif key == "KM": 26 | self.komi = float(val) 27 | elif key == "B": 28 | self.history.append((BLACK, as_move(val))) 29 | elif key == "W": 30 | self.history.append((WHITE, as_move(val))) 31 | elif key == "PB": 32 | self.black_player = val 33 | elif key == "PW": 34 | self.white_player = val 35 | elif key == "AB" or key == "AW": 36 | raise Exception("Do not support for AB/AW tag in the SGF file.") 37 | elif key == "RE": 38 | if "B+" in val: 39 | self.winner = BLACK 40 | elif "W+" in val: 41 | self.winner = WHITE 42 | elif val == "0": 43 | self.winner = EMPTY 44 | else: 45 | self.winner = INVLD 46 | 47 | def _parse(self, sgf): 48 | nesting = 0 49 | idx = 0 50 | node_cnt = 0 51 | key = str() 52 | while idx < len(sgf): 53 | c = sgf[idx] 54 | idx += 1; 55 | 56 | if c == '(': 57 | nesting += 1 58 | elif c == ')': 59 | nesting -= 1 60 | 61 | if c in ['(', ')', '\t', '\n', '\r'] or nesting != 1: 62 | continue 63 | elif c == ';': 64 | node_cnt += 1 65 | elif c == '[': 66 | end = sgf.find(']', idx) 67 | val = sgf[idx:end] 68 | self._process_key_value(key, val) 69 | key = str() 70 | idx = end+1 71 | else: 72 | key += c 73 | 74 | def _load_file(filename): 75 | try: 76 | with open(filename, "r") as f: 77 | data = f.read().strip() 78 | except Exception as e: 79 | print(e) 80 | return None 81 | return data 82 | 83 | def chop_sgfs_string(sgfs_string): 84 | sgfs_list = list() 85 | sgfs_string = sgfs_string.strip() 86 | 87 | nesting = 0 88 | head_idx = 0 89 | tail_idx = 0 90 | while tail_idx < len(sgfs_string): 91 | c = sgfs_string[tail_idx] 92 | tail_idx += 1; 93 | 94 | if c == '(': 95 | if nesting == 0: 96 | head_idx = tail_idx - 1 97 | nesting += 1 98 | elif c == ')': 99 | nesting -= 1 100 | if nesting == 0: 101 | sgfs_list.append(sgfs_string[head_idx:tail_idx]) 102 | 103 | if c in ['(', ')', ';', '\t', '\n', '\r'] or nesting != 1: 104 | continue 105 | elif c == '[': 106 | end = sgfs_string.find(']', tail_idx) 107 | tail_idx = end + 1 108 | return sgfs_list 109 | 110 | def parse_from_dir(root): 111 | sgfs_files = list() 112 | sgfs_files.extend(glob.glob(os.path.join(root, "*.sgf"))) 113 | sgfs_files.extend(glob.glob(os.path.join(root, "*.sgfs"))) 114 | sgfs = list() 115 | for filename in sgfs_files: 116 | data = _load_file(filename) 117 | if data: 118 | sgfs_list = chop_sgfs_string(data) 119 | for sgf_string in sgfs_list: 120 | try: 121 | sgf = SgfParser(sgf_string) 122 | sgfs.append(sgf) 123 | except Exception as e: 124 | print(e) 125 | return sgfs 126 | 127 | if __name__ == "__main__": 128 | parser = argparse.ArgumentParser() 129 | parser.add_argument("-d", "--sgf-dir", metavar="", 130 | help="input SGF directory", type=str) 131 | args = parser.parse_args() 132 | 133 | try: 134 | sgfs = get_sgf_from_dir(args.sgf_dir) 135 | print("\nSuccessfuly parse every SGF string...") 136 | except Exception as e: 137 | print(e) 138 | -------------------------------------------------------------------------------- /sgf.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/CGLemon/pyDLGO/731792f82d9079aa033a84419627d7127db5f349/sgf.zip -------------------------------------------------------------------------------- /time_control.py: -------------------------------------------------------------------------------- 1 | import time 2 | 3 | class TimeControl: 4 | def __init__(self): 5 | self.main_time = 0 6 | self.byo_time = 7 * 24 * 60 * 60 # one week per move 7 | self.byo_stones = 1 8 | 9 | self.maintime_left = [0, 0] 10 | self.byotime_left = [0, 0] 11 | self.stones_left = [0, 0] 12 | self.in_byo = [False, False] 13 | 14 | self.clock_time = time.time() 15 | self.reset() 16 | 17 | def check_in_byo(self): 18 | self.in_byo[0] = True if self.maintime_left[0] <= 0 else False 19 | self.in_byo[1] = True if self.maintime_left[1] <= 0 else False 20 | 21 | def reset(self): 22 | self.maintime_left = [self.main_time] * 2 23 | self.byotime_left = [self.byo_time] * 2 24 | self.stones_left = [self.byo_stones] * 2 25 | self.check_in_byo() 26 | 27 | def time_settings(self, main_time, byo_time, byo_stones): 28 | self.main_time = main_time 29 | self.byo_time = byo_time 30 | self.byo_stones = byo_stones 31 | self.reset() 32 | 33 | def time_left(self, color, time, stones): 34 | if stones == 0: 35 | self.maintime_left[color] = time 36 | else: 37 | self.maintime_left[color] = 0 38 | self.byotime_left[color] = time 39 | self.stones_left[color] = stones 40 | self.check_in_byo() 41 | 42 | def clock(self): 43 | self.clock_time = time.time() 44 | 45 | def took_time(self, color): 46 | remaining_took_time = time.time() - self.clock_time 47 | if not self.in_byo[color]: 48 | if self.maintime_left[color] > remaining_took_time: 49 | self.maintime_left[color] -= remaining_took_time 50 | remaining_took_time = -1 51 | else: 52 | remaining_took_time -= self.maintime_left[color] 53 | self.maintime_left[color] = 0 54 | self.in_byo[color] = True 55 | 56 | if self.in_byo[color] and remaining_took_time > 0: 57 | self.byotime_left[color] -= remaining_took_time 58 | self.stones_left[color] -= 1 59 | if self.stones_left[color] == 0: 60 | self.stones_left[color] = self.byo_stones 61 | self.byotime_left[color] = self.byo_time 62 | 63 | def get_thinking_time(self, color, board_size, move_num): 64 | estimate_moves_left = max(4, int(board_size * board_size * 0.4) - move_num) 65 | lag_buffer = 1 # Remaining some time for network hiccups or GUI lag 66 | remaining_time = self.maintime_left[color] + self.byotime_left[color] - lag_buffer 67 | if self.byo_stones == 0: 68 | return remaining_time / estimate_moves_left 69 | return remaining_time / self.stones_left[color] 70 | 71 | def should_stop(self, max_time): 72 | elapsed = time.time() - self.clock_time 73 | return elapsed > max_time 74 | 75 | def get_timeleft_string(self, color): 76 | out = str() 77 | if not self.in_byo[color]: 78 | out += "{s} sec".format( 79 | s=int(self.maintime_left[color])) 80 | else: 81 | out += "{s} sec, {c} stones".format( 82 | s=int(self.byotime_left[color]), 83 | c=self.stones_left[color]) 84 | return out 85 | 86 | def __str__(self): 87 | return "".join(["Black: ", 88 | self.get_timeleft_string(0), 89 | " | White: ", 90 | self.get_timeleft_string(1)]) 91 | -------------------------------------------------------------------------------- /train.py: -------------------------------------------------------------------------------- 1 | from network import Network 2 | from config import BOARD_SIZE, INPUT_CHANNELS 3 | from board import Board, PASS, BLACK, WHITE, EMPTY, INVLD, NUM_INTESECTIONS 4 | 5 | import sgf, argparse 6 | import copy, time, os, shutil, glob 7 | import numpy as np 8 | import matplotlib.pyplot as plt 9 | 10 | import torch 11 | import torch.nn as nn 12 | import torch.optim as optim 13 | 14 | CACHE_TRAIN_DIR = "tdata-cache" 15 | CACHE_VALID_DIR = "vdata-cache" 16 | 17 | def gather_filenames(dirname): 18 | def gather_recursive_files(root): 19 | l = list() 20 | for name in glob.glob(os.path.join(root, "*")): 21 | if os.path.isdir(name): 22 | l.extend(gather_recursive_files(name)) 23 | else: 24 | l.append(name) 25 | return l 26 | return gather_recursive_files(root=dirname) 27 | 28 | def get_currtime(): 29 | lt = time.localtime(time.time()) 30 | return "{y}-{m}-{d} {h:02d}:{mi:02d}:{s:02d}".format( 31 | y=lt.tm_year, m=lt.tm_mon, d=lt.tm_mday, h=lt.tm_hour, mi=lt.tm_min, s=lt.tm_sec) 32 | 33 | def get_weights_name(prefix): 34 | return "{}-{}.pt".format(prefix, get_currtime().replace(":", "-").replace(" ", "-")) 35 | 36 | class Data: 37 | def __init__(self): 38 | self.inputs = None # should be numpy array, shape is [INPUT_CHANNELS, BOARD_SIZE, BOARD_SIZE] 39 | self.policy = None # should be integer, range is 0 ~ NUM_INTESECTIONS 40 | self.value = None # should be float, range is -1 ~ 1 41 | self.to_move = None 42 | 43 | def _get_symmetry_plane(self, symm, plane): 44 | use_flip = False 45 | if symm // 4 != 0: 46 | use_flip = True 47 | symm = symm % 4 48 | 49 | transformed = np.rot90(plane, symm) 50 | 51 | if use_flip: 52 | transformed = np.flip(transformed, 1) 53 | return transformed 54 | 55 | def do_symmetry(self, symm=None): 56 | assert self.policy != None, "" 57 | 58 | if symm is None: 59 | symm = int(np.random.choice(8, 1)[0]) 60 | 61 | for i in range(INPUT_CHANNELS-2): # last 2 channels is side to move. 62 | p = self.inputs[i] 63 | self.inputs[i][:][:] = self._get_symmetry_plane(symm, p)[:][:] 64 | 65 | if self.policy != NUM_INTESECTIONS: 66 | buf = np.zeros(NUM_INTESECTIONS) 67 | buf[self.policy] = 1 68 | buf = self._get_symmetry_plane(symm, np.reshape(buf, (BOARD_SIZE, BOARD_SIZE))) 69 | self.policy = int(np.argmax(buf)) 70 | 71 | def from_npfile(self, filename): 72 | npdata = np.load(filename) 73 | self.inputs = npdata["i"] 74 | self.policy = npdata["p"][0] 75 | self.value = npdata["v"][0] 76 | self.to_move = npdata["t"][0] 77 | 78 | class Dataset(torch.utils.data.Dataset): 79 | def __init__(self, source_dir, num_virtual_samples=None): 80 | self.filenames = gather_filenames(source_dir) 81 | self.num_virtual_samples = num_virtual_samples \ 82 | if num_virtual_samples is not None else len(self.filenames) 83 | 84 | def __len__(self): 85 | return self.num_virtual_samples 86 | 87 | def __getitem__(self, i): 88 | current_idx = i % len(self.filenames) 89 | data = Data() 90 | data.from_npfile(self.filenames[current_idx]) 91 | data.do_symmetry() 92 | 93 | inputs = torch.tensor(data.inputs).float() 94 | policy = torch.tensor(data.policy).long() 95 | value = torch.tensor([data.value]).float() 96 | return inputs, policy, value 97 | 98 | # Load the SGF files and save the training data to the disk. 99 | class DataChopper: 100 | def __init__(self, dir_name, num_sgfs): 101 | self.num_data = 0 102 | self._chop_data(dir_name, num_sgfs) 103 | 104 | def __del__(self): 105 | # Do not delete the training data in the cache dir. We may 106 | # use them next time. 107 | pass 108 | 109 | def _chop_data(self, dir_name, num_sgfs): 110 | # Load the SGF files and tranfer them to training data. 111 | sgf_games = sgf.parse_from_dir(dir_name) 112 | total_games = min(len(sgf_games), num_sgfs) 113 | 114 | print("imported {} SGF files".format(total_games)) 115 | 116 | if os.path.isdir(CACHE_TRAIN_DIR): 117 | shutil.rmtree(CACHE_TRAIN_DIR, ignore_errors=True) 118 | os.makedirs(CACHE_TRAIN_DIR) 119 | 120 | if os.path.isdir(CACHE_VALID_DIR): 121 | shutil.rmtree(CACHE_VALID_DIR, ignore_errors=True) 122 | os.makedirs(CACHE_VALID_DIR) 123 | 124 | for s in range(total_games): 125 | game = sgf_games[s] 126 | buf = self._process_one_game(game) 127 | 128 | if (s+1) % (max(1, total_games//100)) == 0: 129 | print("parsed {:.2f}% games".format(100 * (s+1)/total_games)) 130 | self._save_data(buf) 131 | print("done! parsed {:.2f}% games".format(100)) 132 | 133 | def _save_data(self, buf): 134 | size = len(buf) 135 | 136 | for i in range(size): 137 | # Allocate data buffer 138 | inputs_buf = np.zeros((INPUT_CHANNELS, BOARD_SIZE, BOARD_SIZE), dtype=np.int8) 139 | policy_buf = np.zeros((1), dtype=np.int32) 140 | value_buf = np.zeros((1), dtype=np.float32) 141 | to_move_buf = np.zeros((1), dtype=np.int8) 142 | 143 | # Fill the data buffer. 144 | data = buf[i] 145 | inputs_buf[:] = data.inputs[:] 146 | policy_buf[:] = data.policy 147 | value_buf[:] = data.value 148 | to_move_buf[:] = data.to_move 149 | 150 | # Save the date on disk. 151 | use_valid = int(np.random.choice(10, 1)[0]) == 0 152 | if use_valid: 153 | filename = os.path.join(CACHE_VALID_DIR, "data_{}.npz".format(self.num_data)) 154 | else: 155 | filename = os.path.join(CACHE_TRAIN_DIR, "data_{}.npz".format(self.num_data)) 156 | np.savez_compressed(filename, i=inputs_buf, p=policy_buf, v=value_buf, t=to_move_buf) 157 | self.num_data += 1 158 | 159 | def _process_one_game(self, game): 160 | # Collect training data from one SGF game. 161 | 162 | if game.board_size is not BOARD_SIZE: 163 | return list() 164 | 165 | temp = list() 166 | winner = game.winner 167 | board = Board(BOARD_SIZE) 168 | 169 | for color, move in game.history: 170 | data = Data() 171 | data.inputs = board.get_features() 172 | data.to_move = color 173 | if move: 174 | x, y = move 175 | data.policy = board.get_index(x, y) 176 | board.play(board.get_vertex(x, y)) 177 | else: 178 | data.policy = board.num_intersections 179 | board.play(PASS) 180 | temp.append(data) 181 | 182 | for data in temp: 183 | if winner == EMPTY: 184 | data.value = 0 185 | elif winner == data.to_move: 186 | data.value = 1 187 | elif winner != data.to_move: 188 | data.value = -1 189 | return temp 190 | 191 | def plot_loss(record): 192 | if len(record) <= 1: 193 | return 194 | 195 | p_running_loss = [] 196 | v_running_loss = [] 197 | step = [] 198 | for (s, p, v) in record: 199 | p_running_loss.append(p) 200 | v_running_loss.append(v) 201 | step.append(s) 202 | 203 | y_upper = max(max(p_running_loss), max(v_running_loss)) 204 | 205 | plt.plot(step, p_running_loss, label="policy loss") 206 | plt.plot(step, v_running_loss, label="value loss") 207 | plt.ylabel("loss") 208 | plt.xlabel("steps") 209 | plt.ylim([0, y_upper * 1.1]) 210 | plt.legend() 211 | plt.show() 212 | 213 | def load_checkpoint(network, optimizer, workspace): 214 | filenames = gather_filenames(workspace) 215 | if len(filenames) == 0: 216 | return network, optimizer, 0 217 | 218 | filenames.sort(key=os.path.getmtime, reverse=True) 219 | last_pt = filenames[0] 220 | 221 | state_dict = torch.load(last_pt, map_location=network.gpu_device, weights_only=True) 222 | network.load_state_dict(state_dict["network"]) 223 | optimizer.load_state_dict(state_dict["optimizer"]) 224 | steps = state_dict["steps"] 225 | return network, optimizer, steps 226 | 227 | def save_checkpoint(network, optimizer, steps, workspace): 228 | state_dict = dict() 229 | state_dict["network"] = network.state_dict() 230 | state_dict["optimizer"] = optimizer.state_dict() 231 | state_dict["steps"] = steps 232 | torch.save(state_dict, os.path.join(workspace, "checkpoint-s{}.pt".format(steps))) 233 | 234 | def training_process(args): 235 | # Set the network. Will push on GPU device later if it is 236 | # available. 237 | network = Network(BOARD_SIZE) 238 | network.trainable(True) 239 | 240 | # SGD instead of Adam. Seemd the SGD performance 241 | # is better than Adam. 242 | optimizer = optim.SGD(network.parameters(), 243 | lr=args.learning_rate, 244 | momentum=0.9, 245 | nesterov=True, 246 | weight_decay=1e-3) 247 | if not os.path.isdir(args.workspace): 248 | os.mkdir(args.workspace) 249 | network, optimizer, steps = load_checkpoint(network, optimizer, args.workspace) 250 | cross_entry = nn.CrossEntropyLoss() 251 | mse_loss = nn.MSELoss() 252 | 253 | if args.dir is not None: 254 | data_chopper = DataChopper( 255 | args.dir, 256 | args.imported_games 257 | ) 258 | 259 | # Leave two cores for training pipe. 260 | num_workers = max(min(os.cpu_count(), 16) - 2 , 1) \ 261 | if args.num_workers is None else max(args.num_workers, 1) 262 | 263 | print("Use {n} workers for loader.".format(n=num_workers)) 264 | 265 | data_loader = torch.utils.data.DataLoader( 266 | dataset=Dataset(CACHE_TRAIN_DIR, args.batch_size * args.steps), 267 | batch_size=args.batch_size, 268 | shuffle=True, 269 | num_workers=num_workers 270 | ) 271 | 272 | print("Start training..."); 273 | 274 | # init some basic parameters 275 | p_running_loss = 0 276 | v_running_loss = 0 277 | max_steps = steps + args.steps 278 | running_loss_record = [] 279 | clock_time = time.time() 280 | 281 | for _, batch in enumerate(data_loader): 282 | if args.lr_decay_steps is not None: 283 | learning_rate = optimizer.param_groups[0]["lr"] 284 | if (steps+1) % args.lr_decay_steps == 0: 285 | print("Drop the learning rate from {} to {}.".format( 286 | learning_rate, 287 | learning_rate * args.lr_decay_factor 288 | )) 289 | learning_rate = learning_rate * args.lr_decay_factor 290 | for param in optimizer.param_groups: 291 | param["lr"] = learning_rate 292 | 293 | # First, get the batch data. 294 | inputs, target_p, target_v = batch 295 | 296 | # Second, Move the data to GPU memory if we use it. 297 | if network.use_gpu: 298 | inputs = inputs.to(network.gpu_device) 299 | target_p = target_p.to(network.gpu_device) 300 | target_v = target_v.to(network.gpu_device) 301 | 302 | # Third, compute the network result. 303 | p, v = network(inputs) 304 | 305 | # Fourth, compute the loss result and update network. 306 | p_loss = cross_entry(p, target_p) 307 | v_loss = mse_loss(v, target_v) 308 | loss = p_loss + args.value_loss_scale * v_loss 309 | 310 | optimizer.zero_grad() 311 | loss.backward() 312 | optimizer.step() 313 | 314 | # Accumulate running loss. 315 | p_running_loss += p_loss.item() 316 | v_running_loss += v_loss.item() 317 | 318 | # Fifth, dump training verbose. 319 | if (steps+1) % args.verbose_steps == 0: 320 | elapsed = time.time() - clock_time 321 | rate = args.verbose_steps/elapsed 322 | remaining_steps = max_steps - steps 323 | estimate_remaining_time = int(remaining_steps/rate) 324 | print("[{}] steps: {}/{}, {:.2f}% -> policy loss: {:.4f}, value loss: {:.4f} | rate: {:.2f}(steps/sec), estimate: {}(sec)".format( 325 | get_currtime(), 326 | steps+1, 327 | max_steps, 328 | 100 * ((steps+1)/max_steps), 329 | p_running_loss/args.verbose_steps, 330 | v_running_loss/args.verbose_steps, 331 | rate, 332 | estimate_remaining_time)) 333 | running_loss_record.append( 334 | (steps+1, p_running_loss/args.verbose_steps, v_running_loss/args.verbose_steps)) 335 | p_running_loss = 0 336 | v_running_loss = 0 337 | save_checkpoint(network, optimizer, steps+1, args.workspace) 338 | clock_time = time.time() 339 | steps += 1 340 | 341 | print("Training is over."); 342 | if not args.noplot: 343 | # Sixth plot the running loss graph. 344 | plot_loss(running_loss_record) 345 | network.save_pt(get_weights_name("weights")) 346 | 347 | if __name__ == "__main__": 348 | parser = argparse.ArgumentParser() 349 | parser.add_argument("-d", "--dir", metavar="", 350 | help="The input SGF files directory. Will use data cache if set None.", type=str) 351 | parser.add_argument("-s", "--steps", metavar="", 352 | help="Terminate after these steps for each run.", type=int, required=True) 353 | parser.add_argument("-v", "--verbose-steps", metavar="", 354 | help="Dump verbose and save checkpoint every X steps.", type=int, default=1000) 355 | parser.add_argument("-b", "--batch-size", metavar="", 356 | help="The batch size number.", type=int, required=True) 357 | parser.add_argument("-l", "--learning-rate", metavar="", 358 | help="The learning rate.", type=float, required=True) 359 | parser.add_argument("-w", "--workspace", metavar="", default="workspace", 360 | help="Will save the checkpoint here.", type=str) 361 | parser.add_argument("-i", "--imported-games", metavar="", 362 | help="The max number of imported games.", type=int, default=10240000) 363 | parser.add_argument("--noplot", action="store_true", 364 | help="Disable plotting.", default=False) 365 | parser.add_argument("--lr-decay-steps", metavar="", 366 | help="Reduce the learning rate every X steps.", type=int, default=None) 367 | parser.add_argument("--lr-decay-factor", metavar="", 368 | help="The learning rate decay multiple factor.", type=float, default=0.1) 369 | parser.add_argument("--value-loss-scale", metavar="", 370 | help="Scaling factor of value loss. Default is 0.25 based on AlphaGo paper.", type=float, default=0.25) 371 | parser.add_argument("--num-workers", metavar="", 372 | help="Select a specific number of workerer for DataLoader.", type=int, default=None) 373 | 374 | args = parser.parse_args() 375 | training_process(args) 376 | -------------------------------------------------------------------------------- /validate.py: -------------------------------------------------------------------------------- 1 | from network import Network 2 | from config import BOARD_SIZE 3 | from board import NUM_INTESECTIONS 4 | 5 | import argparse 6 | import torch 7 | import torch.nn as nn 8 | from train import CACHE_VALID_DIR, DataChopper, Dataset 9 | 10 | def report_stats(total, total_samples, correct_policy, total_value_loss): 11 | policy_acc = correct_policy / total if total > 0 else 0 12 | value_loss = total_value_loss / total if total > 0 else 0 13 | print(f"[{total}/{total_samples}] Policy Acc: {100 * policy_acc:.2f}% | Value MSE: {value_loss:.4f}") 14 | 15 | @torch.no_grad() 16 | def validate(args): 17 | # Prepare the validation dataset. 18 | if args.dir is not None: 19 | DataChopper(args.dir, args.imported_games) 20 | 21 | dataset = Dataset(CACHE_VALID_DIR) 22 | dataloader = torch.utils.data.DataLoader( 23 | dataset, batch_size=args.batch_size, shuffle=False) 24 | 25 | # Load the model. 26 | network = Network(BOARD_SIZE) 27 | network.trainable(False) 28 | if args.weights is not None: 29 | network.load_pt(args.weights) 30 | else: 31 | raise ValueError("Please specify --weights") 32 | 33 | # Validation loop. 34 | total = 0 35 | correct_policy = 0 36 | total_value_loss = 0.0 37 | mse_loss = nn.MSELoss(reduction='sum') 38 | 39 | total_samples = len(dataset) 40 | 41 | for idx, (inputs, policy, value) in enumerate(dataloader): 42 | inputs = inputs.to(network.gpu_device) 43 | policy = policy.to(network.gpu_device) 44 | value = value.to(network.gpu_device) 45 | pred_policy, pred_value = network(inputs) 46 | # policy: take the index of the maximum value 47 | pred_policy_idx = torch.argmax(pred_policy, dim=1) 48 | correct_policy += (pred_policy_idx == policy).sum().item() 49 | # value: MSE 50 | total_value_loss += mse_loss(pred_value.squeeze(), value.squeeze()).item() 51 | total += inputs.size(0) 52 | 53 | if idx % 10 == 0: 54 | report_stats(total, total_samples, correct_policy, total_value_loss) 55 | report_stats(total, total_samples, correct_policy, total_value_loss) 56 | 57 | if __name__ == "__main__": 58 | parser = argparse.ArgumentParser() 59 | parser.add_argument("-d", "--dir", metavar="", 60 | help="The input SGF files directory. Will use data cache if set None.", type=str, default=None) 61 | parser.add_argument("-w", "--weights", metavar="", 62 | help="The weights file name.", type=str, required=True) 63 | parser.add_argument("-b", "--batch-size", metavar="", 64 | help="The batch size number.", type=int, default=256) 65 | parser.add_argument("-i", "--imported-games", metavar="", 66 | help="The max number of imported games.", type=int, default=10240000) 67 | args = parser.parse_args() 68 | validate(args) --------------------------------------------------------------------------------