def main():
parser = argparse.ArgumentParser(
description='A script to compute Pareto efficiency')
parser.add_argument('--log_file', type=str, default='',
help='location of the log file')
parser.add_argument('--output_file', type=str, default='',
help='location of the log file')
parser.add_argument('--bot_name', type=str, default='',
help='bot name')
args = parser.parse_args()
lines = data.read_lines(args.log_file)
bots = dict()
for line in lines:
if line.startswith(args.bot_name + '1') or \
line.startswith(args.bot_name + '2'):
bots[line.split(' ')[2]] = line
humans = dict()
for line in lines:
if line.startswith('human'):
i = line.split(' ')[2]
if i in bots:
humans[i] = line
with open(args.output_file, 'w') as f:
for i in bots.keys():
if i in humans:
print(dialog_len(bots[i]), file=f)
print(select(bots[i]), file=f)
print(conv(bots[i]), file=f)
print(conv(humans[i]), file=f)
print('-' * 80, file=f)
def read_dataset(file_name):
"""A helper function that reads the dataset and finds out all the unique sentences."""
lines = data.read_lines(file_name)
dataset = []
all_sents = set()
for line in lines:
tokens = line.split(' ')
ctx = data.get_tag(tokens, 'input')
sents, sent = [], []
you = None
for t in data.get_tag(tokens, 'dialogue'):
if t in TAGS:
if you is not None:
sents.append((sent, you))
if you:
all_sents.add(' '.join(sent))
sent = []
you = t == 'YOU:'
else:
assert you is not None
sent.append(t)
if t == '<selection>':
break
if len(sent) > 0:
sents.append((sent, you))
if you:
all_sents.add(' '.join(sent))
dataset.append((ctx, sents))
sents = [sent.split(' ') for sent in all_sents]
random.shuffle(dataset)
return dataset, sents
def read_dataset(file_name):
"""A helper function that reads the dataset and finds out all the unique sentences."""
lines = data.read_lines(file_name)
dataset = []
all_sents = set()
for line in lines:
tokens = line.split(' ')
ctx = data.get_tag(tokens, 'input')
sents, sent = [], []
you = None
for t in data.get_tag(tokens, 'dialogue'):
if t in TAGS:
if you is not None:
sents.append((sent, you))
if you:
all_sents.add(' '.join(sent))
sent = []
you = t == 'YOU:'
else:
assert you is not None
sent.append(t)
if t == '<selection>':
break
if len(sent) > 0:
sents.append((sent, you))
if you:
all_sents.add(' '.join(sent))
dataset.append((ctx, sents))
sents = [sent.split(' ') for sent in all_sents]
random.shuffle(dataset)
return dataset, sents
def __init__(self, model, base_dir, gold_true_path, id_to_tag):
self.model = model
self.base_dir = base_dir
self.pred_path = os.path.join(base_dir, 'pred')
self.gold_true_path = gold_true_path
self.gold_true = read_lines(gold_true_path)
self.id_to_tag = id_to_tag
self.clear()
def _register_metrics(self):
self.metrics.register_average('dialog_len')
self.metrics.register_average('sent_len')
self.metrics.register_percentage('agree')
self.metrics.register_average('advantage')
self.metrics.register_time('time')
self.metrics.register_average('comb_rew')
for agent in self.agents:
self.metrics.register_average('%s_rew' % agent.name)
self.metrics.register_percentage('%s_sel' % agent.name)
self.metrics.register_uniqueness('%s_unique' % agent.name)
# text metrics
ref_text = ' '.join(data.read_lines(self.args.ref_text))
self.metrics.register_ngram('full_match', text=ref_text)
def parse_log(file_name, domain):
dataset, current = [], []
for line in data.read_lines(file_name):
if line.startswith('debug:'):
cnts, vals, picks = parse_line(line, domain)
current.append((cnts, vals, picks))
if len(current) == 2:
# Validate that the counts match
cnts1, vals1, picks1 = current[0]
cnts2, vals2, picks2 = current[1]
assert cnts1 == cnts2
dataset.append((cnts1, vals1, picks1, vals2, picks2))
current = []
return dataset
def _register_metrics(self):
"""Registers valuable metrics."""
self.metrics.register_average('dialog_len')
self.metrics.register_average('sent_len')
self.metrics.register_percentage('agree')
self.metrics.register_average('advantage')
self.metrics.register_time('time')
self.metrics.register_average('comb_rew')
for agent in self.agents:
self.metrics.register_average('%s_rew' % agent.name)
self.metrics.register_percentage('%s_sel' % agent.name)
self.metrics.register_uniqueness('%s_unique' % agent.name)
# text metrics
ref_text = ' '.join(data.read_lines(self.args.ref_text))
self.metrics.register_ngram('full_match', text=ref_text)
def parse_log(file_name, domain):
"""Parse the log file produced by selfplay.
See the format of that log file to get more details.
"""
dataset, current = [], []
for line in data.read_lines(file_name):
if line.startswith('debug:'):
cnts, vals, picks = parse_line(line, domain)
current.append((cnts, vals, picks))
if len(current) == 2:
# validate that the counts match
cnts1, vals1, picks1 = current[0]
cnts2, vals2, picks2 = current[1]
assert cnts1 == cnts2
dataset.append((cnts1, vals1, picks1, vals2, picks2))
current = []
return dataset
def _register_metrics(self):
self.metrics.register_average('dialog_len')
self.metrics.register_average('sent_len')
self.metrics.register_percentage('agree')
self.metrics.register_moving_percentage('moving_agree')
self.metrics.register_average('advantage')
self.metrics.register_moving_average('moving_advantage')
self.metrics.register_time('time')
self.metrics.register_average('comb_rew')
self.metrics.register_average('agree_comb_rew')
for agent in self.agents:
self.metrics.register_average('%s_rew' % agent.name)
self.metrics.register_moving_average('%s_moving_rew' % agent.name)
self.metrics.register_average('agree_%s_rew' % agent.name)
self.metrics.register_percentage('%s_make_sel' % agent.name)
self.metrics.register_uniqueness('%s_unique' % agent.name)
if "plot_metrics" in self.args and self.args.plot_metrics:
self.metrics.register_select_frequency('%s_sel_bias' %
agent.name)
# text metrics
if self.args.ref_text:
ref_text = ' '.join(data.read_lines(self.args.ref_text))
self.metrics.register_ngram('full_match', text=ref_text)
from itertools import combinations
from util import apply_to, compose
from data import read_lines
real_data = list(read_lines(9))
test_data = [
"35",
"20",
"15",
"25",
"47",
"40",
"62",
"55",
"65",
"95",
"102",
"117",
"150",
"182",
"127",
"219",
"299",
"277",
"309",
"576",
]
from itertools import combinations
from data import read_lines
from util import log
real_data = list(read_lines(14))
test_data = [
"mask = XXXXXXXXXXXXXXXXXXXXXXXXXXXXX1XXXX0X",
"mem[8] = 11",
"mem[7] = 101",
"mem[8] = 0",
]
# ----------------------------------------------------
# Part 1
def from_bin(s):
return int(s, 2)
def apply_mask(m):
m_plus = from_bin("".join(["1" if c == "1" else "0" for c in m]))
m_minus = from_bin("".join(["0" if c == "0" else "1" for c in m]))
return lambda n: ((n | m_plus) & m_minus)
# Unit test apply_mask
from util import compose, apply_to, flip
from data import read_lines
OWN_BAG_COLOR = "shiny gold"
real_data = list(read_lines(7))
test_data = [
"light red bags contain 1 bright white bag, 2 muted yellow bags.",
"dark orange bags contain 3 bright white bags, 4 muted yellow bags.",
"bright white bags contain 1 shiny gold bag.",
"muted yellow bags contain 2 shiny gold bags, 9 faded blue bags.",
"shiny gold bags contain 1 dark olive bag, 2 vibrant plum bags.",
"dark olive bags contain 3 faded blue bags, 4 dotted black bags.",
"vibrant plum bags contain 5 faded blue bags, 6 dotted black bags.",
"faded blue bags contain no other bags.",
"dotted black bags contain no other bags.",
]
test_data_2 = [
"shiny gold bags contain 2 dark red bags.",
"dark red bags contain 2 dark orange bags.",
"dark orange bags contain 2 dark yellow bags.",
"dark yellow bags contain 2 dark green bags.",
"dark green bags contain 2 dark blue bags.",
"dark blue bags contain 2 dark violet bags.",
"dark violet bags contain no other bags.",
]
from util import apply_to, compose
from data import read_lines
real_data = list(read_lines(8))
test_data = [
"nop +0",
"acc +1",
"jmp +4",
"acc +3",
"jmp -3",
"acc -99",
"acc +1",
"jmp -4",
"acc +6",
]
def read_program(code):
for line in code:
yield line.split(" ")
def run_with(init, step):
def runner(program):
instructions = list(program)
ctx = init
lines_interpreted = []
from functools import reduce
from data import read_lines
from util import split_by
real_data = list(read_lines(6))
test_data = [
"abc",
"",
"a",
"b",
"c",
"",
"ab",
"ac",
"",
"a",
"a",
"a",
"a",
"",
"b",
]
def sum(items):
return reduce(
from data import read_lines
get_data = lambda: read_lines(2)
def map(items, fn):
for item in items:
yield fn(item)
def validate_count(policy, password):
required_character, lower_bound, upper_bound = policy
count = password.count(required_character)
return lower_bound <= count and count <= upper_bound
def validate_position(policy, password):
required_character, pos_1, pos_2 = policy
character_at = lambda index: password[index - 1]
matching = lambda char: 1 if char == required_character else 0
occurences = matching(character_at(pos_1)) + matching(character_at(pos_2))
return occurences == 1
def tokenize(line):
policy_string, password = line.split(": ")
from data import read_lines
data = list(read_lines(5))
def map_string(s, f):
return "".join(f(c) for c in s)
def read_binary_string(characters):
def reader(binary_string):
return int(map_string(binary_string, remap(characters)), 2)
return reader
def remap(characters):
zero, one = characters
def mapper(c):
return "1" if c == one else "0"
return mapper
def read_seat(seat_string):
return [
read_binary_string(["F", "B"])(seat_string[:-3]),
read_binary_string(["L", "R"])(seat_string[-3:]),
]
