`softplus` outputs `inf` for large inputs after converting to lite model
Hi @YaoJiayi 

I was able to reproduce this issue. Please find the gist [here](https://colab.research.google.com/gist/pjpratik/5adbb5fe6d6eaae645b5f2862c14f097/60892.ipynb).

@pkgoogle Could you please look into this issue? 

Thanks. I tried the flex op option just in case it converts better:

[gist](https://colab.sandbox.google.com/gist/pkgoogle/54790a01e7daf4faafc424143a934380/60892.ipynb)

It is likely the conversion doesn't account properly for softplus having an out of bounds intermediary value.

Hi @haozha111, can you please take a look? Thanks. Just adding info:

Tensorflow performs this approximation/optimization here:
https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/softplus_op.h#32
```c++
struct Softplus {
  // Computes Softplus activation.
  //
  // features: any shape.
  // activations: same shape as "features".
  void operator()(const Device& d, typename TTypes<T>::ConstTensor features,
                  typename TTypes<T>::Tensor activations) {
    // Choose a threshold on x below which exp(x) may underflow
    // when added to 1, but for which exp(x) is always within epsilon of the
    // true softplus(x).  Offset of 2 from machine epsilon checked
    // experimentally for float16, float32, float64.  Checked against
    // softplus implemented with numpy's log1p and numpy's logaddexp.
    static const T threshold =
        Eigen::numext::log(Eigen::NumTraits<T>::epsilon()) + T(2);
    // Value above which exp(x) may overflow, but softplus(x) == x
    // is within machine epsilon.
    auto too_large = features > features.constant(-threshold);
    // Value below which exp(x) may underflow, but softplus(x) == exp(x)
    // is within machine epsilon.
    auto too_small = features < features.constant(threshold);
    auto features_exp = features.exp();
    activations.device(d) = too_large.select(
        features,                       // softplus(x) ~= x for x large
        too_small.select(features_exp,  // softplus(x) ~= exp(x) for x small
                         features_exp.log1p()));
  }
};
``` I am having the same problem here with Convolutional layers with softplus activation function at the end of the network as a regressor model. For prediction with lower values, the converted model turns out nicely. Here is examples of [[predicted]] [label]
```
[[87.694496]] [83]
[[79.957184]] [80]
[[71.28555]] [70]
[[72.062096]] [70]
[[71.2224]] [70]
```
However, for the prediction of higher values, a different converted model cannot handle this problem. See examples:
```
[[inf]] [125]
[[inf]] [124]
[[inf]] [140]
[[inf]] [135]
[[inf]] [138]
```
### 1. System information

- OS Platform and Distribution (e.g., Linux Ubuntu 16.04): Linux Ubuntu 20.04
- TensorFlow installation (pip package or built from source): pip
- TensorFlow library (version, if pip package or github SHA, if built from source): 2.14.0-dev20230602

### 2. Code
This is the minimized code to reproduce the issue:
```python
import tensorflow as tf
import numpy as np

x1 = tf.constant([100., 100.], shape=[1, 2])

class Model(tf.keras.Model):

  def __init__(self):
    super(Model, self).__init__()

  @tf.function(input_signature=[tf.TensorSpec(x1.shape, x1.dtype)])
  def call(self, x):
    return tf.math.softplus(x)

# Initializing the model
m = Model()

m(x1)
print('Keras mode output: ', m(x1))

converter = tf.lite.TFLiteConverter.from_keras_model(m)
tflite_model = converter.convert()

def _evaluateTFLiteModel(tflite_model, input_data):
    interpreter = tf.lite.Interpreter(model_content=tflite_model)
    interpreter.allocate_tensors()

    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    for i in range(len(input_data)):
        interpreter.set_tensor(input_details[i]['index'], input_data[i])

    interpreter.invoke()
    output_data = [interpreter.get_tensor(output_details[i]['index'])
                   for i in range(len(output_details))]
    return output_data

print('Lite mode output: ', _evaluateTFLiteModel(tflite_model,[x1])[0])
```
### 3. Failure after conversion
Output:
```
Keras mode output:  tf.Tensor([[100. 100.]], shape=(1, 2), dtype=float32)
Lite mode output:  [[inf inf]]
```
Model produces wrong results:
- The original model will produce `[[100, 100]]`, which is the same as the input tensor `x1`
- After converting to tflite, the model may compute `softplus(x) = log(exp(x) + 1)` by first computing `exp`, which causes overflow `[[inf, inf]]`

