Incorrect result when using tf.norm to conduct p-norm computation on float16 precision
@QuantumCoder4 Thank you for raising this issue. Could you please have a look at this [gist](https://colab.research.google.com/gist/sushreebarsa/555614567807ebe2f50e55a5fc1588d5/63643.ipynb) and confirm the results?
Thank you! Yes, I confirm the result. I would be appreciated if you could fix it.
### Issue type

Bug

### Have you reproduced the bug with TensorFlow Nightly?

Yes

### Source

source

### TensorFlow version

2.15.0

### Custom code

Yes

### OS platform and distribution

_No response_

### 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 behavior?

tf.norm outputs incorrect result under float16 computation when the ord is large. Here is the code to reproduce:

```
import tensorflow as tf
input = tf.constant(1.751, dtype="float16")
p = 144111111
print(tf.norm(input, p))   # tf.Tensor(1.0, shape=(), dtype=float16)
```
Instead, if I change the dtype to 'float32', tf.norm outputs `inf`. It seems that tf.norm overflows during this computation https://github.com/tensorflow/tensorflow/blob/9ce1d5f2f7e5e8866a55633c182cc2dda1a2d6b8/tensorflow/python/ops/linalg_ops.py#L784

Although fixing this issue by letting tf.norm also outputs `inf` in `float16` (which is consistent with the result in `float32`. I am suggesting another possible fix according to this post https://timvieira.github.io/blog/post/2014/11/10/numerically-stable-p-norms/

Indeed, the original implementation may not be numerical stable, a more stable one is to normalize the input before doing the actual computation. Here is the naive implementation of original tf.norm and the numerical stable one as a possible fix:

```
import tensorflow as tf
input = tf.constant(1.751, dtype="float16")
p = 144111111

def origin_norm(x, p):
  result = tf.math.abs(x)
  result = tf.math.pow(
      tf.reduce_sum(tf.math.pow(result, p), axis=None, keepdims=True),
      1.0 / p)
  return result

def refined_norm(x, p):
  a = np.abs(x).max()
  return a * origin_norm(x/a, p)

print(f"The original tf.norm's output is: ", tf.norm(input, p))
print(f"The naive implementation of tf.norm: {origin_norm(input, p)}, the refined norm: {refined_norm(input, p)}")
```

The `refined_norm` will output correct results (i.e., 1.7509765625) not only for `float16` computation but also for `float32` computation.


### Standalone code to reproduce the issue

```shell
import tensorflow as tf
input = tf.constant(1.751, dtype="float16")
p = 144111111

def origin_norm(x, p):
  result = tf.math.abs(x)
  result = tf.math.pow(
      tf.reduce_sum(tf.math.pow(result, p), axis=None, keepdims=True),
      1.0 / p)
  return result

def refined_norm(x, p):
  a = np.abs(x).max()
  return a * origin_norm(x/a, p)

print(f"The original tf.norm's output is: ", tf.norm(input, p))
print(f"The naive implementation of tf.norm: {origin_norm(input, p)}, the refined norm: {refined_norm(input, p)}")
```


### Relevant log output

_No response_