One thing I could do is check test_func._call_counter.get_tracing_count(), but I don't like the use of a variable with _ starting the name. Is there a more visible function for doing this?

Indeed, you should avoid using private fields - they may change at any moment.

The easiest and most robust way is to use a global Python counter, like so:

>>> trace_count = 0
>>> @tf.function
>>> def f(x):
...   global trace_count
...   trace_count += 1
...   # the rest of your code
>>> trace_count
0
>>> f(tf.constant(1))
>>> trace_count
1
>>> f(tf.constant(2))
>>> trace_count
1
>>> f(tf.constant([1, 2]))
>>> trace_count
2

This only works for certain cases, and doesn't seem scalable to every function everywhere. I'd have to have a different global variable for each function.

What if my function is written in one file, and I wrap it in tf.function in another file? I can't use a global variable as descirbed above to test the trace count in the caller code, which is where I would like to test.

I missed that this was a feature request. Sounds reasonable to me.

Any suggestions on how this can be implemented? I would like to give a try if we have any pointers

A simple solution would be to just add a public method to the Function class, that returns self._call_counter.get_tracing_count().

I'm not sure of the implications of this though, as _call_counter is a private field.

Fields are kept private by default, and we only expose public methods if there is a need for one. This helps keep the API clean - once a method is made public, it's extremely difficult to remove it. So for now, I recommend naming the method/property with the experimental_ prefix to control its adoption.

I'd like to give this a shot. Can I submit a PR for this?

@ammirato @mdanatg Thanks. Will work on this.

can i work on this? @ammirato

@ammirato, can I work on this and submit a PR

How about a static variable in the function class?

import my_function
@pytest.mark.unit
@pytest.mark.parametrize('use_tf_function', [True, False])
def test_my_function(use_tf_function):

def test(arg1, arg2):
    # REQUEST: Check to make sure this is not being retraced many times.
    return my_function(arg1, arg2)

# Sometimes test in Eager mode for debugging, sometimes test in graph mode.
test_func = test
if use_tf_function:
    test_func = tf.function(test_func)

#####Test 1
arg1, arg2 = #some setup stuff
test_func(arg1, arg2)  # create the graph (tracing happens).
results = test_func(arg1, arg2)  # hopefully tracing does not happen a second time.
assert results

#####Test 2
arg4, arg3 = #some setup stuff
results = test_func(arg3, arg4)  # hopefully tracing does not happen again (if the inputs are tensors and the shapes do not change)
assert results

#is it right....?

Is this issue closed? or is it open for contributions? I see that the PR is closed. Thanks

PR has been closed in unmerged state

If I got the issue correctly you want to save the state of your graph so you can use lru cache, I tested both inside tensorflow library and only combination of @tf.function and @lru_cache in my main.py and both worked fine but actually i was testing a simple graph with one plus, I don't know the side effects

Is this feature still needed? I can see previous PR was closed in an unmerged state. Thanks.

if hv mentioned the right one......