def solve_part_two(day_input: List[str]) -> str:
lst = convert(day_input)
# Same as part one, until getting the list of alergen possible ingredients
ingredients = set(flatten(line[0] for line in lst))
alergens = set(flatten(line[1] for line in lst))
alergen_ingredients: Dict[str, Set[str]] = \
dict(zip(alergens, [set(ingredients) for _ in range(len(alergens))]))
for line in lst:
for alerg in line[1]:
alergen_ingredients[alerg].intersection_update(line[0])
# Basic constraint propagation, again
constraints = [
alerg for alerg, ingr_lst in alergen_ingredients.items()
if len(ingr_lst) == 1
]
while (len(constraints) > 0):
alerg = constraints.pop()
ingr = next(iter(alergen_ingredients[alerg]))
for k, v in alergen_ingredients.items():
if k != alerg and ingr in v:
v.remove(ingr)
if len(v) == 1: # New constraint
constraints.append(k)
# Join the result. Lots of manipulations because the structure is somewhat complex
return ','.join(
[next(iter(v)) for _, v in sorted(alergen_ingredients.items())])
def solve_part_one(day_input: List[str]) -> int:
fields, _, tickets = convert(day_input)
# Invalid numbers aren't in any of the ranges
all_ranges = list(flatten(fields.values()))
res = (n for n in flatten(tickets) if not any(n in r for r in all_ranges))
return sum(res)
def sendRaw(self, *data):
"""
inputs:
data - characters or strings that get merged and sent over the
serial interface
outputs:
bool - returns True if the data was written; False otherwise
"""
byteString = "".join(common.flatten(data))
try:
bytesWritten = self.interface.write(byteString)
self.interface.flush() # Wait for the output to be written
if byteString and bytesWritten:
self.logger.log.debug("Successfully wrote serial data: {}". \
format(byteString))
return True
else:
self.logger.log.error("Did not write serial data: {}". \
format(byteString))
return False
except Exception as e:
self.logger.log.error("Got exception: {}". \
format(e))
self.logger.log.error("Did not write serial data: {}". \
format(byteString))
return False
def compute(data, results, correct_hash):
# Compute commitment
hashed_data = poseidon_hash(flatten(data))
[x.assert_eq(y) for (x, y) in zip(hashed_data, correct_hash)]
# Compute outputs
output = {}
for category in data:
num_pell = sum([i >= 10 for i in data[category]])
num_non_pell = sum([i < 10 for i in data[category]])
num_all = num_pell + num_non_pell
received_bachelors_pell = LinCombFxp(
sum([i == 11 for i in data[category]]))
different_institution_pell = LinCombFxp(
sum([i == 12 for i in data[category]]))
same_institution_pell = LinCombFxp(
sum([i == 13 for i in data[category]]))
received_bachelors_non_pell = LinCombFxp(
sum([i == 1 for i in data[category]]))
different_institution_non_pell = LinCombFxp(
sum([i == 2 for i in data[category]]))
same_institution_non_pell = LinCombFxp(
sum([i == 3 for i in data[category]]))
output[category] = {
"Pell": {
"Received Bachelor's":
received_bachelors_pell / num_pell,
"Enrolled at same institution":
same_institution_pell / num_pell,
"Enrolled at different insitution":
different_institution_pell / num_pell
},
"No Pell": {
"Received Bachelor's":
received_bachelors_non_pell / num_non_pell,
"Enrolled at same institution":
same_institution_non_pell / num_non_pell,
"Enrolled at different insitution":
different_institution_non_pell / num_non_pell
},
"All Students": {
"Received Bachelor's":
(received_bachelors_pell + received_bachelors_non_pell) /
num_all,
"Enrolled at same institution":
(same_institution_pell + same_institution_non_pell) / num_all,
"Enrolled at different insitution":
(different_institution_pell + different_institution_non_pell) /
num_all
}
}
for category in results:
for student_type in results[category]:
for outcome in results[category][student_type]:
output[category][student_type][outcome].assert_eq(
results[category][student_type][outcome])
def generate(self, target_file=None):
if self.components != []:
target_file = open(self.file_name, "w")
target_file.write('ASTRON HEADER\n')
target_file.write('INCLUDED LIBRARIES\n')
target_file.write('ENTITY DECLARATION\n')
target_file.write('ARCHITECTURE str OF %s IS\n' %self.name)
target_file.write('. CONSTANT DECLARATIONS\n')
# Get the signal declaration from each internal component's port object
for component in self.components:
for port_name, port in component.ports.iteritems():
target_file.write(port.signal.vhdl_signal_declaration)
target_file.write('BEGIN\n')
# Write this component's connections
for connection in cm.flatten(self.connections):
# print connection
target_file.write(connection.vhdl_assignment)
# Iterate through internal components
for component in self.components:
component.generate()
target_file.write(component.get_vhdl_instance())
target_file.write('END str\n')
target_file.close()
def uniqueAttribs(self, xpath):
"""Return a list of attributes that uniquely distinguish the element at each segment"""
acceptedAttribs = []
# select examples which contain the relevant xpath
docs = [doc for doc in self.docs() if doc.tree().xpath(str(xpath))]
for i, section in enumerate(xpath.walk()):
sectionElements = flatten([doc.tree().xpath(section) for doc in docs])
try:
siblingElements = flatten([[s for s in e.itersiblings() if s.tag == e.tag] for e in sectionElements])
except AttributeError:
pass
else:
siblingAttribs = flatten([self.extractAttribs(e) for e in siblingElements])
proposedAttribs = self.commonAttribs(sectionElements)
acceptedAttribs.append([a for a in proposedAttribs if a not in siblingAttribs])
return acceptedAttribs
def getModel(x, num_output, K, stages, wd, is_training, transfer_mode= False):
with tf.variable_scope('conv1'):
x = common.spatialConvolution(x, 3, 1, 2*K, wd= wd)
# x = common.batchNormalization(x, is_training= is_training)
# x = tf.nn.relu(x)
# x = common.maxPool(x, 3, 2)
print x
with tf.variable_scope('block0'):
x = block(x, stages[0], K, is_training= is_training, wd= wd)
print x
with tf.variable_scope('trans1'):
x = transition(x, K, wd= wd, is_training= is_training)
print x
with tf.variable_scope('block2'):
x = block(x, stages[1], K, is_training= is_training, wd= wd)
print x
with tf.variable_scope('trans2'):
x = transition(x, K, wd= wd, is_training= is_training)
print x
with tf.variable_scope('block3'):
x = block(x, stages[2], K, is_training= is_training, wd= wd)
print x
x = common.avgPool(x,8,1, padding='VALID')
x= common.flatten(x)
if not transfer_mode:
with tf.variable_scope('output'):
x = common.fullyConnected(x, num_output, wd= wd)
else:
with tf.variable_scope('transfer_output'):
x = common.fullyConnected(x, num_output, wd= wd)
return x
def compute(data, results, correct_hash):
# Compute commitment
hashed_data = poseidon_hash(flatten(data))
[x.assert_eq(y) for (x,y) in zip(hashed_data, correct_hash)]
# Compute graduation rates by category
output = {}
for category in data:
arr2011 = [x == 1 for x in data[category]]
arr2013 = [x == 11 for x in data[category]]
graduated2011 = LinCombFxp(sum(arr2011))
graduated2013 = LinCombFxp(sum(arr2013))
length2011 = PrivVal(len(arr2011))
length2013 = PrivVal(len(arr2013))
gr2011 = graduated2011 * 100 / (length2011 + (length2011 == 0))
gr2013 = graduated2013 * 100 / (length2013 + (length2013 == 0))
output[category] = {
"Began in 2011": gr2011,
"Began in 2013": gr2013
}
# # Assert results are correct
for category in results:
output[category]["Began in 2011"].assert_eq(results[category]["Began in 2011"])
output[category]["Began in 2013"].assert_eq(results[category]["Began in 2013"])
def solve_part_two(day_input: List[str]) -> int:
fields, ours, tickets = convert(day_input)
# Valid tickets have all their numbers in at least one range
all_ranges = list(flatten(fields.values()))
valid_tickets = [
t for t in tickets if all(any(n in r for r in all_ranges) for n in t)
]
# For each field collect which positions are possible for it
possible: Dict[str, List[int]] = defaultdict(list)
for field, ranges in fields.items():
# This could be done in a single list comprehension but would be unreadable
for pos in range(len(ours)):
# if all ticket values in this position are in at least one of the ranges of the field,
# this position is possible for the field
vals = [t[pos] for t in valid_tickets]
if all(any(v in r for r in ranges) for v in vals):
possible[field].append(pos)
# Basic constraint propagation, doesn't work in all scenarios, only well behaved ones
constraints = [field for field, pos in possible.items() if len(pos) == 1]
while len(constraints) > 0:
constr = constraints.pop()
pos = possible[constr][0]
for k, v in possible.items():
if k != constr and pos in v:
v.remove(pos)
if len(v) == 1:
# New constraint
constraints.append(k)
# Assuming that the previous constraint propagation uniquely defined the fields...
res = (ours[pos] for pos in (
[v[0] for k, v in possible.items() if k.startswith("departure")]))
return prod(res)
def inner(values, mask):
i, m = mask
if m == '1':
values = list(map(lambda v: set_bit(v, i), values))
elif m == 'X':
values = flatten([(set_bit(v, i), clear_bit(v, i))
for v in values])
return values
def possible_names(s):
parsed = parse(s)
all_ingredients = flatten([ings for ings, allerg in parsed])
ingredient_set = set(all_ingredients)
possble_allergen_names = possible_allerggens(parsed)
allergen_set = set.union(*possble_allergen_names.values())
non_allergens = ingredient_set - allergen_set
return sum(all_ingredients.count(allrg) for allrg in non_allergens)
def do_return(self, inst=[]):
#if self.last_seen_fn:
# self.last_seen_fn.pop()
ASM = []
ASM.append("// DO_RETURN")
#FRAME=LCL
ASM.append("@LCL")
ASM.append("D=M")
ASM.append("@13") #FRAME in M[13]
ASM.append("M=D")
# RET = *(FRAME-5)
ASM.append("@5")
ASM.append("A=D-A")
ASM.append("D=M")
ASM.append("@14") #RET in M[14]
ASM.append("M=D")
# *ARG = pop()
ASM.append("@SP")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@ARG")
ASM.append("A=M")
ASM.append("M=D")
# SP = ARG +1
ASM.append("@ARG")
ASM.append("D=M+1")
ASM.append("@SP")
ASM.append("M=D")
# THAT = *(FRAME-1)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@THAT")
ASM.append("M=D")
# THIS = *(FRAME-2)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@THIS")
ASM.append("M=D")
# ARG = *(FRAME-3)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@ARG")
ASM.append("M=D")
# LCL = *(FRAME-4)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@LCL")
ASM.append("M=D")
# goto RET
ASM.append("@14")
ASM.append("A=M")
ASM.append("0;JMP")
return "\n ".join(common.flatten(ASM))
def do_return(self, inst=[]):
#if self.last_seen_fn:
# self.last_seen_fn.pop()
ASM=[]
ASM.append("// DO_RETURN")
#FRAME=LCL
ASM.append("@LCL")
ASM.append("D=M")
ASM.append("@13") #FRAME in M[13]
ASM.append("M=D")
# RET = *(FRAME-5)
ASM.append("@5")
ASM.append("A=D-A")
ASM.append("D=M")
ASM.append("@14") #RET in M[14]
ASM.append("M=D")
# *ARG = pop()
ASM.append("@SP")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@ARG")
ASM.append("A=M")
ASM.append("M=D")
# SP = ARG +1
ASM.append("@ARG")
ASM.append("D=M+1")
ASM.append("@SP")
ASM.append("M=D")
# THAT = *(FRAME-1)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@THAT")
ASM.append("M=D")
# THIS = *(FRAME-2)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@THIS")
ASM.append("M=D")
# ARG = *(FRAME-3)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@ARG")
ASM.append("M=D")
# LCL = *(FRAME-4)
ASM.append("@13")
ASM.append("AM=M-1")
ASM.append("D=M")
ASM.append("@LCL")
ASM.append("M=D")
# goto RET
ASM.append("@14")
ASM.append("A=M")
ASM.append("0;JMP")
return "\n ".join(common.flatten(ASM))
def main():
parser = OptionParser(
usage = "usage: %prog [options] dir1 ... dirN",
option_list= [
make_option("-c", "--capacity",
type = "int",
default = 736000000,
help = "Storage unit capacity (in bytes)"),
make_option("-r", "--recursive",
action = "store_true",
help = "Scan each directory recursively"),
make_option("-i", "--include",
action = "append",
default = [],
help = "Filename pattern of files to be included"
" (more than one can be specified)"),
make_option("-x", "--exclude",
action = "append",
default = [],
help = "Filename pattern of files to be excluded"
" (more than one can be specified)"),
make_option("-p", "--preserveStructure",
action = "store_true",
help = "Preserve the directory tree hierarchy "
"in the partition"),
])
options,dirs = parser.parse_args()
if not dirs:
dirs = ['.']
fileLists = getFileLists(dirs, options.include, options.exclude,
options.recursive, options.preserveStructure)
getSize = os.path.getsize
bins = getBins(fileLists, options.capacity, getSize)
files = flatten(fileLists)
totalSize = sum(map(getSize,files))
minBound = int(math.ceil(totalSize / float(options.capacity)))
print "*** SUMMARY ***"
print "* %d files (%s)" % (len(files), _sizeAsString(totalSize))
print "* %s storage unit capacity" % _sizeAsString(options.capacity)
print "* %d storage units are required at minimum" % minBound
print "* %d sections were allocated" % len(bins)
print
print "* Listing files per unit"
for i,bin in enumerate(sorted(bins,key=Bin.size,descending=True)):
print " - Unit %d (%s / %.2f%%)" % (
i, _sizeAsString(bin.size()),
100 * bin.size() / float(options.capacity))
for object in sorted(bin, key=getSize, descending=True):
print " %s (%s)" % (object, _sizeAsString(getSize(object)))
def main():
parser = OptionParser(
usage="usage: %prog [options] dir1 ... dirN",
option_list=[
make_option("-c",
"--capacity",
type="int",
default=736000000,
help="Storage unit capacity (in bytes)"),
make_option("-r",
"--recursive",
action="store_true",
help="Scan each directory recursively"),
make_option("-i",
"--include",
action="append",
default=[],
help="Filename pattern of files to be included"
" (more than one can be specified)"),
make_option("-x",
"--exclude",
action="append",
default=[],
help="Filename pattern of files to be excluded"
" (more than one can be specified)"),
make_option("-p",
"--preserveStructure",
action="store_true",
help="Preserve the directory tree hierarchy "
"in the partition"),
])
options, dirs = parser.parse_args()
if not dirs:
dirs = ['.']
fileLists = getFileLists(dirs, options.include, options.exclude,
options.recursive, options.preserveStructure)
getSize = os.path.getsize
bins = getBins(fileLists, options.capacity, getSize)
files = flatten(fileLists)
totalSize = sum(map(getSize, files))
minBound = int(math.ceil(totalSize / float(options.capacity)))
print "*** SUMMARY ***"
print "* %d files (%s)" % (len(files), _sizeAsString(totalSize))
print "* %s storage unit capacity" % _sizeAsString(options.capacity)
print "* %d storage units are required at minimum" % minBound
print "* %d sections were allocated" % len(bins)
print
print "* Listing files per unit"
for i, bin in enumerate(sorted(bins, key=Bin.size, descending=True)):
print " - Unit %d (%s / %.2f%%)" % (i, _sizeAsString(
bin.size()), 100 * bin.size() / float(options.capacity))
for object in sorted(bin, key=getSize, descending=True):
print " %s (%s)" % (object, _sizeAsString(getSize(object)))
def hist(data, vocab):
hist = {key: 0 for key in vocab}
hist[UNK] = 0
cnt = Counter(flatten(data))
for k, v in cnt.items():
if k in hist:
hist[k] += v
else:
hist[UNK] += v
return hist
def do_funct(self, inst=[]):
self.last_seen_fn.append(inst[1])
ASM = []
ASM.append("// DO_FUNC")
nVars = int(inst[2])
ASM.append("(%s)" % inst[1])
for i in range(0, nVars):
ASM.append(self.do_push(["push", "constant", "0"]))
return "\n ".join(common.flatten(ASM))
def parse_line(line):
line = line.replace("nil", "None")
try:
a = eval(line)
f = flatten(a)
# print(a, "--f->", f)
return f
except Exception as e:
print("WARNING: Can't parse line - ", line, e)
return [0]
def load_things(keys, query):
_things = simplejson.loads(store.get_many(keys))
xthings.update(_things)
for k, v in query.requested.items():
k = web.lstrips(k, query.prefix)
if isinstance(v, Query):
keys2 = common.flatten([d.get(k) for d in _things.values() if d.get(k)])
keys2 = [k['key'] for k in keys2]
load_things(set(keys2), v)
def do_funct(self, inst=[]):
self.last_seen_fn.append(inst[1])
ASM=[]
ASM.append("// DO_FUNC")
nVars=int(inst[2])
ASM.append("(%s)"%inst[1])
for i in range(0, nVars):
ASM.append(self.do_push(["push", "constant", "0"]))
return "\n ".join(common.flatten(ASM))
def parse(responses):
timeslots_raw = common.flatten(list(map(parse_response, responses)))
format = '%Y-%m-%dT%H:%M:%S%z'
timeslots = [
common.string_to_datetime(format, timeslot)
for timeslot in timeslots_raw
]
return timeslots
def load_things(keys, query):
_things = simplejson.loads(store.get_many(keys))
xthings.update(_things)
for k, v in query.requested.items():
k = web.lstrips(k, query.prefix)
if isinstance(v, Query):
keys2 = common.flatten(
[d.get(k) for d in _things.values() if d.get(k)])
keys2 = [k['key'] for k in keys2]
load_things(set(keys2), v)
def compute(data, results, correct_hash):
# Compute commitment
hashed_data = poseidon_hash(flatten(data))
[x.assert_eq(y) for (x, y) in zip(hashed_data, correct_hash)]
# Compute GPA
total = sum(data)
num_students = PrivVal(len(data))
gpa = total / num_students
# Assert GPAs match
gpa.assert_eq(results)
def uniqueAttribs(self, xpath):
"""Return a list of attributes that uniquely distinguish the element at each segment"""
acceptedAttribs = []
# select examples which contain the relevant xpath
docs = [doc for doc in self.docs() if doc.tree().xpath(str(xpath))]
for i, section in enumerate(xpath.walk()):
sectionElements = flatten(
[doc.tree().xpath(section) for doc in docs])
try:
siblingElements = flatten(
[[s for s in e.itersiblings() if s.tag == e.tag]
for e in sectionElements])
except AttributeError:
pass
else:
siblingAttribs = flatten(
[self.extractAttribs(e) for e in siblingElements])
proposedAttribs = self.commonAttribs(sectionElements)
acceptedAttribs.append(
[a for a in proposedAttribs if a not in siblingAttribs])
return acceptedAttribs
def solve_part_one(day_input: List[str]) -> int:
lst = convert(day_input)
# Get all different ingredients and alergens
ingredients = set(flatten(line[0] for line in lst))
alergens = set(flatten(line[1] for line in lst))
# Get ingredients possible for each alergen: for each alergen it's the union of ingredients
# in which it appears
alergen_ingredients: Dict[str, Set[str]] = \
dict(zip(alergens, [set(ingredients) for _ in range(len(alergens))]))
for line in lst:
for alerg in line[1]:
alergen_ingredients[alerg].intersection_update(line[0])
# Good ingredients don't appear in the alergen list
good_ingredients = [
ingr for ingr in ingredients
if ingr not in list(flatten(alergen_ingredients.values()))
]
res = sum(l[0].count(ingr) for l in lst for ingr in good_ingredients)
return res
def inference(x,
num_output,
wd,
dropout_rate,
is_training,
transfer_mode=False):
with tf.variable_scope('conv1'):
network = common.spatialConvolution(x, 11, 4, 64, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
#common.activation_summary(network)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('conv2'):
network = common.spatialConvolution(network, 5, 1, 192, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
#common.activation_summary(network)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('conv3'):
network = common.spatialConvolution(network, 3, 1, 384, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
#common.activation_summary(network)
with tf.variable_scope('conv4'):
network = common.spatialConvolution(network, 3, 1, 256, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
with tf.variable_scope('conv5'):
network = common.spatialConvolution(network, 3, 1, 256, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
network = common.maxPool(network, 3, 2)
network = common.flatten(network)
with tf.variable_scope('fc1'):
network = tf.nn.dropout(network, dropout_rate)
network = common.fullyConnected(network, 4096, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
with tf.variable_scope('fc2'):
network = tf.nn.dropout(network, dropout_rate)
network = common.fullyConnected(network, 4096, wd=wd)
network = common.batchNormalization(network, is_training=is_training)
network = tf.nn.relu(network)
if not transfer_mode:
with tf.variable_scope('output'):
network = common.fullyConnected(network, num_output, wd=wd)
else:
with tf.variable_scope('transfer_output'):
network = common.fullyConnected(network, num_output, wd=wd)
return network
def translate(self, parsedlines):
asmlines=[]
#initialise the stack pointer
asmlines.append("@256")
asmlines.append("D=A")
asmlines.append("@SP")
asmlines.append("M=D")
#Call Sys.init
asmlines.append(self.do_call(["call", "Sys.init", 0]))
for line in parsedlines:
asmlines.append(self.transfn[line["type"]](line["inst"]))
return common.flatten(asmlines)
def translate(self, parsedlines):
asmlines = []
#initialise the stack pointer
asmlines.append("@256")
asmlines.append("D=A")
asmlines.append("@SP")
asmlines.append("M=D")
#Call Sys.init
asmlines.append(self.do_call(["call", "Sys.init", 0]))
for line in parsedlines:
asmlines.append(self.transfn[line["type"]](line["inst"]))
return common.flatten(asmlines)
def get_turnout():
try:
today = datetime.datetime.today()
turnout = common.flatten(api.get_turnout_data(today))
string = []
for i in range(len(turnout)):
string.append(f"{common.ranges[i]}: {turnout[i]}")
return "\n".join(string)
except Exception as ex:
log.critical(ex)
return "_Nessun dato disponibile oggi._"
def parse_response(resp):
import sys, json
json_response = json.loads(resp)
timeslots_raw = [[
timeslot.get('startTime') for timeslot in time.get('timeslots')
] for time in json_response["data"]["providerLocations"][0]["availability"]
["times"]]
timeslots_by_day = list(filter(lambda ts: len(ts) > 0,
list(timeslots_raw)))
timeslots = common.flatten(timeslots_by_day)
return timeslots
def inference(x, num_output, wd, dropout_rate, is_training, transfer_mode= False):
conv_weight_initializer = tf.truncated_normal_initializer(stddev= 0.1)
fc_weight_initializer = tf.truncated_normal_initializer(stddev= 0.01)
with tf.variable_scope('conv1'):
network = common.spatialConvolution(x, 11, 4, 64, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu (network)
#common.activation_summary(network)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('conv2'):
network = common.spatialConvolution(network, 5, 1, 192, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu(network)
#common.activation_summary(network)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('conv3'):
network = common.spatialConvolution(network, 3, 1, 384, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu(network)
#common.activation_summary(network)
with tf.variable_scope('conv4'):
network = common.spatialConvolution(network, 3, 1, 256, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu(network)
with tf.variable_scope('conv5'):
network = common.spatialConvolution(network, 3, 1, 256, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu(network)
network = common.maxPool(network, 3, 2)
network = common.flatten(network)
with tf.variable_scope('fc1'):
network = tf.nn.dropout(network, dropout_rate)
network = common.fullyConnected(network, 4096, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu(network)
with tf.variable_scope('fc2'):
network = tf.nn.dropout(network, dropout_rate)
network = common.fullyConnected(network, 4096, wd= wd)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.relu(network)
output = [None]*len(num_output)
for o in xrange(0,len(num_output)):
with tf.variable_scope('output'+str(o)):
output[o] = common.fullyConnected(network, num_output[o], weight_initializer= fc_weight_initializer, bias_initializer= tf.zeros_initializer, wd= wd)
return output
def solve_part_one(day_input: List[str]) -> int:
tiles = convert(day_input)
# Get all tiles that have 2 edges not compatible with any others
# This is not a necessary condition for a tile to be in a corner, but it is a sufficient
# one (a tile with 2 edges not compatible with others must be in a corner)
corners = []
for tile in tiles:
other_edges = list(
flatten([
other.edges + other.edges_reversed() for other in tiles
if other.key != tile.key
]))
found = sum(edge in other_edges for edge in tile.edges)
if found == 2:
corners.append(tile)
return prod(int(t.key) for t in corners)
def check_linked_phrases(link_phrases, vocab):
phrases = set(flatten([p for p in list(link_phrases.values())]))
def oov_rate(vocab):
tmp = set(vocab)
cnt = 0
for phrase in phrases:
oov_words = [w for w in phrase.split() if w not in tmp]
if oov_words:
cnt += 1
#print phrase.split(), [(w, vocab_dict[w]) for w in oov_words]
return 1.0 * cnt / len(phrases)
#sys.stdout.write('Number of Entities (N>=%d): %d\n' % (args.min_qfreq, len(link_phrases)))
sys.stdout.write('Linked phrase vocab size: %d\n' % (len(phrases)))
for N in [30000, 50000, 100000, 150000]:
sys.stdout.write('OOV linked phrase rate (n_vocab=%d): %f\n' %
(N, oov_rate(vocab[:N])))
def compute(data, results, correct_hash):
# Compute commitment
hashed_data = poseidon_hash(flatten(data))
[x.assert_eq(y) for (x, y) in zip(hashed_data, correct_hash)]
# Begin with just 2016-2017
output = {}
for year in data:
output[year] = {}
for income in data[year]:
year_data = data[year][income]
total = sum(year_data)
length = PrivVal(len(year_data))
output[year][income] = total / length
# Check equality
for year in results:
for income in results[year]:
output[year][income].assert_eq(results[year][income])
def inference(x, num_output, wd, dropout_rate, is_training, transfer_mode= False, model_type= 'A'):
# Create tables describing VGG configurations A, B, D, E
if model_type == 'A':
config = [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']
elif model_type == 'B':
config = [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']
elif model_type == 'D':
config = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M']
elif model_type == 'E':
config = [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M']
else:
print('Unknown model type: ' + model_type + ' | Please specify a modelType A or B or D or E')
network= x
for k,v in enumerate(config):
if v == 'M':
network= common.maxPool(network, 2, 2)
else:
with tf.variable_scope('conv'+str(k)):
network = common.spatialConvolution(network, 3, 1, v, wd= wd)
network = tf.nn.relu(network)
network= common.flatten(network)
with tf.variable_scope('fc1'):
network = common.fullyConnected(network, 4096, wd= wd)
network = tf.nn.relu(network)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.dropout(network, dropout_rate)
with tf.variable_scope('fc2'):
network = common.fullyConnected(network, 4096, wd= wd)
network = tf.nn.relu(network)
network = common.batchNormalization(network, is_training= is_training)
network = tf.nn.dropout(network, dropout_rate)
if not transfer_mode:
with tf.variable_scope('output'):
network = common.fullyConnected(network, num_output, wd= wd)
else:
with tf.variable_scope('transfer_output'):
network = common.fullyConnected(network, num_output, wd= wd)
return network
def inference(x, num_output, wd, is_training, transfer_mode=False):
with tf.variable_scope('block1'):
network = block(x, [11, 4, 96], wd, is_training)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('block2'):
network = block(network, [5, 1, 256], wd, is_training)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('block3'):
network = block(network, [3, 1, 384], wd, is_training)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('block4'):
network = block(network, [3, 1, 1024], wd, is_training)
network = common.avgPool(network, 7, 1)
network = common.flatten(network)
output = [None] * len(num_output)
for o in xrange(0, len(num_output)):
with tf.variable_scope('output' + str(o)):
output[o] = common.fullyConnected(network, num_output[o], wd=wd)
return output
def inference(x, num_output, wd, is_training, transfer_mode=False):
with tf.variable_scope('block1'):
network = block(x, [11, 4, 96], wd, is_training)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('block2'):
network = block(network, [5, 1, 256], wd, is_training)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('block3'):
network = block(network, [3, 1, 384], wd, is_training)
network = common.maxPool(network, 3, 2)
with tf.variable_scope('block4'):
network = block(network, [3, 1, 1024], wd, is_training)
network = common.avgPool(network, 7, 1)
network = common.flatten(network)
if not transfer_mode:
with tf.variable_scope('output'):
network = common.fullyConnected(network, num_output, wd=wd)
else:
with tf.variable_scope('transfer_output'):
network = common.fullyConnected(network, num_output, wd=wd)
return network
def generate(self, target_file=None):
if self.components != []:
target_file = open(self.file_name, "w")
target_file.write('ASTRON HEADER\n')
target_file.write('INCLUDED LIBRARIES\n')
target_file.write('ENTITY DECLARATION\n')
target_file.write('ARCHITECTURE str OF %s IS\n' %self.name)
target_file.write('. CONSTANT DECLARATIONS\n')
target_file.write('. SIGNAL DECLARATIONS\n')
target_file.write('BEGIN\n')
# Write this component's connections
for connection in cm.flatten(self.connections):
print connection
target_file.write(connection.vhdl_assignment)
# Iterate through internal components
for component in self.components:
component.generate()
target_file.write(component.get_vhdl_instance())
target_file.write('END str\n')
target_file.close()
def translate(self, parsedlines):
asmlines=[]
for line in parsedlines:
asmlines.append(self.transfn[line["type"]](line["inst"]))
return common.flatten(asmlines)
def do_call(self, inst=[]):
ASM=[]
ASM.append("// DO_CALL: "+inst[1])
self.call_return=self.call_return +1
call_label="RETFROM_"+inst[1]+str(self.call_return)
numargs= int(inst[2])
# push return-address
ASM.append("@%s"%(call_label))
ASM.append("D=A")
ASM.append("@SP")
ASM.append("AM=M+1")
ASM.append("A=A-1")
ASM.append("M=D")
# push LCL
ASM.append("@LCL")
ASM.append("D=M")
ASM.append("@SP")
ASM.append("AM=M+1")
ASM.append("A=A-1")
ASM.append("M=D")
# push ARG
ASM.append("@ARG")
ASM.append("D=M")
ASM.append("@SP")
ASM.append("AM=M+1")
ASM.append("A=A-1")
ASM.append("M=D")
# push THIS
ASM.append("@THIS")
ASM.append("D=M")
ASM.append("@SP")
ASM.append("AM=M+1")
ASM.append("A=A-1")
ASM.append("M=D")
# push THAT
ASM.append("@THAT")
ASM.append("D=M")
ASM.append("@SP")
ASM.append("AM=M+1")
ASM.append("A=A-1")
ASM.append("M=D")
# ARG = SP-n-5
ASM.append("@SP")
ASM.append("D=M")
ASM.append("@"+str(numargs+5))#we're doing work in machine that could be done in-compiler: numargs+5
ASM.append("D=D-A")
ASM.append("@ARG")
ASM.append("M=D")
# LCL = SP
ASM.append("@SP")
ASM.append("D=M")
ASM.append("@LCL")
ASM.append("M=D")
# goto f
ASM.append("@%s"%(str(inst[1])))
ASM.append("0;JMP")
# set label return-address
ASM.append("(%s)"%(call_label))
return "\n ".join(common.flatten(ASM))
def usage():
print"""
python S1VM.py <source>
where <source> is a valid vm file or a folder containing vm files.
"""
if __name__=="__main__":
translator=Translator()
parser=Parser(instdict)
outASM=[]
try:
givenpath = sys.argv[1]
except IndexError:
usage()
exit()
if os.path.isdir(givenpath):
for file in os.listdir(givenpath):
if file[-3:] == ".vm":
outASM.append(translator.translate(parser.parse(os.path.join(givenpath, file))))
elif os.path.isfile(givenpath) and givenpath[-3:] == ".vm":
outASM.append(translator.translate(parser.parse(givenpath)))
else:
print("Error: Path supplied is invalid!")
exit()
print "\n".join(common.flatten(outASM))
def generate(self, target_vhdl_file=None):
if self.components != []: # Sub-components determine the contents of this generated file (e.g. top level)
target_vhdl_file = open(self.vhdl_file_name, "w")
###############################################################################
# ASTRON HEADER, INFO
###############################################################################
target_vhdl_file.write(ASTRON_HEADER)
target_vhdl_file.write(self.info)
target_vhdl_file.write("\n")
###############################################################################
# USED LIBRARIES
###############################################################################
target_vhdl_file.write(STANDARD_LIBS)
for component in self.components:
target_vhdl_file.write(component.vhdl_lib)
# print component.vhdl_lib
vhdl_lib_str_words = component.vhdl_lib.replace(";", "").split(" ")
for word in vhdl_lib_str_words:
# print word
if "_lib" in word and not "USE" in word and not "." in word and word not in self.hdllib_used_libs:
self.hdllib_used_libs += word.replace("_lib", "").replace("\n", "") + " "
# target_vhdl_file.write(STANDARD_LIBS)
# Paste our default entity with replaced entity name.
# target_vhdl_file.write(ENTITY_TEMPPLATE.replace('DESIGN_NAME', self.name))
###############################################################################
# ENTITY DECLARATION
###############################################################################
target_vhdl_file.write(ENTITY_DECLARATION_TOP.replace("DESIGN_NAME", self.name))
for component in self.components:
for vhdl_port_declaration in component.vhdl_port_declarations:
# Put the port declarations this component needs in the top level entity
target_vhdl_file.write(vhdl_port_declaration)
target_vhdl_file.write(ENTITY_DECLARATION_BOTTOM.replace("DESIGN_NAME", self.name))
###############################################################################
# ARCHITECTURE DECLARATION
###############################################################################
target_vhdl_file.write("ARCHITECTURE str OF %s IS\n\n" % self.name)
###############################################################################
# CONSTANT + SIGNAL DECLARATIONS
###############################################################################
for component in self.components:
# Paste the parent constants
# print component.vhdl_parent_constants
for vhdl_parent_constant in component.vhdl_parent_constants:
# print 'debug', vhdl_parent_constant
target_vhdl_file.write(vhdl_parent_constant)
target_vhdl_file.write(component.vhdl_name_comment_block)
# Paste this component's SIGNAL and CONSTANT declarations
target_vhdl_file.write(component.vhdl_constants)
target_vhdl_file.write(component.vhdl_signals)
# Get the signal declaration from each internal component's port object
for port_name, port in component.ports.iteritems():
target_vhdl_file.write(port.signal.vhdl_signal_declaration)
target_vhdl_file.write("\n")
###############################################################################
# ARCHITECTURE BEGIN
###############################################################################
target_vhdl_file.write("BEGIN\n")
###############################################################################
# COMPONENT CONNECTIONS
###############################################################################
# Write this component's connections
for connection in cm.flatten(self.connections):
# print connection
target_vhdl_file.write(connection.vhdl_assignment)
###############################################################################
# COMPONENT INSTANCES
###############################################################################
# Iterate through internal components
for component in self.components:
target_vhdl_file.write(component.vhdl_name_comment_block)
target_vhdl_file.write(component.get_vhdl_instance())
###############################################################################
# ARCHITECTURE END
###############################################################################
target_vhdl_file.write("\nEND str;\n")
target_vhdl_file.close()
###############################################################################
# hdllib.cfg
###############################################################################
hdllib_file = open("generated/hdllib.cfg", "w")
hdllib_file.write("hdl_lib_name = %s\n" % self.name)
hdllib_file.write("hdl_library_clause_name = %s_lib\n" % self.name)
hdllib_file.write("hdl_lib_uses_synth = %s\n" % self.hdllib_used_libs)
hdllib_file.write("synth_files =\n")
for component in self.components:
if component.vhdl_file_name != None:
hdllib_file.write(" ../%s\n" % component.vhdl_file_name)
hdllib_file.write(" ../%s\n" % self.vhdl_file_name)
hdllib_file.write("synth_top_level_entity =\n")
hdllib_file.write("test_bench_files =\n")
hdllib_file.write(" tb_%s.vhd\n" % self.name)
hdllib_file.write("quartus_copy_files =\n")
hdllib_file.write(" qsys_mm_master.qsys .\n")
for component in self.components:
hdllib_file.write(component.hdllib_entries)
hdllib_file.write("quartus_sdc_files =\n")
for component in self.components:
hdllib_file.write(component.hdllib_entries_sdc)
# FIXME QSYS MM master QIP path depends on board...we should get rid of that.
# . Put both options here as workaround. We don't want to forward self.name to either mm_master.py or ctrl_unb_common.
# . Also, we don't want QSYS stuff in ctrl_unb_common or ctrl_unb_common stuff in mm_master.
hdllib_file.write("quartus_qip_files =\n")
hdllib_file.write(
" $HDL_BUILD_DIR/unb1/quartus/%s/qsys_mm_master/synthesis/qsys_mm_master.qip\n" % self.name
)
hdllib_file.write(
" $HDL_BUILD_DIR/unb2/quartus/%s/qsys_mm_master/synthesis/qsys_mm_master.qip\n" % self.name
)
hdllib_file.write("quartus_tcl_files =\n")
hdllib_file.write(" %s_pins.tcl\n" % self.name)
hdllib_file.close()
###############################################################################
# Pin TCL file
###############################################################################
pin_file = open("generated/%s_pins.tcl" % self.name, "w")
for component in self.components:
pin_file.write(component.tcl_pin_files)
pin_file.close()
for component in self.components: # Chance for subcomponents to run their own overloaded generate()
component.generate()
