app.py

import streamlit as st
import librosa
from speechbrain.inference.classifiers import EncoderClassifier
import tempfile
import streamlit as st
import io
import matplotlib.pyplot as plt
import streamlit as st
import tempfile
from speechbrain.inference.classifiers import EncoderClassifier
import numpy as np
from pydub import AudioSegment

# Convertir MP3 a WAV antes de pasar al modelo
def convertir_a_wav(uploaded_file):
    audio = AudioSegment.from_file(uploaded_file)
    tmp_wav = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
    audio.export(tmp_wav.name, format="wav")
    return tmp_wav.name


# Cargar el modelo de SpeechBrain
@st.cache_resource
def cargar_modelo_speechbrain():
    return EncoderClassifier.from_hparams(
        source="speechbrain/urbansound8k_ecapa",
        savedir="pretrained_models/urbansound8k_ecapa"
    )


st.title("Muestra de Implementación Reconocimiento de Audio Ambiental para la Detección de situaciones de Emergencia en Vehículos Inteligentes")



st.write("""
En la actualidad, los sistemas de asistencia al conductor han centrado sus esfuerzos principalmente en la percepción visual,
incorporando tecnologías como sensores de proximidad, cámaras y radares. No obstante, uno de los sentidos humanos menos explorados 
dentro de los sistemas inteligentes de los automóviles es el sentido auditivo.

En entornos urbanos, donde los sonidos de emergencia tales como las sirenas de ambulancias, patrullas policiales o camiones de bomberos
desempeñan un papel fundamental en la seguridad vial, es preocupante que muchos conductores no respondan adecuadamente ante su presencia.
Factores como el volumen de la música, el aislamiento acústico del vehículo o la simple distracción contribuyen a esta falta de reacción oportuna.
""")

st.subheader("Objetivo del Proyecto")

st.write("""
El propósito de este proyecto es desarrollar un sistema auditivo inteligente para detectar sirenas en entornos urbanos desde el interior del vehículo.
""")

st.subheader(" ¿Cómo Funciona?")

st.write("""
1. Carga o graba un audio.
2. El sistema analiza el sonido con un modelo para procesamiento de audio.
3. Si detecta una sirena, genera una alerta.
""")




st.write("Sube un archivo de audio (.wav o .mp3) para escucharlo.")

# Subida de archivo
audio_file = st.file_uploader("Sube tu archivo de audio aquí", type=["wav", "mp3"])

# Reproducir audio si se ha subido
if audio_file is not None:
    st.audio(audio_file, format='audio/wav')
    st.success("✅ Archivo cargado exitosamente.")





# Function to record audio
def record_audio(filename="recorded.wav", duration=3, fs=22050):
    st.info("Grabando")
    #recording = sd.rec(int(duration * fs), samplerate=fs, channels=1, dtype=np.int16)
    #sd.wait()
    #wavio.write(filename, recording, fs, sampwidth=2)
    #st.session_state["recorded_file"] = filename
    st.info("Audio No detectado")

# Streamlit UI
st.title("Grabar Audio")

if "recorded_file" not in st.session_state:
    st.session_state["recorded_file"] = None

if st.button("Grabando..."):
    print("Subir Audio de prueba")










modelo_sb = cargar_modelo_speechbrain()


st.write("Tiempo estimado de procesamiento: 15 seg")


if audio_file is not None:
    # Cargar audio con librosa
    audio_bytes = audio_file.read()
    y, sr = librosa.load(io.BytesIO(audio_bytes), sr=None)

    st.audio(audio_bytes, format='audio/mp3')


    # Mostrar información del audio
    duration = librosa.get_duration(y=y, sr=sr)
    st.markdown(f"**Duración:** {duration:.2f} segundos")
    st.markdown(f"**Tasa de muestreo:** {sr} Hz")

    # Forma de onda
    st.subheader("Forma de Onda")
    fig_wave, ax_wave = plt.subplots(figsize=(10, 3))
    librosa.display.waveshow(y, sr=sr, ax=ax_wave)
    ax_wave.set_title("Forma de Onda")
    ax_wave.set_xlabel("Tiempo (s)")
    ax_wave.set_ylabel("Amplitud")
    st.pyplot(fig_wave)

    # Espectrograma
    st.subheader("Espectrograma")
    fig_spec, ax_spec = plt.subplots(figsize=(10, 4))
    D = librosa.amplitude_to_db(np.abs(librosa.stft(y)), ref=np.max)
    img = librosa.display.specshow(D, sr=sr, x_axis='time', y_axis='log', ax=ax_spec)
    ax_spec.set_title("Espectrograma Logarítmico")
    fig_spec.colorbar(img, ax=ax_spec, format="%+2.f dB")
    st.pyplot(fig_spec)


        # Energía del audio
    st.subheader("Energía a lo largo del tiempo")
    hop_length = 512
    frame_length = 1024
    energy = np.array([
        sum(abs(y[i:i+frame_length]**2))
        for i in range(0, len(y), hop_length)
    ])
    fig_energy, ax_energy = plt.subplots(figsize=(10, 2.5))
    ax_energy.plot(energy, color='orange')
    ax_energy.set_title("Energía del audio")
    ax_energy.set_xlabel("Frames")
    ax_energy.set_ylabel("Energía")
    st.pyplot(fig_energy)

    # Espectro promedio
    st.subheader("Espectro Promedio (Frecuencia vs Magnitud)")
    S = np.abs(librosa.stft(y))
    spectral_avg = np.mean(S, axis=1)
    freqs = librosa.fft_frequencies(sr=sr)
    fig_spec_avg, ax_spec_avg = plt.subplots(figsize=(10, 3))
    ax_spec_avg.semilogy(freqs, spectral_avg)
    ax_spec_avg.set_xlabel("Frecuencia (Hz)")
    ax_spec_avg.set_ylabel("Magnitud promedio")
    ax_spec_avg.set_title("Espectro Promedio")
    st.pyplot(fig_spec_avg)

    # Spectral Roll-off
    st.subheader("Punto de Roll-off Espectral")
    rolloff = librosa.feature.spectral_rolloff(y=y, sr=sr)[0]
    fig_roll, ax_roll = plt.subplots(figsize=(10, 2.5))
    ax_roll.plot(rolloff, color='purple')
    ax_roll.set_ylabel('Hz')
    ax_roll.set_xlabel('Frames')
    ax_roll.set_title('Spectral Roll-off (frecuencia donde se concentra la energía)')
    st.pyplot(fig_roll)




    
    from speechbrain.inference.classifiers import EncoderClassifier
    st.audio(audio_file, format='audio/mp3')
    
    # Convertir a WAV
    wav_path = convertir_a_wav(audio_file)

    # Clasificar con SpeechBrain
    prediccion = modelo_sb.classify_file(wav_path)
    clase_predicha = prediccion[3][0]
    st.markdown(f"**Predicción del modelo:** {clase_predicha}")

    if clase_predicha.lower() == "siren":
        st.warning("Sirena detectada en el audio.!!!!!")
    else:
        st.info("No se detectó sirena en el audio.")






st.subheader("Conclusión y Aplicaciones del Modelo")

with st.expander("Ver Conclusión"):
    st.markdown("""
**Este proyecto demuestra la viabilidad de utilizar modelos de reconocimiento acústico para detectar sonidos críticos como las sirenas de ambulancia en entornos urbanos.** A través de un sistema auditivo pasivo, se pueden generar alertas en tiempo real dentro del vehículo sin necesidad de intervención del conductor.

---

### Aplicaciones en vehículos inteligentes

-  **Asistencia al conductor en tiempo real: Al detectar sirenas, el vehículo puede alertar al conductor para que tome decisiones seguras, como ceder el paso a vehículos de emergencia, asi ser complemento a sensores visuales**: Este sistema actúa como un canal sensorial adicional que no depende de la visibilidad, mejorando la percepción del entorno.

---

### Conclusión final

Este sistema demuestra cómo los modelos de audio de procesamiento pueden implementarse  para **mejorar la seguridad vial** y **la capacidad de respuesta del conductor ** ante situaciones de emergencia.
    """)