def play(self):
key = Arrow.input()
while key != Arrow.NONE:
print(key)
key = Arrow.input()
print("None of the arrow keys was pressed")
def min_approx_error_arrow(arrow: Arrow,
input_data: List,
error_filter=is_error_port,
**kwargs) -> CompositeArrow:
"""
Find parameter values of arrow which minimize approximation error of arrow(data)
Args:
arrow: Parametric Arrow
input_data: List of input data for each input of arrow
Returns:
parametric_arrow with parameters fixed
"""
with tf.name_scope(arrow.name):
input_tensors = gen_input_tensors(arrow)
output_tensors = arrow_to_graph(arrow, input_tensors)
# show_tensorboard_graph()
param_tensors = [
t for i, t in enumerate(input_tensors)
if is_param_port(arrow.in_ports()[i])
]
error_tensors = [
t for i, t in enumerate(output_tensors)
if error_filter(arrow.out_ports()[i])
]
assert len(param_tensors) > 0, "Must have parametric inports"
assert len(error_tensors) > 0, "Must have error outports"
train_tf(param_tensors, error_tensors, input_tensors, output_tensors,
input_data, **kwargs)
def play(self):
self.print_board()
key = Arrow.input()
while key != Arrow.NONE and self.game_going():
self.arrange_board(key)
self.open_two()
self.open_two()
self.print_board()
key = Arrow.input()
if self.game_going():
print("None of the arrow keys was pressed")
else:
print("Game over!")
def play(self):
self.add_number()
self.add_number()
self.print_board()
key = Arrow.input()
while key != Arrow.NONE:
print(key)
moves = self.turn(key)
if moves != 0:
self.turn_finish()
self.add_number()
self.print_board()
if self.lose_check():
break
key = Arrow.input()
print("None of the arrow keys was pressed")
def extract_tensors(arrow: Arrow, grabs, extra_ports=[], optional=None):
"""
Converts an arrow into a graph and extracts tensors which correspond to
ports with particular properties
Args:
arrow: arrow to convert
grabs: dict {name: filter function}
append_default: append to default grabs, if false then replaces it
Returns:
"""
optional = set() if optional is None else optional
_grabs = grabs
# Convert to tensorflow graph and get input, output, error, and parma_tensors
with tf.name_scope(arrow.name):
input_tensors = gen_input_tensors(arrow, param_port_as_var=False)
port_grab = {p: None for p in extra_ports}
output_tensors = arrow_to_graph(arrow,
input_tensors,
port_grab=port_grab)
extra_tensors = list(port_grab.values())
output = {}
for grab_key, grab_func in _grabs.items():
all_dem = []
for i, t in enumerate(input_tensors):
if grab_func(arrow.in_port(i)):
all_dem.append(t)
for i, t in enumerate(output_tensors):
if grab_func(arrow.out_port(i)):
all_dem.append(t)
# for port, t in port_grab:
# if grab_func(port):
# all_dem.append(t)
assert grab_key in optional or len(all_dem) > 0, "%s empty" % grab_key
if len(all_dem) > 0:
output[grab_key] = all_dem
output['extra'] = extra_tensors
return output
def wrap(a: Arrow):
"""Wrap an arrow in a composite arrow"""
c = CompositeArrow(name=a.name)
for port in a.ports():
c_port = c.add_port()
if is_in_port(port):
make_in_port(c_port)
c.add_edge(c_port, port)
if is_param_port(port):
make_param_port(c_port)
if is_out_port(port):
make_out_port(c_port)
c.add_edge(port, c_port)
if is_error_port(port):
make_error_port(c_port)
transfer_labels(port, c_port)
assert c.is_wired_correctly()
return c
def generic_binary_inv(arrow: Arrow, port_values: PortAttributes,
PInverseArrow, Port0ConstArrow, Port0ConstPortMap,
Port1ConstArrow,
Port1ConstPortMap) -> Tuple[Arrow, PortMap]:
# FIXME: Is this actually correct for mul/add/sub
port_0_const = is_constant(arrow.in_ports()[0], port_values)
port_1_const = is_constant(arrow.in_ports()[1], port_values)
if port_0_const and port_1_const:
# If both ports constant just return arrow as is
inv_arrow = deepcopy(arrow)
port_map = {0: 0, 1: 1, 2: 2}
elif port_0_const:
inv_arrow = Port0ConstArrow()
port_map = Port0ConstPortMap
elif port_1_const:
inv_arrow = Port1ConstArrow()
port_map = Port1ConstPortMap
else:
# Neither constant, do 'normal' parametric inversison
inv_arrow = PInverseArrow()
port_map = {0: 2, 1: 3, 2: 0}
return inv_arrow, port_map
def input_gen(arrow: Arrow):
return [np.random.rand() for i in range(arrow.num_in_ports())]
def generate_constraints(arrow: Arrow,
input_expr: MutableMapping[int, Expr],
output_expr: MutableMapping[int, Expr]) -> Set[Rel]:
if arrow.is_primitive():
return arrow.gen_constraints(input_expr, output_expr)
def input_gen(arrow: Arrow):
ndim = 3
maxdim = 100
input_shape = tuple([np.random.randint(1, maxdim) for i in range(ndim)])
return {port: {'shape': (), 'value': 5} for port in arrow.out_ports()} # if not is_param_port(port)}
