def node_to_graph(node, namer, namespace, value_hints):
"""Convert Python code to equivalent TF graph mode code.
Args:
node: A Python AST node representing the code to convert.
namer: A naming.Namer object.
namespace: Dict mapping symbol names to their corresponding live objects.
value_hints: A dict containing value hints for symbols like function
parameters.
Returns:
A tuple (node, deps):
* node: A Python ast node, representing the converted code.
* deps: A set of strings, the fully qualified names of object
dependencies that this node has.
"""
# TODO(mdan): Get rid of this.
node = gradients_function.transform(node)
node = access.resolve(node)
node = live_values.resolve(node, namespace, config.PYTHON_LITERALS)
node = type_info.resolve(node, value_hints)
# TODO(mdan): Factor out common elements.
# These include:
# * keeping track of symbols that have been created
# * marking nodes (e.g. py_func wrappers) to suppress further processing
node = print_functions.transform(node)
node = call_trees.transform(node, namer, config.DEFAULT_UNCOMPILED_MODULES)
node = control_flow.transform(node, namer)
node = logical_expressions.transform(node)
node = side_effect_guards.transform(node, namer)
return node
def test_uncompiled_modules(self):
def test_fn(a):
a = math_ops.multiply(a, constant_op.constant(2))
a = math_ops.add(a, constant_op.constant(1))
return a
node = self._parse_and_analyze(test_fn, {
'math_ops': math_ops,
'constant_op': constant_op
})
node = call_trees.transform(node, TestNamer(), {},
set(((math_ops.__name__,),
(constant_op.__name__,))), ())
result = compiler.ast_to_object(node)
setattr(result, 'math_ops', math_ops)
setattr(result, 'constant_op', constant_op)
with self.test_session() as sess:
# Not renamed, because the converter doesn't rename the definition itself.
# (the caller is responsible for that).
result_tensor = result.test_fn(constant_op.constant(1))
result_val = sess.run(result_tensor)
self.assertEquals(3, result_val)
def node_to_graph(node, namer, namespace, value_hints):
"""Convert Python code to equivalent TF graph mode code.
Args:
node: A Python AST node representing the code to convert.
namer: A naming.Namer object.
namespace: Dict mapping symbol names to their corresponding live objects.
value_hints: A dict containing value hints for symbols like function
parameters.
Returns:
A tuple (node, deps):
* node: A Python ast node, representing the converted code.
* deps: A set of strings, the fully qualified names of object
dependencies that this node has.
"""
node = access.resolve(node)
node = live_values.resolve(node, namespace, config.PYTHON_LITERALS)
node = type_info.resolve(node, value_hints)
# TODO(mdan): Factor out common elements.
# These include:
# * keeping track of symbols that have been created
# * marking nodes (e.g. py_func wrappers) to suppress further processing
node = print_functions.transform(node)
node = call_trees.transform(node, namer, config.DEFAULT_UNCOMPILED_MODULES)
node = control_flow.transform(node, namer)
node = logical_expressions.transform(node)
node = side_effect_guards.transform(node, namer)
return node
def node_to_graph(node, namer, namespace, value_hints, nocompile_decorators):
"""Convert Python code to equivalent TF graph mode code.
Args:
node: A Python AST node representing the code to convert.
namer: A naming.Namer object.
namespace: Dict mapping symbol names to their corresponding live objects.
value_hints: A dict containing value hints for symbols like function
parameters.
nocompile_decorators: A tuple containing decorators to be stripped from
functions during conversion.
Returns:
A tuple (node, deps):
* node: A Python ast node, representing the converted code.
* deps: A set of strings, the fully qualified names of object
dependencies that this node has.
"""
# TODO(mdan): Verify arguments for correctness.
# TODO(mdan): Factor out common elements.
# These include:
# * keeping track of symbols that have been created
# * marking nodes (e.g. py_func wrappers) to suppress further processing
# * code move between blocks
# * insertion of new global references
# * visiting blocks in transformers
# Certain steps, especially canonicalization, insert new symbols into the
# tree, which must be accounted. Although less efficient, it is most robust
# to re-run the analysis.
node = _static_analysis_pass(node, namespace, value_hints)
node = decorators.transform(node, nocompile_decorators)
node = break_canonicalization.transform(node, namer)
# Note: sequencing continue canonicalization before for loop one avoids
# dealing with the extra loop increment operation that the for
# canonicalization creates.
node = continue_canonicalization.transform(node, namer)
namespace['len'] = len
node = _static_analysis_pass(node, namespace, value_hints)
node = for_canonicalization.transform(node, namer)
# for_canonicalization may insert new global references.
node = builtin_functions.transform(node)
# builtin_functions may insert new global references.
namespace['print'] = print
node = _static_analysis_pass(node, namespace, value_hints)
node = print_functions.transform(node)
node = call_trees.transform(node, namer, namespace,
config.DEFAULT_UNCOMPILED_MODULES,
nocompile_decorators)
node = control_flow.transform(node, namer)
node = logical_expressions.transform(node)
node = side_effect_guards.transform(node, namer)
return node
def node_to_graph(node, namer, namespace, value_hints):
"""Convert Python code to equivalent TF graph mode code.
Args:
node: A Python AST node representing the code to convert.
namer: A naming.Namer object.
namespace: Dict mapping symbol names to their corresponding live objects.
value_hints: A dict containing value hints for symbols like function
parameters.
Returns:
A tuple (node, deps):
* node: A Python ast node, representing the converted code.
* deps: A set of strings, the fully qualified names of object
dependencies that this node has.
"""
node = access.resolve(node)
node = live_values.resolve(node, namespace, config.PYTHON_LITERALS)
node = type_info.resolve(node, value_hints)
# TODO(mdan): Factor out common elements.
# These include:
# * keeping track of symbols that have been created
# * marking nodes (e.g. py_func wrappers) to suppress further processing
node = for_canonicalization.transform(node, namer)
node = builtin_functions.transform(node)
# The transformation steps above insert new variables. Although less
# efficient, it is most robust to re-run the analysis.
# We also need to ensure the namespace contains any new references that may
# have been created.
namespace['len'] = len
namespace['print'] = print
node = access.resolve(node)
node = live_values.resolve(node, namespace, config.PYTHON_LITERALS)
node = type_info.resolve(node, value_hints)
node = print_functions.transform(node)
node = call_trees.transform(node, namer, config.DEFAULT_UNCOMPILED_MODULES)
node = control_flow.transform(node, namer)
node = logical_expressions.transform(node)
node = side_effect_guards.transform(node, namer)
return node
def test_basic(self):
def test_fn_1(_):
raise ValueError('This should not be called in the compiled verison.')
def renamed_test_fn_1(a):
return a + 1
def test_fn_2(a):
return test_fn_1(a) + 1
node = self._parse_and_analyze(test_fn_2, {'test_fn_1': test_fn_1})
node = call_trees.transform(node, TestNamer(), set())
result = compiler.ast_to_object(node)
# Only test_fn_2 is transformed, so we'll insert renamed_test_fn_1 manually.
setattr(result, 'renamed_test_fn_1', renamed_test_fn_1)
self.assertEquals(3, result.renamed_test_fn_2(1))
def test_basic(self):
def test_fn_1(_):
raise ValueError('This should not be called in the compiled verison.')
def renamed_test_fn_1(a):
return a + 1
def test_fn_2(a):
return test_fn_1(a) + 1
node = self._parse_and_analyze(test_fn_2, {'test_fn_1': test_fn_1})
node = call_trees.transform(node, TestNamer(), {}, (), ())
result = compiler.ast_to_object(node)
# Only test_fn_2 is transformed, so we'll insert renamed_test_fn_1 manually.
setattr(result, 'renamed_test_fn_1', renamed_test_fn_1)
self.assertEquals(3, result.test_fn_2(1))
def test_uncompiled_modules(self):
def test_fn(a):
a = math_ops.multiply(a, constant_op.constant(2))
a = math_ops.add(a, constant_op.constant(1))
return a
node = self._parse_and_analyze(test_fn, {
'math_ops': math_ops,
'constant_op': constant_op
})
node = call_trees.transform(node, TestNamer(),
set((math_ops.__name__, constant_op.__name__)))
result = compiler.ast_to_object(node)
setattr(result, 'math_ops', math_ops)
setattr(result, 'constant_op', constant_op)
with self.test_session() as sess:
result_tensor = result.renamed_test_fn(constant_op.constant(1))
result_val = sess.run(result_tensor)
self.assertEquals(3, result_val)
def test_uncompiled_modules(self):
def test_fn(a):
a = math_ops.multiply(a, constant_op.constant(2))
a = math_ops.add(a, constant_op.constant(1))
return a
node = self._parse_and_analyze(test_fn, {
'math_ops': math_ops,
'constant_op': constant_op
})
node = call_trees.transform(node, TestNamer(),
set(((math_ops.__name__,),
(constant_op.__name__,))))
result = compiler.ast_to_object(node)
setattr(result, 'math_ops', math_ops)
setattr(result, 'constant_op', constant_op)
with self.test_session() as sess:
result_tensor = result.renamed_test_fn(constant_op.constant(1))
result_val = sess.run(result_tensor)
self.assertEquals(3, result_val)
