Inconsistent output results between actual chip deployment and nntool for the same model

[zyx77777]

hi，
I developed a classification network model and performed 8-bit quantization using tflite. However, after deploying it on the chip, I cannot obtain correct classification results. I used the nntool to examine the output of each layer and found that nntool can produce correct results! Here's the specific situation:
In nntool, I discovered that 'adjust' and 'fusions --scale8' commands have no effect on the softmax layer output. Simply loading the model and applying 'set input_norm_func "x: x/255"' or 'imageformat input_1 bw8 shift_int8' can yield correct classification results. However, when deployed on the actual chip, the results are completely different.
I found a way to get the same incorrect softmax output in both environments: after applying 'adjust', 'fusions --scale8', and 'imageformat input_1 bw8 offset_int8', both environments produce the same incorrect softmax values. I've tried various approaches but still cannot obtain the correct softmax values.
Can anyone help me with this issue?
The following are the same inputs

[zyx77777]

#include "classification.h"
#include "classificationKernels.h"
#include "pmsis.h"
#include "bsp/bsp.h"
#include "cpx.h"
#include "test_image_data.h" // Include generated test image data
#include "classificationInfo.h" // Include quantization parameter information
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "timers.h"

// Add MIN/MAX macro definitions
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
#ifndef MAX
#define MAX(a,b) ((a)>(b)?(a):(b))
#endif

// Add Flash variable declaration
AT_HYPERFLASH_FS_EXT_ADDR_TYPE classification_L3_Flash = 0;

// Modified to unsigned char？？
static signed char *Input_1; // Input pointer
static short int *Output_1; // Output pointer

// Core variables
static struct pi_device cluster_dev;
static struct pi_cluster_task *task;
static struct pi_cluster_conf cluster_conf;

#define NUM_CLASSES 5
const char* GESTURE_NAMES[NUM_CLASSES] = {
"UP", "DOWN", "LEFT", "RIGHT", "STOP"
};

// Run neural network
static void RunNetwork()
{
classificationCNN(Input_1, Output_1);
}

// Input processing function
static void prepare_input() {
char buffer[256];

// 1. Print original input values
snprintf(buffer, sizeof(buffer), "\nOriginal input values (first 10): [");
for(int i = 0; i < 10; i++) {
    snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer),
            "%d%s", test_image[i], (i < 9) ? ", " : "]\n");
}
cpxPrintToConsole(LOG_TO_CRTP, buffer);

// 2. Direct copy input, conversion done inside CNN
for(int i = 0; i < 96*96; i++) {
    Input_1[i] = test_image[i];
}

// 3. Print input statistics
unsigned char min_val = 255;
unsigned char max_val = 0;
float avg_val = 0;

for(int i = 0; i < 96*96; i++) {
    min_val = MIN(min_val, Input_1[i]);
    max_val = MAX(max_val, Input_1[i]);
    avg_val += Input_1[i];
}
avg_val /= (96*96);

snprintf(buffer, sizeof(buffer), "\nInput statistics:\n"
         "Min: %u\nMax: %u\nAvg: %.2f\n"
         "First 10 values: [%u, %u, %u, %u, %u, %u, %u, %u, %u, %u]\n",
         min_val, max_val, avg_val,
         Input_1[0], Input_1[1], Input_1[2], Input_1[3], Input_1[4],
         Input_1[5], Input_1[6], Input_1[7], Input_1[8], Input_1[9]);
cpxPrintToConsole(LOG_TO_CRTP, buffer);

}

// Output processing function
static void process_outputs() {
char buffer[256];

// 1. Print raw int16 output
snprintf(buffer, sizeof(buffer), "\nRaw int16 output: [%d, %d, %d, %d, %d]\n",
         Output_1[0], Output_1[1], Output_1[2], Output_1[3], Output_1[4]);
cpxPrintToConsole(LOG_TO_CRTP, buffer);

// 2. Dequantization processing
float dequantized[NUM_CLASSES];
float max_prob = -1.0f;
int max_idx = 0;

// Use correct dequantization parameters
const float scale = 1.0f/32768.0f;  // For int16 output

// Dequantize and find maximum value
for(int i = 0; i < NUM_CLASSES; i++) {
    // Directly use int16 value for dequantization
    dequantized[i] = (float)Output_1[i] * scale;
    
    // Print intermediate values
    snprintf(buffer, sizeof(buffer), "Class %d: raw=%d, dequant=%.6f\n",
             i, Output_1[i], dequantized[i]);
    cpxPrintToConsole(LOG_TO_CRTP, buffer);
    
    if(dequantized[i] > max_prob) {
        max_prob = dequantized[i];
        max_idx = i;
    }
}

// 3. Print probability distribution
snprintf(buffer, sizeof(buffer), "\nProbability distribution: [%.6f, %.6f, %.6f, %.6f, %.6f]\n",
         dequantized[0], dequantized[1], dequantized[2], 
         dequantized[3], dequantized[4]);
cpxPrintToConsole(LOG_TO_CRTP, buffer);

// 4. Output prediction result
snprintf(buffer, sizeof(buffer), "\nPrediction result: %s (Confidence: %.2f%%)\n", 
         GESTURE_NAMES[max_idx], dequantized[max_idx] * 100.0f);
cpxPrintToConsole(LOG_TO_CRTP, buffer);

}

[zyx77777]

adjust
fusions --scale8
imageformat input_1 bw8 offset_int8
The two can get the same error value, other adjustments cannot get the same value, and the actual deployment is always the wrong classification