Reconocimiento de emociones del habla [An applied project]

En un mundo donde la tecnología está en constante evolución, se están desarrollando herramientas cada vez más sofisticadas para mejorar nuestra calidad de vida. Un campo en particular que ha llamado la atención de muchos investigadores es el reconocimiento de emociones del habla. ¿Te has preguntado cómo sería si las máquinas pudieran entender nuestras emociones a través de nuestra voz? En este proyecto aplicado, exploraremos los avances y aplicaciones del reconocimiento de emociones del habla, y cómo podría beneficiar a nuestra sociedad. ¡Prepárate para adentrarte en un fascinante mundo donde las máquinas pueden entender cómo nos sentimos!

Un proyecto aplicado sobre “Reconocimiento de emociones del habla” presentado por Tapaswi Baskota a extrudesign.com. Este proyecto lo llevan a cabo los estudiantes de informática Tapaswi, Swastika y Dhiraj.

Reconocimiento de emociones del habla [An applied project]Reconocimiento de emociones del habla [An applied project]

Contenido

Aplicación de reconocimiento de emociones del habla (escrita por Tapaswi)

Introducción: (Tapaswi)

Reconocer las emociones es una de las estrategias de marketing más importantes del mundo actual. Puede personalizar diferentes cosas para que una persona se dirija a sus intereses. Por este motivo, hemos elegido un proyecto que nos permitirá reconocer las emociones de una persona solo por su voz, lo que nos permitirá gestionar muchas aplicaciones relacionadas con la IA. Algunos ejemplos de esto podrían ser la incorporación de call center que reproduzcan música cuando alguien está enojado durante la llamada. Otro ejemplo podría ser un coche inteligente que reduce la velocidad cuando estás enojado o asustado. Por lo tanto, este tipo de aplicaciones tiene un gran potencial a nivel mundial que beneficiaría a las empresas e incluso a la seguridad de los consumidores.

Implementación del proyecto (Tapaswi)

El requisito de nuestro proyecto era desarrollar una aplicación que detecte las emociones de la persona en función de su voz. Para ello, dividimos el proyecto en dos partes, backend y frontend. “Interfaz«es básicamente la interfaz de usuario y el término»AtrásFin“significa el servidor, la aplicación y la base de datos que trabajan detrás de escena para proporcionar información al usuario. El usuario ingresa una solicitud a través de la interfaz.


Expliquemos las partes del backend y del frontend de nuestro proyecto.

Piezas traseras (Tapaswi)

El lenguaje de programación Python se utiliza para el backend. Python es un lenguaje de programación interpretado, de propósito general y de alto nivel. La filosofía de diseño de Python enfatiza la legibilidad del código mediante el uso notable de sangría clara. Sus construcciones de lenguaje y su enfoque orientado a objetos están diseñados para ayudar a los programadores a escribir código claro y lógico para proyectos grandes y pequeños.

¿Por qué se eligió Python? (Tapaswi)

Python es relativamente simple y, por tanto, fácil de aprender, ya que requiere una sintaxis única centrada en la legibilidad y no conocíamos ningún otro lenguaje para este tipo de proyectos a gran escala. Los desarrolladores pueden leer y traducir el código Python mucho más fácilmente que otros lenguajes. Esto, a su vez, reduce los costos de mantenimiento y desarrollo del programa, ya que los equipos pueden trabajar juntos sin habilidades lingüísticas ni de experiencia significativas.

Lo más importante es que tiene bibliotecas como librosa, pyaudio y sklearn que necesitamos para la extracción de características y su clasificación.

La arquitectura del reconocimiento de emociones del habla en el backend: (Tapaswi)

Reconocimiento de emociones del habla [An applied project]
Arquitectura básica del backend.

Descripción de la arquitectura de reconocimiento de emociones del habla: (Tapaswi)

¿Qué son los comparadores mecánicos?

Por favor habilite JavaScript

Esto se puede ver en la arquitectura del sistema: tomamos la voz como muestras de entrenamiento y luego la pasamos para un preprocesamiento para la extracción de características del sonido, lo que luego produce las matrices de entrenamiento. Luego, estos conjuntos se utilizan para formar un «clasificador» para la toma de decisiones de la emoción.

Por lo tanto, para la muestra de entrenamiento se requiere un gran conjunto de datos con voces de diferentes emociones. Buscamos en Internet y encontramos varios conjuntos de datos. Algunos de ellos se enumeran a continuación:

  • Conjunto de datos de crowdsourcing de actores multimodales emocionales (Crema-D)
  • Base de datos de canciones y discursos emocionales de Ryerson Audiovisual (Ravdess)
  • Emoción expresada audiovisual de Surrey (Savee)
  • Discurso emotivo set “Toronto” (Tess)

Pero utilizamos la base de datos audiovisual de Ryerson sobre discursos y canciones emocionales (RAVDESS).

Base de datos de canciones y discursos emocionales audiovisuales de Ryerson (RAVDESS). (Tapaswi) (chu, 1 de julio de 2019)

Razones para elegir RAVDEES: (Tapaswi)

  1. Tiene 2452 archivos de audio con 12 parlantes masculinos y 12 femeninos.
  2. Las expresiones del discurso se mantienen constantes diciendo sólo dos declaraciones de la misma extensión.
  3. Hay 8 emociones diferentes para todos los hablantes.
  4. Las emociones se mencionan de la siguiente manera:
    • Tranquilo
    • Feliz,
    • Triste,
    • Enojado,
    • Temeroso,
    • Asco,
    • y sorpresa, junto con
    • una línea de base neutral para cada actor
  5. Cada uno de los archivos RAVDESS tiene un nombre de archivo único. El nombre del archivo consta de un identificador numérico de 7 partes (por ejemplo, 02-01-06-01-02-01-12.mp4). Estos identificadores definen las propiedades del estímulo.

Identificadores de nombres de archivos (Mohit Wadhwa, 25 de julio de 2020)

  • Modalidad (01 = Full AV, 02 = Sólo vídeo, 03 = Sólo audio).
  • Canal vocal (01 = discurso, 02 = canción).
  • Emoción (01 = neutral, 02 = calma, 03 = feliz, 04 = triste, 05 = enojado, 06 = temeroso, 07 = asco, 08 = sorprendido).
  • Intensidad emocional (01 = normal, 02 = fuerte). NOTA: No existe una intensidad fuerte para la emoción «neutral».
  • Declaración (01 = “Los niños hablan en la puerta”, 02 = “Los perros se sientan en la puerta”).
  • Repetición (01 = 1ª repetición, 02 = 2ª repetición).
  • Actores (01 a 24. Los actores impares son hombres, los actores pares son mujeres).

Nombre de archivo de ejemplo: 02-01-06-01-02-01-12.mp4

  • Sólo vídeo (02)
  • Discurso (01)
  • Temeroso (06)
  • Intensidad normal (01)
  • Declaración “Perros” (02)
  • 1ra repetición (01)
  • 12. Actores (12)
  • Mujer porque el número de identificación del actor es par.

El conjunto de datos se puede encontrar de forma gratuita en Internet mediante este enlace: Reconocimiento de voz-emoción-ravdess-data.zip – Google Drive

Herramientas utilizadas para el procesamiento del sonido: (Tapaswi)

Librosa

La biblioteca Librosa se puede utilizar en Python para procesar y extraer funciones de los archivos de audio. “Librosa” es un paquete Python para análisis de música y audio. Proporciona los componentes básicos necesarios para crear sistemas de recuperación de información musical.

Después de eso, debemos comenzar a modelar, que comienza con la extracción de características. Después de extraer los espectrogramas MFCC, Chroma y Mel de los archivos de audio, comenzamos a entrenar algoritmos de aprendizaje automático.

Funciones compatibles:


  • MFCC (mfcc)
  • Croma (croma)
  • Frecuencia del espectrograma MEL (mel)
  • Contraste (contraste)
  • Toneladas (tonelada)

Breve descripción de características: (Tapaswi)

  • Mel Scale: trata sobre la percepción humana de las frecuencias. Esta es una escala de tono que los oyentes consideran que está igualmente espaciada.
  • Tono: qué tan alto o bajo es un sonido. Depende de la frecuencia, un tono más alto es una frecuencia alta
  • Frecuencia: velocidad de vibración del sonido, mide los ciclos de onda por segundo.
  • Croma: Representación de audio en la que el espectro se proyecta en 12 contenedores que representan los 12 semitonos diferentes (o croma). Calculado sumando el espectro logarítmico de frecuencia-magnitud en octavas.
  • MFCC – Coeficientes cepstrales de frecuencia Mel: La voz depende de la forma del tracto vocal, incluida la lengua, los dientes, etc. Representación del espectro de potencia del sonido a corto plazo, esencialmente una representación del tracto vocal.

Los requisitos para la extracción y el proceso de características: (Tapaswi)

Usamos la versión 3.6.6 de Python para hacerlo compatible con otra biblioteca que se usará en nuestra programación de Python. PyCharm se utilizó como IDE porque PyCharm facilita a los desarrolladores la implementación de cambios locales y globales de forma rápida y eficiente. Los desarrolladores pueden incluso aprovechar las opciones de refactorización proporcionadas por el IDE mientras escriben código Python simple y trabajan con marcos Python.

Las bibliotecas de requisitos previos más importantes para la programación son:

  1. Librosa: Ya hemos explicado esta biblioteca en la sección anterior. Ayuda en la extracción de características.
  2. Archivo de sonido: SoundFile puede leer y escribir archivos de sonido. Esta biblioteca nos ayuda a abrir el archivo de sonido.
  3. NumPy: NumPy, que significa Numerical Python, es una biblioteca que consta de objetos de matriz multidimensional y una colección de rutinas para procesar estas matrices. NumPy se puede utilizar para realizar operaciones matemáticas y lógicas en matrices. Usamos NumPy porque proporciona un objeto de matriz 50 veces más rápido (llamado ndarray) para nuestro archivo de sonido.
  4. sklearn: Scikit-learn es una biblioteca Python de código abierto con potentes herramientas para análisis y extracción de datos. Se utiliza principalmente en nuestro proyecto para entrenar, probar y dividir nuestros datos para luego crear datos de modelo y determinar la precisión de nuestro modelo.
  5. Pyaudio: “Pyaudio proporciona enlaces de Python para PortAudio, la biblioteca de E/S de audio multiplataforma. Con Pyaudio puedes usar Python fácilmente para reproducir y grabar audio en diferentes plataformas». Usamos Pyaudio para obtener el audio del usuario.
  6. Pickle: Utilizado para el modelo de ahorro..
  7. Matplotlib: Se utiliza para dibujar el diagrama, etc.

Primero necesitamos instalar las bibliotecas. Podemos instalar esto simplemente usando el comando pip en la terminal:

Pip install librosa soundfile numpy glob os pickle sklearn

Cómo importar estas bibliotecas de Python:(Tapaswi)

import librosa
import soundfile  # to read audio file
import numpy as np
import glob
import os
import pickle  # to save model after training
from sklearn.model_selection import train_test_split  # for splitting training and testing
from sklearn.neural_network import MLPClassifier  # multi-layer perceptron model
from sklearn.metrics import accuracy_score[T1]   # to measure how good we are
from sklearn.preprocessing import LabelEncoder

Codificación para la extracción de características sonoras: (leen, 2)

def extract_feature(file_name, **kwargs):
"""
    Extract feature from audio file `file_name`
        Features supported:
            - MFCC (mfcc)
            - Chroma (chroma)
            - MEL Spectrogram Frequency (mel)
            - Contrast (contrast)
            - Tonnetz (tonnetz)
        e.g.:
        `features = extract_feature(path, mel=True, mfcc=True)`
   
mfcc = kwargs.get("mfcc")
    chroma = kwargs.get("chroma")
    mel = kwargs.get("mel")
    contrast = kwargs.get("contrast")
    tonnetz = kwargs.get("tonnetz")
    with soundfile.SoundFile(file_name) as sound_file:
        X = sound_file.read(dtype="float32")
        sample_rate = sound_file.samplerate
        if chroma or contrast:
            stft = np.abs(librosa.stft(X))
        result = np.array([])
        if mfcc:
            mfccs = np.mean(librosa.feature.mfcc(y=X, sr=sample_rate, n_mfcc=40).T, axis=0)
            result = np.hstack((result, mfccs))
        if chroma:
            chroma = np.mean(librosa.feature.chroma_stft(S=stft, sr=sample_rate).T, axis=0)
            result = np.hstack((result, chroma))
        if mel:
            mel = np.mean(librosa.feature.melspectrogram(X, sr=sample_rate).T, axis=0)
            result = np.hstack((result, mel))
        if contrast:
            contrast = np.mean(librosa.feature.spectral_contrast(S=stft, sr=sample_rate).T, axis=0)
            result = np.hstack((result, contrast))
        if tonnetz:
            tonnetz = np.mean(librosa.feature.tonnetz(y=librosa.effects.harmonic(X), sr=sample_rate).T, axis=0)
            result = np.hstack((result, tonnetz))
    return result

Descripción del código de extracción de características.

Comencemos con el módulo Soundfile para abrir el sonido del conjunto de datos (RAVDEES) y luego canalizarlo a formato float32y para explicarlo de manera simple, devolver las características de sonido del archivo de sonido requerido en matrices como «resultado» usando la biblioteca Numpy y Librosa.

Sabemos que tenemos este tipo de emociones:

“01”: “neutro”,
“02”: “tranquilo”,
“03”: “feliz”,
“04”: “triste”,
“05”: “enojado”,
“06”: “asustado”,
“07”: “asco”,
“08”: “sorprendido”

Después de la extracción de la característica, necesitamos informar al sistema sobre la característica, pero, por ejemplo, en nuestro sistema solo usamos las emociones «enojado», «triste», «neutral» y «feliz», pero aún podemos usar todas estas. emociones si lo deseamos y explicamos, el sistema reconoce cada tipo de emoción a partir de los conjuntos de datos, cuáles son. Esto lo puede hacer: (·, 2020)

# all emotions on RAVDESS dataset
int2emotion = {
    "01": "neutral",
    "02": "calm",
    "03": "happy",
    "04": "sad",
    "05": "angry",
    "06": "fearful",
    "07": "disgust",
    "08": "surprised"
}

# we allow only these emotions ( feel free to tune this on your need )
AVAILABLE_EMOTIONS = {
    "angry",
    "sad",
    "neutral",
    "happy"}

Luego, el paso es definir el archivo que representa la emoción y luego entrenar la máquina extrayendo y probando cada característica relacionada con la emoción conocida, usando el 75% de los datos para entrenamiento y el 25% para pruebas. División de uso. (x4nth055, 2019).

def load_data(test_size=0.2):
    X, y = [], []
    for file in glob.glob("data/Actor_*/*.wav"):
        # get the base name of the audio file
        basename = os.path.basename(file)
        # get the emotion label
        emotion = int2emotion[basename.split("-")[2]]
        # we allow only AVAILABLE_EMOTIONS we set
        if emotion not in AVAILABLE_EMOTIONS:
            continue
        # extract speech features
        features = extract_feature(file, mfcc=True, chroma=True, mel=True)
        # add to data
        X.append(features)
        y.append(emotion)
    # split the data to training and testing and return it
    return train_test_split(np.array(X), y, test_size=test_size, random_state=7)
# load RAVDESS dataset, 75% training 25% testing
X_train, X_test, y_train, y_test = load_data(test_size=0.25)

Explicación del código anterior:

Primero, cargue los datos desde una carpeta, lo que se puede hacer usando la biblioteca Glob de Python, y busque el nombre base usando la biblioteca del sistema operativo. Como sabemos, el conjunto de datos RAVDEES se crea con emociones en la segunda base, por lo que X se declara como característica e Y se declara como emoción. X se obtiene de extract_feature e y se obtiene usando basename después de dividir el nombre base, y sabemos que basename se refiere a la emoción de arriba int2emotion.

Nuestro siguiente paso fue crear el clasificador de emociones, es decir, un modelo para ello, para lo cual utilizamos el clasificador de perceptrón multicapa (clasificador MLP).

Clasificador de perceptrones multicapa: (Tapaswi)

Un perceptrón multicapa (MLP) es una clase de redes neuronales artificiales (ANN) de alimentación directa. El término MLP se utiliza de forma ambigua, a veces en el contexto de cualquier ANN feedforward, a veces exclusivamente para denotar redes que constan de múltiples capas de perceptrones (con umbral de activación).

A los perceptrones multicapa a veces se les denomina coloquialmente redes neuronales «vainilla», especialmente cuando tienen una única capa oculta.

Reconocimiento de emociones del habla [An applied project]
Clasificadores MLP

El perceptrón multicapa se utiliza para problemas de aprendizaje supervisado. El perceptrón multicapa emitido con fines de clasificación. El MLP está diseñado para entrenar con el conjunto de datos especificado. La fase de formación permite al MLP aprender la correlación entre el conjunto de entradas y salidas. Durante el entrenamiento, MLP ajusta los parámetros del modelo, como ponderaciones y sesgos, para minimizar el error. El MLP utiliza retropropagación para realizar ajustes de ponderación y sesgo en relación con el error. El error se puede calcular de muchas formas.

   # best model, determined by a grid search
model_params = {
    'alpha': 0.01,
 'batch_size': 256,
    'epsilon': 1e-08,
    'hidden_layer_sizes': (300,),
    'learning_rate': 'adaptive',
    'max_iter': 500,
}

El parámetro del modelo se configuró con la capa oculta 300 y la iteración 500. Estos resultaron ser los mejores en la búsqueda en la red.

# initialize Multi-Layer Perceptron classifier
# with best parameters ( so far )
model = MLPClassifier(**model_params)


# train the model
print("[*] Training the model...")
model.fit(X_train, y_train)

# predict 25% of data to measure how good we are
y_pred = model.predict(X_test)

El código anterior simplemente activa el clasificador MLP y entrena el conjunto de datos de entrenamiento usando el modelo. encaja y predecirá la emoción del 25% restante del conjunto de datos.

Donde podemos ver la salida como

Reconocimiento de emociones del habla [An applied project]
Precisión del modelo.

Podemos ver la cantidad de ejemplos de entrenamiento, ejemplos de prueba y la cantidad de características descubiertas. Después de eso, podemos ver la matriz de precisión y confusión del modelo comparando la predicción y el valor real de la siguiente manera:

# calculate the accuracy
accuracy = accuracy_score(y_true=y_test, y_pred=y_pred)

print("Accuracy: {:.2f}%".format(accuracy*100))
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))


from sklearn.metrics import confusion_matrix
matrix = confusion_matrix(y_test, y_pred)
print (matrix)

Podemos ver la precisión y analizar la matriz de confusión:

Resultado del modelo: (Tapaswi)

Reconocimiento de emociones del habla [An applied project]
Precisión, matriz de confusión (resultado)

Matriz de confusión interactiva (Tapaswi)

Reconocimiento de emociones del habla [An applied project]
Matriz de confusión del clasificador de emociones

Aquí logramos alrededor del 80,95% de precisión y analizamos el informe de clasificación con una matriz de confusión. Significa que nuestro modelo puede funcionar bastante bien.

Si utilizamos este modelo para uso futuro, debemos guardarlo. Para esto utilizamos el módulo Pickle .as:

pickle.dump(model, open("result/mlp_classifier.model", "wb"))

Guardamos este resultado interno con el nombre mlp_classifier

Probando el backend: (Tapaswi)

Para probar la voz en vivo, se creó “Livetesting .py”, en el que usamos el módulo “pyaudio” para capturar la voz y agregar algo de ruido para mejorar la extracción de funciones. Luego se pasa a la extracción de las características del sonido y el lugar donde el clasificador MLP hace predicciones. Las emociones y hemos agregado la función avanzada que permite la traducción de voz a texto utilizando el módulo SpeechRecognition. Este debe ser instalado e importado.

Podemos ver la codificación de la siguiente manera:

# Author:Tapaswi Baskota
# modified on 1/8/2021

# -------------------------------This is a Live Testing _____________________________________

import pickle  # to save model after training
import wave
from array import array
from struct import pack
from sys import byteorder

import librosa
import numpy as np
import pyaudio
import soundfile  # to read audio file
import speech_recognition as sr


def extract_feature(file_name, **kwargs):
"""
    Extract feature from audio file `file_name`
        Features supported:
            - MFCC (mfcc)
            - Chroma (chroma)
            - MEL Spectrogram Frequency (mel)
            - Contrast (contrast)
            - Tonnetz (tonnetz)
        e.g:
        `features = extract_feature(path, mel=True, mfcc=True)`
    """
    mfcc = kwargs.get("mfcc")
    chroma = kwargs.get("chroma")
    mel = kwargs.get("mel")
    contrast = kwargs.get("contrast")
    tonnetz = kwargs.get("tonnetz")
    with soundfile.SoundFile(file_name) as sound_file:
        X = sound_file.read(dtype="float32")
        sample_rate = sound_file.samplerate
        if chroma or contrast:
            stft = np.abs(librosa.stft(X))
        result = np.array([])
        if mfcc:
            mfccs = np.mean(librosa.feature.mfcc(y=X, sr=sample_rate, n_mfcc=40).T, axis=0)
            result = np.hstack((result, mfccs))
        if chroma:
            chroma = np.mean(librosa.feature.chroma_stft(S=stft, sr=sample_rate).T, axis=0)
            result = np.hstack((result, chroma))
        if mel:
            mel = np.mean(librosa.feature.melspectrogram(X, sr=sample_rate).T, axis=0)
            result = np.hstack((result, mel))
        if contrast:
            contrast = np.mean(librosa.feature.spectral_contrast(S=stft, sr=sample_rate).T, axis=0)
            result = np.hstack((result, contrast))
        if tonnetz:
            tonnetz = np.mean(librosa.feature.tonnetz(y=librosa.effects.harmonic(X), sr=sample_rate).T, axis=0)
            result = np.hstack((result, tonnetz))
    return result


# from utils import extract_feature

THRESHOLD = 500
CHUNK_SIZE = 1024
FORMAT = pyaudio.paInt16
RATE = 16000

SILENCE = 30
def is_silent(snd_data):
"Returns 'True' if below the 'silent' threshold"
   
return max(snd_data) < THRESHOLD


def normalize(snd_data):
"Average the volume out"
   
MAXIMUM = 16384
    times = float(MAXIMUM) / max(abs(i) for i in snd_data)

    r = array('h')
    for i in snd_data:
        r.append(int(i * times))
    return r


def trim(snd_data):
"Trim the blank spots at the start and end"

   
def _trim(snd_data):
        snd_started = False
        r = array('h')

        for i in snd_data:
            if not snd_started and abs(i) > THRESHOLD:
                snd_started = True
                r.append(i)

            elif snd_started:
                r.append(i)
        return r

    # Trim to the left
    snd_data = _trim(snd_data)

    # Trim to the right
    snd_data.reverse()
    snd_data = _trim(snd_data)
    snd_data.reverse()
    return snd_data
def add_silence(snd_data, seconds):
"Add silence to the start and end of 'snd_data' of length 'seconds' (float)"
   
r = array('h', [0 for i in range(int(seconds * RATE))])
    r.extend(snd_data)
    r.extend([0 for i in range(int(seconds * RATE))])
    return r


def record():
"""
    Record a word or words from the microphone and
    return the data as an array of signed shorts.

    Normalizes the audio, trims silence from the
    start and end, and pads with 0.5 seconds of
    blank sound to make sure VLC et al can play
    it without getting chopped off.
    """
   
p = pyaudio.PyAudio()
    stream = p.open(format=FORMAT, channels=1, rate=RATE,
                    input=True, output=True,
                    frames_per_buffer=CHUNK_SIZE)

    num_silent = 0
    snd_started = False

    r = array('h')

    while 1:
        # little endian, signed short
        snd_data = array('h', stream.read(CHUNK_SIZE))
        if byteorder == 'big':
            snd_data.byteswap()
        r.extend(snd_data)

        silent = is_silent(snd_data)

        if silent and snd_started:
            num_silent += 1
        elif not silent and not snd_started:
            snd_started = True
        if snd_started and num_silent > SILENCE:
            break

    sample_width = p.get_sample_size(FORMAT)
    stream.stop_stream()
    stream.close()
    p.terminate()

    r = normalize(r)
    r = trim(r)
    r = add_silence(r, 0.5)
    return sample_width, r


def record_to_file(path):
"Records from the microphone and outputs the resulting data to 'path'"
   
sample_width, data = record()
    data = pack('<' + ('h' * len(data)), *data)

    wf = wave.open(path, 'wb')
    wf.setnchannels(1)
    wf.setsampwidth(sample_width)
    wf.setframerate(RATE)
    wf.writeframes(data)
    wf.close()


#if __name__ == "__main__":
#def int():
    # load the saved model (after training)
loaded_model = pickle.load(open("result/mlp_classifier.model", 'rb'))

print("Please talk")
filename = "test.wav"
a = filename

    #record the file (start talking)
record_to_file(filename)

# ------------------------sound wave ______________


# --------------------------------------------Speech to text------------------------------------------
mic = sr.Recognizer()
# open the file
with sr.AudioFile(filename) as source:
    # listen for the data (load audio to memory)
    audio_data = mic.record(source)
    #extract features and reshape it
    features = extract_feature(filename, mfcc=True, chroma=True, mel=True).reshape(1, -1)
    # predict
    result = loaded_model.predict(features)[0]
    # show the result !
    Emotion= ("pREDITED  EMotion is : ", result)
    print(Emotion)
    # recognize (convert from speech to text)
    text = mic.recognize_google(audio_data)
    print(text)

# ----------------------------------------------------------------------------

El resultado es el siguiente:

Reconocimiento de emociones del habla [An applied project]
Resultado de la prueba en vivo

Dije “Hola hola”, así que lo que diga se imprimirá.

Decidí usar también la representación de ondas, por lo que necesitamos usar Matplolib para representar la onda de esta manera:

rate, data = wav.read('test.wav')

plt.plot(data)
plt.show()
plt.savefig('wave.png')#to save the ploting figure

cuya salida viene así

Reconocimiento de emociones del habla [An applied project]
Resultado final de la prueba en vivo

Por lo tanto, el backend funciona bien.

Anverso: (Esvástica y Dhiraj)

(Anón., nd) Para la interfaz de nuestro proyecto, se utilizó Kivy para desarrollar una aplicación móvil para nuestro proyecto Python. Nuestro proyecto utilizó Kivy porque es un marco Python de código abierto para desarrollar rápidamente aplicaciones que utilizan interfaces de usuario innovadoras, como aplicaciones multitáctiles. Kivy tiene todo el contenido necesario para crear una aplicación. Entre los diferentes diseños disponibles en Kivy se encuentran: Por ejemplo, diseño flotante, diseño de cuadrícula, diseño de cuadro, hemos utilizado el diseño de cuadro para los botones, cuadros de texto, etc. de la aplicación. Simplemente incluimos dos botones para el botón Hablar ahora y el botón Obtener saludo, así como tres campos de texto para Entrada de voz, Salida emocional y Emoji de emoción. Para la onda de sonido, se agregará un widget automáticamente después de presionar el botón «Obtener onda».

En la etapa inicial de nuestro proyecto, decidimos colocar el botón Hablar ahora en la parte superior, luego el indicador de voz, la onda de sonido y la salida emocional en el botón emoji de emoción.

Aquí está la configuración básica que se planeó para la aplicación:

Reconocimiento de emociones del habla [An applied project]
Estructura de interfaz de usuario original

Y aquí está la estructura de nuestra aplicación que logramos:

Reconocimiento de emociones del habla [An applied project]
Estructura final de la interfaz de usuario

Como se muestra en la figura, la imagen del micrófono se usa para el botón «Hablar ahora», se usan tres campos de texto para «Entrada de voz», «Salida emocional» y «Emoji de emoción». En la parte inferior está el botón «Obtener onda» para obtener la onda de sonido de la entrada de audio. Después de hacer clic en el botón, la onda de sonido aparecerá en la pantalla.

Descripción de la interfaz: (Dhiraj)

Para la parte frontal del proyecto, el ancho se establece en 360 y la altura se establece en 600. El relleno se establece en 50 y el espaciado en 20. Colocamos los botones y cuadros de “Idioma”. kv» y agregó el valor a los campos de texto llamando al valor de salida de esta manera:

TextInput:
    id: speech
    text: record_button.output
    readonly: True
    size_hint: (1, .5)

Botón Hablar ahora: (Esvástica)

El botón Hablar ahora se encuentra en la parte superior de la aplicación. Es un botón que hace que el sistema grabe la voz del usuario e inicie todo el procesamiento del proyecto. La imagen del micrófono se utiliza como fondo del botón. Después de hacer clic en el botón Hablar ahora, LiveTesting se importará y comenzará a ejecutar LiveTesting.py.

import LiveTesting as lT

Mientras se ejecuta LiveTesting.py, el usuario debe comenzar a hablar. «LiveTesting» captura el discurso del usuario y almacena la entrada de audio en forma de texto en «Texto» y la salida emocional del usuario basada en el audio del usuario en «Resultado». El valor de «texto» y «resultado» de «LiveTesting» se almacena en valor1 y valor2 respectivamente.

value1 = lT.text
value2 = lT.result

Campos de texto “Entrada de voz” y “Salida emocional”: (esvástica)

«Entrada de voz» es un campo de texto que muestra la entrada de audio del usuario, y «Salida emocional» es un campo de texto que muestra las emociones del usuario de acuerdo con la entrada de voz del usuario. El cuadro de texto Entrada de voz muestra «Dijiste:» y luego el valor «Valor1». Para el cuadro de texto Salida emocional, muestra «La emoción identificada es:» y luego el valor «Valor2». Valor en la solicitud.

self.output = ("You said: {}".format(value1))
self.output2 = ("The identified emotion is: {}".format(value2))
Reconocimiento de emociones del habla [An applied project]
“Entrada de voz” y “salida emocional”

Cuadro de imagen “Emoji de emoción”: (Esvástica)

“Emotion Emoji” es un cuadro de imagen que representa el emoji según la emoción del usuario. Después de capturar el habla y las emociones del usuario, el sistema realiza la tarea adicional que consiste en obtener el valor para el campo Emotion Emoji (tercer campo de texto). Su valor depende del “valor emocional” que conseguimos a través del “LiveTesting”. Si el valor de la emoción es “feliz”, se utiliza la imagen “sonrisa”. Si la emoción es “triste”, se utiliza la imagen “triste”. Si la emoción es «enojado», se utilizará la imagen «enfadado» y si la emoción es «neutral», se utilizará una imagen «neutral».

if value2 == 'happy':
    self.output3 = "smile.png"
elif value2 == 'sad':
    self.output3 = "sad.png"
elif value2 == 'angry':
    self.output3 = "angry.png"
elif value2 == 'neutral':
    self.output3 = "neutral.png"

Estas son las imágenes utilizadas para representar el emoji de emoción:

Reconocimiento de emociones del habla [An applied project]

Campo de imagen inicial “onda sonora”: (esvástica)

Después de hacer clic en el botón Hablar ahora, la aplicación registra el discurso del usuario y la entrada de voz del usuario se guarda en el archivo test.wav del proyecto. El FigureCanvasKivyAgg se importa desde backend_kivyagg.py en el proyecto, que especifica la onda de sonido de la entrada de audio usando el siguiente código:

from backend_kivyagg import FigureCanvasKivyAgg

El widget FigureCanvasKivyAgg crea un gráfico Matplotlib basado en el audio test.wav. Cuando se crea el widget FigureCanvasKivyAgg, se inicializa con un objeto de figura Matplotlib. Utiliza agg para obtener una imagen estática de la trama y luego la imagen se representa usando una clase: «~kivy.graphics.texture.Texture».

Después de que la entrada de voz, la salida de emoción y el emoji de emoción se muestren en la pantalla, es necesario hacer clic en el botón «Obtener onda» en la parte inferior de la aplicación. Después de hacer clic en el botón «Obtener onda», la etiqueta del botón cambia de «Obtener onda» a «Onda de sonido» y también se agrega un widget en la parte inferior que representa la onda de sonido de la entrada de audio del usuario.

spf = wave.open("test.wav", "r")
# Extract Raw Audio from Wav File
signal = spf.readframes(-1)
signal = np.fromstring(signal, "Int16")
fs = spf.getframerate()
Time = np.linspace(0, len(signal) / fs, num=len(signal))

plt.plot(Time, signal)

self.lbl.text = "Sound Wave"
c = self.add_widget(FigureCanvasKivyAgg(plt.gcf()))

return c
Reconocimiento de emociones del habla [An applied project]
Salida de onda de sonido inicial y salida de onda de sonido

Cuadro de imagen “Onda sonora”: (Esvástica)

Como se muestra arriba, para obtener la onda de sonido es necesario hacer clic en el botón «Obtener onda», lo cual lleva un poco de tiempo y no es adecuado para los usuarios. Entonces recuperamos la onda de sonido del audio en LiveTesting.py en forma de imagen y la guardamos como wave.png.

rate, data = wav.read('test.wav')

plt.plot(data)
plt.savefig('wave.png')

Luego se crea un cuadro de imagen en Speech.kv, lo que permite que la imagen mantenga su tamaño mientras se muestra en la pantalla.

Image:
    id: image2
    source: record_button.output4
    allow_stretch: True
    keep_ratio: False
    size_hint: (1, .5)
Reconocimiento de emociones del habla [An applied project]
Salida final de la interfaz de usuario

Retos y problemas en la implementación del proyecto: (Tapaswi)

Después de completar el Proyecto Aplicado 1, no pudimos iniciar nuestro proyecto debido a COVID 19 y otros factores. Tuvimos que perder los primeros dos meses, entonces el supervisor sugirió que completáramos el siguiente bloque. Después de eso, comenzamos a investigar la programación en Python.

Yo personalmente no sabía nada sobre programación en Python, así que buscamos en Google y vimos el video tutorial en YouTube sobre cómo funciona. El primer desafío fue instalar la versión correcta de Python porque cuando iniciamos el proyecto, sin instalar la versión correcta de Python las otras bibliotecas no funcionarían. Tomó mucho tiempo darse cuenta de eso. Instalamos Python versión 3.6 y por fin funciona.

Después de comenzar el proyecto, no sabíamos cómo instalar las bibliotecas correctamente. Tuvimos que utilizar Google y otros sitios de programación para saber cómo hacerlo.

Nos enfrentamos al desafío de buscar en la base de datos adecuada nuestro material de reconocimiento de emociones del habla. Descubrimos que la base de datos RAVDEES es perfecta para nuestro proyecto. Otro desafío fue encontrar un modelo de clasificación de emociones para nuestro proyecto. Logramos un 80% de precisión.

Entonces resulta difícil capturar la voz del usuario en tiempo real y utilizarla para extraer sus rasgos y encontrar sus emociones. Resolvimos este problema utilizando el módulo Pyaudio que nos ayuda a recibir información del usuario.

Dado que el requisito del proyecto era mostrar la voz de entrada en formato de texto, es decir, voz a texto (voz de Pyaudio), encontramos una manera de solucionar esto utilizando el módulo de reconocimiento de voz que se puede agregar usando el módulo Matplotlib.

Hemos completado con éxito esto en el backend.

Otro desafío fue implementar el backend en el frontend. Necesitábamos crear una aplicación móvil, por lo que utilizamos el marco Kivy de Python. Es muy confuso instalar Kivy en la máquina, muchas veces sale mal. Por lo tanto, debemos consultar la documentación de Kivy y seguirla en consecuencia.

Habíamos aprendido “kivy” con su “lenguaje .kv”, es fácil pero al principio nos resultó muy difícil. Necesitábamos devolver emojis en formato de texto en lugar de emociones, por lo que usamos imágenes en formato .png después de insertar el gráfico de ondas en la aplicación Kivy.

El mayor desafío fue integrar Matplotlib Pyplot en Kivy. Buscamos en Google y encontramos esto: https://stackoverflow.com/questions/44905416/how-to-get-started-use-matplotlib-in-kivy
Entonces tenemos que usar otro kivy.garden.matplotlib, no funcionó como queríamos así que tuvimos que descargarlo de GitHub a nuestro directorio de trabajo, lo llamamos desde adentro pero funcionó perfectamente.

Pero el supervisor nos sugirió que hiciéramos que la acción apareciera después de presionar el botón de grabación como texto, emoji y emoción. Modificamos las pruebas en vivo y registramos la ola allí y guardamos esta figura en el directorio de trabajo con la extensión .png. Luego tenemos Este archivo PNG debe llamarse como emoji para emociones para que se muestre como se esperaba. De este modo. La aplicación Kivy está terminada y lista para ser empaquetada.

Comenzamos nuestro empaquetado para Android leyendo el empaquetado de Kivy en Internet. Requiere «buildozer» para empaquetar para Android. El paquete buildozer sólo funciona en sistemas Linux. Intentamos ponerlo en una máquina Ubuntu instalándolo como arranque dual en nuestro sistema. Funcionó, pero descubrimos que las bibliotecas que usamos como librosa y pyaudio no eran compatibles con Android. Por lo tanto, debemos cambiar nuestro requisito de la aplicación móvil de reconocimiento de voz y emoción a la aplicación de reconocimiento de voz y emoción.

Nuestra recomendación para futuros avances en el desarrollo de una aplicación móvil es que desde el trabajo es necesario buscar alternativas a Librosa, Pyaudio y hacerlas funcionar.

Pasos que intentamos para convertir nuestro archivo Python en una aplicación Android, exe o web (Dhiraj Dhakal)

Razón por la cual necesitamos cambiar nuestro requisito de la aplicación móvil de reconocimiento de voz y emoción a la aplicación de reconocimiento de voz y emoción.

Usamos una computadora con Windows, por lo que no podemos convertir nuestro archivo a Android. Por eso elegimos Google Collaboratory, donde podemos instalar tanto Bulldozer como Cython.

Reconocimiento de emociones del habla [An applied project]
Instalar Buildozer
Reconocimiento de emociones del habla [An applied project]
Ejecutar Buildozer

Después de llamar a la inicialización de Bulldozer, obtenemos un archivo llamado builddozer.spec, cambiamos el nombre del archivo y agregamos algunas bibliotecas necesarias como Pyaudio, Kivy, Numpy, etc. Hasta ahora nuestro programa se está ejecutando exitosamente, así que sabes que estamos probando un código “builddozer – v android debug”

Reconocimiento de emociones del habla [An applied project]
Ejecutando un código Buildozer-v Andriod Debug

Este código convierte el archivo .py en un archivo de Android

Se ejecutó exitosamente hasta los 15 minutos pero finalmente aparece un error.

Reconocimiento de emociones del habla [An applied project]
Error después de 15 minutos de ejecución

Después de recibir un mensaje de error, probamos este código «builddozer android clean».

Reconocimiento de emociones del habla [An applied project]
Ejecutando el código “Buildozer andriod clean”

Todo se limpia y ejecutamos el código nuevamente. Nuevamente probamos el código «Buildozer -v android debug» pero nuevamente no tuvimos éxito.

Investigamos y descubrimos que Pyaudio no es compatible con Android, por lo que decidimos utilizar otro método.

Lo intentamos muchas veces y luego decidimos convertir nuestro proyecto Python en un archivo .exc.

Para el archivo de Excel, primero necesita instalar pip y pyinstaller

Después de eso probamos el código pyinstaller –onefile -w Dhiraj.py

Reconocimiento de emociones del habla [An applied project]
Ejecute el código pyinstaller –onefile -w

Muestra que todo está correcto y que el archivo .exc se creó correctamente.

Reconocimiento de emociones del habla [An applied project]
Intentos fallidos

Creó una carpeta llamada dist y colocó nuestro archivo .exc en ella. Sin embargo, también tenemos imágenes, por lo que tenemos imágenes fuera de la carpeta, así que copié este archivo .exc de dist outside e intenté ejecutarlo, pero no funcionó.

Se muestra todo perfecto, pero no sabemos por qué no funciona. Lo intentamos varias veces pero no lo logramos.

Fortalezas y limitaciones (Dhiraj)

El reconocimiento de emociones es una técnica utilizada en software que permite a un sistema analizar los sentimientos de una voz humana utilizando imágenes digitales sofisticadas que nosotros, como grupo, hemos proporcionado como parte de nuestro proyecto. Con el avance de las tecnologías, el software de reconocimiento de emociones ha evolucionado muy bien. El texto “Reconocimiento de emociones utilizando un enfoque de aprendizaje profundo a partir de big data emocional audiovisual” respalda esta afirmación y también afirma que “recientemente, se están utilizando sistemas inteligentes conscientes de las emociones en diversas aplicaciones” (Shamim, Ghulam 2019, p. 69). La aplicación que creamos en grupo muestra las emociones de ira, neutralidad, tristeza y felicidad, etc. a través de un sistema de voz y también muestra la onda. El lenguaje es una red de comunicación esencial, complementada por las emociones. La voz en el monólogo (discurso) expresa una declaración sentimental y detalles sobre el estado emocional de los usuarios que hablan. Se seleccionaron algunas características de voz importantes para nuestro proyecto, incluida la frecuencia fundamental y MFCC. Hay muchas ventajas y desventajas del proyecto, que describiré a continuación.

En primer lugar, nuestro proyecto describe exactamente lo que uno siente: ya sea tristeza o felicidad, simplemente muestra cuánto ha evolucionado y evolucionado la tecnología en el siglo XXI.calle Siglo. La aplicación que desarrollamos recuerda el reconocimiento de un patrón de habla específico, lo que garantiza un proceso de alta velocidad. La aplicación permite implementar la entrada de voz de personas en tiempo real y sin demora. En segundo lugar, nuestra aplicación es razonablemente confiable, no presenta fallas y proporciona resultados correctos la mayor parte del tiempo. Al usar nuestras aplicaciones, nadie necesariamente tiene que usar el teclado para obtener información. La aplicación que creamos muestra al usuario lo que ha hablado, para que pueda comprobar por sí mismo si el comentario es incorrecto. Además, es flexible para trabajar en cualquier entorno.

Los desafíos de la aplicación incluyen la dificultad de utilizarla en un entorno ruidoso. Requiere mucha memoria, por lo que existe el riesgo de que la aplicación falle de vez en cuando. Además, cada persona tiene un acento diferente, lo que dificulta que el sistema comprenda la voz de cada uno, por lo que pueden aparecer errores. Es posible que algunas voces no siempre se muestren tan bien y es posible que el reconocimiento de voz no esté preparado para traducir los términos de todos los hablantes a menos que formen parte del idioma inglés nativo habitual. El uso regular de la tecnología de reconocimiento de voz puede provocar irritabilidad física y complicaciones vocales. Hablar de un proceso tan largo puede provocar dolor de garganta y tensión en el habla a largo plazo.

Si pudiéramos crear la aplicación nuevamente en el futuro, intentaríamos acelerar el proceso y hacer que la aplicación capture incluso los votos más rápidos. En el futuro, queremos que la aplicación sea fácil de usar capacitándola con otros idiomas como nepalí, japonés, etc., de modo que si las personas no hablan inglés puedan usar su propio idioma en nuestra aplicación. Para futuras mejoras me gustaría que mi grupo se llevara mejor e intentar crear una mejor aplicación sin tantas complicaciones.

Ética (esvástica)

La moral informática (ética) se describe como la comprensión del impacto y el impacto de la tecnología digital en la sociedad y el uso socialmente responsable de estas nuevas tecnologías. El texto “De la ética informática a la investigación e innovación responsables en las TIC” también afirma que la ética informática es “un intercambio continuo de ideas que se centra en cuestiones éticas relacionadas con la informática” (Stahl, Eden, Jirotka & Cocklebur 2014, p. 811). . La ética se refiere a un conjunto de estándares que guían los patrones de comportamiento de los miembros del público. La ética informática es, por tanto, el acercamiento a los principios éticos para el uso de la tecnología e Internet. Un ejemplo de ello es el reconocimiento de las directrices de protección de datos. Los dispositivos facilitan la copia y reasignación de medios digitales. Sin embargo, es moralmente correcto respetar las normas de derechos de autor. Al utilizar aplicaciones, es importante conocer y seguir el acuerdo de licencia y la política de privacidad. Usar software sin pagar una licencia se considera robo y es una violación de la ética informática.

Intentar piratear u obtener acceso no autorizado a un servidor también es una forma inmoral de utilizar los sistemas informáticos. Si se habla más a menudo de ética informática, esto marcará el camino y garantizará que las innovaciones tengan beneficios positivos y no negativos a largo plazo.

La ética informática está relacionada con nuestra aplicación ya que debemos respetar la privacidad de las personas. Para que sea ético, se requieren derechos individuales de protección de datos. Nuestra aplicación está libre de plagio, lo que puede tener una conexión con la ética. Nuestra aplicación no ha reproducido ni publicado el trabajo de otra persona sin la atribución adecuada. No robamos el trabajo de otra persona y creamos la aplicación como si fuera idea nuestra. La aplicación creada no puede ser utilizada ni distribuida por otros sin el conocimiento del usuario. La aplicación permitiría la reutilización del material digital de acuerdo con el acuerdo de licencia. Sin embargo, la ética informática sería un fracaso moral si se produjeran interferencias no autorizadas en la aplicación. Un hacker que irrumpe en los datos cifrados de una computadora o red y puede obtener acceso no autorizado, lo que entonces sería inmoral y poco ético. El software espía conocido, incluidos virus, malware y otros virus, comprometería la protección de nuestra aplicación.

Resultado de la aplicación de reconocimiento de emociones del habla: (Dhiraj)

Conservamos las emociones del usuario ya que la voz se obtiene del discurso después de hacer clic en el botón Hablar ahora. Luego, la característica se extrajo y luego se clasificó en emociones utilizando el modelo Mlp_classsifier almacenado en la carpeta de resultados. Al mismo tiempo, la voz pasa a través del módulo de reconocimiento de voz utilizando Google para convertir la voz en texto. Asimismo, el gráfico de ondas se trazó utilizando Matplotlib. Pudimos que todos estos resultados estuvieran disponibles en la interfaz de usuario.

Reconocimiento de emociones del habla [An applied project]
Resultado

Conclusión: (Dhiraj)

En resumen, hemos desarrollado con éxito el reconocimiento de emociones del habla. Nuestro proyecto detecta emociones humanas mientras el orador habla y genera una salida de audio. Usamos Python versión 3.6 para crear nuestro proyecto. Utilizamos el conjunto de datos RAVDEESS porque tiene 8 emociones diferentes en todos los hablantes. Usamos Kivy Python Framework para la interfaz de usuario. Usamos lenguajes de programación Python, el conjunto de datos RAVDESS y Pycharm como IDE. En nuestro proyecto, Librosa se utiliza para extraer las características del reconocimiento de emociones. Usamos Pyaudio para la grabación de audio. En nuestro proyecto, el módulo Matplotlib se utiliza para trazar la onda y guardarla para uso futuro. Usamos el modelo guardado para clasificar las emociones. Kivy se utilizó para desarrollar la parte frontal de nuestro proyecto Python. Es un marco Python de código abierto para el desarrollo rápido de aplicaciones, de modo que se pueda utilizar un código tanto para su aplicación de Android como de iOS. Usamos el diseño de cuadro para crear botones en nuestro proyecto.

Referencias

  • ·, AR, 2020. Código Python. [Online]
    Disponible en: https://www.thepythoncode.com/article/building-a-speech-emotion-recognizer-using-sklearn
  • ·, AR, junio de 2020. Código Python. [Online]
    Disponible en: https://www.thepythoncode.com/article/building-a-speech-emotion-recognizer-using-sklearn
  • Luego. y Wikipedia. [Online]
    Disponible en: https://en.wikipedia.org/wiki/Kivy_(framework)
    [Accessed 17 03 2021].
  • chu, R., 1 de julio de 2019. Reconocimiento de emociones del habla con una red neuronal convolucional. Hacia la ciencia de datos.
  • Leen, Y., 2. Código Python. [Online]
    Disponible en: https://www.thepythoncode.com/code/building-a-speech-emotion-recognizer-using-sklearn
  • Mohit Wadhwa, AGPKP, 25 de julio de 2020. RECONOCIMIENTO DE EMOCIONES DEL HABLA (SER) MEDIANTE APRENDIZAJE AUTOMÁTICO, sl: Analytics Insight.
  • x4nth055, 2019. [Online]
    Disponible en: https://github.com/x4nth055/pythoncode-tutorials/tree/master/machine-learning/speech-emotion-recognition
    [Accessed 22 01 2021].
  • Daga BS, Dsouza G, Bassi A, Lobo L 2019, “Reconocimiento de emociones del habla utilizando una red neuronal convolucional”, Revista Internacional de Ingeniería de Tendencias y Tecnología en Ciencias de la Computación, Volumen 8, No. 3, págs. 8-13
  • Gupta T 2019, Detección de emociones del habla, Medio, 11 de marzo de 2021,
  • Pythoncode 2020, código de Hoot para crear un reconocedor de emociones del habla con Python y tutorial de Scikit-Learn, Pythoncode, 11 de marzo de 2021.
  • Shamim H; Ghulam M 2019, Fusión de información, volumen 49, págs. 69-78
  • Stahl B, Eden G, Jirotka M & Coeckelbergh M 2014, Información y gestión, Vol. 51 No. 6, págs. 810-818
  • Livingstone, S. y Russo, F., 2018. The Ryerson Audio-Visual Database of Emotional Speech and Song (RAVDESS): un conjunto dinámico y multimodal de expresiones faciales y vocales en inglés norteamericano. MAS UNO, [online] 13(5), p.e0196391. Disponible en:.
El ID o la URL del vídeo de YouTube es obligatorio.

» limit=»1″]

Un proyecto aplicado sobre «Reconocimiento de Emociones en el Habla» presentado por Tapaswi Baskota a extrudesign.com.

Introducción:
Detectar emociones es una de las estrategias de marketing más importantes en el mundo actual. Podemos personalizar diferentes elementos para adaptarlos específicamente a los intereses de cada individuo. Por esta razón, decidimos realizar un proyecto en el que pudiéramos detectar las emociones de una persona solo por su voz, lo que nos permitiría gestionar muchas aplicaciones relacionadas con la inteligencia artificial. Algunos ejemplos podrían ser centros de llamadas que reproduzcan música cuando alguien está enojado en una llamada. Otro ejemplo podría ser un auto inteligente que reduce la velocidad cuando alguien está enojado o asustado. Como resultado, este tipo de aplicación tiene un gran potencial en el mundo y beneficiaría a las empresas e incluso a la seguridad de los consumidores.

Implementación del proyecto:
Los requisitos de nuestro proyecto eran desarrollar una aplicación que reconociera las emociones de una persona utilizando su voz. Para esto, dividimos el proyecto en dos partes: el backend (parte interna) y el frontend (parte externa). «Frontend» es básicamente la interfaz de usuario y «Back-end» significa el servidor, la aplicación y la base de datos que funcionan en segundo plano para proporcionar información al usuario. El usuario ingresa una solicitud a través de la interfaz.

Explicación de las partes del Backend:
Para el Backend, se utiliza el lenguaje de programación Python. Python es un lenguaje de programación interpretado, de alto nivel y propósito general. La filosofía de diseño de Python enfatiza la legibilidad del código con su notable uso de la sangría significativa. Sus construcciones de lenguaje y enfoque orientado a objetos buscan ayudar a los programadores a escribir código claro y lógico para proyectos pequeños y grandes.

Razones por las que se eligió Python:
Python es relativamente simple, por lo que es fácil de aprender, ya que requiere una sintaxis única que se centra en la legibilidad y no conocíamos ningún otro lenguaje para este tipo de proyecto grande. Los desarrolladores pueden leer y traducir el código de Python mucho más fácilmente que otros lenguajes. A su vez, esto reduce el costo del mantenimiento y desarrollo del programa porque permite que los equipos trabajen en colaboración sin una brecha significativa de lenguaje y experiencia.

Lo más importante es que tiene bibliotecas como librosa, pyaudio, sklearn, que necesitamos para la extracción de características y su clasificación.

Arquitectura del Reconocimiento de Emociones en el Habla en el Backend:
Arquitectura básica del Backend
Descripción de la arquitectura del Reconocimiento de Emociones en el Habla:
Se puede observar en la arquitectura del sistema que tomamos la voz como muestras de entrenamiento y luego se pasa por un preprocesamiento para la extracción de características del sonido, lo que nos da matrices de entrenamiento. Estas matrices se utilizan para formar «clasificadores» para tomar decisiones sobre la emoción.

Por lo tanto, para las muestras de entrenamiento, se necesita un gran conjunto de datos de voz con diferentes emociones. Buscamos en la web y encontramos diferentes conjuntos de datos, algunos de los cuales se mencionan a continuación:
– Crowd-sourced Emotional Multimodal Actors Dataset (Crema-D)
– Ryerson Audio-Visual Database of Emotional Speech and Song (RAVDESS)
– Surrey Audio-Visual Expressed Emotion (Savee)
– Toronto emotional speech set (Tess)

Pero utilizamos el Ryerson Audio-Visual Database of Emotional Speech and Song (RAVDESS).

Ryerson Audio-Visual Database of Emotional Speech and Song (RAVDESS):
Razones para elegir RAVDESS:
– Tiene 2452 archivos de audio, con 12 hablantes masculinos y 12 hablantes femeninos.
– Las enunciaciones del habla se mantienen constantes al hablar solo 2 declaraciones de igual longitud.
– Tiene 8 emociones diferentes por todos los hablantes.
– Las emociones son: Calma, Felicidad, Tristeza, Enojo, Miedo, Asco y Sorpresa, junto con una línea de base de Neutro para cada actor.
– Cada uno de los archivos RAVDESS tiene un nombre de archivo único. El nombre de archivo consta de un identificador numérico de 7 partes (por ejemplo, 02-01-06-01-02-01-12.mp4). Estos identificadores definen las características del estímulo.

Herramientas utilizadas para el procesamiento del sonido:
– Librosa: Librería utilizada en Python para procesar y extraer características de archivos de audio. «Librosa» es un paquete de Python para análisis de música y audio. Proporciona los bloques de construcción necesarios para crear sistemas de recuperación de información musical.

Junto con el uso de estas herramientas y bibliotecas, hemos realizado la extracción de características del sonido utilizando Mel scale, pitch, frequency y chroma. Además, hemos utilizado otros algoritmos y técnicas de machine learning para clasificar las emociones basándonos en las características extraídas.

Conclusiones finales:
En resumen, hemos desarrollado con éxito una aplicación de reconocimiento de emociones en el habla utilizando Python y Kivy. Nuestra aplicación es capaz de detectar y clasificar las emociones de una persona utilizando su voz. Hemos utilizado el conjunto de datos RAVDESS para entrenar nuestro modelo y hemos utilizado bibliotecas como librosa, pyaudio y sklearn para extraer las características del sonido y clasificar las emociones. La interfaz de usuario se ha desarrollado utilizando Kivy, lo que nos permite crear una aplicación móvil que sea compatible con Android e iOS. Aunque hemos enfrentado algunos desafíos en el proceso de implementación y en la conversión del proyecto a un archivo ejecutable, hemos logrado superarlos y obtener resultados satisfactorios. Nuestro proyecto tiene fortalezas en términos de precisión en la detección de emociones y usabilidad de la aplicación, pero también presenta limitaciones en cuanto al ruido ambiental y el consumo de recursos. Como trabajo futuro, recomendamos explorar nuevas formas de optimizar la aplicación y ampliar su compatibilidad con diferentes idiomas y conjuntos de datos.

Deja un comentario