Saltar al contenido principal

Detección de palabras clave con TensorFlow Lite en Raspberry Pi Mic HAT

Introducción​

Este proyecto demuestra cómo usar TensorFlow Lite para la detección de palabras clave en el ReSpeaker 2-Mics Pi HAT v2. La detección de palabras clave permite la detección en tiempo real de palabras predefinidas a partir de una entrada de audio, lo que habilita aplicaciones como dispositivos controlados por voz y sistemas interactivos. Te guiaremos a través de los pasos para entrenar un modelo de TensorFlow Lite, desplegarlo en el ReSpeaker HAT y ejecutar el reconocimiento de voz localmente.

Requisitos de hardware y software​

  • Hardware: Raspberry Pi con ReSpeaker 2-Mics Pi HAT v2
  • Software: TensorFlow Lite, Google Colab, Python y bibliotecas de soporte

Aplicaciones​

La detección de palabras clave se puede aplicar en:

  • Dispositivos de hogar inteligente
  • Robots controlados por voz
  • Quioscos interactivos

¿Qué es TensorFlow Lite?​

TensorFlow Lite es una versión ligera de TensorFlow diseñada para dispositivos móviles y embebidos. Permite la inferencia de aprendizaje automático con baja latencia y binarios pequeños, lo que lo hace ideal para ejecutar modelos en dispositivos de borde como Raspberry Pi.

Entrenar y obtener el modelo de TensorFlow Lite​

Conjunto de datos​

Usaremos un subconjunto del conjunto de datos Speech Commands para el entrenamiento. El conjunto de datos contiene archivos de audio WAV de personas diciendo diferentes palabras, recopilados por Google y publicados bajo una licencia CC BY. El conjunto de datos se puede descargar desde aquí. Para obtener más información sobre conjuntos de datos, consulta esta guía.

¿Por qué usar Google Colab?​

Google Colab es una plataforma en la nube para ejecutar notebooks de Jupyter. Proporciona acceso gratuito a recursos de GPU, lo que lo convierte en una excelente opción para entrenar modelos de aprendizaje automático sin requerir potencia de cómputo local.

Pasos​

Ahora usaremos un Notebook de Google Colab para realizar el entrenamiento de datos y generar un modelo de TensorFlow Lite en formato .tflite.

  • Paso 1. Abre este Notebook de Python

    Load Notebook

    De forma predeterminada, cargará el conjunto de datos mini Speech Commands, que es una versión más pequeña del conjunto de datos Speech Commands. El conjunto de datos original consta de más de 105 000 archivos de audio en formato de archivo de audio WAV (Waveform) de personas diciendo 35 palabras diferentes. Estos datos fueron recopilados por Google y publicados bajo una licencia CC BY.

  • Paso 2. Conéctate a un nuevo runtime seleccionando Changing runtime type -> CPU -> Save, luego haz clic en Connect.

    Change runtime type - 1 Change runtime type - 2

  • Paso 3. Navega a Runtime > Run all para ejecutar todas las celdas de código. Este proceso tardará unos 10 minutos en completarse.

    Run all

  • Paso 4. Una vez que se ejecuten todas las celdas de código, agrega una nueva celda y ejecuta el siguiente código para generar el archivo de modelo .tflite.

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

    with open('model.tflite', 'wb') as f:
    f.write(tflite_model)

    Append a new cell

  • Paso 5. Haz clic derecho en el archivo model.tflite generado y selecciona Download para guardar el archivo en tu computadora.

    Download

Inferencia local​

Ejecución del script de inferencia​

El script inference.py realiza los siguientes pasos:

  1. Carga el modelo entrenado de TensorFlow Lite.
  2. Procesa el audio de entrada en un espectrograma adecuado para la inferencia.
  3. Ejecuta la inferencia y muestra la palabra clave detectada junto con las puntuaciones de confianza para cada etiqueta.

Pasos para ejecutar​

  1. Sube el archivo de modelo model.tflite a tu Pi; en este ejemplo, lo colocamos en ~/speech_recognition/model.tflite.

  2. Guarda el siguiente script como ~/speech_recognition/inference.py:

    import numpy as np
    from scipy import signal
    from tflite_runtime.interpreter import Interpreter
    import soundfile as sf

    MODEL_PATH = 'model.tflite'
    LABELS = ['no', 'yes', 'down', 'go', 'left', 'up', 'right', 'stop']


    def get_spectrogram(waveform, expected_time_steps=124, expected_freq_bins=129):
        _, _, Zxx = signal.stft(
            waveform,
            fs=16000,
            nperseg=255,
            noverlap=124,
            nfft=256
        )
        spectrogram = np.abs(Zxx)

        if spectrogram.shape[0] != expected_freq_bins:
            spectrogram = np.pad(spectrogram, ((
                0, expected_freq_bins - spectrogram.shape[0]), (0, 0)), mode='constant')
        if spectrogram.shape[1] != expected_time_steps:
            spectrogram = np.pad(spectrogram, ((
                0, 0), (0, expected_time_steps - spectrogram.shape[1])), mode='constant')

        if spectrogram.shape != (expected_freq_bins, expected_time_steps):
            raise ValueError(
                f"Invalid spectrogram shape. Got {spectrogram.shape}, expected ({expected_freq_bins}, {expected_time_steps})."
            )

        spectrogram = np.transpose(spectrogram)

        return spectrogram


    def preprocess_audio(file_path):
        waveform, sample_rate = sf.read(file_path)
        if sample_rate != 16000:
            raise ValueError("Expected sample rate is 16 kHz")

        if len(waveform.shape) > 1:
            waveform = waveform[:, 0]

        spectrogram = get_spectrogram(waveform)
        spectrogram = spectrogram[..., np.newaxis]
        spectrogram = spectrogram[np.newaxis, ...]

        return spectrogram


    def run_inference(file_path):
        spectrogram = preprocess_audio(file_path)

        interpreter = Interpreter(MODEL_PATH)
        interpreter.allocate_tensors()

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

        input_shape = input_details[0]['shape']
        if spectrogram.shape != tuple(input_shape):
            raise ValueError(
                f"Expected input shape {input_shape}, got {spectrogram.shape}"
            )

        interpreter.set_tensor(
            input_details[0]['index'], spectrogram.astype(np.float32))

        interpreter.invoke()

        output_data = interpreter.get_tensor(output_details[0]['index'])[0]
        prediction = np.argmax(output_data)
        confidence = np.exp(output_data) / \
            np.sum(np.exp(output_data))

        print(f"command: {LABELS[prediction].upper()}")
        for label, conf in zip(LABELS, confidence):
            print(f"{label}: {conf:.2%}")


    if __name__ == "__main__":
        audio_file_path = 'test_audio.wav'
        run_inference(audio_file_path)

  3. Graba un sonido usando el siguiente comando; las palabras clave disponibles son: no, yes, down, go, left, up, right, stop.

    $ arecord -D "plughw:2,0" -f S16_LE -r 16000 -d 1 -t wav ~/speech_recognition/test_audio.wav

  4. Ejecuta el script:

    $ python3 inference.py
    INFO: Created TensorFlow Lite XNNPACK delegate for CPU.
    command: YES
    no: 8.74%
    yes: 21.10%
    down: 5.85%
    go: 14.57%
    left: 11.02%
    up: 8.25%
    right: 10.53%
    stop: 19.94%

Interpretación de los resultados​

El script muestra el comando detectado (por ejemplo, YES) y las puntuaciones de confianza para todas las etiquetas. Esto proporciona información sobre las predicciones del modelo y te permite evaluar su rendimiento.

Soporte técnico y debate sobre el producto​

Gracias por elegir nuestros productos. Estamos aquí para ofrecerte diferentes tipos de soporte y garantizar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para adaptarnos a diferentes preferencias y necesidades.

Loading Comments...