El reconocimiento de voz es un problema complejo en varias industrias. Conocer algunos de los conceptos básicos sobre el manejo de datos de audio y cómo clasificar muestras de sonido es algo bueno para tener en su caja de herramientas de ciencia de datos.  Vamos a ver un ejemplo de cómo clasificar algunos clips de sonido usando   . Para cuando supere esto, sabrá lo suficiente como para poder construir sus propios modelos de reconocimiento de voz. Con investigación adicional, puede tomar estos conceptos y aplicarlos a archivos de audio más grandes y complejos. Tensorflow  Puede encontrar el código completo en este repositorio de   . Github  Obtener los datos  La recopilación de datos es uno de los problemas difíciles en la ciencia de datos. Hay tantos datos disponibles, pero no todos son fáciles de usar en problemas de aprendizaje automático. Debe asegurarse de que los datos estén limpios, etiquetados y completos.  Para hacer nuestro ejemplo, vamos a utilizar algunos   . archivos de audio publicados por Google  Primero, crearemos una nueva   . Aquí es donde podrá construir, entrenar y probar su modelo y compartir un enlace con cualquier otra persona interesada:  canalización de Conducto          path =   root = co.Serial(image = get_image())   root[   ] = co.Exec(run_whole_thing,   )   root ### # Main Pipeline ###      -> co.Serial: def main () "/conducto/data/pipeline" # Get data from keras for testing and training "Get Data" f"   /raw" {path} return  Entonces empezaremos a escribir el  función:    run_whole_thing    os.makedirs(out_dir, exist_ok=   )   seed =   tf.random.set_seed(seed) np.random.seed(seed) data_dir = pathlib.Path(   )      : def run_whole_thing (out_dir) True # Set seed for experiment reproducibility 55 "data/mini_speech_commands"  A continuación, debemos configurar el directorio para almacenar los archivos de audio:       data_dir.exists():   tf.keras.utils.get_file(   , origin=   , extract=   ) if not # Get the files from external source and put them in an accessible directory 'mini_speech_commands.zip' "http://storage.googleapis.com/download.tensorflow.org/data/mini_speech_commands.zip" True  Preprocesamiento de los datos  Ahora que tenemos nuestros datos en el directorio correcto, podemos dividirlos en conjuntos de datos de entrenamiento, prueba y validación.  Primero, necesitamos escribir algunas funciones para ayudar a preprocesar los datos para que funcionen en nuestro modelo.  Necesitamos los datos en un formato que nuestro algoritmo pueda entender. Usaremos una red neuronal convolucional, por lo que los datos deben transformarse en imágenes.  Esta primera función convertirá el archivo de audio binario en un tensor:       audio, _ = tf.audio.decode_wav(audio_binary)   tf.squeeze(audio, axis=   ) # Convert the binary audio file to a tensor      : def decode_audio (audio_binary) return -1  Como tenemos un tensor con el que podemos trabajar que tiene los datos sin procesar, necesitamos obtener las etiquetas para que coincidan. Eso es lo que hace la siguiente función al obtener la etiqueta de un archivo de audio de la ruta del archivo:       parts = tf.strings.split(file_path, os.path.sep)   parts[   ] # Get the label (yes, no, up, down, etc) for an audio file.      : def get_label (file_path) return -2  A continuación, debemos asociar los archivos de audio con las etiquetas correctas. Estamos haciendo esto y devolviendo una tupla con la que Tensorflow puede trabajar:       label = get_label(file_path) audio_binary = tf.io.read_file(file_path) waveform = decode_audio(audio_binary)   waveform, label # Create a tuple that has the labeled audio files      : def get_waveform_and_label (file_path) return  Mencionamos brevemente el uso del algoritmo de red neuronal convolucional (CNN) anteriormente. Esta es una de las formas en que podemos manejar un modelo de reconocimiento de voz como este. Por lo general, las CNN funcionan muy bien con datos de imágenes y ayudan a reducir el tiempo de preprocesamiento.  Vamos a aprovechar eso convirtiendo nuestros archivos de audio en espectrogramas. Un espectrograma es una imagen de un espectro de frecuencias. Si observa un archivo de audio, verá que solo son datos de frecuencia. Así que vamos a escribir una función que convierta nuestros datos de audio en imágenes:         zero_padding = tf.zeros([   ] - tf.shape(waveform), dtype=tf.float32)   waveform = tf.cast(waveform, tf.float32) equal_length = tf.concat([waveform, zero_padding],   ) spectrogram = tf.signal.stft( equal_length, frame_length=   , frame_step=   ) spectrogram = tf.abs(spectrogram)   spectrogram # Convert audio files to images      : def get_spectrogram (waveform) # Padding for files with less than 16000 samples 16000 # Concatenate audio with padding so that all audio clips will be of the same length 0 255 128 return  Ahora que hemos formateado nuestros datos como imágenes, debemos aplicar las etiquetas correctas a esas imágenes. Esto es similar a lo que hicimos con los archivos de audio originales:       spectrogram = get_spectrogram(audio) spectrogram = tf.expand_dims(spectrogram,   ) label_id = tf.argmax(label == commands)   spectrogram, label_id # Label the images created from the audio files and return a tuple      : def get_spectrogram_and_label_id (audio, label) -1 return  La última función auxiliar que necesitamos es la que manejará todas las operaciones anteriores para cualquier conjunto de archivos de audio que le pasemos:         files_ds = tf.data.Dataset.from_tensor_slices(files)   output_ds = files_ds.map(get_waveform_and_label, num_parallel_calls=autotune)   output_ds = output_ds.map( get_spectrogram_and_label_id, num_parallel_calls=autotune)   output_ds # Preprocess any audio files      : def preprocess_dataset (files, autotune, commands) # Creates the dataset # Matches audio files with correct labels # Matches audio file images to the correct labels return  Ahora que tenemos todas estas funciones auxiliares, podemos dividir los datos.  Dividir los datos en conjuntos de datos  La conversión de archivos de audio a imágenes ayuda a que los datos sean más fáciles de procesar con una CNN y es por eso que escribimos todas esas funciones auxiliares. Haremos un par de cosas para simplificar la división de datos.  Primero, obtendremos una lista de todos los comandos potenciales para los archivos de audio que usaremos en algunos otros lugares del código:     commands = np.array(tf.io.gfile.listdir(str(data_dir))) commands = commands[commands !=   ] # Get all of the commands for the audio files 'README.md'  Luego obtendremos una lista de todos los archivos en el directorio de datos y los mezclaremos para que podamos asignar valores aleatorios a cada uno de los conjuntos de datos que necesitamos:     filenames = tf.io.gfile.glob(str(data_dir) +   )   filenames = tf.random.shuffle(filenames)   train_files = filenames[:   ]   validation_files = filenames[   :   +   ]   test_files = filenames[   :] # Get a list of all the files in the directory '/*/*' # Shuffle the file names so that random bunches can be used as the training, testing, and validation sets # Create the list of files for training data 6400 # Create the list of files for validation data 6400 6400 800 # Create the list of files for test data -800  Ahora tenemos nuestros archivos de entrenamiento, validación y prueba claramente separados para que podamos continuar y preprocesar estos archivos para prepararlos para construir y probar nuestro modelo. Estamos usando autoajuste aquí para ajustar el valor de nuestros parámetros dinámicamente en tiempo de ejecución:    autotune = tf.data.AUTOTUNE  Este primer ejemplo es solo para mostrar cómo funciona el preprocesamiento y nos da la  valor que necesitaremos en un momento:    spectrogram_ds    files_ds = tf.data.Dataset.from_tensor_slices(train_files) waveform_ds = files_ds.map( get_waveform_and_label, num_parallel_calls=autotune) spectrogram_ds = waveform_ds.map( get_spectrogram_and_label_id, num_parallel_calls=autotune) # Get the converted audio files for training the model  Como ha visto lo que es pasar por los pasos de preprocesamiento, podemos continuar y usar la función de ayuda para manejar esto para todos los conjuntos de datos:     train_ds = preprocess_dataset(train_files, autotune, commands) validation_ds = preprocess_dataset( validation_files, autotune, commands) test_ds = preprocess_dataset(test_files, autotune, commands) # Preprocess the training, test, and validation datasets  Queremos establecer una cantidad de ejemplos de entrenamiento que se ejecuten en cada iteración de las épocas, por lo que estableceremos un tamaño de lote:     batch_size =   train_ds = train_ds.batch(batch_size) validation_ds = validation_ds.batch(batch_size) # Batch datasets for training and validation 64  Por último, podemos reducir la cantidad de latencia en el entrenamiento de nuestro modelo aprovechando el almacenamiento en caché:     train_ds = train_ds.cache().prefetch(autotune) validation_ds = validation_ds.cache().prefetch(autotune) # Reduce latency while training  Nuestros conjuntos de datos finalmente están en una forma con la que podemos entrenar el modelo.  Construyendo el modelo  Dado que nuestros conjuntos de datos están claramente definidos, podemos seguir adelante y construir el modelo. Usaremos una CNN para crear nuestro modelo, por lo que necesitaremos obtener la forma de los datos para obtener la forma correcta para nuestras capas. Luego seguimos construyendo el modelo secuencialmente:       spectrogram, _   spectrogram_ds.take(   ): input_shape = spectrogram.shape num_labels = len(commands) norm_layer = preprocessing.Normalization() norm_layer.adapt(spectrogram_ds.map(   x, _: x)) model = models.Sequential([ layers.Input(shape=input_shape), preprocessing.Resizing(   ,   ), norm_layer, layers.Conv2D(   ,   , activation=   ), layers.Conv2D(   ,   , activation=   ), layers.MaxPooling2D(), layers.Dropout(   ), layers.Flatten(), layers.Dense(   , activation=   ), layers.Dropout(   ), layers.Dense(num_labels), ]) model.summary() # Build model for in 1 lambda 32 32 32 3 'relu' 64 3 'relu' 0.25 128 'relu' 0.5  Hacemos una configuración en el modelo para que nos dé la mayor precisión posible:     model.compile( optimizer=tf.keras.optimizers.Adam(), loss=tf.keras.losses.SparseCategoricalCrossentropy( from_logits=   ), metrics=[   ], ) # Configure built model with losses and metrics True 'accuracy'  El modelo está construido, así que ahora todo lo que queda es entrenarlo.  Entrenando al modelo  Después de todo el trabajo de preprocesamiento de los datos y construcción del modelo, el entrenamiento es relativamente simple. Determinamos cuántas épocas queremos ejecutar con nuestros conjuntos de datos de entrenamiento y validación:     EPOCHS =   model.fit( train_ds, validation_data=validation_ds, epochs=EPOCHS, callbacks=tf.keras.callbacks.EarlyStopping(verbose=   , patience=   ), ) # Finally train the model and return info about each epoch 10 1 2  ¡Eso es todo! El modelo ha sido entrenado y ahora solo falta probarlo.  Probando el modelo  Ahora que tenemos un modelo con una precisión de aproximadamente el 83 %, es hora de que probemos qué tan bien funciona con nuevos datos. Así que tomamos nuestro conjunto de datos de prueba y separamos los archivos de audio de las etiquetas:     test_audio = [] test_labels = []   audio, label   test_ds: test_audio.append(audio.numpy()) test_labels.append(label.numpy()) test_audio = np.array(test_audio) test_labels = np.array(test_labels) # Test the model for in  Luego tomamos los datos de audio y los usamos en nuestro modelo para ver si predice la etiqueta correcta:     y_pred = np.argmax(model.predict(test_audio), axis=   ) y_true = test_labels test_acc = sum(y_pred == y_true) / len(y_true) print(   ) # See how accurate the model is when making predictions on the test dataset 1 f'Test set accuracy:   ' {test_acc:   %} .0  Terminando la tubería  Solo hay un pequeño fragmento de código que necesitará para terminar su canalización y poder compartirlo con cualquiera. Esto define la imagen que se usará en esta canalización de Conducto y maneja la ejecución del archivo:             co.Image(   , copy_dir=   , reqs_py=[   ,   ,   ], )   __name__ ==   : co.main(default=main) ### # Pipeline Helper functions ###      : def get_image () return "python:3.8-slim" "." "conducto" "tensorflow" "keras" if "__main__"  Ahora puedes correr  en su terminal y debería generar un enlace a una nueva tubería de Conducto. Si no tienes una cuenta, puedes    python pipeline.py --local crear una gratis aquí.  Conclusión  Esta es una de las formas en que puede resolver un problema de procesamiento de audio, pero puede ser mucho más complejo según los datos que intente analizar. Construirlo en una canalización hace que sea fácil compartirlo con compañeros de trabajo y obtener ayuda o comentarios si se encuentra con errores.       Publicado anteriormente aquí .

Google

2022 - HackerNoon Contributor of the Year - Deep Learning

Check out my site!

Nominated for 2022 - HackerNoon Contributor of the Year - Deep Learning

Este audio es producido en el idioma original de la historia!

Cree su propio modelo de reconocimiento de voz con Tensorflow

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Nómadas digitales escuchen: lo que necesitan saber sobre la nueva visa DTV de Tailandia

Toque para ganar: Telegram puede incorporar a los próximos 10 mil millones de usuarios de criptomonedas antes de Solana

La guía completa para una migración exitosa a la nube: estrategias y mejores prácticas

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Nómadas digitales escuchen: lo que necesitan saber sobre la nueva visa DTV de Tailandia

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps