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. """)