Why are not all of my conv2d layer weights Int8 when converting with dynamic range quantization?
Since two people already took a look at this issue: Could you perhaps comment on whether what I experience is to be expected or if it is, indeed, a bug? Hi @christian-steinmeyer 

Sorry for the delayed response. 

I was able to reproduce the issue for dynamic range quantization, but with representative dataset, the full integer quantization, the conversion works fine. Please find this [gist](https://colab.research.google.com/gist/pjpratik/c44593dbedf19f58327a3e3eb4b44aa2/61896.ipynb).

@pkgoogle Could you please check this issue?

Thanks. Hi @pjpratik and thank you for getting back to me! Just now, using a representative dataset is not an option for me (although it is likely to be a step down the line - so thanks for already checking that it works!). And mostly I am looking for an answer to the question: Did I misunderstand anything or should all conv2d layers have int8 weights? Hi @christian-steinmeyer, the default behavior of the quantization system is to fallback to float32 ops if the converter finds it impossible (for various reasons) to convert the entire model to int8 ... that being said if it is possible to convert it to int8 and it doesn't, then that's a bug. So unless explicitly stated otherwise, you can expect the default behavior. Thanks for the response @pkgoogle! Are those various reasons documented somewhere? Hi @christian-steinmeyer, unfortunately, not that I currently know of .. there are some code changes coming up which will make it more obvious/known to end users (at least when it fails), but it will likely be experimental when first releasing. Alright, looking forward to those changes - I suppose they are coming with 2.15? @christian-steinmeyer, Unfortunately not, I am not comfortable making a prediction yet on it's release date yet. Alright - thanks for the feedback! For the case I posted above, how exactly can I find out if it is expected behavior? Do you know that by chance?

I created the model using code like this
```py
    model = tf.keras.Sequential([
        tf.keras.layers.InputLayer(input_shape=(5, None, 1)),
        tf.keras.layers.Conv2D(16, (3, 3), padding='same', activation='relu'),
        tf.keras.layers.DepthwiseConv2D((3, 3), padding='same'),
        tf.keras.layers.Conv2D(16, (3, 3), padding='same', activation='relu'),
        tf.keras.layers.AveragePooling2D((3, 3), padding='same'),
    ])
``` Hi @christian-steinmeyer,

I don't see a reason why that shouldn't be fully convertable, @abattery, can you please take a look? Thanks. Hello @christian-steinmeyer, I'm encountering the same problem, some Conv2d layers are DQing into int8 and some are not. Have you found a workaround or the source of the problem?  Hi @Doomski99, I have not. Without diving deep into the code, I pretty much just accepted TF's behavior at that point. 
### 1. System information

- OS Platform and Distribution (e.g., Linux Ubuntu 16.04): MacOS Ventura 13.5.2 (22G91)
- TensorFlow installation (pip package or built from source): pip 
- TensorFlow library (version, if pip package or github SHA, if built from source): 2.13.0

### 2. Code
I have a [Keras model](https://github.com/tensorflow/tensorflow/files/12650691/model.zip) (here, I uploaded just an untrained sub-model which is equivalent to the beginning of my actual model) and follow the [Post-training dynamic range quantization guide](https://www.tensorflow.org/lite/performance/post_training_quant) to convert it to a tflite model.
```py
# model defined above
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
```

### 3. Failure after conversion
- Model produces correct results, but it is slower than the dynamic range Float16 quantized version.
- Tflite model has some Conv2D layers with Int8 weights (expected) and some Conv2D layers with Float32 weights (not expected)

### 5. (optional) Any other info / logs
I am confused because I didn't come across any documentation whatsoever stating that only parts of the model might be quantized. 