Nota: El próximo artículo lo ayudará con: Una guía práctica para el procesamiento diferencial de señales digitales empleando redes neuronales
En el creciente campo de la ciencia y la tecnología, el término “IA (inteligencia artificial)” juega un papel esencial gracias a los adelantos recientes que hicieron que la inteligencia artificial sea más popular que nunca y los conceptos de IA (inteligencia artificial) y estudio automático se vuelven populares entre las masas.
La IA (inteligencia artificial) ha jugado un papel clave y ha permitido que las máquinas aprendan de la experiencia, utilizando datos y procesamiento de datos para realizar tareas de forma más eficiente.
Se dice que la red neuronal artificial está inspirada en la composición del cerebro humano, lo que ayuda a las computadoras y máquinas a pensar y procesar mucho más como humanos.
Con cada descubrimiento y desarrollo, hay aún más para entender la composición perfecta de las redes neuronales de inteligencia artificial y sus procedimientos operativos.
Las redes neuronales artificiales, asimismo conocidas como ANN, son una herramienta clave de aprendizaje automático en la actualidad.
Las redes neuronales constan de una capa de entrada y una de salida, y una capa oculta en medio de la arquitectura, que contiene entidades que transforman los datos de entrada en salida, de modo que la cubierta de salida pueda utilizar el valor procesado.
Estas son herramientas útiles para encontrar patrones que son varios y complejos para que los desarrolladores los recobren y, por consiguiente, las máquinas están capacitadas para admitir patrones valiosos.
Las RNA constan de múltiples nodos que paralelamente imitan el desempeño de las neuronas biológicas del cerebro humano.
Las neuronas presentes en una red neuronal están interconectadas y también interaccionan constantemente entre sí conforme la red procesa la información.
Los nodos de entrada tienen la posibilidad de tomar datos de entrada y efectuar múltiples operaciones en ellos.
Los desenlaces de estas operaciones luego se emiten a otras neuronas.
La salida en cada nodo se asigna a un valor de activación o nodo.
Esta técnica de procesamiento imita el cerebro humano y, por ende, se transformó en la base de cara al desarrollo de algoritmos que pueden emplearse para modelar patrones complejos y problemas predictivos.
Asimismo se le llama MLP o perceptrón multicapa gracias a sus muchas capas.
La cubierta esconde provoca que la red sea mucho más rápida y eficaz al identificar solo la información esencial que se procesará desde la entrada, enfocándose en los pesos asignados y, en consecuencia, suprimiendo información redundante.
La clave para crear un buen modelo que dé predicciones exactas es encontrar los pesos perfectos que minimicen el fallo de predicción.
Esto se consigue implementando un método popular como algoritmo de retropropagación.
Este procedimiento transforma a ANN en un algoritmo de estudio como fallo de estudio; el modelo se optimización de forma automática.
Las redes neuronales dependen en gran medida de los datos de entrenamiento para estudiar y progresar su precisión con el tiempo.
Cuando estos algoritmos de aprendizaje se ajustan con precisión, se convierten en poderosas herramientas informáticas y de inteligencia artificial para clasificar y agrupar datos a alta velocidad.
Tareas como el reconocimiento automático del habla o el reconocimiento de imágenes pueden llevar minutos en vez de horas si los expertos efectúan la identificación manual.
El algoritmo de búsqueda de Google plus es un ejemplo de una red neuronal bien desarrollada.
La mayoría de las apps comerciales y las empresas comerciales usan estas tecnologías para solucionar problemas complejos como el reconocimiento de patrones o el reconocimiento facial.
Varias otras apps incluyen la transcripción de voz a artículo, el análisis de datos, el reconocimiento de escritura a mano para el procesamiento de talones, la predicción meteorológica y el procesamiento de señales.
¿Qué es el procesamiento de señales digitales diferenciales?
DDSP o Digital Signal Processing se puede llamar entre los pilares de la sociedad actualizada, con respecto a las telecomunicaciones, el transporte, el audio y muchas tecnologías médicas.
Los procesadores de señales digitales toman las formas de onda de voz, sonido, imagen, temperatura y después las procesan matemáticamente.
La iniciativa clave de DSP es hacer señales complejas y realistas controlando y ajustando con precisión sus varios parámetros.
Por ejemplo, se puede usar una colección de filtros lineales y osciladores sinusoidales para hacer un sonido de violín verdadera si las frecuencias y las respuestas se sintonizan correctamente.
No obstante, a veces es difícil supervisar de forma manual todos estos factores, con lo que la salida de los sintetizadores de sonido no es natural y robótica.
DDSP es una biblioteca de código abierto que usa una red neuronal para editar la entrada del usuario en controles DSP complejos que pueden contribuir a crear señales mucho más realistas.
La entrada puede ser cualquier forma de audio, incluidas las funcionalidades extraídas del propio audio.
Ya que las unidades DDSP son diferenciables, se puede entrenar una red neuronal para que se ajuste a un conjunto de datos mediante la propagación hacia atrás.
Elementos DDSP como cubierta final de salida del codificador automático.
Combina el sintetizador aditivo armónico, que añade ondas sinusoidales en muchas frecuencias distintas, con el sintetizador de ruido sustractivo, que filtra el ruido usando filtros cambiantes en el tiempo.
Luego, la señal de cada sintetizador se combina y pasa a través del módulo de reverberación para producir la manera de onda de sonido final.
Las pérdidas se calculan comparando el audio generado y los espectrogramas del audio fuente en seis tamaños de cuadro diferentes.
Dado que todos los elementos son diferenciables, tenemos la posibilidad de usar la propagación hacia atrás y el descenso de gradiente estocástico para entrenar la red de extremo a radical.
Fuente de imagen
Primeros pasos con el código
En este artículo, usaremos la biblioteca DDSP y las redes neuronales para hacer un convertidor de voz a música.
El modelo va a tomar el habla humana como entrada y reemplazará las maneras de onda con música afín a la de un violín.
Asimismo compararemos el audio original con el audio procesado para ver la clara diferencia.
El siguiente código es la implementación oficial de los programadores de DDSP y Magenta, cuyo ubicación página oficial está disponible en este enlace.
Instalación de la biblioteca
El paso inicial será disponer nuestra librería requerida; puede emplear el próximo comando para ello,
#Instalando biblioteca !pip install -qU ddsp==1.6.3
Importación de dependencias
Además de esto, importaremos dependencias y funcionalidades socorrieres para ayudar a crear nuestra canalización modelo y entablar la frecuencia de muestreo para nuestro convertidor de audio.
#Importar las dependencias necesarias importar copiar importar les tiempo de importación importar crepé importar ddsp importar ddsp.training desde ddsp.colab.colab_utils importar (auto_tune, get_tuning_factor, bajar, reproducir, grabar, diagrama de especificaciones, cargar, DEFAULT_SAMPLE_RATE) desde ddsp.training.postprocessing import ( detect_notes, fit_quantile_transform ) import gin from google plus.colab import archivos import librosa import matplotlib.pyplot as plt import numpy as np import pickle import tensorflow.compat.v2 as tf import tensorflow_datasets as tfds # Funciones socorrieres sample_rate = DEFAULT_SAMPLE_RATE # 16000
Grabación de audio para procesamiento
Además, en este momento ofreceremos a nuestro modelo una grabación de voz de 5 segundos como entrada, que nuestra canalización modelo procesará más.
#grabación de audio grabar_o_cargar = “Grabar” grabar_segundos = si grabar_o_cargar == “Grabar”: audio = grabar(segundos=grabar_segundos) else: nombres de ficheros, audio = cargar() audio = audio[0]sonido = sonido[np.newaxis, :]print(‘\nExtrayendo funciones de audio…’) # Plot. specplot(audio) play(audio) # Establecer sesión. ddsp.spectral_ops.reset_crepe() # Calcula funciones de audio de voz. start_time = time.time() audio_features = ddsp.training.metrics.compute_audio_features(audio) audio_features[‘loudness_db’] = funciones_de_audio[‘loudness_db’].astype(eg.float32) audio_features_mod = Ninguno print(‘Las funcionalidades de audio tardaron %.1f segundos’ % (time.time() – start_time)) TRIM = -15
En este momento también tracemos las peculiaridades de audio del discurso procesado,
# Trazar funciones de audio de voz. #Quita las especificaciones básicas de continuidad (f0) y volumen fig, ax = plt.subplots(nrows=3ncols=1sharex=True, size fig=(6, 8)) ax[0].plot(audio_features[‘loudness_db’][:TRIM]) hacha[0].set_ylabel(‘db_volumen’) hacha[1].plot(librosa.hz_to_midi(audio_features[‘f0_hz’][:TRIM])) hacha[1].set_ylabel(‘f0 [midi]’) hacha[2].plot(audio_features[‘f0_confidence’][:TRIM]) hacha[2].set_ylabel(‘certidumbre f0’) _ = hacha[2].set_xlabel(‘Paso de tiempo [frame]’)
Salida :
Nota: Los ficheros de audio anteriores unicamente se pueden ver en tiempo de ejecución).
La salida reproducirá el clip de audio de voz grabado de 5 segundos, y el modelo también traza características como el volumen, la frecuencia y la confianza.
Cargando el modelo de audio para la conexión
En este momento combinemos el sonido del habla con el sonido de otro instrumento monótono, que se sintetizará de nuevo para crear un nuevo sonido. Cargamos el sonido del instrumento violín aquí.
# Cargando modelo de audio modelo = “Violín” MODELO = modelo # Iterar mediante directorios hasta que se encuentre el directorio del modelo def find_model_dir (dirname): para raíz, directorios, nombres de archivo en les.walk (dirname): para nombre del archivo en nombres de archivo: si nombre del archivo.
termina (“.gin”), no el nombre del archivo.comienza con (“.”): model_dir = root break return model_dir si el modelo está en (‘Violín’, ‘Flauta’, ‘Flauta2’, ‘Trompeta’, ‘Saxofón_Tenor’) : # Cargue modelos antes entrenados.
PRETRAINED_DIR = ‘/contenido/entrenado’ .
!rm -r $PRETRAINED_DIR &> /dev/null !mkdir $PRETRAINED_DIR &> /dev/null GCS_CKPT_DIR = ‘gs://ddsp/models/timbre_transfer_colab/2021-07-08’ model_dir = os.path.join(GCS_CKPT_DIR , ‘solo_%s_ckpt’ % model.lower()) !gsutil cp $model_dir/* $PRETRAINED_DIR &> /dev/null model_dir = PRETRAINED_DIR gin_file = os.path.join(model_dir, ‘operative_config-0.gin’) else : # Modelos de usuario.
UPLOAD_DIR = ‘/content/uploaded’ !mkdir $UPLOAD_DIR uploaded_files = archivos.upload() for fnames in uploaded_files.keys(): print(“Desempaquetando… “.format(fnames)) !unzip -o “/content/ $fnames” -d $UPLOAD_DIR &> /dev/null model_dir = find_model_dir(UPLOAD_DIR) gin_file = les.path.join(model_dir, ‘operative_config-0.gin’) # Cargar estadísticas del grupo de datos.
DATASET_STATS = Ninguno dataset_stats_file = les.path.join(model_dir, ‘dataset_statistics.pkl’) print(f’Loading dataset stats from dataset_stats_file’) intente: si tf.io.gfile.exists(dataset_stats_file): con tf.io .gfile.GFile(dataset_stats_file, ‘rb’) como f: DATASET_STATS = pickle.load(f) salvo excepción como err: print(‘Fallo al cargar las estadísticas del conjunto de datos de pickle: .’.format(err) ) # Make asegúrese de que las dimensiones y las frecuencias de muestreo sean iguales time_steps_train = gin.query_parameter(‘F0LoudnessPreprocessor.time_steps’) n_samples_train = gin.query_parameter(‘Harmonic.n_samples’) hop_size = int(n_samples_train / time_steps_train) time_steps = int(audio.shapes)[1] /hop_size) n_samples = time_steps * hop_size gin_params = [‘Harmonic.n_samples = ’.format(n_samples),‘FilteredNoise.n_samples = ’.format(n_samples),‘F0LoudnessPreprocessor.time_steps = ’.format(time_steps),‘oscillator_bank.use_angular_cumsum = True’,]
with gin.unlock_config(): gin.parse_config(gin_params) # Cortar todos y cada uno de los vectores de audio de entrada a la longitud adecuada para la clave [‘f0_hz’, ‘f0_confidence’, ‘loudness_db’]: audio_features[key] = funciones_de_audio[key][:time_steps]
funciones_de_audio[‘audio’] = funciones_de_audio[‘audio’][:, :n_samples]
# Configure el modelo solo para adivinar el sonido dado el nuevo modelo de acondicionamiento = ddsp.training.models.Autoencoder() model.restore(ckpt) # Construya el modelo ejecutándolo por lotes. start_time = time.time() _ = model(audio_features, training=False) print(‘La restauración del modelo tomó %.1f segundos’ % (time.time() – start_time))
Creando nuestro sonido resintetizado
Nuestro paso final será enseñar y procesar nuestro sonido original con el sonido cargado para crear un sonido único,
#Resynthesize Audio af = audio_features si audio_features_mod es None other audio_features_mod # Realizar lote de predicción. start_time = time.time() outputs = model(af, training=False) audio_gen = model.get_audio_from_outputs(outputs) print(‘La predicción tomó %.1f segundos’ % (time.time() – start_time)) # Trazar un gráfico para equiparar print(‘Original’) reproducir(audio) print(‘Resíntesis’) reproducir(audio_gen) specplot(audio) plt.title(“Original”) specplot(audio_gen) _ = plt.title(“Resíntesis”)
La salida contendrá 2 ficheros de audio, el primero será nuestro audio de voz grabado original y el segundo va a ser el audio de síntesis.
En este momento tenemos la posibilidad de observar precisamente la diferencia entre los dos con el gráfico trazado.
Visualizaciones finales
En el artículo, exploramos qué es una red neuronal y cuáles son sus probables apps.
Asimismo creamos un modelo de conversión de voz a música usando redes neuronales y la biblioteca de procesamiento de señales digitales diferenciales.
Por último, procesamos, sintetizamos y equiparamos nuestro sonido para notar la diferencia entre ellos.
La próxima implementación se puede encontrar como un cuaderno de Colab al que se puede entrar a través del enlace aquí.
¡Que tengas un buen estudio!
Bibliografía
~~~~~~~~📱~~~~~~~~
Fikiri.net es el sitio perfecto para encontrar las últimas noticias y comentarios sobre gadgets y aplicaciones tecnológicas, así para conseguir consejos y trucos para sacar el máximo provecho de tu tecnología.
