def main(self): setLoggingEnabled(True) self.pullThread = threading.Thread(target=self.pollWork) self.pullThread.daemon = True self.pullThread.start() self.pushThread = threading.Thread(target=self.pushResults) self.pushThread.daemon = True self.pushThread.start() printNoWork = True while True: while len(self.workQueue) == 0: if printNoWork: logMsg("I have no work!") printNoWork = False time.sleep(0.05) printNoWork = True self.policy = self.policyUpdater.update(self.policy) nextWork = self.workQueue[0] rpack = self.doEvaluation(nextWork) self.resultsQueue.append(rpack) del self.workQueue[0]
def test_ExampleGames(self): """ provided examples should play out as expected """ prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) def playGameByMoves(moves): game = self.subject if prntVerbose: self.printGameWithTensor(game) for move in moves: if game.hasEnded(): break game = game.playMove(move) if prntVerbose: self.printGameWithTensor(game) return game examples = self.getExampleGameSequences() logMsg("\nPlaying", len(examples), "examples") for idx, (moves, expectedTurns, expectedWinner) in enumerate(examples): logMsg("Playing example game", idx) resultState = playGameByMoves(moves) self.assertEqual(resultState.getTurn(), expectedTurns) self.assertTrue(resultState.hasEnded()) self.assertEqual(resultState.getWinnerNumber(), expectedWinner)
def test_areExamplesEqual(self): prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) exampleA, exampleB = self.makeEqualExamples() batcher = self.subject.getExamplePrepareObject() self.assertTrue(batcher.areExamplesEqual(exampleA, exampleB))
def test_fit(self): prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) # we just make up some target data for learning games = self.getRandomGameStates() reports = [] policyUUID = str(uuid.uuid4()) for gidx, game in enumerate(games): reports.append(self.packageGameAsFrame(game, gidx, policyUUID)) prevUUID = self.subject.getUUID() preparedReports = [ self.subject.prepareExample(report) for report in reports ] for e in range(250): self.subject.fit( self.subject.packageExamplesBatch(preparedReports), e, 1) self.assertNotEqual(prevUUID, self.subject.getUUID()) forwards = self.forwardToLists(games) for ridx, report in enumerate(reports): winnerIndex = report["knownResults"][0] moveIndex = np.argmax(report["policyIterated"]) forward = forwards[ridx] self.assertEqual(np.argmax(forward[0]), moveIndex) self.assertEqual(np.argmax(forward[1]), winnerIndex)
def measureFrametime(configPath, idx, run): setproctitle.setproctitle("x0_fe_worker_" + str(idx)) startTime = time.monotonic() core = loadMlConfig(configPath) setLoggingEnabled(True) worker = core.worker(recursive=True) worker.initSelfplay(run) times = [] exs = [] ns = [] for _ in range(BATCH_COUNT): tx, ex, n = worker.playBatch() times.append(tx) exs.append(ex) ns.append(n) while time.monotonic() - startTime < MIN_TIME: tx, ex, n = worker.playBatch() times.append(tx) exs.append(ex) ns.append(n) if not None in exs: logMsg("Avg number of mcts nodes used by playBatch(): ", np.mean(exs)) return np.mean(times), np.sum(ns)
def mlConfigBasedMain(configPath): setLoggingEnabled(True) registerClasses() logMsg("Running", *sys.argv) config = mlconfig.load(configPath) return config
def test_HashFits(self): prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) exampleA, exampleB = self.makeEqualExamples() batcher = self.subject.getExamplePrepareObject() self.assertEqual(batcher.getHashForExample(exampleA), batcher.getHashForExample(exampleB))
def evaluateNetwork(self, onDataSet): setLoggingEnabled(False) tester = DatasetPolicyTester2( PolicyPlayer(self.policy, None, TemperatureMoveDecider(-1)), None, self.initialGame, onDataSet) result = tester.main() setLoggingEnabled(True) return result
def test_hashProperties(self): """ When playing random games there should be less than 20% hash collisions and at most 16 states that share a single hash in the generated states. """ prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) numTestGames = 250 states = map(lambda x: self.playRandomGame(x), range(numTestGames)) statesByHash = dict() uniqueStates = 0 oCnt = 0 allStates = [] worstLen = 0 worstHashValue = 0 for ss in states: for s in ss: allStates.append(s) oCnt += 1 h = hash(s) if not h in statesByHash: statesByHash[h] = [s] uniqueStates += 1 else: isKnownState = len( list(filter(lambda x: x == s, statesByHash[h]))) > 0 if not isKnownState: statesByHash[h].append(s) if len(statesByHash[h]) > worstLen: worstLen = len(statesByHash[h]) worstHashValue = h uniqueStates += 1 for aIdx in range(len(allStates)): for bIdx in range(aIdx + 1, len(allStates)): a = allStates[aIdx] b = allStates[bIdx] if a == b: self.assertEqual(hash(a), hash(b), "Equality must imply equal hash values") uniqueHashes = len(statesByHash) dupes = uniqueStates - uniqueHashes result = dupes / float(uniqueStates) logMsg("\nFound ", uniqueHashes, "unique hashs for", uniqueStates, "unique states. Overall ", oCnt, "moves played! Worst hash has", worstLen, "collisions, it is the hash number", worstHashValue) self.assertTrue(uniqueHashes <= uniqueStates) self.assertTrue(result < 0.2) self.assertTrue(worstLen < 17)
def test_loadStore(self): prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) games = self.getRandomGameStates() x = self.subject.store() forwards = self.forwardToLists(games) originalUUID = self.subject.getUUID() self.subject.reset() self.assertNotEqual(forwards, self.forwardToLists(games)) self.assertNotEqual(originalUUID, self.subject.getUUID()) self.subject.load(x) self.assertEqual(self.subject.getUUID(), originalUUID) self.assertEqual(forwards, self.forwardToLists(games))
def setUpClass(cls): prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) logMsg("Working with tests data in " + config["dataPath"]) with open(config["configFile"], "w") as f: json.dump(config, f) silence = subprocess.DEVNULL if prntVerbose: silence = None cls.process = subprocess.Popen([ "python", "-m", "core.mains.command", "--config", config["configFile"] ], stdout=silence, stderr=silence) # wait a moment so the process is started, 1 second should be plenty time.sleep(1.5)
def test_mergeInto(self): prntVerbose = ('-v' in sys.argv) or ('--verbose' in sys.argv) setLoggingEnabled(prntVerbose) exampleA, exampleB = self.makeEqualExamples() batcher = self.subject.getExamplePrepareObject() aMoves = exampleA[1] bMoves = exampleB[1] aWins = exampleA[2] bWins = exampleB[2] aMovesBefore = torch.clone(aMoves) aWinsBefore = torch.clone(aWins) batcher.mergeInto(exampleA, exampleB, 0.6) self.assertTrue( torch.equal(exampleA[1], aMovesBefore * 0.4 + 0.6 * exampleB[1])) self.assertTrue( torch.equal(exampleA[2], aWinsBefore * 0.4 + 0.6 * exampleB[2]))
def startProxy(secret, command, forPolicy=None): setproctitle.setproctitle("x0_players_proxy") setLoggingEnabled(True) app = falcon.API() app.add_route("/players/{runId}", ProxyResource(command, secret, forPolicy)) try: with make_server("127.0.0.1", 1337, app) as httpd: if forPolicy is None: logMsg("Started players_proxy!") else: logMsg("Started players_proxy for policy %s!" % forPolicy) httpd.serve_forever() except OSError as error: if error.errno == 98: #port in use logMsg( "Failed to start players_proxy, seems there is already one running!" ) else: raise error
# Not needed by this script directly, but in a distributed setting you likely use the DistributedReporter, which additionally needs: # --worker <worker-name> A self-play worker for linear or league self play. # --eval <worker-name> An evaluation worker meant for MCTS Tree self play. # --training spawns the trainer instead of the playing-worker # example calls # python -m core.mains.distributed --command 'http://127.0.0.1:8042' --secret 42 --run 'c8e187a0-de60-4251-b985-9b3464b831dd' --worker test1 # python -m core.mains.distributed --command https://x0.cclausen.eu --secret 42 --run '4cdf1719-ed90-455b-b9a0-ac3a5c7fbab5' --worker test1 # python -m core.mains.distributed --command https://x0.cclausen.eu --secret 42 --run '4cdf1719-ed90-455b-b9a0-ac3a5c7fbab5' --eval test1 # for the trainer it might be necessary to increase the open file limit: # ulimit -n 300000; python -m ... if __name__ == "__main__": setLoggingEnabled(True) setproctitle.setproctitle("x0_distributed_setup") hasArgs = ("--secret" in sys.argv) and ("--run" in sys.argv) and ("--command" in sys.argv) if not hasArgs: raise Exception( "You need to provide arguments for the distributed worker: --secret <server password>, --run <uuid> and --command <command server host>!" ) secret = sys.argv[sys.argv.index("--secret") + 1] run = sys.argv[sys.argv.index("--run") + 1] commandHost = sys.argv[sys.argv.index("--command") + 1]
def main(self): setLoggingEnabled(self.mode == "shell") return self.runTest()
return bestAccuracy class CombinedLogger(): def __init__(self, path): self.json = JSONLogger(path) self.console = ScreenLogger() def update(self, event, instance): self.json.update(event, instance) self.console.update(event, instance) if __name__ == "__main__": setproctitle.setproctitle("x0_hyperopt") setLoggingEnabled(False) pbounds = { #'blocks': (2, 4), #'filters': (32, 64), #'extraFilters': (4, 16), #'nodes': (20, 40), 'cpuct': (0.25, 6), #'rootNoise': (0.01, 0.5), 'drawValue': (0, 1), #'explorationPlyCount': (10, 40), 'fpu': (0, 1), #'lr': (0.0005, 0.005), #'wd': (0.00005, 0.001), #'windowSize': (100000, 250000), #'reportsPerIteration': (10000, 42000),