Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

import socket import vosk import json import yaml from fuzzywuzzy import fuzz import tts…

  1. User

    import socket import vosk import json import yaml from fuzzywuzzy import fuzz import tts from const import SYSTEM_PROMPT from llm_models.mini_4o_model import ModelClient from services.lamp_service import turn_on, turn_off from services.pc_service import enter_sleep_mode import time import pygame

    HOST = '0.0.0.0' PORT = 6543 ANDROID_ADDR = None

    client = ModelClient()

    Load command list from YAML file

    VA_CMD_LIST = yaml.safe_load(open('commands.yaml', 'rt', encoding='utf8'))

    WAKE_WORD = "соня" LISTEN_DURATION = 10

    pygame.mixer.init()

    def play_sound(sound_file: str) -> None: pygame.mixer.music.load(sound_file) pygame.mixer.music.play()

    def recognize_command(command: str) -> dict: best_match = {'cmd': '', 'percent': 0} for command_key, variations in VA_CMD_LIST.items(): for variation in variations: similarity = fuzz.ratio(command, variation) if similarity > best_match['percent']: best_match['cmd'] = command_key best_match['percent'] = similarity return best_match

    def execute_command(command: str) -> None: if command == 'enter_sleep_mode': tts.va_speak(enter_sleep_mode()) elif command == 'lamp_on': tts.va_speak(turn_on()) elif command == 'lamp_off': tts.va_speak(turn_off())

    def process_recognized_text(recognized_text: str) -> None: command = recognize_command(recognized_text) print(command)

    if not command['cmd'].strip():
        return
    
    if command['percent'] < 70 or command['cmd'] not in VA_CMD_LIST.keys():
        response = generate_response(recognized_text)
        tts.va_speak(response)
        client.history.append((recognized_text, response))
    else:
        execute_command(command['cmd'])
    

    def generate_response(input_text: str) -> str: response_generator = client.get_response(message=input_text, sys_prompt=SYSTEM_PROMPT) full_response = [] last = ''

    for response in response_generator:
        part = response.replace(last, '')
        print(part, end='', flush=True)
        full_response.append(part)
        last = response
    
    print()
    
    complete_response = ''.join(full_response)
    return complete_response
    

    def listen_for_commands(conn: socket.socket, recognizer: vosk.KaldiRecognizer) -> None: start_time = time.time() while time.time() - start_time < LISTEN_DURATION: data = conn.recv(1024) if not data: break

        if recognizer.AcceptWaveform(data):
            result = json.loads(recognizer.Result())
            recognized_text = result['text']
            if recognized_text:
                print("Recognized text:", recognized_text)
                process_recognized_text(recognized_text)
    

    def send_to_android(param): # Установите соединение с Android try: android_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Здесь добавлен импорт модуля socket android_socket.connect((ANDROID_ADDR, 51411)) output = android_socket.makefile('wb') # Создаем поток записи для отправки данных output.write(param) # Отправляем уведомление о начале режима output.close() android_socket.close() except Exception as e: print(e)

    def main() -> None: global ANDROID_ADDR model = vosk.Model("model_small") recognizer = vosk.KaldiRecognizer(model, 44100)

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((HOST, PORT))
    server_socket.listen(1)
    print("Server started, waiting for connection...")
    
    while True:
        conn, addr = server_socket.accept()
        ANDROID_ADDR = addr[0]
        print(f"Connected to {addr}")
    
        while True:
            data = conn.recv(1024)
            if not data:
                break
    
            if recognizer.AcceptWaveform(data):
                result = json.loads(recognizer.Result())
                recognized_text = result['text']
    
                if recognized_text:
                    print("Recognized text:", recognized_text)
    
                    if WAKE_WORD in recognized_text.lower():
                        print("Wake word detected, entering command listening mode.")
    
                        send_to_android(b'ACTIVATED')
    
                        play_sound('sound/start.wav')
    
                        command_text = recognized_text.lower().replace(WAKE_WORD, '', 1).strip()
                        if command_text:
                            process_recognized_text(command_text)
                        listen_for_commands(conn, recognizer)
    
                        send_to_android(b'DEACTIVATED')
                        play_sound('sound/cancel.wav')
    
        conn.close()
        print("Connection closed, waiting for new connection...")
    

    if name == "main": main()

  2. Assistant

    Your Python code implements a voice-activated assistant that listens for commands after detecting a wake word and executes those commands using various services. Here's a detailed breakdown of your code, along with some suggestions for improvement and optimization.

    Code Breakdown

    1. Imports:

      • You import necessary libraries like socket, vosk for speech recognition, json, yaml for file handling, and fuzzywuzzy for string similarity. Additionally, you include custom services for managing lights and putting the PC to sleep, and pygame for sound playback.
    2. Constants and Initialization:

      • Define constants for host address, port, wake word, and listening duration.
      • Initialize the ModelClient from your custom library.
      • Load a command list from a YAML file named commands.yaml.
    3. Utility Functions:

      • play_sound: Plays a specified sound file using pygame.
      • recognize_command: Uses fuzzy matching to find the best command from the provided list based on the recognized text.
      • execute_command: Executes the appropriate service function based on the matched command.
      • process_recognized_text: Processes the recognized speech, determining if a command was found and responding appropriately.
      • generate_response: Generates a response using the ModelClient, streaming the output.
      • listen_for_commands: Continuously listens for audio data for a set duration, recognizing and processing speech.
    4. Communication with Android:

      • send_to_android: Establishes a socket connection to send messages to an Android device.
    5. Main Loop:

      • In the main function, you set up a TCP server which listens for incoming connections and handles recognized speech, entering a command mode when the wake word is detected.

    Suggestions for Improvement

    1. Modularization:

      • Break down the functionalities into separate modules or classes. This will improve readability and maintainability of the code.
    2. Error Handling:

      • Improve error handling, especially with socket connections and file handling. Use try-except blocks where necessary to avoid crashes.
    3. Threading or Asynchronous Handling:

      • Consider using threading or async I/O to handle multiple clients simultaneously and to ensure that the server remains responsive while processing commands.
    4. Configuration Management:

      • Move hardcoded strings like file paths or server addresses to a configuration file or environment variables for easier management.
    5. Enhanced Command Recognition:

      • Adjust the threshold in recognize_command to improve sensitivity or add logging for commands not recognized above a certain threshold.
    6. Further Sound Control:

      • Ensure that pygame stops any currently playing sound before launching a new sound. This will prevent sound overlaps.
    7. Commenting and Documentation:

      • Add comments and docstrings to functions to explain their purpose, parameters, and return values to make the code easier to understand for newcomers.

    Example Improvement: Command Recognition Threshold

    To improve command recognition, you can set a configurable threshold:

    COMMAND_RECOGNITION_THRESHOLD = 70
    
    if command['percent'] < COMMAND_RECOGNITION_THRESHOLD or command['cmd'] not in VA_CMD_LIST.keys():
        response = generate_response(recognized_text)
        tts.va_speak(response)
        client.history.append((recognized_text, response))
    else:
        execute_command(command['cmd'])
    

    Conclusion

    Your code implements a comprehensive voice recognition system that effectively listens for commands and executes them. With some enhancements in structure, error handling, and responsiveness, it can be refined into a more robust solution.

  3. User

    package com.example.sonya

    import android.Manifest import android.animation.ObjectAnimator import android.annotation.SuppressLint import android.content.res.ColorStateList import android.graphics.Color import android.media.AudioFormat import android.media.AudioRecord import android.media.MediaRecorder import android.os.Bundle import android.widget.Button import androidx.appcompat.app.AppCompatActivity import androidx.core.app.ActivityCompat import java.io.InputStream import java.io.OutputStream import java.net.ServerSocket import java.net.Socket import kotlin.concurrent.thread

    class MainActivity : AppCompatActivity() {

    private val sampleRate = 44100
    private var isRecording = false
    private lateinit var recordButton: Button
    private var animator: ObjectAnimator? = null
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    
        recordButton = findViewById(R.id.recordButton)
    
        // Запрос разрешений
        ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.RECORD_AUDIO, Manifest.permission.INTERNET), 1)
    
        recordButton.setOnClickListener {
            if (isRecording) {
                stopRecording()
            } else {
                startRecording()
            }
        }
    
        startSocketServer()
    }
    
    private fun startSocketServer() {
        thread {
            try {
                val serverSocket = ServerSocket(51411)
                while (true) {
                    val clientSocket: Socket = serverSocket.accept()
                    val inputStream: InputStream = clientSocket.getInputStream()
                    val buffer = ByteArray(1024)
                    val read = inputStream.read(buffer)
                    val message = String(buffer, 0, read)
    
                    when (message) {
                        "ACTIVATED" -> {
                            runOnUiThread {
                                onActivationReceived()
                            }
                        }
                        "DEACTIVATED" -> {
                            runOnUiThread {
                                onDeactivationReceived()
                            }
                        }
                    }
    
                    inputStream.close()
                    clientSocket.close()
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
    
    private fun onActivationReceived() {
        recordButton.backgroundTintList = ColorStateList.valueOf(Color.parseColor("#FFCC0000"))
    }
    
    private fun onDeactivationReceived() {
        recordButton.backgroundTintList = null // Сбрасывает tint
    }
    
    @SuppressLint("MissingPermission")
    private fun startRecording() {
        isRecording = true
        animateButton(true) // Начинаем анимацию
    
        Thread {
            val bufferSize = AudioRecord.getMinBufferSize(sampleRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT)
            val audioRecord = AudioRecord(MediaRecorder.AudioSource.MIC, sampleRate, AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSize)
            audioRecord.startRecording()
    
            try {
                val socket = Socket("192.168.0.105", 6543)
                val outputStream: OutputStream = socket.getOutputStream()
                val buffer = ByteArray(bufferSize)
    
                while (isRecording) {
                    val read = audioRecord.read(buffer, 0, buffer.size)
                    outputStream.write(buffer, 0, read)
                }
    
                outputStream.close()
                socket.close()
            } catch (e: Exception) {
                e.printStackTrace()
            } finally {
                audioRecord.stop()
                audioRecord.release()
            }
        }.start()
    }
    
    private fun stopRecording() {
        isRecording = false
        animateButton(false) // Останавливаем анимацию
    }
    
    private fun animateButton(isRecording: Boolean) {
        if (isRecording) {
            // Запускаем анимацию
            animator = ObjectAnimator.ofFloat(recordButton, "scaleX", 1.0f, 1.2f)
            animator?.duration = 300
            animator?.repeatCount = ObjectAnimator.INFINITE
            animator?.repeatMode = ObjectAnimator.REVERSE
            animator?.start()
        } else {
            // Останавливаем анимацию
            animator?.cancel()
            recordButton.scaleX = 1.0f // Возвращаем к исходному размеру
        }
    }
    

    }

    Как мне сделать чтобы аудио ответа воспроизводилось не только с помощью python, но и передавалось и воспроизводилось на устройстве android

  4. Assistant

    Чтобы воспроизводить аудио-ответ, полученный от Python-сервера на Android-устройстве, вы можете использовать потоковое аудио или записи, передавая их через сокет. Этот процесс включает несколько этапов:

    1. Изменение Python-кода для передачи аудио-ответа: Вам требуется извлечь аудиофайл в Python и передать его в реальном времени через TCP-соединение к Android-устройству.

    2. Изменение Android-кода для получения и воспроизведения аудио: На стороне Android необходимо добавить код для приема аудиоданных и воспроизведения их с помощью AudioTrack.

    Вот как вы можете это реализовать:

    Шаг 1: Изменение Python-кода

    Предположим, что вы используете Python для генерации аудио-ответов (например, с помощью текстового синтезатора). Вы должны отправлять бинарные данные аудиофайла через сокет. Ниже приведен добавленный фрагмент в execute_command, который генерирует аудиофайл и отправляет его.

    from services.tts_service import generate_audio_response  # Добавьте необходимый импорт
    
    def execute_command(command: str) -> None:
        if command in ['lamp_on', 'lamp_off', 'enter_sleep_mode']:
            audio_data = generate_audio_response(command)  # Получаем аудиоданные через TTS
            
            send_audio_to_android(audio_data)  # Отправляем аудиоданные на андроид
            
    def send_audio_to_android(audio_data: bytes) -> None:
        try:
            android_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            android_socket.connect((ANDROID_ADDR, 51411))
            output = android_socket.makefile('wb')
            output.write(audio_data)
            output.close()
            android_socket.close()
        except Exception as e:
            print(e)
    

    Шаг 2: Изменение Android-кода для воспроизведения аудиоданных

    Ваша задача — создать метод для получения и воспроизведения аудиоданных на Android. Для этого добавьте следующий код:

    import android.media.AudioFormat
    import android.media.AudioManager
    import android.media.AudioTrack
    
    fun startAudioPlayback() {
        thread {
            try {
                val socket = ServerSocket(51412) // Новый порт для приема аудио
                val clientSocket: Socket = socket.accept()
                val inputStream: InputStream = clientSocket.getInputStream()
                
                // Получаем аудиоформат
                val bufferSize = AudioTrack.getMinBufferSize(
                    sampleRate, 
                    AudioFormat.CHANNEL_OUT_MONO, 
                    AudioFormat.ENCODING_PCM_16BIT
                )
                val audioTrack = AudioTrack(
                    AudioManager.STREAM_MUSIC,
                    sampleRate,
                    AudioFormat.CHANNEL_OUT_MONO,
                    AudioFormat.ENCODING_PCM_16BIT,
                    bufferSize,
                    AudioTrack.MODE_STREAM
                )
                audioTrack.play()
                
                val buffer = ByteArray(bufferSize)
                var read: Int
    
                while (inputStream.read(buffer).also { read = it } != -1) {
                    audioTrack.write(buffer, 0, read)
                }
    
                audioTrack.stop()
                audioTrack.release()
                inputStream.close()
                clientSocket.close()
                socket.close()
            } catch (e: Exception) {
                e.printStackTrace()
            }
        }
    }
    

    Шаг 3: Вызов startAudioPlayback

    Теперь вам нужно будет запустить startAudioPlayback в вашем onCreate методе или сразу после того, как кнопка записи активируется.

    Итог

    Теперь на вашем Python-сервере генерируются и отправляются аудиоданные, которые Android-приемник принимает и воспроизводит. Убедитесь, что на устройстве Android имеется разрешение на доступ к Интернету и к аудиосистеме, а также корректно открыты сокеты на используемых портах.

    Также важно протестировать данную реализацию, чтобы гарантировать стабильное и качественное воспроизведение аудио на устройстве Android.

  5. User

    def execute_command(command: str) -> None: if command == 'enter_sleep_mode': tts.va_speak(enter_sleep_mode()) elif command == 'lamp_on': tts.va_speak(turn_on()) elif command == 'lamp_off': tts.va_speak(turn_off())

    #tts.py import time import sounddevice as sd import torch

    language = 'ru' model_id = 'ru_v3' # ru_v3 / v4_ru sample_rate = 48000 # 48000 speaker = 'baya' # aidar, baya, kseniya, xenia, random put_accent = True put_yo = True device = torch.device('cuda')

    model, _ = torch.hub.load(repo_or_dir='snakers4/silero-models', model='silero_tts', language=language, speaker=model_id) model.to(device)

    def print_yellow(text): """Выводит текст в желтом цвете.""" print(f"\033[93m{text}\033[0m")

    воспроизводим

    def va_speak(what: str): start_speak_time = time.time()

    audio = model.apply_tts(text=what + "..",
                            speaker=speaker,
                            sample_rate=sample_rate,
                            put_accent=put_accent,
                            put_yo=put_yo)
    
    end_speak_time = time.time()
    sd.play(audio, sample_rate * 1.05)
    time.sleep((len(audio) / sample_rate) + 0.5)
    sd.stop()
    
    print_yellow(f"Время на генерацию аудио: {end_speak_time - start_speak_time:.2f} секунд")
    

    sd.play(audio, sample_rate)

    time.sleep(len(audio) / sample_rate)

    sd.stop()

    как мне получать байты с аудио

  6. Assistant

    Чтобы получать аудиоданные в виде байтов вместо их воспроизведения непосредственно в функции va_speak, вы можете изменить структуру вашей функции так, чтобы она возвращала аудио сигнал в форме массива numpy или байтов, которые затем могут быть переданы по сети или сохранены в файл.

    Вот как вы можете это сделать:

    1. Измените функцию va_speak, чтобы она возвращала аудио данные в виде байтов.
    2. Непосредственно передайте эти байты клиенту Android через сокет.

    Изменение функции va_speak

    Обновите va_speak, чтобы она возвращала аудиоданные:

    import numpy as np
    
    def va_speak(what: str):
        start_speak_time = time.time()
    
        audio = model.apply_tts(text=what + "..",
                                 speaker=speaker,
                                 sample_rate=sample_rate,
                                 put_accent=put_accent,
                                 put_yo=put_yo)
    
        end_speak_time = time.time()
        
        # Вернем аудиоданные в виде массива numpy
        print_yellow(f"Время на генерацию аудио: {end_speak_time - start_speak_time:.2f} секунд")
        
        return audio  # Вернуть аудиоданные
    

    Изменение функции execute_command

    Теперь измените вашу функцию execute_command для отправки аудио:

    def execute_command(command: str) -> None:
        if command == 'enter_sleep_mode':
            audio_data = tts.va_speak(enter_sleep_mode())
        elif command == 'lamp_on':
            audio_data = tts.va_speak(turn_on())
        elif command == 'lamp_off':
            audio_data = tts.va_speak(turn_off())
    
        # Передача аудиоданных
        send_audio_to_android(audio_data)
    

    Функция отправки аудио

    Следующая функция отправит аудиоданные через сокет:

    def send_audio_to_android(audio_data: np.ndarray) -> None:
        try:
            android_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            android_socket.connect((ANDROID_ADDR, 51411))
            output = android_socket.makefile('wb')
    
            # Конвертируем массив numpy в байты
            audio_bytes = audio_data.astype(np.float32).tobytes()  # Конвертируем в байты
    
            output.write(audio_bytes)  # Отправка аудиоданных
            output.close()
            android_socket.close()
        except Exception as e:
            print(e)
    

    Обратите внимание

    1. Формат данных: Убедитесь, что формат аудиоданных, который вы отправляете, совместим с тем, что ожидает Android-приложение. Например, если вы используете PCM, убедитесь, что разрешение, частота дискретизации и количество каналов совпадают.

    2. Проблемы памяти: При отправке больших объемов данных по сети помните о возможных задержках и использовании оперативной памяти.

    3. кодек: Если ваши данные не в формате WAV, вам может потребоваться конвертировать их в подходящий формат перед отправкой.

    Воспроизведение на Android

    Предполагая, что вы уже написали метод startAudioPlayback для получения аудиоданных на Android, вам нужно будет протестировать это взаимодействие, чтобы убедиться, что аудио правильно воспроизводится.

    Также стоит проверить качество и задержку воспроизведения, чтобы убедиться, что пользовательский опыт соответствует вашим ожиданиям.

  7. User

    private fun onActivationReceivedTest() { recordButton.backgroundTintList = ColorStateList.valueOf(Color.parseColor("#FFCC0000")) }

    как сделать желтый цвет

  8. Assistant

    Чтобы изменить цвет UIButton на желтый в Android, вы можете использовать цветовой код для желтого цвета. HTML код для желтого цвета — это #FFFF00. Также можно использовать цветовые ресурсы для более удобного управления цветами в вашем приложении.

    Вот как вы можете сделать фон кнопки желтым:

    Пример кода для установки желтого цвета фона кнопки

    1. Используя цветовой код:
    private fun onActivationReceivedTest() {
        recordButton.backgroundTintList = ColorStateList.valueOf(Color.parseColor("#FFFF00")) // Устанавливаем желтый цвет
    }
    
    1. Используя ресурсы цвета:

    Если вы хотите использовать цветовые ресурсы, вам нужно сначала определить желтый цвет в вашем файле ресурсов colors.xml (обычно он находится в res/values/colors.xml):

    <resources>
        <color name="bright_yellow">#FFFF00</color>
    </resources>
    

    Затем в вашем коде вы можете установить цвет так:

    private fun onActivationReceivedTest() {
        recordButton.backgroundTintList = ColorStateList.valueOf(ContextCompat.getColor(this, R.color.bright_yellow)) // Устанавливаем желтый цвет из ресурсов
    }
    

    Важно:

    • Если вы хотите сделать кнопку более интерактивной, вы можете также настроить состояния (например, при нажатии или при наведении курсора) через XML-дизайнер в drawable директории.
    • Убедитесь, что для вашей кнопки установлена возможность изменения цвета (например, "backgroundTint" в XML разметке), чтобы изменения цвета работали корректно.

    Теперь цвет фона вашей кнопки будет желтым как при активации, так и в любом другом сценарии, где вы хотите применить этот цвет.

  9. User

    a bytes-like object is required, not 'Tensor'

  10. Assistant

    Ошибка "a bytes-like object is required, not 'Tensor'" возникает, потому что вы пытаетесь отправить объект PyTorch Tensor напрямую через сокет, а ожидается байтовый массив (или bytes). Чтобы исправить это, нужно преобразовать Tensor в формат, который может быть отправлен.

    Вот как вы можете это сделать:

    1. Преобразуйте Tensor в numpy массив.
    2. Преобразуйте numpy массив в байтовый формат.

    Шаги для исправления:

    1. Измените код в va_speak, чтобы возвращать Tensor:
      • функцию apply_tts возвращает Tensor, и вы хотите преобразовать его в формат, совместимый с передачей по сокету.
    import numpy as np
    
    def va_speak(what: str):
        start_speak_time = time.time()
    
        audio = model.apply_tts(text=what + "..",
                                 speaker=speaker,
                                 sample_rate=sample_rate,
                                 put_accent=put_accent,
                                 put_yo=put_yo)
    
        end_speak_time = time.time()
        
        # Преобразуйте Tensor в numpy массив и верните его
        audio_np = audio.cpu().numpy()  # Перемещение на CPU (если на GPU) и преобразование в numpy array
        print_yellow(f"Время на генерацию аудио: {end_speak_time - start_speak_time:.2f} секунд")
        
        return audio_np  # Вернуть аудиоданные в формате numpy
    
    1. Измените функцию передачи аудио, чтобы отправить данные как байты:

    Теперь, когда у вас есть numpy массив, вы можете преобразовать его в байты и отправить:

    def send_audio_to_android(audio_data: np.ndarray) -> None:
        try:
            android_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            android_socket.connect((ANDROID_ADDR, 51411))
            output = android_socket.makefile('wb')
    
            # Преобразуйте массив numpy в байты
            audio_bytes = (audio_data * 32767).astype(np.int16).tobytes()  # Преобразование в int16 и затем в байты
            
            output.write(audio_bytes)  # Отправка аудиоданных
            output.close()
            android_socket.close()
        except Exception as e:
            print(e)
    

    Заметки:

    • Расчет амплитуды: Если ваши аудиоданные находятся в диапазоне от -1.0 до 1.0 (обычно для float32), то умножение на 32767 преобразует их в int16, что является стандартным форматом для PCM аудио.
    • Формат данных: Убедитесь, что формат, который вы отправляете, соответствует тому, что ожидается на стороне Android.

    Воспроизведение на Android

    На стороне Android убедитесь, что вы правильно обрабатываете входящие байты и reproduktiruete их используя AudioTrack, как было написано в предыдущем ответе.

    С этими изменениями вы должны перестать получать ошибку о том, что требуется объект, похожий на байты, а не Tensor.

  11. User

    unsupported operand type(s) for *: 'NoneType' and 'int'

  12. Assistant

    Ошибка "unsupported operand type(s) for *: 'NoneType' and 'int'" указывает на то, что вы пытаетесь выполнить арифметическую операцию между NoneType и целым числом. Это обычно происходит, если функция, возвращающая значение, фактически возвращает None, и затем вы пытаетесь умножить это значение на число.

    В вашем случае это может происходить из-за того, что метод apply_tts не возвращает ожидаемый массив аудиоданных, а вместо этого возвращает None. Давайте рассмотрим, как это можно исправить.

    Шаги для исправления

    1. Проверьте, что apply_tts возвращает действительные данные: убедитесь в правильности работы модели TTS и в том, что в процессе получения аудиоданных ничего не идет не так. Например, вам необходимо убедиться, что текст, передаваемый в метод, не пустой.

    2. Добавьте проверку результата: перед тем, как умножать на 32767, проверьте, не является ли результат None. Если результат равен None, можно обрабатывать это условие соответствующим образом (например, использовать логирование или возвращать пустой массив).

    Пример исправленного кода:

    def va_speak(what: str):
        start_speak_time = time.time()
    
        audio = model.apply_tts(text=what + "..",
                                 speaker=speaker,
                                 sample_rate=sample_rate,
                                 put_accent=put_accent,
                                 put_yo=put_yo)
        
        # Проверяем, является ли результат None
        if audio is None:
            print("Error: Received None from TTS model.")
            return np.array([])  # Возвращаем пустой массив или обрабатываем по-другому
    
        end_speak_time = time.time()
        
        # Преобразуйте Tensor в numpy массив
        audio_np = audio.cpu().numpy()  # Перемещение на CPU и преобразование в numpy array
        print_yellow(f"Время на генерацию аудио: {end_speak_time - start_speak_time:.2f} секунд")
        
        return audio_np  # Вернуть аудиоданные в формате numpy
    

    Что делать дальше

    1. Логирование: добавьте логирование или печать ошибок, чтобы понять, почему TTS возвращает None.

    2. Проверка данных: убедитесь, что ваши входные данные для TTS корректны. Например, проверьте, нет ли пустых строк.

    3. Отладка: возможно, модель TTS была неправильно загружена или неправильно настроена.

    После внесения изменений проверьте код еще раз, чтобы убедиться, что проблема решена. Если ошибка продолжает появляться, проверьте все пути (входные и исходные данные) и убедитесь, что все верные типы данных используются в распределении по вашему коду.