Gathering Sensor Data using Keyword Spotting

void loop()
{
    microphone_inference_record();

    signal_t signal;
    signal.total_length = EI_CLASSIFIER_SLICE_SIZE;
    signal.get_data = &microphone_audio_signal_get_data;
    ei_impulse_result_t result = {0};

    EI_IMPULSE_ERROR r = run_classifier_continuous(&signal, &result, debug_nn);
    if (r != EI_IMPULSE_OK)
    {
        displayAndPrint("ERR: Failed to run classifier.");
        return;
    }

    if (++print_results >= (EI_CLASSIFIER_SLICES_PER_MODEL_WINDOW))
    {
        // Assume the cyclical buffer is fully valid and of length EI_CLASSIFIER_RAW_SAMPLE_COUNT
        signed short *classified_buffer = inference.cyclical_buffer;
        unsigned int buffer_length = EI_CLASSIFIER_RAW_SAMPLE_COUNT;

        for (size_t ix = 0; ix < EI_CLASSIFIER_LABEL_COUNT; ix++)
        {
            if (result.classification[ix].value > 0.5)
            {
                displayAndPrint((String(result.classification[ix].label) + ": " + result.classification[ix].value).c_str());
                saveAudioToSD(result.classification[ix].label, classified_buffer, buffer_length);
            }
        }
        print_results = 0;
    }

    clearDisplayAfterDuration();
}

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Conv2D, DepthwiseConv2D, Dense, BatchNormalization, ReLU, GlobalAveragePooling2D, Reshape, Dropout, Input
from tensorflow.keras.optimizers import Adam
from typing import Tuple
from sklearn.utils.class_weight import compute_class_weight

def mb_conv_block(inputs, filters, kernel_size, strides):
    x = Conv2D(filters, kernel_size, strides=strides, padding='same', use_bias=False)(inputs)
    x = BatchNormalization()(x)
    x = ReLU()(x)

    x = DepthwiseConv2D(kernel_size=(3, 3), strides=(1, 1), padding='same', use_bias=False)(x)
    x = BatchNormalization()(x)
    x = ReLU()(x)

    x = Conv2D(filters, kernel_size=(1, 1), strides=(1, 1), padding='same', use_bias=False)(x)
    x = BatchNormalization()(x)
    return x

def create_efficientnet_like_model(input_shape: Tuple[int, int, int], num_classes: int) -> Model:
    inputs = Input(shape=input_shape)
    x = mb_conv_block(inputs, filters=32, kernel_size=(3, 3), strides=(2, 2))
    x = mb_conv_block(x, filters=64, kernel_size=(3, 3), strides=(1, 1))
    x = mb_conv_block(x, filters=128, kernel_size=(3, 3), strides=(2, 2))
    x = mb_conv_block(x, filters=256, kernel_size=(3, 3), strides=(1, 1))

    x = GlobalAveragePooling2D()(x)
    x = Reshape((1, 1, 256))(x)
    x = Dropout(0.3)(x)
    x = Dense(num_classes, activation='softmax')(x)
    x = Reshape((num_classes,))(x)

    model = Model(inputs=inputs, outputs=x)
    model.compile(optimizer=Adam(learning_rate=0.001),
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    return model

# Calculate class weights
labels = np.argmax(y_train, axis=1)  # Assuming y_train is one-hot encoded
class_weights = compute_class_weight('balanced', classes=np.unique(labels), y=labels)
class_weights_dict = dict(enumerate(class_weights))

# Model configuration
num_classes = y_train.shape[1]  # Number of classes, ensure y_train is defined
input_shape = (X_train.shape[1], X_train.shape[2], 1)  # Adjust based on your actual input shape, ensure X_train is defined

model = create_efficientnet_like_model(input_shape, num_classes)
model.summary()

# Fit and evaluate model
X_train_reshaped = X_train[..., np.newaxis]  # Add a channel dimension, ensure X_train is defined
X_test_reshaped = X_test[..., np.newaxis]    # Add a channel dimension, ensure X_test is defined

history = model.fit(X_train_reshaped, y_train, validation_split=0.2, epochs=50, batch_size=32, verbose=2, class_weight=class_weights_dict)
loss, accuracy = model.evaluate(X_test_reshaped, y_test, verbose=2)  # Ensure y_test is defined
print(f'Test loss: {loss}')
print(f'Test accuracy: {accuracy}')

# save model as best_model.h5
model.save('best_model.h5')