Nota: El siguiente producto lo va a ayudar con: Guía de la biblioteca de procesamiento de señales digitales diferenciales (DDSP) con código python
El procesamiento de señal digital diferenciable (DDSP) es una biblioteca de generación de sonido que emplea elementos interpretables DSP tradicionales (como osciladores, filtros, sintetizadores) con modelos de aprendizaje profundo.
Fue presentado por Jesse Engel, Lamtharn (Hanoi) Hantrakul, Chenjie Gu y Adam Roberts (producto de ICLR).
Antes de entrar en los datos de la biblioteca, familiaricémonos con el concepto de DSP.
¿Qué es DSP?
El procesamiento de señales digitales (DSP) es el proceso mediante el cual se toman como entrada señales digitalizadas como audio, video, presión, temperatura, etc. para efectuar operaciones matemáticas sobre ellas, p.
Agregar, restar o multiplicar señales.
Visite esta página para obtener detalles de DSP.
Descripción general de DDSP
La biblioteca DDSP crea señales de audio complicadas y realistas al controlar los factores de un DSP fácil y también interpretable, como sintonizar las frecuencias y las respuestas de los osciladores sinusoidales y los filtros lineales; puede sintetizar el sonido de un instrumento realista como violín, flauta, etc.
¿De qué manera marcha DSP?
Fuente de imagen: Documentación Oficial
Los modelos de redes neuronales como WaveNet, utilizados para producir audio, pueden generar maneras de onda tomando una muestra a la vez.
A diferencia de estos modelos, DDSP pasa factores mediante algoritmos de síntesis de audio conocidos.
Todos los elementos de la figura anterior son diferenciables, el modelo se puede entrenar de radical a radical a través de el descenso de gradiente estocástico y la retropropagación.
Implementación práctica de DDSP
Fuente de imagen: La demostración oficial de Colab
Aquí hay una demostración de transferencia de color (tono/tono) empleando DDSP.
El código fue implementado empleando Google+ colab z Pitón 3.7.10 Y dsp 1.2.0 versiones.
La explicación punto por punto del código es la próxima:
- Disponer la biblioteca DDSP
!pip instalar ddsp
- Importe las bibliotecas y los módulos necesarios.
importar observaciones.filteradvertencias(“ignorar”) importar copia importar o # para la interacción del S.O. tiempo de importación importar crepé importar ddsp importar ddsp.entrenamiento de ddsp.colab importar colab_utils de ddsp.colab.colab_utils importar ( auto_tune, detector_notes, fit_quantile_transform , get_tuning_factor , bajar, reproducir, grabar, plotear, subir, DEFAULT_SAMPLE_RATE) importar gin desde google+.colab importar ficheros importar librosa importar matplotlib.pyplot como pl importar numpy como np importar pickle importar tensorflow.compat.v2 como tf importar tensorflow_datasets como tfds
- Inicialice la continuidad de muestreo de la señal (aquí se usa la frecuencia de muestreo ya establecida de 16000 definida en ddsp.spectral_ops)
sample_rate = DEFAULT_SAMPLE_RATE
- Enseñar opciones para que el usuario grabe o transmita la entrada de audio.
En la situacion de grabación, debería ser viable elegir el número de segundos a lo largo de los cuales se va a grabar.
#Permitir cargar archivos .mp3 o .wav record_or_upload = “Subir (.mp3 o .wav)” #@param [“Record”, “Upload (.mp3 or .wav)”]””” La duración de la grabación se puede ingresar de 1 a 10 segundos; se puede cambiar en el paso 1 segundo “”” record_seconds = 20 #@param type:”number”, min:1max:10, step:1
- Defina las acciones a realizar dependiendo de la selección del usuario de una grabación o carga de audio.
#Si el usuario escoge “Grabar”, grabe el audio desde el navegador empleando el método record() definido aquí if record_or_upload == “Grabar”: audio = record(seconds=record_seconds) “”” Si el usuario escoge “Subir”, deja cargar un archivo de audio .wav o .mp3 desde el disco a colab utilizando el procedimiento upload() definido aquí “”” else: filenames, audios = upload() “”” upload() devuelve los nombres de los ficheros cargados y sus que corresponden sonido.
Si un usuario está cargando múltiples ficheros, elija el primero de la matriz “audios” “”” audio=audios[0]sonido = sonido[np.newaxis, :]print(‘\nExtrayendo funcionalidades de audio…’)
- Trace el espectro de una señal de audio empleando el método specplot().
diagrama de informaciones (audio)
Cree un widget de audio HTML5 empleando el procedimiento play() para reproducir un fichero de audio
reproducir sonido)
Restablezca el estado CREPE global para reconstruir el modelo
ddsp.spectral_ops.reset_crepe()
- Almacenar la hora de comienzo del sonido
hora_inicio = hora.hora()
Calcular funciones de audio
audio_features = ddsp.training.metrics.compute_audio_features(audio)
Registre el volumen (en decibelios) del sonido
funciones_de_audio[‘loudness_db’] = funciones_de_audio[‘loudness_db’].astype(eg.float32) audio_features_mod = Ninguno
Calcule el tiempo necesario para calcular la función de audio quitando la hora de inicio de la hora de hoy
print(‘Las funciones de audio tardaron %.1f segundos’ % (time.time() – start_time))
- Marcar las características calculadas
fig, ax = plt.subplots(nrows=3ncols=1sharex=True, size fig=(6, 8)) #Trazar el volumen del hacha de audio[0].plot(audio_features[‘loudness_db’][:-15]) hacha[0].set_ylabel(‘loudness_db’) #Plot nota frecuencia MIDI hacha[1].plot(librosa.hz_to_midi(audio_features[‘f0_hz’][:TRIM])) hacha[1].set_ylabel(‘f0 [midi]’) #Trazar la seguridad de la señal de audio del hacha[2].plot(audio_features[‘f0_confidence’][:TRIM]) hacha[2].set_ylabel(‘certeza f0’) _ = hacha[2].set_xlabel(‘Paso de tiempo [frame]’)
Salida:
El fichero de audio .mp3 que usamos para la demostración:
(Fuente del fichero de audio)
- Seleccione el modelo de instrumento entrenado que se usará.
modelo=”Violín” #@param [‘Violin’, ‘Flute’, ‘Flute2’, ‘Trumpet’, ‘Tenor_Saxophone’, ‘Upload your own (checkpoint folder as .zip)’]MODELO = modelo
Determinar una función para encontrar el modelo elegido
def find_model_dir(directoryname): # Iterar a través de los directorios hasta encontrar el directorio del modelo para raíz, directorios, nombres de archivo en les.walk(directoryname): for filename in filenames: if filename.ends(“.gin”) y no file_name.starts with ( “.”): model_dir = root devuelve model_dir
- Escoja el modelo que desea utilizar.
if model w (‘Violin’, ‘Flauta’, ‘Flute2’, ‘Trumpet’, ‘Tenor_Saxophone’): # Modelos pre-entrenados.
PRETRAINED_DIR = ‘/content/pretrained’ # Copia de gs:// para una carga mucho más rápida.
!rm -r $PRETRAINED_DIR &> /dev/null !mkdir $PRETRAINED_DIR &> /dev/null GCS_CKPT_DIR = ‘gs://ddsp/models/timbre_transfer_colab/2021-01-06’ model_dir = les.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 = os.path.join(model_dir, ‘operative_config-0.Gin’)
- Cargue el fichero de 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: #Cargar el archivo de estadísticas del conjunto de datos si existe if tf.io.gfile . existe (dataset_stats_file): with tf.io.gfile.GFile(dataset_stats_file, ‘rb’) como f: DATASET_STATS = pickle.load(f) #publicar salvedad si falla la carga del fichero salvo excepción como err: print( ‘Cargando grupo de datos estadísticos desde pickle falló: .’.format(err))
- Determinar un procedimiento para investigar la configuración de la ginebra
#Primero, desbloquee temporalmente la configuración utilizando el gestor de contexto con gin.unlock_config(): #Examine el archivo con parse_config_file() definido aquí gin.parse_config_file(gin_file, skip_unknown=True)
- Almacenar archivos de puntos de control
“”” Para cada archivo en la lista que tiene dentro ficheros de catálogo de modelos, agréguelo a “ckpt_files” si tiene un punto de control “”” ckpt_files= [f for f in tf.io.gfile.listdir(model_dir) if ‘ckpt’ in f]#Quita el nombre del archivo del punto de control ckpt_name= archivos_ckpt[0].división(‘.’)[0]#Agregue el nombre del archivo del punto de control a la ruta del directorio del modelo
- Compruebe que las dimensiones y las frecuencias de muestreo sean iguales
“”” gin.query_parameter() devuelve el valor en la actualidad asociado con la clave de vinculación especificada como su factor.
Un link es un factor cuyo valor necesitamos consultar “””.
número de muestras entre fotogramas sucesivos (llamado ‘tamaño de salto’) hop_size = int(n_samples_train / time_steps_train) # Calcular el tiempo total del paso y el número de muestras time_steps = int(audio.shape[1] / jump_size) n_samples = time_steps * jump_size
- Crear una lista de factores de ginebra
gin_parámetros = [ ‘Harmonic.n_samples = ’.format(n_samples), ‘FilteredNoise.n_samples = ’.format(n_samples), ‘F0LoudnessPreprocessor.time_steps = ’.format(time_steps), ‘oscillator_bank.use_angular_cumsum = True’, ]Examine los parámetros de gin precedentes #Primero desbloquee la configuración con gin.unlock_config(): #Examine la lista de links de parámetros con parse_config() gin.parse_config(gin_params)
- Recorte los vectores de entrada a las longitudes adecuadas
#Dispara cada frecuencia, seguridad y volumen a la duración del paso de tiempo para la entrada [‘f0_hz’, ‘f0_confidence’, ‘loudness_db’]: audio_features[key] = funciones_de_audio[key][:time_steps]
#Trip vector ‘audio’ a una longitud igual al total de muestras de audio_features[‘audio’] = funciones_de_audio[‘audio’][:, :n_samples]
- Inicializar el modelo para adivinar el sonido.
modelo = ddsp.entrenamiento.modelos.Autoencoder()
Restaurar puntos de control del modelo
modelo.volver a poner(ckpt)
- Cree el modelo corriendo un grupo de funcionalidades de audio en él.
#Registra la hora de comienzo del audio start_time = time.time() #Crea el modelo utilizando las funciones calculadas _ = model(audio_features, training=False) “”” Muestra el tiempo preciso para construir el modelo calculando la diferencia entre la hora de hoy y la hora de inicio del audio “” ” print(‘Tomó %.1f segundos volver a poner el modelo’ % (time.time() – start_time))
Salida de muestra: Se tardó 2,0 segundos en restaurar el modelo.
- Los modelos preentrenados (violín, flauta, etcétera.) no fueron entrenados de forma directa para el timbre, por lo que pueden sonar poco naturales si las frecuencias de entrada y el volumen del sonido son muy dispares de los datos de entrenamiento (lo que será cierto en la mayoría de los casos). tiempo).
Hacer controles deslizantes para condicionar el modelo
#@markdown ## Detección de notas #@markdown Puede dejarlo en 1.0 para la mayoría de los casos umbral = 1 #@param tipo: “deslizador”, min: 0.0max:2.0paso:0.01 #@markdown ## AJUSTE automático = Verdadero #@paramtype:”boolean” #@markdown Partes silenciosas sin notas detectadas (dB) quiet = 20 #@param type:”slider”, min: 0max:60, step:1 #@markdown Force Pitch siguiente nota (cantidad) autotune = 0 #@param tipo: “deslizador”, min: 0.0max:1.0step:0.1 #@markdown ## Manual #@markdown Cambio de tono (octava) pitch_shift = 0 # @param tipo :”slider”, min:-2max:2step:1 #@markdown Ajusta el volumen general (dB) Louness_shift = 0 #@param type:”slider”, min:-20, max:20, step:1 audio_features_mod = k: v.copia() para k, v en audio_features.items()
Los controles deslizantes para cambiar el condicionamiento aparecen en colab de la próxima manera:
- Definir el método de cambio de volumen
def shift_ld(audio_features, ld_shift=0.0): #Aumentar el volumen por ld_shift audio_features[‘loudness_db’] += ld_shift #Return funcionalidades de audio cambiadas return audio_features
- Determinar el procedimiento de cambiar la frecuencia por el número de octavas
def shift_f0(audio_features, pitch_shift=0.0): # Multiplica la continuidad por 2^ Pitch_shift audio_features[‘f0_hz’] *= 2.0 ** (cambio_de_tono) funciones_de_audio[‘f0_hz’] = np.clip(audio_features[‘f0_hz’].0.0librosa.midi_to_hz(110.0)) devolver audio_features
- Advertir secciones de audio que están “activadas”
si ADJUST y DATASET_STATS no son Ninguno: #Guardar volumen, seguridad y notas de la sección “on” mask_on, note_on_value = detect_notes(audio_functions)[‘loudness_db’]funciones_de_audio[‘f0_confidence’],límite)
Desplazamiento de cuantiles de la parte con la sección “activada”.
_, volume_norm = colab_utils.fit_quantile_transform(audio_features[‘loudness_db’],mask_on, inv_quantile=DATASET_STATS[‘quantile_transform’])
Baje las unas partes de audio con notas “apagadas”.
#Si mask_on no es verdadero, asigne esta nota como ‘mask_off’ mask_off = np.logical_not(mask_on) #En la tabla de sonoridad normalizada, calcule la sonoridad de estas notas excluidas[mask_off] -= relajado * (1.0 – atención_a_los_valores[mask_off][:, np.newaxis]) #Reformar matriz de sonoridad normalizada volume_norm = np.reshape(loudness_norm, audio_features[‘loudness_db’].shape) #Actualizar volumen (en dB) a audio_features_mod volumen normalizado[‘loudness_db’] = Loudness_norm #Si se selecciona “autotune” a través del control deslizante, si autotune: #Continuidad (Hz) para la conversión de notas MIDI f0_midi = np.array(ddsp.core.hz_to_midi (audio_features_mod[‘f0_hz’])) # Consiga el movimiento en centavos, al grupo más consistente de intervalos cromáticos tuning_factor = get_tuning_factor(f0_midi, audio_features_mod[‘f0_confidence’]mask_on) #Reduce la variación de continuidad de los intervalos cromáticos o escala f0_midi_at = auto_tune(f0_midi, tuning_factor, mask_on, cantidad=autotune) #Ahorra continuidad en Hz convirtiendo notas MIDI a Hz audio_features_mod[‘f0_hz’] = ddsp.core.midi_to_hz(f0_midi_at) “”” Exhibe el mensaje apropiado si ‘ADJUST’ no está marcado o no se advierten notas “”” otra cosa: print(‘\nOmitiendo el ajuste automático (no se detectan notas o el campo COINCIDIR está vacío). ‘ “” ” Mostrar mensaje si ‘AJUSTAR’ no está marcado o no está el archivo de estadísticas del grupo de datos “”” más: print(‘\nOmitiendo el ajuste automático (casilla sin marcar o no se hallaron estadísticas del conjunto de datos).’)
- Realice cambios manuales de volumen y frecuencia usando los métodos especificados en los pasos (20) y (21)
audio_features_mod = shift_ld(audio_features_mod, volumen_ness) audio_features_mod = shift_f0(audio_features_mod, pitch_shift)
- Dibujar las características
# Revisar si las notas ‘on’ tienen has_mask = int (mask_on es ninguno) #3 subprocesos si hay ‘has_mask’. 1 (Verdadero), solo que de lo contrario 2 subparcelas de sonoridad y continuidad n_parcelas = 3 si tiene_máscara de lo contrario 2#Inicializar la figura y los factores de los ejes fig, axes = plt.subplots(nrows=n_plots, ncols=1sharex=True, size fig=(2* n_plots , 8)) # Marcar máscara de nota “on” si existe, si tiene_mask: ax = ejes[0]ax.plot(por servirnos de un ejemplo, ones_like(mask_on[:TRIM]) * umbral, ‘k:’) ax.plot(note_on_value[:TRIM]) ax.plot(mask_on[:TRIM]) ax.set_ylabel(‘Máscara de nota sobre’) ax.set_xlabel(‘Paso de tiempo [frame]’) hacha.leyenda([‘Threshold’, ‘Likelihood’,’Mask’]) # Marcar volumen original y configurado ax = ejes[0 + has_mask]ax.plot(audio_features[‘loudness_db’][:TRIM]) ax.plot(audio_features_mod[‘loudness_db’][:TRIM]) ax.set_ylabel(‘db_volumen’) ax.legend([‘Original’,’Adjusted’]) # Marcar las frecuencias auténticos y ajustadas ax = ejes[1 + has_mask]ax.plot(librosa.hz_to_midi(audio_features[‘f0_hz’][:TRIM])) ax.plot(librosa.hz_to_midi(audio_features_mod[‘f0_hz’][:TRIM])) ax.set_ylabel(‘f0 [midi]’) _ = hacha.historia de historia legendaria([‘Original’,’Adjusted’])
Salida:
- Resintetiza el sonido
Primero anote las funciones de audio calculadas
af = audio_features si audio_features_mod es No hay otro audio_features_mod
Ejecutar un lote de conjeturas
#Registrar la hora de inicio del audio start_time = time.time() #Utilizar el modelo definido en el paso (17) utilizando la salida calculada de la función de audio = model(af, training=False)
Extraiga la salida de audio del diccionario de salida
audio_gen = model.get_audio_from_outputs
Muestre el tiempo necesario para llevar a cabo predicciones calculando la diferencia entre la hora de hoy y la hora de inicio del audio de entrada
print(‘El pronóstico tomó %.1f segundos’ % (time.time() – start_time))
- Dibuje un widget HTML5 para reproducir el audio original y resintetizado, tal como los fantasmas de las dos señales.
print(‘Original’) reproducir(audio) print(‘Resíntesis’) reproducir(audio_gen) specplot(audio) plt.title(“Original”) specplot(audio_gen) _ = plt.title(“Resíntesis”)
Widgets de salida:
Gráficos de salida:
Sonido original:
Sonido resintetizado (utilizando el modelo “Violín”):
Bloc de notas de la colaboración de Google+ La implementación anterior está disponible aquí.
Bibliografía
~~~~~~~~📱~~~~~~~~
Fikiri.net es el sitio perfecto para encontrar las últimas noticias y comentarios sobre gadgets y apps tecnológicas, de esta forma para obtener consejos y trucos para sacar el máximo partido de tu tecnología.
