In Ardiono:Hybrid models are not supported on TFLite Micro. Node FULLY_CONNECTED (number 12f) failed to prepare with status 1
Hi @MohamedGehad12 

Which type of quantization have chosen? For TFLite micro, you should go for full integer quantization. The default optimization leaves part of the operations as floating point (hence hybrid) and mixing isn't supported in micro. See here:
https://www.tensorflow.org/lite/performance/post_training_quantization

Thank You



 This issue is stale because it has been open for 7 days with no activity. It will be closed if no further activity occurs. Thank you. This issue was closed because it has been inactive for 7 days since being marked as stale. Please reopen if you'd like to work on this further. 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/64223">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/64223">No</a>

### Issue type

Support

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

No

### Source

source

### TensorFlow version

2.15

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

in Ardiono this message show up and i Don't know why . Hybrid models are not supported on TFLite Micro.
Node FULLY_CONNECTED (number 12f) failed to prepare with status 1

### Standalone code to reproduce the issue

```shell
#include <LSM6DS3.h>
#include <Wire.h>


#include <TensorFlowLite.h>
#include <tensorflow/lite/micro/all_ops_resolver.h>
#include <tensorflow/lite/micro/micro_error_reporter.h>
#include <tensorflow/lite/micro/micro_interpreter.h>/
#include <tensorflow/lite/schema/schema_generated.h>
//#include <tensorflow/lite/version.h>

#include "your_model_tflite.h"

#define NUM_READINGS 141
int readingIndex = 0;
float reshaped_readings[1][NUM_READINGS][1];
// global variables used for TensorFlow Lite (Micro)
tflite::MicroErrorReporter tflErrorReporter;

// pull in all the TFLM ops, you can remove this line and
// only pull in the TFLM ops you need, if would like to reduce
// the compiled size of the sketch.
tflite::AllOpsResolver tflOpsResolver;

const tflite::Model* tflModel = nullptr;
tflite::MicroInterpreter* tflInterpreter = nullptr;
TfLiteTensor* tflInputTensor = nullptr;
TfLiteTensor* tflOutputTensor = nullptr;

// Create a static memory buffer for TFLM, the size may need to
// be adjusted based on the model you are using
constexpr int tensorArenaSize = 90 * 1024;
byte tensorArena[tensorArenaSize] __attribute__((aligned(16)));

// array to map gesture index to a name
const char* GESTURES[] = {
  "Class 1",
  "Class 2",
  "Class 3",
  "Class 4",
  "Class 5"
};

#define NUM_GESTURES (sizeof(GESTURES) / sizeof(GESTURES[0]))
void setup() {
  // put your setup code here, to run once:
Serial.begin(115200);
pinMode(2, INPUT); // Setup for leads off detection LO +
pinMode(3, INPUT); // Setup for leads off detection LO -
while(!Serial);
Serial.println("awl haga fe setupp");
 // get the TFL representation of the model byte array
  tflModel = tflite::GetModel(your_model_tflite);
  if (tflModel->version() != TFLITE_SCHEMA_VERSION) {
    Serial.println("Model schema mismatch!");
    while (1);
  }
  Serial.println("after while 1 ");
  tflInterpreter = new tflite::MicroInterpreter(tflModel, tflOpsResolver, tensorArena, tensorArenaSize, &tflErrorReporter);
  Serial.println("after tflInterpreter = new ");
  // Allocate memory for the model's input and output tensors
  TfLiteStatus allocare_status = tflInterpreter->AllocateTensors();
  if(allocare_status !=kTfLiteOk){
    Serial.println("arena size  failed!");
    Serial.println(allocare_status);
     Serial.println(kTfLiteOk);
  }
  Serial.println(" after tflInterpreter->AllocateTensors() ");
}

void loop() {
  // put your main code here, to run repeatedly:
 Serial.println("awl haga f eloop");
  
 while (readingIndex < NUM_READINGS) {
if((digitalRead(2) == 1)||(digitalRead(3) == 1)){
Serial.println('!');
}
else{
// send the value of analog input 0:
Serial.println(analogRead(A0));
 int number = analogRead(A0);
  number = number - 512;
  float normalized = number / 512.0; // Convert to float for accurate division
  reshaped_readings[0][readingIndex][0] = normalized;
}
readingIndex++;
 } 
  Serial.println("redings :");
  for(int i=0;i<NUM_READINGS;i++){
  Serial.print(reshaped_readings[0][i][0]); 
  }
  float* input_data = tflInputTensor->data.f;
    for (int i = 0; i < NUM_READINGS; i++) {
      Serial.println(i);
        *input_data++ = reshaped_readings[0][i][0];
    }
  Serial.println("after the inputing the data ");
  TfLiteStatus invokeStatus = tflInterpreter->Invoke();
    if (invokeStatus != kTfLiteOk) {
      Serial.println("Invoke failed!");
      while (1);
      return;
    }
    Serial.println("after the invoking ");
 delay(100);
 Serial.println();
}
```


### Relevant log output

_No response_