Update app.py

app.py

@@ -1,90 +1,109 @@
-import tempfile
-import webrtcvad
-import speech_recognition as sr
-import numpy as np
 import streamlit as st
-import sounddevice as sd
-from traceback import format_exc
+import base64
+import io
+from huggingface_hub import InferenceClient
+from gtts import gTTS
+from audiorecorder import audiorecorder
+import speech_recognition as sr
+from pydub import AudioSegment
+
+pre_prompt_text = "Eres una IA conductual, tus respuestas deberán ser breves, estóicas y humanistas."
 
-def update_vad_status(status):
-    vad_status.text(status)
+if "history" not in st.session_state:
+    st.session_state.history = []
 
-def process_microphone_input():
-    # Configuramos la tasa de muestreo y el tamaño del frame
-    sample_rate = 16000
-    frame_size = 30
-    chunk_size = 1024  # Adjust as needed for responsiveness
+if "pre_prompt_sent" not in st.session_state:
+    st.session_state.pre_prompt_sent = False
 
-    # Creamos un objeto VAD y un reconocedor de voz
-    vad = webrtcvad.Vad()
+def recognize_speech(audio_data, show_messages=True):
     recognizer = sr.Recognizer()
+    audio_recording = sr.AudioFile(audio_data)
 
-    # Indicadores de estado
-    vad_active = False
-    speech_detected = False
-    phrase = ""
+    with audio_recording as source:
+        audio = recognizer.record(source)
 
     try:
-        # Configuramos la captura de audio desde el micrófono
-        with sd.InputStream(callback=callback, channels=1, dtype=np.int16):
-            st.warning("Habla y observa los cambios en tiempo real...")
-
-            # Mantenemos la aplicación en ejecución
-            st.experimental_rerun()
-            
-    except Exception as e:
-        st.error(f"Error during microphone input: {e}")
-        st.error("Traceback:")
-        st.error(format_exc())
-
-def callback(indata, frames, time, status):
-    if status:
-        print(f"Error in callback: {status}")
-        return
-
-    # Procesamos el audio en chunks
-    for i in range(0, len(indata), chunk_size):
-        chunk = indata[i:i + chunk_size]
-
-        # Procesamos cada chunk en frames
-        for j in range(0, len(chunk), frame_size):
-            # Obtenemos el frame actual
-            frame = chunk[j:j + frame_size]
-
-            # Detectamos si hay voz en el frame
-            is_speech = vad.is_speech(frame, sample_rate)
-
-            # Actualizamos los indicadores de estado
-            if is_speech and not vad_active:
-                vad_active = True
-                speech_detected = True
-                update_vad_status("️ Detección de voz iniciada")
-            elif not is_speech and vad_active:
-                vad_active = False
-                update_vad_status("⏹️ Detección de voz finalizada")
-
-            # Si se ha detectado voz y hay un silencio, transcribimos la frase
-            if speech_detected and not is_speech:
-                # Transcribimos la frase
-                with sr.AudioData(frame.tobytes(), sample_rate) as source:
-                    audio = recognizer.record(source)
-                    try:
-                        text = recognizer.recognize_google(audio)
-                        phrase += f" {text}"
-                        st.text(f"️ {text}")
-                    except sr.RequestError:
-                        st.error("⚠️ Error al transcribir la frase - RequestError")
-                    except sr.UnknownValueError:
-                        st.error("⚠️ No se ha reconocido la frase - UnknownValueError")
-
-                # Reiniciamos el indicador de frase
-                speech_detected = False
-
-    # Imprimimos la frase completa
-    st.success(f"Transcripción completa: {phrase}")
-
-# Streamlit UI
-st.title("VAD and Speech Recognition App (Microphone Input)")
-
-vad_status = st.empty()
-process_microphone_input()
+        audio_text = recognizer.recognize_google(audio, language="es-ES")
+        if show_messages:
+            st.subheader("Texto Reconocido:")
+            st.write(audio_text)
+            st.success("Reconocimiento de voz completado.")
+    except sr.UnknownValueError:
+        st.warning("No se pudo reconocer el audio. ¿Intentaste grabar algo?")
+        audio_text = ""
+    except sr.RequestError:
+        st.error("Hablame para comenzar!")
+        audio_text = ""
+
+    return audio_text
+
+def format_prompt(message, history):
+    prompt = "<s>"
+
+    if not st.session_state.pre_prompt_sent:
+        prompt += f"[INST] {pre_prompt_text} [/INST]"
+        st.session_state.pre_prompt_sent = True
+
+    for user_prompt, bot_response in history:
+        prompt += f"[INST] {user_prompt} [/INST]"
+        prompt += f" {bot_response}</s> "
+
+    prompt += f"[INST] {message} [/INST]"
+    return prompt
+
+def generate(audio_text, history, temperature=None, max_new_tokens=512, top_p=0.95, repetition_penalty=1.0):
+    client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
+
+    temperature = float(temperature) if temperature is not None else 0.9
+    temperature = max(temperature, 1e-2)
+    top_p = float(top_p)
+
+    generate_kwargs = dict(
+        temperature=temperature,
+        max_new_tokens=max_new_tokens,
+        top_p=top_p,
+        repetition_penalty=repetition_penalty,
+        do_sample=True,
+        seed=42)
+
+    formatted_prompt = format_prompt(audio_text, history)
+    stream = client.text_generation(formatted_prompt, **generate_kwargs, stream=True, details=True, return_full_text=True)
+    response = ""
+
+    for response_token in stream:
+        response += response_token.token.text
+    
+    response = ' '.join(response.split()).replace('</s>', '')
+    audio_file = text_to_speech(response, speed=1.3)
+    return response, audio_file
+
+def text_to_speech(text, speed=1.3):
+    tts = gTTS(text=text, lang='es')
+    audio_fp = io.BytesIO()
+    tts.write_to_fp(audio_fp)
+    audio_fp.seek(0)
+    audio = AudioSegment.from_file(audio_fp, format="mp3")
+    modified_speed_audio = audio.speedup(playback_speed=speed)
+    modified_audio_fp = io.BytesIO()
+    modified_speed_audio.export(modified_audio_fp, format="mp3")
+    modified_audio_fp.seek(0)
+    return modified_audio_fp
+
+def main():
+    audio_data = audiorecorder("Presiona para hablar", "Deteniendo la grabación...")
+
+    if not audio_data.empty():
+        st.audio(audio_data.export().read(), format="audio/wav")
+        audio_data.export("audio.wav", format="wav")
+        audio_text = recognize_speech("audio.wav")
+
+        if audio_text:
+            output, audio_file = generate(audio_text, history=st.session_state.history)  
+
+            if audio_file is not None:
+                st.markdown(
+                    f"""<audio autoplay="autoplay" controls="controls" src="data:audio/mp3;base64,{base64.b64encode(audio_file.read()).decode()}" type="audio/mp3" id="audio_player"></audio>""",
+                    unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    main()