Nota: El siguiente producto lo 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 clásicos (como osciladores, filtros, sintetizadores) con modelos de aprendizaje profundo.
Fue anunciado por Jesse Engel, Lamtharn (Hanoi) Hantrakul, Chenjie Gu y Adam Roberts (artículo de ICLR).
Antes de entrar en los detalles de la biblioteca, familiaricémonos con el concepto de DSP.
¿Qué es DSP?
El procesamiento de señales digitales (DSP) es el desarrollo a través de el cual se toman como entrada señales digitalizadas como audio, vídeo, presión, temperatura, etcétera. para efectuar operaciones matemáticas sobre ellas, p.
Agregar, restar o multiplicar señales.
Visite esta página para obtener datos de DSP.
Descripción general de DDSP
La biblioteca DDSP crea señales de audio complejas y realistas al controlar los factores de un DSP simple 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.
¿Cómo marcha DSP?
Fuente de imagen: Documentación Oficial
Los modelos de redes neuronales como WaveNet, utilizados para generar audio, tienen la posibilidad de producir maneras de onda tomando una exhibe al unísono.
En contraste a estos modelos, DDSP pasa parámetros por medio de algoritmos de síntesis de audio conocidos.
Todos los elementos de la figura previo son diferenciables, el modelo se puede entrenar de extremo 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 utilizando Google plus colab z Pitón 3.7.10 Y dsp 1.2.0 ediciones.
La explicación pasito a pasito del código es la próxima:
- Disponer la biblioteca DDSP
!pip disponer ddsp
- Importe las bibliotecas y los módulos precisos.
importar advertencias.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 , descargar, 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 frecuencia de muestreo de la señal (aquí se emplea la continuidad de muestreo predeterminada de 16000 definida en ddsp.spectral_ops)
sample_rate = DEFAULT_SAMPLE_RATE
- Mostrar opciones a fin de 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 durante los cuales se va a grabar.
#Aceptar cargar ficheros .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 entrar 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 efectuar dependiendo de la selección del usuario de una grabación o carga de audio.
#Si el usuario selecciona “Grabar”, grabe el audio desde el navegador usando el procedimiento record() definido aquí if record_or_upload == “Grabar”: audio = record(seconds=record_seconds) “”” Si el usuario elige “Subir”, permite cargar un archivo de audio .wav o .mp3 desde el disco a colab usando el procedimiento upload() definido aquí “”” else: filenames, audios = upload() “”” upload() devuelve los nombres de los ficheros cargados y sus correspondientes 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 utilizando el método specplot().
diagrama de especificaciones (audio)
Cree un widget de audio HTML5 utilizando el método play() para reproducir un archivo de audio
reproducir sonido)
Restituya el estado CREPE global para reconstruir el modelo
ddsp.spectral_ops.reset_crepe()
- Guardar la hora de comienzo del sonido
hora_inicio = hora.hora()
Calcular funcionalidades 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 preciso para calcular la función de audio quitando la hora de comienzo de la hora de hoy
print(‘Las funciones de audio tardaron %.1f segundos’ % (time.time() – start_time))
- Marcar las peculiaridades calculadas
fig, ax = plt.subplots(nrows=3ncols=1sharex=True, size fig=(6, 8)) #Marcar 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(‘certidumbre f0’) _ = hacha[2].set_xlabel(‘Paso de tiempo [frame]’)
Salida:
El fichero de audio .mp3 que empleamos para la demostración:
(Fuente del archivo de audio)
- Seleccione el modelo de instrumento entrenado que se empleará.
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 seleccionado
def find_model_dir(directoryname): # Iterar por medio de los directorios hasta encontrar el directorio del modelo para raíz, directorios, nombres de archivo en os.walk(directoryname): for filename in filenames: if filename.ends(“.gin”) y no file_name.starts with ( “.”): model_dir = root devuelve model_dir
- Seleccione el modelo que desea usar.
if model w (‘Violin’, ‘Flauta’, ‘Flute2’, ‘Trumpet’, ‘Tenor_Saxophone’): # Modelos pre-entrenados.
PRETRAINED_DIR = ‘/content/pretrained’ # Copia de gs:// para una carga 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 = les.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 grupo 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 excepción si falla la carga del archivo salvo salvedad como err: print( ‘Cargando grupo de datos estadísticos desde pickle falló: .’.format(err))
- Determinar un procedimiento para analizar la configuración de la ginebra
#Primero, desbloquee por un tiempo la configuración utilizando el administrador de contexto con gin.unlock_config(): #Examine el fichero con parse_config_file() definido aquí gin.parse_config_file(gin_file, skip_unknown=True)
- Guardar ficheros de puntos de control
“”” Para cada fichero en la lista que contiene archivos 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]#Añada el nombre de 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 detallada como su parámetro.
Un enlace 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 parámetros 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 anteriores #Primero desbloquee la configuración con gin.unlock_config(): #Examine la lista de enlaces 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 predecir el sonido.
modelo = ddsp.entrenamiento.modelos.Autoencoder()
Restaurar puntos de control del modelo
modelo.volver a poner(ckpt)
- Cree el modelo ejecutando un conjunto de funcionalidades de audio en él.
#Registra la hora de comienzo del audio start_time = time.time() #Crea el modelo utilizando las funcionalidades calculadas _ = model(audio_features, training=False) “”” Muestra el tiempo necesario para construir el modelo calculando la diferencia entre la hora actual y la hora de inicio del audio “” ” print(‘Tomó %.1f segundos restaurar el modelo’ % (time.time() – start_time))
Salida de exhibe: Se tardó 2,0 segundos en restaurar el modelo.
- Los modelos preentrenados (violín, flauta, etc.) no fueron entrenados directamente para el timbre, con lo que tienen la posibilidad de sonar poco naturales si las frecuencias de entrada y el volumen del sonido son muy diferentes de los datos de entrenamiento (lo que será cierto en la mayoría de las situaciones). tiempo).
Crear controles deslizantes para condicionar el modelo
#@markdown ## Detección de notas #@markdown Puede dejarlo en 1.0 para la mayoría de las situaciones umbral = 1 #@param tipo: “slider”, min: 0.0max:2.0paso:0.01 #@markdown ## AJUSTE automático = Verdadero #@paramtype:”boolean” #@markdown Partes sigilosas 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.elementos()
Los controles deslizantes para cambiar el condicionamiento se muestran en colab de la siguiente forma:
- Determinar el método de cambio de volumen
def shift_ld(audio_features, ld_shift=0.0): #Acrecentar el volumen por ld_shift audio_features[‘loudness_db’] += ld_shift #Return funciones de audio modificadas return audio_features
- Definir el método de cambiar la continuidad por el número de octavas
def shift_f0(audio_features, pitch_shift=0.0): # Multiplica la frecuencia 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, confianza 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)
Movimiento 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 dichas 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’])) # Obtenga el desplazamiento 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 advierten notas o el campo COINCIDIR está vacío). ‘ “” ” Enseñar mensaje si ‘AJUSTAR’ no está marcado o no se encuentra el archivo de estadísticas del grupo de datos “”” más: print(‘\nOmitiendo el ajuste automático (casilla sin marcar o no se encontraron estadísticas del conjunto de datos).’)
- Realice cambios manuales de volumen y frecuencia utilizando los métodos concretados 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 especificaciones
# Comprobar si las notas ‘on’ tienen has_mask = int (mask_on es ninguno) #3 subprocesos si hay ‘has_mask’. 1 (Verdadero), solo que en caso contrario 2 subparcelas de sonoridad y continuidad n_parcelas = 3 si tiene_máscara en caso contrario 2#Inicializar la figura y los parámetros de los ejes fig, axes = plt.subplots(nrows=n_plots, ncols=1sharex=True, size fig=(2* n_plots , 8)) # Trazar 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.historia de historia legendaria([‘Threshold’, ‘Likelihood’,’Mask’]) # Trazar 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.leyenda([‘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
Realizar un lote de predicciones
#Registrar la hora de comienzo del audio start_time = time.time() #Aplicar el modelo definido en el paso (17) empleando 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 preciso para realizar conjeturas calculando la diferencia entre la hora de hoy y la hora de comienzo 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, así 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 (usando el modelo “Violín”):
Bloc de notas de la colaboración de Google plus 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 aplicaciones tecnológicas, de esta manera para obtener consejos y trucos para sacar el máximo partido de tu tecnología.
