tf.experimental.numpy.power behaves differently when inputs are large numbers
The CPU behavior matches NumPy. The result overflows the underlying data type in NumPy.
```
>>> import numpy as np
>>> np.power(2, 62)
4611686018427387904
>>> np.power(2, 63)
-9223372036854775808
>>> np.power(2, 64)
0
>>> np.power(2, 128)
0
```

On GPU, the result is wrapping for some reason:
```
with tf.device("gpu"):
    print(tf.experimental.numpy.power(2, 63))
    print(tf.experimental.numpy.power(2, 64))
    print(tf.experimental.numpy.power(2, 65))
    print(tf.experimental.numpy.power(2, 66))
    print(tf.experimental.numpy.power(2, 67))
...

tf.Tensor(-9223372036854775808, shape=(), dtype=int64)
tf.Tensor(1, shape=(), dtype=int64)
tf.Tensor(2, shape=(), dtype=int64)
tf.Tensor(4, shape=(), dtype=int64)
tf.Tensor(8, shape=(), dtype=int64)
```

I haven't gotten too deep into the implementation (I'm new), but CPU and GPU seem to follow the same path all the way through `gen_math_ops.py._pow()`'s call to `pywrap_tfe.TFE_Py_FastPathExecute()`. I don't have the time to figure out what happens in `TFE_Py_FastPathExecute_C()` and maybe `GetOp()` are doing based on the device. @trickiwoo Thanks for reporting this issue.

I was able to reproduce this behaviour on TF 2.11 and TF Nightly 2.13.0-dev20230215. 

However, `tf.math.pow` has not shown any such behaviour on GPU. Please find the [gist](https://colab.research.google.com/gist/pjpratik/cc9e46c992bcc4631133f57064f9e7db/59705.ipynb) here.

@tilakrayal Could you please look into this. Thanks! Right, `tf.experimental.numpy.pow()` converts its scalar arguments to `tf.Tensor` before passing to `gen_math_ops._pow()`.

`tf.math.pow()` passes them as scalars. That seems to make a difference in the GPU case, but apparently not in the CPU case. Tried with Apple M1 GPU and it is giving the expected result.
Seems to be issue only when NVIDIA GPU is used. It needs more investigation.
```
with tf.device("gpu"):
    x_t = tf.experimental.numpy.power(2, 64)
    print(x_t)
```
`tf.Tensor(0, shape=(), dtype=int64)` This results is a signed int overflow, which is undefined behavior.  Different compilers can choose to do different things, so your program output is unpredictable, which is what you're seeing here. Are you satisfied with the resolution of your issue?
<a href="https://docs.google.com/forms/d/e/1FAIpQLSfaP12TRhd9xSxjXZjcZFNXPGk4kc1-qMdv3gc6bEP90vY1ew/viewform?entry.85265664=Yes&entry.2137816233=https://github.com/tensorflow/tensorflow/issues/59705">Yes</a>
<a href="https://docs.google.com/forms/d/e/1FAIpQLSfaP12TRhd9xSxjXZjcZFNXPGk4kc1-qMdv3gc6bEP90vY1ew/viewform?entry.85265664=No&entry.2137816233=https://github.com/tensorflow/tensorflow/issues/59705">No</a>

<details><summary>Click to expand!</summary> 
 
 ### Issue Type

Bug

### Have you reproduced the bug with TF nightly?

Yes

### Source

source

### Tensorflow Version

2.13.0.dev20230204

### Custom Code

Yes

### OS Platform and Distribution

Ubuntu 20.04.4 LTS

### Mobile device

_No response_

### Python version

_No response_

### Bazel version

_No response_

### GCC/Compiler version

_No response_

### CUDA/cuDNN version

_No response_

### GPU model and memory

_No response_

### Current Behaviour?

```shell
tf.experimental.numpy.power behaves differently when inputs are large numbers
```


### Standalone code to reproduce the issue

```shell
import tensorflow as tf

with tf.device("cpu"):
    x_t = tf.experimental.numpy.power(2, 64)
    print(x_t)

with tf.device("gpu"):
    x_t = tf.experimental.numpy.power(2, 64)
    print(x_t)
```


### Relevant log output

```shell
tf.Tensor(0, shape=(), dtype=int64)
tf.Tensor(1, shape=(), dtype=int64)
```
</details>