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),