barak/tim-the-enchanter
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

pep8

Browse source
This commit is contained in:
Barak Michener 2013-07-26 23:01:48 -04:00
parent 9a5e14b884
commit e77323d8a1
1 changed files with 104 additions and 104 deletions
Download patch file Download diff file Expand all files Collapse all files

208
tim.py
View file

@ -6,135 +6,135 @@ import pprint
def ResistanceGame(n_players): def ResistanceGame(n_players):
full_set = [("G1", True), ("G2", True), ("G3", True), ("E1", False), ("E2", False), full_set = [("G1", True), ("G2", True), ("G3", True),
("G4", True), ("E3", False), ("G5", True), ("G6", True), ("E4", False)] ("E1", False), ("E2", False), ("G4", True),
return full_set[:n_players] ("E3", False), ("G5", True), ("G6", True), ("E4", False)]
return full_set[:n_players]
class DeceptionGame(object): class DeceptionGame(object):
def __init__(self, player_array): def __init__(self, player_array):
self.player_array = player_array self.player_array = player_array
self.all_permutations = list(itertools.permutations(player_array)) self.all_permutations = list(itertools.permutations(player_array))
self.deck_var = mc.DiscreteUniform("deal", 0, len(self.all_permutations) - 1) self.deck_var = mc.DiscreteUniform("deal", 0,
self.n_players = len(player_array) len(self.all_permutations) - 1)
self.model = None self.n_players = len(player_array)
self.model = None
self.player_alliance_vars = []
self.player_role_vars = []
self.role_ids = {}
self.role_alliance = {}
i = 0
self.player_alliance_vars = [] for card in player_array:
self.player_role_vars = [] role, good = card
self.role_ids = {} self.role_ids[role] = i
self.role_alliance = {} self.role_alliance[i] = good
i = 0 i += 1
for card in player_array: def player_alliance(x, role):
role, good = card return self.role_alliance[role]
self.role_ids[role] = i
self.role_alliance[i] = good
i += 1
def player_alliance(x, role): def player_role(x, deck_var=self.deck_var):
return self.role_alliance[role] role_str = self.all_permutations[deck_var][x][0]
return self.role_ids[role_str]
def player_role(x, deck_var = self.deck_var): for x in range(self.n_players):
role_str = self.all_permutations[deck_var][x][0] role = mc.Deterministic(eval=functools.partial(player_role, x),
return self.role_ids[role_str] name="player_role_%d" % x,
parents={"deck_var": self.deck_var},
doc="Who is player %d?" % x,
dtype=str,
trace=True,
plot=False)
self.player_role_vars.append(role)
for x in range(self.n_players): alliance = mc.Deterministic(eval=functools.partial(
role = mc.Deterministic(eval = functools.partial(player_role, x), player_alliance, x),
name = "player_role_%d" % x, name="player_alliance_%d" % x,
parents = { "deck_var" : self.deck_var }, parents={"role": role},
doc = "Who is player %d?" % x, doc="Is player %d good?" % x,
dtype = str, dtype=bool,
trace = True, trace=True,
plot = False) plot=False)
self.player_role_vars.append(role)
alliance = mc.Deterministic(eval = functools.partial(player_alliance, x), self.player_alliance_vars.append(alliance)
name = "player_alliance_%d" % x,
parents = { "role" : role},
doc = "Is player %d good?" % x,
dtype = bool,
trace = True,
plot = False)
self.player_alliance_vars.append(alliance) self.observations = []
self.tid = 0
self.observations = [] def add_known_alliance(self, player_id, is_good):
self.tid = 0 transaction = []
obs = mc.Bernoulli("player_seen_tid%d" % self.tid,
self.player_alliance_vars[player_id],
value=is_good,
observed=True)
transaction.append(obs)
self.observations.append(transaction)
self.tid += 1
def add_known_alliance(self, player_id, is_good): def add_known_role(self, player_id, role_str):
transaction = [] transaction = []
obs = mc.Bernoulli("player_seen_tid%d" % self.tid, obs = mc.Bernoulli("player_seen_role_tid%d" % self.tid,
self.player_alliance_vars[player_id], self.player_role_vars[player_id],
value = is_good, value=self.role_ids[role_str],
observed = True) observed=True)
transaction.append(obs) transaction.append(obs)
self.observations.append(transaction) self.observations.append(transaction)
self.tid += 1 self.tid += 1
def add_known_role(self, player_id, role_str): def eval(self, length=40000):
transaction = [] mcmc = mc.MCMC(self._build_model_list())
obs = mc.Bernoulli("player_seen_role_tid%d" % self.tid, mcmc.sample(length, 2000)
self.player_role_vars[player_id], self.model = mcmc
value = self.role_ids[role_str],
observed = True)
transaction.append(obs)
self.observations.append(transaction)
self.tid += 1
def report(self):
if self.model is None:
self.eval()
out = []
for i in range(self.n_players):
out.append(self.get_player_data(i))
return out
def eval(self, length=40000): def get_player_data(self, i):
mcmc = mc.MCMC(self._build_model_list()) out = {}
mcmc.sample(length, 2000) role_key = "player_role_%d" % i
self.model = mcmc alliance_key = "player_alliance_%d" % i
def report(self): temp_role = self._aggregate(list(self.model.trace(role_key)))
if self.model is None: out["role"] = {}
self.eval() for k, v in temp_role.iteritems():
out = [] out["role"][self.player_array[int(k)][0]] = v
for i in range(self.n_players): out["alliance"] = self._aggregate(list(self.model.trace(alliance_key)))
out.append(self.get_player_data(i)) return out
return out
def get_player_data(self, i): def _aggregate(self, l):
out = {} out = dd(float)
role_key = "player_role_%d" % i size = len(l) * 1.0
alliance_key = "player_alliance_%d" % i for x in l:
out[x] += 1 / size
return dict(out)
temp_role = self._aggregate(list(self.model.trace(role_key))) def print_report(self):
out["role"] = {} pp = pprint.PrettyPrinter(indent=4)
for k, v in temp_role.iteritems(): pp.pprint(self.report())
out["role"][self.player_array[int(k)][0]] = v
out["alliance"] = self._aggregate(list(self.model.trace(alliance_key)))
return out
def _aggregate(self, l): def _build_model_list(self):
out = dd(float) out = []
size = len(l) * 1.0 out.append(self.deck_var)
for x in l: out.extend(self.player_alliance_vars[:])
out[x] += 1 / size out.extend(self.player_role_vars[:])
return dict(out) flattened = [item for transaction in self.observations
for item in transaction]
out.extend(flattened[:])
def print_report(self): return list(set(out))
pp = pprint.PrettyPrinter(indent = 4)
pp.pprint(self.report())
def _build_model_list(self):
out = []
out.append(self.deck_var)
out.extend(self.player_alliance_vars[:])
out.extend(self.player_role_vars[:])
flattened = [item for transaction in self.observations for item in transaction]
out.extend(flattened[:])
return list(set(out))
base_game = DeceptionGame(ResistanceGame(5)) base_game = DeceptionGame(ResistanceGame(5))
base_game.eval(10000) base_game.eval(20000)
base_game.add_known_role(0, "G1") base_game.add_known_role(0, "G1")
base_game.add_known_alliance(1, False) base_game.add_known_alliance(1, False)
base_game.eval() base_game.eval()
base_game.print_report() base_game.print_report()