Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Project structure: ArsenAI/ ├── audiofiles/ │ ├── audio.wav │ ├── recording.wav │ ├──…

  1. User

    Project structure:

    ArsenAI/ ├── audio_files/ │ ├── audio.wav │ ├── recording.wav │ ├── recording_1723749763.wav │ ├── recording_1723750110.wav │ ├── recording_1724005566.wav │ ├── recording_1724005614.wav │ ├── recording_1724006017.wav │ ├── recording_1724015867.wav │ ├── recording_1724015888.wav │ ├── recording_1724015903.wav │ ├── recording_1724018743.wav │ ├── recording_1724067849.wav │ ├── recording_1724067866.wav │ ├── recording_1724067927.wav │ ├── recording_1724067932.wav │ ├── recording_1724067963.wav │ ├── recording_1724067966.wav │ ├── recording_1724068241.wav │ ├── recording_1724068253.wav │ ├── recording_1724068312.wav │ ├── recording_1724068316.wav │ ├── recording_1724068423.wav │ ├── recording_1724068431.wav │ ├── recording_1724069008.wav │ ├── recording_1724069016.wav │ ├── recording_1724069337.wav │ ├── recording_1724069342.wav │ ├── recording_1724088967.wav │ ├── recording_1724089423.wav │ └── recording_1729344160.wav ├── processed_audio_chunks/ │ ├── processed_chunks_1724089423.wav │ ├── processed_chunks_1729344160.wav │ ├── processed_chunks_1729346895.wav │ ├── processed_chunks_1729346910.wav │ └── processed_chunks_1729346920.wav ├── static/ │ ├── css/ │ │ └── style.css │ ├── js/ │ │ ├── script.js │ │ └── worklet.js ├── templates/ │ └── index.html ├── test_audio_temp/ │ ├── chunk_1724069008.wav │ ├── chunk_1724069010.wav │ ├── chunk_1724069011.wav │ ├── chunk_1724069012.wav │ ├── chunk_1724069013.wav │ ├── chunk_1724069014.wav │ ├── chunk_1724069015.wav │ ├── chunk_1724069016.wav │ ├── chunk_1724069337.wav │ ├── chunk_1724069338.wav │ ├── chunk_1724069339.wav │ ├── chunk_1724069340.wav │ ├── chunk_1724069341.wav │ ├── chunk_1724069342.wav │ ├── vad_input_1724088931.wav │ ├── vad_input_1724088932.wav │ ├── vad_input_1724088933.wav │ ├── vad_input_1724088959.wav │ ├── vad_input_1724088962.wav │ ├── vad_input_1724088963.wav │ ├── vad_input_1724088964.wav │ ├── vad_input_1724088965.wav │ ├── vad_input_1724088966.wav │ ├── vad_input_1724088967.wav │ ├── vad_input_1724089417.wav │ ├── vad_input_1724089420.wav │ ├── vad_input_1724089421.wav │ ├── vad_input_1724089422.wav │ ├── vad_input_1724089423.wav │ ├── vad_input_1729341948.wav │ ├── vad_input_1729344151.wav │ └── vad_input_1729344152.wav ├── app.py ├── audio_handler.py └── main.py

    Project files:

    app.py

    import os
    import numpy as np
    import torch
    import wave
    from flask import Flask, render_template
    from flask_socketio import SocketIO, emit
    from collections import deque
    import time
    import threading
    from scipy.signal import resample_poly  # Быстрее для ресемплинга
    from queue import Queue
    
    # Константы
    INPUT_SAMPLE_RATE = 48000
    VAD_SAMPLE_RATE = 16000
    CHANNELS = 1
    CHUNK_SIZE = 512  # 32 мс при 16 кГц
    UPLOAD_FOLDER = 'audio_files'
    TEMP_AUDIO_FOLDER = 'test_audio_temp'
    PROCESSED_AUDIO_FOLDER = 'processed_audio_chunks'
    PROCESSING_INTERVAL = 0.05  # 50 мс для повышения отзывчивости
    
    app = Flask(__name__)
    app.config['SECRET_KEY'] = 'secret!'
    app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
    app.config['TEMP_AUDIO_FOLDER'] = TEMP_AUDIO_FOLDER
    app.config['PROCESSED_AUDIO_FOLDER'] = PROCESSED_AUDIO_FOLDER
    
    # Используем eventlet для лучшей конкурентности
    socketio = SocketIO(app, async_mode='eventlet', cors_allowed_origins="*")
    
    # Выбор устройства (CPU или GPU)
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # Инициализация Silero VAD
    vad_model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad',
                                     model='silero_vad',
                                     force_reload=True)
    vad_model = vad_model.to(device)
    vad_model.eval()
    
    # Глобальные переменные
    audio_buffer = deque()
    processing_queue = Queue()
    speech_detected = False
    previous_speech_detected = False
    last_processed_time = 0
    processing_lock = threading.Lock()
    
    # Буфер для VAD
    vad_buffer = np.array([])
    
    # Буфер для тестового сохранения (можно отключить для повышения производительности)
    processed_audio_chunks = []
    
    def ensure_folder_exists(folder):
        if not os.path.exists(folder):
            os.makedirs(folder)
    
    def int2float(sound):
        abs_max = np.abs(sound).max()
        sound = sound.astype('float32')
        if abs_max > 0:
            sound *= 1 / 32768
        sound = sound.squeeze()
        return sound
    
    def save_audio_chunk_to_file(audio_chunk, folder, filename):
        file_path = os.path.join(folder, filename)
        int_data = np.int16(audio_chunk * 32767)
        os.makedirs(folder, exist_ok=True)
        with wave.open(file_path, 'wb') as wf:
            wf.setnchannels(CHANNELS)
            wf.setsampwidth(2)
            wf.setframerate(VAD_SAMPLE_RATE)
            wf.writeframes(int_data.tobytes())
        print(f"Saved chunk to {file_path}")
    
    def save_processed_audio_chunks():
        global processed_audio_chunks
    
        if processed_audio_chunks:
            filename = f'processed_chunks_{int(time.time())}.wav'
            file_path = os.path.join(app.config['PROCESSED_AUDIO_FOLDER'], filename)
    
            # Соединяем все чанки
            all_chunks = np.concatenate(processed_audio_chunks)
            int_data = np.int16(all_chunks * 32767)
    
            os.makedirs(app.config['PROCESSED_AUDIO_FOLDER'], exist_ok=True)
            with wave.open(file_path, 'wb') as wf:
                wf.setnchannels(CHANNELS)
                wf.setsampwidth(2)
                wf.setframerate(VAD_SAMPLE_RATE)
                wf.writeframes(int_data.tobytes())
    
            print(f"Processed audio saved to {file_path}")
            processed_audio_chunks.clear()
        else:
            print("No processed audio chunks to save.")
    
    def detect_speech(audio_chunk):
        global speech_detected, vad_model, device, processed_audio_chunks
    
        # Преобразуем в float
        audio_float32 = int2float(audio_chunk)
    
        # Опционально сохраняем чанк для отладки
        # save_audio_chunk_to_file(audio_float32, app.config['TEMP_AUDIO_FOLDER'], f'vad_input_{int(time.time())}.wav')
    
        # Сохраняем чанк в буфере для тестирования
        processed_audio_chunks.append(audio_float32)
    
        try:
            with torch.no_grad():
                tensor = torch.from_numpy(audio_float32).to(device).unsqueeze(0)
                speech_prob = vad_model(tensor, VAD_SAMPLE_RATE).item()
                print(f"speech_prob = {speech_prob}")
        except RuntimeError as e:
            if "out of memory" in str(e):
                print("CUDA out of memory. Falling back to CPU.")
                torch.cuda.empty_cache()
                device = torch.device('cpu')
                vad_model = vad_model.to(device)
                tensor = torch.from_numpy(audio_float32).to(device).unsqueeze(0)
                speech_prob = vad_model(tensor, VAD_SAMPLE_RATE).item()
            else:
                raise e
    
        speech_detected = speech_prob > 0.5
        return speech_detected
    
    def audio_processing_worker():
        global vad_buffer, speech_detected, previous_speech_detected, last_processed_time
    
        while True:
            audio_chunk = processing_queue.get()
            if audio_chunk is None:
                break
    
            # Накопление в буфере для VAD
            vad_buffer = np.concatenate((vad_buffer, audio_chunk))
    
            while len(vad_buffer) >= CHUNK_SIZE:
                current_chunk = vad_buffer[:CHUNK_SIZE]
                is_speech = detect_speech(current_chunk)
    
                if is_speech != previous_speech_detected:
                    print(f"SWITCH TO: {is_speech}")
                    socketio.emit('speech_status', {'is_speech': is_speech})
                    previous_speech_detected = is_speech
    
                # Удаляем обработанный чанк из буфера
                vad_buffer = vad_buffer[CHUNK_SIZE:]
    
                last_processed_time = time.time()
    
            processing_queue.task_done()
    
    # Запускаем рабочий поток для обработки аудио
    processing_thread = threading.Thread(target=audio_processing_worker, daemon=True)
    processing_thread.start()
    
    @app.route('/')
    def index():
        return render_template('index.html')
    
    @app.route('/save_processed_audio', methods=['POST'])
    def save_processed_audio():
        save_processed_audio_chunks()
        return "Processed audio saved."
    
    @socketio.on('audio_data')
    def handle_audio_data(data):
        # Предполагается, что данные отправляются как ArrayBuffer
        audio_chunk = np.frombuffer(data, dtype=np.float32)
    
        if audio_chunk.ndim > 1:
            audio_chunk = np.mean(audio_chunk, axis=1)
    
        # Ресемплируем с 48 кГц до 16 кГц (коэффициент up=1, down=3)
        resampled_chunk = resample_poly(audio_chunk, up=1, down=3)
    
        processing_queue.put(resampled_chunk)
    
    @socketio.on('stop_recording')
    def handle_stop_recording():
        save_processed_audio_chunks()
        # Нет необходимости сохранять буфер здесь, так как обрабатывается через очередь
    
    def save_audio_to_file(audio_data):
        filename = f'recording_{int(time.time())}.wav'
        file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
    
        int_data = np.int16(np.array(audio_data) * 32767)
    
        os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)
        with wave.open(file_path, 'wb') as wf:
            wf.setnchannels(CHANNELS)
            wf.setsampwidth(2)
            wf.setframerate(VAD_SAMPLE_RATE)
            wf.writeframes(int_data.tobytes())
    
        print(f"Audio saved to {file_path}")
    
    if __name__ == '__main__':
        ensure_folder_exists(app.config['UPLOAD_FOLDER'])
        ensure_folder_exists(app.config['TEMP_AUDIO_FOLDER'])
        ensure_folder_exists(app.config['PROCESSED_AUDIO_FOLDER'])
        socketio.run(app, debug=True, host='0.0.0.0', port=8081)
    

    audio_handler.py

    import wave
    import os
    import numpy as np
    from pydub import AudioSegment
    
    audio_data = []
    
    def save_audio(data):
        global audio_data
        audio_data.append(np.frombuffer(data, dtype=np.int16))
    
    def finalize_audio():
        global audio_data
        if audio_data:
            audio_array = np.concatenate(audio_data)
            audio_segment = AudioSegment(
                audio_array.tobytes(),
                frame_rate=44100,
                sample_width=2,
                channels=1
            )
            output_path = os.path.join('static', 'output.wav')
            audio_segment.export(output_path, format="wav")
            audio_data = []
            return output_path
        return None
    
    

    main.py

    # This is a sample Python script.
    
    # Press Shift+F10 to execute it or replace it with your code.
    # Press Double Shift to search everywhere for classes, files, tool windows, actions, and settings.
    
    
    def print_hi(name):
        # Use a breakpoint in the code line below to debug your script.
        print(f'Hi, {name}')  # Press Ctrl+F8 to toggle the breakpoint.
    
    
    # Press the green button in the gutter to run the script.
    if __name__ == '__main__':
        print_hi('PyCharm')
    
    # See PyCharm help at https://www.jetbrains.com/help/pycharm/
    
    

    static/css/style.css

    body {
        display: flex;
        justify-content: center;
        align-items: center;
        height: 100vh;
        margin: 0;
        background-color: #f0f0f0;
    }
    
    .container {
        display: flex;
        justify-content: center;
        align-items: center;
    }
    
    .voice-button {
        /* display: flex; */
        width: 100px;
        height: 100px;
        border-radius: 50%;
        background-color: #000;
        cursor: pointer;
        transition: all 0.3s ease;
        position: relative;
        /* align-items: center; */
        /* justify-content: center; */
    }
    
    .listening {
        animation: pulse 1s infinite alternate;
        transition: background-color 0.1s ease;
    }
    
    @keyframes pulse {
        0% {
            background-color: #492516;
        }
        100% {
            background-color: #7e391d;
        }
    }
    
    .voice-detect-point {
        background-color: white;
        width: 25px;
        height: 25px;
        border-radius: 100%;
        position: absolute;
        left: 50%;
        top: 50%;
        filter: blur(10px);
        transform: translate(-50%, -50%);
    
        opacity: 0;
        transition: opacity 0.2s;
    }
    

    static/js/script.js

    let isRecording = false;
    let audioContext;
    let socket;
    let analyser;
    let dataArray;
    
    const voiceButton = document.getElementById('voice-button');
    const voiceDetectPoint = document.querySelector('.voice-detect-point');
    voiceButton.addEventListener('click', toggleRecording);
    
    function initSocket() {
        socket = io.connect(location.protocol + '//' + document.domain + ':' + location.port);
    
        // Handler for speech status
        socket.on('speech_status', function(data) {
            if (data.is_speech) {
                voiceDetectPoint.style.opacity = '1';
            } else {
                voiceDetectPoint.style.opacity = '0';
            }
        });
    }
    
    async function toggleRecording() {
        if (!isRecording) {
            try {
                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
                startRecording(stream);
            } catch (err) {
                console.error('Error accessing the microphone:', err);
            }
        } else {
            stopRecording();
        }
    }
    
    async function startRecording(stream) {
        audioContext = new (window.AudioContext || window.webkitAudioContext)();
        await audioContext.audioWorklet.addModule('/static/js/worklet.js');
        const source = audioContext.createMediaStreamSource(stream);
    
        // Create an analyser node
        analyser = audioContext.createAnalyser();
        analyser.fftSize = 256;
        const bufferLength = analyser.frequencyBinCount;
        dataArray = new Uint8Array(bufferLength);
    
        const audioWorkletNode = new AudioWorkletNode(audioContext, 'audio-processor');
        source.connect(audioWorkletNode);
        source.connect(analyser);
    
        audioWorkletNode.port.onmessage = (event) => {
            if (!isRecording) return;
            const buf = new Float32Array(event.data);
            socket.emit('audio_data', buf.buffer);
        };
    
        isRecording = true;
        voiceButton.classList.add('listening');
        // Disable transition during recording for smoother animation
        voiceButton.style.transition = 'none';
        updateButtonSize();
    }
    
    function stopRecording() {
        isRecording = false;
        voiceButton.classList.remove('listening');
        if (audioContext) {
            audioContext.close();
        }
        socket.emit('stop_recording');
    }
    
    function updateButtonSize() {
        if (!isRecording) return;
    
        analyser.getByteFrequencyData(dataArray);
        const average = dataArray.reduce((acc, val) => acc + val, 0) / dataArray.length;
        const volume = average / 255; // Normalize to 0-1 range
    
        // Scale button size based on volume (min 100px, max 200px)
        const size = 130 + ((volume * 100) * 2.5);
        voiceButton.style.width = `${size}px`;
        voiceButton.style.height = `${size}px`;
    
        requestAnimationFrame(updateButtonSize);
    }
    
    document.addEventListener('DOMContentLoaded', initSocket);
    

    static/js/worklet.js

    class AudioProcessor extends AudioWorkletProcessor {
      process(inputs, outputs, parameters) {
        const input = inputs[0];
        const output = outputs[0];
        for (let channel = 0; channel < input.length; ++channel) {
          const inputChannel = input[channel];
          const outputChannel = output[channel];
          for (let i = 0; i < inputChannel.length; ++i) {
            outputChannel[i] = inputChannel[i];
          }
        }
    
        // Send downsampled data to main thread
        // Assuming the server expects float32 data
        this.port.postMessage(input[0].buffer);
    
        return true;
      }
    }
    
    registerProcessor('audio-processor', AudioProcessor);
    

    templates/index.html

    <!DOCTYPE html>
    <html lang="ru">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Голосовой чат-бот</title>
        <link rel="stylesheet" href="../static/css/style.css">
        <script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/4.0.1/socket.io.js"></script>
    </head>
    <body>
        <div class="container">
            <div id="voice-button" class="voice-button">
                <div class="voice-detect-point"></div>
            </div>
        </div>
        <script src="../static/js/script.js"></script>
    </body>
    </html>
    

    Вот мой код для Conversational AI.

    Сейчас проблема с тем, что аудио транслируется на VAD, но он меня не распознает, а сохраненное аудио на сервере - это просто тишина.

    То есть проблема с тем, как аудио передается на сревер.

    VAD не меняй, он принимает строго определенный размер чанка и частоту.

  2. Assistant

    Проблема, которую вы описываете, связана с тем, что аудиоданные передаются на сервер в формате float32, но на сервере происходит неправильная обработка этих данных, что приводит к их чрезмерному снижению уровня громкости. В результате VAD не распознает речь, а сохраняемый аудиофайл содержит только тишину.

    Основная причина проблемы:

    В вашем серверном коде (app.py) функция int2float неправильно обрабатывает уже нормализованные float32 данные, предполагая, что они находятся в формате int16. Это приводит к тому, что значения аудиосигнала делятся на 32768, что делает их крайне малыми и, как следствие, почти незаметными для VAD.

    Детали проблемы:

    1. Клиентская сторона:

      • AudioWorklet (worklet.js): Отправляет аудиоданные в формате Float32Array, значения которых уже нормализованы в диапазоне от -1 до 1.
      • script.js: Корректно отправляет эти данные на сервер без дополнительного изменения их уровня громкости.
    2. Серверная сторона:

      • Обработка аудиоданных (app.py):
        • audio_chunk считывается как float32:
          audio_chunk = np.frombuffer(data, dtype=np.float32)
          
        • Затем вызывается функция int2float, которая ошибочно делит данные на 32768:
          def int2float(sound):
              abs_max = np.abs(sound).max()
              sound = sound.astype('float32')
              if abs_max > 0:
                  sound *= 1 / 32768  # Некорректное масштабирование
              sound = sound.squeeze()
              return sound
          
        • Это приводит к тому, что аудиосигнал становится слишком тихим для VAD.

    Решение:

    Необходимо исправить функцию int2float так, чтобы она не масштабировала уже нормализованные float32 данные. Вот как это можно сделать:

    1. Измените функцию int2float в app.py:

      def int2float(sound):
          # Удаляем неправильное масштабирование
          sound = sound.squeeze()
          return sound
      

      Или полностью уберите функцию int2float и используйте audio_chunk напрямую:

      def detect_speech(audio_chunk):
          global speech_detected, vad_model, device, processed_audio_chunks
      
          # Прямое использование float32 без дополнительного масштабирования
          audio_float32 = audio_chunk
      
          # Опционально сохраняем чанк для отладки
          # save_audio_chunk_to_file(audio_float32, app.config['TEMP_AUDIO_FOLDER'], f'vad_input_{int(time.time())}.wav')
      
          # Сохраняем чанк в буфере для тестирования
          processed_audio_chunks.append(audio_float32)
      
          try:
              with torch.no_grad():
                  tensor = torch.from_numpy(audio_float32).to(device).unsqueeze(0)
                  speech_prob = vad_model(tensor, VAD_SAMPLE_RATE).item()
                  print(f"speech_prob = {speech_prob}")
          except RuntimeError as e:
              if "out of memory" in str(e):
                  print("CUDA out of memory. Falling back to CPU.")
                  torch.cuda.empty_cache()
                  device = torch.device('cpu')
                  vad_model = vad_model.to(device)
                  tensor = torch.from_numpy(audio_float32).to(device).unsqueeze(0)
                  speech_prob = vad_model(tensor, VAD_SAMPLE_RATE).item()
              else:
                  raise e
      
          speech_detected = speech_prob > 0.5
          return speech_detected
      
    2. Проверка сохранения аудио: Убедитесь, что при сохранении аудио не происходит дополнительного неправильного масштабирования. В вашем коде save_audio_chunk_to_file выполняет правильное масштабирование из float32 в int16:

      def save_audio_chunk_to_file(audio_chunk, folder, filename):
          file_path = os.path.join(folder, filename)
          int_data = np.int16(audio_chunk * 32767)  # Корректное масштабирование
          os.makedirs(folder, exist_ok=True)
          with wave.open(file_path, 'wb') as wf:
              wf.setnchannels(CHANNELS)
              wf.setsampwidth(2)
              wf.setframerate(VAD_SAMPLE_RATE)
              wf.writeframes(int_data.tobytes())
          print(f"Saved chunk to {file_path}")
      

    Дополнительные рекомендации:

    1. Проверка частоты дискретизации на клиенте: Убедитесь, что AudioContext на клиенте действительно работает с частотой дискретизации 48000 Hz. Вы можете добавить логирование в script.js для вывода текущей частоты дискретизации:

      async function startRecording(stream) {
          audioContext = new (window.AudioContext || window.webkitAudioContext)();
          console.log('AudioContext sample rate:', audioContext.sampleRate);  // Добавьте эту строку
          await audioContext.audioWorklet.addModule('/static/js/worklet.js');
          // Остальной код...
      }
      

      Если частота дискретизации отличается, возможно, потребуется адаптировать резэмплинг на клиенте или сервере.

    2. Валидация передаваемых данных: На сервере можно добавить проверку диапазона значений audio_chunk перед обработкой:

      def detect_speech(audio_chunk):
          global speech_detected, vad_model, device, processed_audio_chunks
      
          audio_float32 = audio_chunk
          print(f"Audio chunk max: {audio_float32.max()}, min: {audio_float32.min()}")  # Добавьте эту строку для отладки
      
          # Остальной код...
      

      Это поможет убедиться, что данные действительно находятся в диапазоне -1 до 1.

    3. Использование отладочных файлов: Временно включите сохранение аудиочанков для отладки, чтобы проверить, что данные на сервере корректны:

      def detect_speech(audio_chunk):
          global speech_detected, vad_model, device, processed_audio_chunks
      
          audio_float32 = audio_chunk
          save_audio_chunk_to_file(audio_float32, app.config['TEMP_AUDIO_FOLDER'], f'vad_input_{int(time.time())}.wav')  # Включите это временно
      
          # Остальной код...
      

      Это позволит вам прослушать сохраненные файлы и убедиться в их корректности.

    Заключение

    Основная проблема заключалась в неправильном масштабировании аудиоданных на серверной стороне. После удаления или корректировки функции int2float, аудиоданные будут правильно передаваться и обрабатываться VAD, что позволит обнаруживать речь и правильно сохранять аудиофайлы.

    Если после внесения этих изменений проблема сохраняется, рекомендуется добавить дополнительные логирующие сообщения как на клиентской, так и на серверной стороне для более детальной отладки и понимания, на каком этапе происходит потеря данных.