fdf

.cursor/rules/principal.mdc

@@ -0,0 +1,51 @@
+---
+description: 
+globs: 
+alwaysApply: false
+---
+. envia o mínimo possível de arquivos, na verdade tem que baixar mais os arquivos durante a inicialização 
+
+# Resumo do Projeto LLaMA-Omni2 para Hugging Face Spaces
+
+Estou configurando uma aplicação de demonstração do LLaMA-Omni2, um assistente de linguagem e fala, para ser facilmente implantada no Hugging Face Spaces. Aqui está um resumo do que foi implementado:
+
+## Objetivo do Projeto
+Criar uma interface web interativa que demonstre as capacidades do LLaMA-Omni2, permitindo aos usuários interagir com o modelo através de texto e fala, recebendo respostas também nos dois formatos.
+
+## Componentes Principais
+
+1. **Interface Gradio**: Uma interface web amigável com duas abas:
+   - **Entrada de Áudio**: Permite aos usuários falar ou fazer upload de arquivos de áudio
+   - **Entrada de Texto**: Permite interações baseadas em texto
+
+2. **Pipeline de Reconhecimento de Fala**:
+   - Usa o modelo Whisper (tiny) para transcrever áudio para texto
+   - Configurado para carregar diretamente do Hugging Face
+
+3. **Geração de Texto e Fala**:
+   - Usa o modelo LLaMA-Omni2-0.5B para gerar respostas
+   - Suporta dois métodos de geração de fala: `generate_with_speech` e `generate_speech`
+   - Gerencia a conversão de respostas de texto para áudio
+
+4. **Otimizações para Hugging Face Spaces**:
+   - Carregamento dinâmico de modelos (não incluídos no repositório)
+   - Configuração para utilizar GPU quando disponível
+   - Sistema de logging abrangente para depuração
+
+5. **Gestão de Repositório**:
+   - Arquivo `.gitignore` configurado para excluir modelos grandes e artefatos desnecessários
+   - Remoção de arquivos grandes do histórico do git
+   - Estrutura de projeto limpa e organizada
+
+## Arquivos Principais
+- `app.py`: Contém a lógica principal da aplicação e a interface Gradio
+- `requirements.txt`: Lista todas as dependências necessárias
+- `.huggingface-space`: Configuração para o ambiente Hugging Face Spaces
+- `.gitignore`: Exclui arquivos grandes e temporários do controle de versão
+
+## Tecnologias Utilizadas
+- **Frameworks**: PyTorch, Transformers, Gradio
+- **Modelos**: LLaMA-Omni2-0.5B (para texto/fala), Whisper-tiny (para reconhecimento de fala)
+- **Infraestrutura**: Hugging Face Spaces para hospedagem
+
+O projeto está configurado para baixar os modelos dinamicamente quando implantado, em vez de incluí-los no repositório, resultando em um código limpo e eficiente que pode ser facilmente compartilhado e implantado.

.gitignore

@@ -37,6 +37,21 @@ models/
 .cache/
 */.cache/
 *incomplete
+whisper-large-v3/
+cosy2_decoder/
+speech_encoder/
+# Excluir todos os arquivos grandes de modelos de forma explícita
+flow.decoder.estimator.fp32.onnx
+flow.decoder.estimator.fp16.A10.plan
+flow.encoder.fp32.zip
+flow.decoder.estimator.fp16.Volta.plan
+hift.pt
+campplus.onnx
+vocab.json
+tokenizer_config.json
+tokenizer.json
+pytorch_model.bin.index.fp32.json
+model.safetensors.index.fp32.json
 
 # IDEs
 .vscode/

LLaMA-Omni2

@@ -1 +0,0 @@
-Subproject commit feb85982d9effc4ecbc090a71ba6516ef4adaaf0

README.md

@@ -12,72 +12,151 @@ pinned: false
 # Ex: hardware: nvidia-t4
 ---
 
-# LLaMA-Omni2 + Whisper Demo
+# LLaMA-Omni2 Interface
 
-Uma aplicação de demonstração que combina o reconhecimento de fala do Whisper com a geração de texto e fala do LLaMA-Omni2 0.5B. 
+Interface para o modelo LLaMA-Omni2, que permite entrada e saída de áudio com processamento de linguagem natural.
 
-## Sobre o Projeto
+## Características
 
-Esta aplicação demonstra a capacidade do modelo LLaMA-Omni2 0.5B para processar instruções de fala e gerar respostas tanto em texto quanto em fala, tudo com baixa latência. A arquitetura modular é baseada na pesquisa do Institute of Computing Technology da Chinese Academy of Sciences.
+- Transcrição de áudio usando Whisper
+- Processamento de texto com LLaMA-Omni2
+- Síntese de fala usando CosyVoice 2
+- Geração de texto e fala em tempo real
+- Download automático de modelos durante a inicialização
 
-## Principais Recursos
-
-- 🎤 **Reconhecimento de Fala**: Usando o OpenAI Whisper-tiny para transcrição de áudio
-- 💬 **Geração de Texto**: Usando o modelo LLaMA-Omni2 para geração de respostas de texto
-- 🔊 **Síntese de Fala**: Geração de fala a partir das respostas de texto (quando disponível)
-- 🔄 **Pipeline Completo**: Fluxo integrado de áudio → texto → resposta → fala
-
-## Como Usar
+## Requisitos
 
-A interface Gradio oferece três modos de interação:
+- Python 3.8+
+- PyTorch 2.0+
+- Transformers 4.36+
+- Gradio 3.50+
+- CUDA (opcional, mas recomendado para melhor desempenho)
 
-1. **Pipeline Completo**: Envie um arquivo de áudio, ele será transcrito e usado para gerar uma resposta de texto/fala
-2. **Reconhecimento de Fala**: Teste apenas a capacidade de transcrição do Whisper
-3. **Geração de Texto/Fala**: Forneça seu próprio texto para geração de resposta
+## Configuração de Modelos
 
-## Arquitetura LLaMA-Omni2
+Este projeto utiliza um sistema de download automático de modelos durante a inicialização, evitando a necessidade de armazenar arquivos grandes no repositório Git.
 
-O LLaMA-Omni2 é um modelo de linguagem e fala que consiste em 4 componentes principais:
+Os modelos serão baixados automaticamente na primeira execução:
 
-1. **Codificador de Fala**: Baseado no Whisper-large-v3, converte entrada de fala em representações acústicas
-2. **Adaptador de Fala**: Ponte entre os espaços acústico e textual
-3. **Núcleo LLM**: O "motor de raciocínio" baseado em Qwen2.5-Instruct
-4. **Decodificador TTS Streaming**: Converte tokens de texto em fala de forma contínua
+- **Whisper Large V3** - Modelo de reconhecimento de fala
+- **CosyVoice 2** - Vocoder para síntese de fala
+- **LLaMA-Omni2** - Modelo de linguagem multimodal
 
-## Configuração para Uso Local
+Todos os modelos são armazenados na pasta `models/`, que está no `.gitignore` para evitar o commit de arquivos grandes.
 
-Se você deseja executar esta aplicação localmente:
+## Configuração
 
+1. Clone o repositório:
 ```bash
-# Clone o repositório
-git clone https://github.com/seu-usuario/llama-omni-demo
-cd llama-omni-demo
+git clone https://github.com/seu-usuario/llama-omni2.git
+cd llama-omni2
+```
 
-# Instale as dependências
+2. Instale as dependências:
+```bash
 pip install -r requirements.txt
+```
 
-# Execute a aplicação
+3. Execute o aplicativo:
+```bash
 python app.py
 ```
 
-## Requisitos
+Na primeira execução, os modelos serão baixados automaticamente. Isso pode levar algum tempo, dependendo da sua conexão com a internet.
+
+## Uso
+
+Após iniciar o aplicativo, acesse a interface web em http://localhost:7860 para interagir com o modelo.
+
+- **Entrada de Áudio**: Grave ou faça upload de um arquivo de áudio
+- **Saída de Texto**: Veja a transcrição e a resposta do modelo
+- **Saída de Áudio**: Ouça a resposta sintetizada
+
+## Usando o launcher
+
+Você também pode usar o launcher para iniciar a aplicação completa:
+
+```bash
+python launch_llama_omni2.py
+```
+
+Opções do launcher:
+- `--skip-download`: Pula o download das dependências
+- `--extraction-dir`: Define o diretório de extração (padrão: extraction_dir)
+- `--models-dir`: Define o diretório de modelos (padrão: models)
+- `--controller-only`: Inicia apenas o controlador
+- `--worker-only`: Inicia apenas o worker do modelo
+- `--gradio-only`: Inicia apenas a interface Gradio
+
+## Estrutura do Projeto
+
+- `app.py` - Aplicativo Gradio principal
+- `audio_interface.py` - Interface de áudio para LLaMA-Omni2
+- `launch_llama_omni2.py` - Script para lançar todos os componentes
+- `model_downloader.py` - Sistema de download automático de modelos
+- `models/` - Diretório para armazenar os modelos baixados
+- `requirements.txt` - Dependências do projeto
+
+## Funcionamento do Download Automático
+
+O sistema de download automático funciona da seguinte forma:
+
+1. Na inicialização, o script verifica se os modelos necessários existem localmente
+2. Se um modelo não for encontrado, ele é baixado automaticamente do Hugging Face Hub
+3. Após o download, o modelo é carregado normalmente pelo aplicativo
+
+Isso permite:
+- Manter o repositório Git leve, sem arquivos grandes
+- Facilitar a implantação em diferentes ambientes
+- Garantir que os usuários sempre tenham os modelos corretos
+
+## Modo Sem Download
+
+Este projeto suporta um modo "sem download" que permite usar os modelos diretamente do Hugging Face Hub, sem baixá-los localmente. Isso é útil para:
+
+- Desenvolvimento e testes onde não é necessário baixar os modelos completos
+- Ambientes com espaço em disco limitado
+- Integração contínua e cenários de implantação onde os modelos são acessados remotamente
+
+Para ativar o modo sem download, você pode:
+
+1. **Usar o script Python no_download.py (recomendado)**:
+   ```bash
+   # Executar app.py sem download
+   python no_download.py app.py
+   
+   # Executar outro script sem download
+   python no_download.py audio_interface.py
+   ```
+
+2. **Usar o script auxiliar**:
+   ```bash
+   ./run_without_downloads.sh
+   ```
+
+3. **Definir a variável de ambiente**:
+   ```bash
+   export NO_DOWNLOAD=1
+   python app.py
+   ```
 
-- Python 3.10+
-- CUDA compatível (para GPU) ou CPU com pelo menos 8GB de RAM
-- Dependências listadas em requirements.txt
+4. **Usar a opção de linha de comando no launcher**:
+   ```bash
+   python launch_llama_omni2.py --no-model-download
+   ```
 
-## Limitações Atuais
+No modo sem download, o aplicativo usará os modelos diretamente do Hugging Face Hub, sem baixar arquivos localmente. Isso pode ser mais lento para uso contínuo, mas é mais rápido para inicializar e não ocupa espaço em disco.
 
-- O LLaMA-Omni2 é um modelo experimental e pode gerar respostas incorretas ou imprecisas
-- A geração de fala pode não estar disponível se o modelo não tiver sido carregado corretamente
-- Requer recursos computacionais significativos para execução ideal
+## Contribuição
 
-## Referências
+Contribuições são bem-vindas! Por favor, siga estas diretrizes:
 
-- [Repositório LLaMA-Omni2](https://github.com/ictnlp/LLaMA-Omni2)
-- [Whisper OpenAI](https://github.com/openai/whisper)
-- [Artigo LLaMA-Omni2](https://arxiv.org/abs/2505.02625)
+1. Faça um fork do repositório
+2. Crie um branch para sua feature (`git checkout -b feature/nova-feature`)
+3. Faça commit das suas mudanças (`git commit -am 'Adiciona nova feature'`)
+4. Faça push para o branch (`git push origin feature/nova-feature`)
+5. Crie um novo Pull Request
 
 ## Licença
 
-Este projeto é licenciado sob a Licença Apache 2.0. 
+Este projeto está licenciado sob os termos da licença MIT. 

app.py

@@ -17,6 +17,25 @@ from huggingface_hub import snapshot_download
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# Verificar modo sem download (primeiro, antes de importar model_downloader)
+NO_DOWNLOAD = os.environ.get("NO_DOWNLOAD", "0").lower() in ("1", "true", "yes")
+logger.info(f"Inicializando app.py com NO_DOWNLOAD={NO_DOWNLOAD} (valor da env: {os.environ.get('NO_DOWNLOAD', 'não definido')})")
+
+# Import do novo model_downloader
+try:
+    from model_downloader import download_model_if_needed, download_all_models, get_model_repo_id, NO_DOWNLOAD as DOWNLOADER_NO_DOWNLOAD
+    # Verificar se os valores são consistentes
+    if NO_DOWNLOAD != DOWNLOADER_NO_DOWNLOAD:
+        logger.warning(f"Inconsistência detectada: NO_DOWNLOAD no app.py={NO_DOWNLOAD}, mas NO_DOWNLOAD no model_downloader.py={DOWNLOADER_NO_DOWNLOAD}")
+        # Atualizar para o valor no model_downloader.py
+        NO_DOWNLOAD = DOWNLOADER_NO_DOWNLOAD
+except ImportError:
+    logger.warning("model_downloader não pôde ser importado, trabalhando sem ele")
+    # Definir funções vazias para manter compatibilidade
+    def download_model_if_needed(model_key): return False
+    def download_all_models(): pass
+    def get_model_repo_id(model_key): return None
+
 # Configuração do caminho para os modelos
 MODELS_DIR = os.environ.get("MODELS_DIR", "models")
 os.makedirs(MODELS_DIR, exist_ok=True)
@@ -39,53 +58,59 @@ else:
 logger.info(f"Using device: {torch_device} for model loading.")
 logger.info(f"Pipelines will use device_id: {device_for_pipelines} and dtype: {dtype_for_pipelines}")
 
+# --- Check Download Mode ---
+if NO_DOWNLOAD:
+    logger.warning("Modo NO_DOWNLOAD ativado. Os modelos não serão baixados, usando diretamente do Hugging Face Hub.")
+    # Usar IDs dos modelos diretamente do Hugging Face
+    whisper_repo_id = get_model_repo_id("speech_encoder") or "openai/whisper-large-v3"
+    llama_omni_repo_id = get_model_repo_id("llama_omni2") or llama_omni_model_id
+    
+    # Definir caminhos para modelo
+    whisper_path_to_use = whisper_repo_id
+    model_path_to_use = llama_omni_repo_id
+    
+    logger.info(f"Usando modelo whisper direto do HF: {whisper_path_to_use}")
+    logger.info(f"Usando modelo LLaMA-Omni2 direto do HF: {model_path_to_use}")
+else:
+    # --- Download Models if Needed ---
+    logger.info("Verificando se os modelos estão disponíveis localmente...")
+
+    # Download do modelo de speech recognition (Whisper)
+    download_model_if_needed("speech_encoder")
+        
+    # Download do modelo de síntese de voz
+    download_model_if_needed("cosy2_decoder")
+
+    # Download do modelo LLaMA-Omni2
+    download_model_if_needed("llama_omni2")
+    
+    # Configurar caminhos para modelos locais
+    whisper_local_path = os.path.join(MODELS_DIR, "speech_encoder", "whisper-large-v3")
+    whisper_path_to_use = whisper_local_path if os.path.exists(whisper_local_path) else whisper_model_id
+    
+    local_model_path = os.path.join(MODELS_DIR, "LLaMA-Omni2-0.5B")
+    model_path_to_use = local_model_path if os.path.exists(local_model_path) and os.path.isdir(local_model_path) else llama_omni_model_id
+
 # --- Load Speech-to-Text (ASR) Pipeline ---
 asr_pipeline_instance = None
 try:
-    logger.info(f"Loading ASR model: {whisper_model_id}...")
+    logger.info(f"Loading ASR model: {whisper_path_to_use}...")
+    
     asr_pipeline_instance = pipeline(
         "automatic-speech-recognition",
-        model=whisper_model_id,
+        model=whisper_path_to_use,
         torch_dtype=dtype_for_pipelines,
         device=device_for_pipelines
     )
-    logger.info(f"ASR model ({whisper_model_id}) loaded successfully.")
+    logger.info(f"ASR model loaded successfully.")
 except Exception as e:
-    logger.error(f"Error loading ASR model ({whisper_model_id}): {e}")
+    logger.error(f"Error loading ASR model: {e}")
     asr_pipeline_instance = None
 
 # --- Load Text Generation Model ---
 text_gen_pipeline_instance = None
 text_generation_model_id = None  # Will be set to the model that successfully loads
 
-# Verificar se o modelo já está baixado ou baixá-lo usando HF Hub
-try:
-    # Verificar se o modelo está na pasta local
-    local_model_path = os.path.join(MODELS_DIR, os.path.basename(llama_omni_model_id))
-    if os.path.exists(local_model_path) and os.path.isdir(local_model_path):
-        logger.info(f"Found local model at {local_model_path}")
-        model_path_to_use = local_model_path
-    else:
-        # Se não existir localmente, verificar se precisamos baixar
-        logger.info(f"Local model not found, checking if we need to predownload files for {llama_omni_model_id}")
-        # Verifica se estamos no ambiente Hugging Face
-        if os.environ.get("SPACE_ID") is not None:
-            logger.info("Running in Hugging Face Spaces environment")
-            # No Hugging Face Spaces, usamos o caminho direto para o modelo na nuvem
-            model_path_to_use = llama_omni_model_id
-        else:
-            # Em ambientes locais, podemos baixar explicitamente
-            logger.info(f"Downloading model {llama_omni_model_id} to {local_model_path}")
-            snapshot_download(
-                repo_id=llama_omni_model_id,
-                local_dir=local_model_path,
-                token=HF_TOKEN
-            )
-            model_path_to_use = local_model_path
-except Exception as download_error:
-    logger.error(f"Error preparing model path: {download_error}")
-    model_path_to_use = llama_omni_model_id  # Fallback to use the direct model ID
-
 try:
     logger.info(f"Attempting to load LLaMA-Omni2 model: {model_path_to_use}...")
     # LLaMA models often require specific loading configurations
@@ -116,7 +141,7 @@ try:
         device=device_for_pipelines if not torch.cuda.is_available() else None
     )
     text_generation_model_id = llama_omni_model_id
-    logger.info(f"LLaMA-Omni2 model ({llama_omni_model_id}) loaded successfully.")
+    logger.info(f"LLaMA-Omni2 model loaded successfully.")
     logger.info(f"Model has speech generation capabilities: {is_omni2_speech_model}")
     
 except Exception as e:

audio_interface.py

@@ -28,6 +28,14 @@ import whisper
 import aiohttp
 import numpy as np
 
+# Import model downloader
+try:
+    from model_downloader import download_model_if_needed, download_all_models, get_model_repo_id, NO_DOWNLOAD
+    has_model_downloader = True
+except ImportError:
+    has_model_downloader = False
+    NO_DOWNLOAD = False
+
 # Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -52,11 +60,19 @@ class AudioInterface:
         self.read_tokens = read_tokens  # Number of text tokens to read
         self.write_tokens = write_tokens  # Number of speech tokens to write
         
+        # Download required models if needed
+        self._ensure_models_available()
+        
         # Load Whisper model
         try:
+            # Se NO_DOWNLOAD estiver ativado, usar diretamente o modelo do Hugging Face
+            if has_model_downloader and NO_DOWNLOAD:
+                whisper_model_path = "openai/whisper-large-v3"
+                logger.info(f"Modo NO_DOWNLOAD: Carregando Whisper direto do Hugging Face: {whisper_model_path}")
+                
             logger.info(f"Loading Whisper model from {whisper_model_path}")
             self.whisper_model = whisper.load_model("large-v3", 
-                                                   download_root=whisper_model_path, 
+                                                   download_root=whisper_model_path if not NO_DOWNLOAD else None, 
                                                    device=self.device)
             logger.info("Whisper model loaded successfully")
         except Exception as e:
@@ -65,6 +81,10 @@ class AudioInterface:
         
         # Load CosyVoice vocoder
         try:
+            # Se NO_DOWNLOAD estiver ativado, usar diretamente o modelo do Hugging Face
+            if has_model_downloader and NO_DOWNLOAD:
+                logger.warning("Modo NO_DOWNLOAD ativado. O vocoder CosyVoice pode não funcionar corretamente sem os arquivos locais.")
+                
             sys.path.insert(0, vocoder_dir)
             from cosy_voice_2.inference import CosyVoice
             
@@ -79,6 +99,26 @@ class AudioInterface:
         
         logger.info(f"Using LLaMA-Omni2 model: {model_name}")
     
+    def _ensure_models_available(self):
+        """Garante que os modelos necessários estão disponíveis"""
+        # Verificar se temos o model_downloader disponível
+        if has_model_downloader:
+            if NO_DOWNLOAD:
+                logger.info("Modo NO_DOWNLOAD ativado. Pulando verificação de modelos locais.")
+                return
+                
+            logger.info("Verificando modelos necessários...")
+            
+            # Baixar modelo Whisper
+            download_model_if_needed("speech_encoder")
+            
+            # Baixar modelo CosyVoice
+            download_model_if_needed("cosy2_decoder")
+            
+            logger.info("Verificação de modelos concluída")
+        else:
+            logger.warning("model_downloader não está disponível. Assumindo que os modelos já estão disponíveis localmente.")
+    
     async def get_worker_address(self):
         """Get the address of the worker serving the model"""
         try:

launch_llama_omni2.py

@@ -14,6 +14,11 @@ import argparse
 import shutil
 import importlib.util
 import tempfile
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
 # Define paths
 EXTRACTION_DIR = "/home/user/app/llama_omni2_extracted"
@@ -22,6 +27,30 @@ LLAMA_OMNI2_MODEL_NAME = "LLaMA-Omni2-0.5B"
 LLAMA_OMNI2_MODEL_PATH = f"{MODELS_DIR}/{LLAMA_OMNI2_MODEL_NAME}"
 COSYVOICE_PATH = f"{MODELS_DIR}/cosy2_decoder"
 
+# Importe o model_downloader se disponível
+try:
+    from model_downloader import download_model_if_needed, download_all_models, get_model_repo_id, NO_DOWNLOAD
+    has_model_downloader = True
+except ImportError:
+    has_model_downloader = False
+    NO_DOWNLOAD = False
+
+# Garantir que os modelos estão disponíveis
+def ensure_models_available():
+    """Garante que os modelos necessários estão disponíveis"""
+    if has_model_downloader:
+        if NO_DOWNLOAD:
+            logger.info("Modo NO_DOWNLOAD ativado. Os modelos não serão baixados, usando diretamente do Hugging Face Hub.")
+            return
+            
+        logger.info("Verificando modelos necessários para o LLaMA-Omni2...")
+        download_model_if_needed("llama_omni2")
+        download_model_if_needed("cosy2_decoder")
+        download_model_if_needed("speech_encoder")
+        logger.info("Verificação de modelos concluída")
+    else:
+        logger.warning("model_downloader não está disponível. Os modelos devem estar disponíveis em: " + MODELS_DIR)
+
 # Additional imports
 def download_dependencies():
     """Download and install required Python packages for LLaMA-Omni2"""
@@ -32,7 +61,8 @@ def download_dependencies():
         "uvicorn",
         "pydantic",
         "transformers>=4.36.2",
-        "sentencepiece"
+        "sentencepiece",
+        "huggingface_hub"
     ]
     
     try:
@@ -376,94 +406,81 @@ except ImportError:
     return patched_files
 
 def main():
-    """Main function to extract and run LLaMA-Omni2 components"""
-    print("LLaMA-Omni2 Direct Launcher")
-    print("==========================")
-    
-    # Install dependencies first
-    print("Checking and installing dependencies...")
-    download_dependencies()
-    
-    # Create directories directly instead of using extraction script
-    print("Creating necessary directories...")
-    os.makedirs(EXTRACTION_DIR, exist_ok=True)
-    os.makedirs(os.path.join(EXTRACTION_DIR, "llama_omni2"), exist_ok=True)
-    os.makedirs(os.path.join(EXTRACTION_DIR, "llama_omni2", "serve"), exist_ok=True)
-    
-    # Ensure the module structure is complete
-    ensure_module_structure(EXTRACTION_DIR)
-    
-    # Skip patching files as we're not extracting anything
-    print("Skipping file patching as we're not running extraction")
-    
-    # Add the extraction dir to Python path
-    if EXTRACTION_DIR not in sys.path:
-        sys.path.insert(0, EXTRACTION_DIR)
-        print(f"Added {EXTRACTION_DIR} to sys.path")
-    
-    # Skip directly to model download and starting services
-    print("Proceeding directly to model download and starting services...")
-    
-    # Make directories for models
-    os.makedirs(MODELS_DIR, exist_ok=True)
-    os.makedirs(LLAMA_OMNI2_MODEL_PATH, exist_ok=True)
-    os.makedirs(COSYVOICE_PATH, exist_ok=True)
-    
-    # Start controller
-    controller_process = start_controller()
-    if not controller_process:
-        print("Failed to start controller. Exiting.")
-        return 1
-    
-    # Wait for controller to initialize
-    print("Waiting for controller to initialize...")
-    time.sleep(5)
-    
-    # Start model worker
-    model_worker_process = start_model_worker()
-    if not model_worker_process:
-        print("Failed to start model worker. Shutting down controller.")
-        controller_process.terminate()
-        return 1
-    
-    # Wait for model to load - reduced from 300 seconds to 30 seconds
-    print("Waiting for model worker to initialize...")
-    time.sleep(30)
-    
-    # Start Gradio server
-    gradio_process = start_gradio_server()
-    if not gradio_process:
-        print("Failed to start Gradio server. Shutting down other processes.")
-        model_worker_process.terminate()
-        controller_process.terminate()
-        return 1
-    
-    print("\nAll components started successfully!")
-    print(f"Gradio interface should be available at http://0.0.0.0:7860")
-    
+    """Main entry point for the launcher script"""
+    parser = argparse.ArgumentParser(description="LLaMA-Omni2 Direct Launcher")
+    parser.add_argument("--skip-download", action="store_true", help="Skip downloading dependencies")
+    parser.add_argument("--no-model-download", action="store_true", help="Don't download models, use them directly from HF Hub")
+    parser.add_argument("--extraction-dir", type=str, default=EXTRACTION_DIR, help="Directory to extract LLaMA-Omni2 to")
+    parser.add_argument("--models-dir", type=str, default=MODELS_DIR, help="Directory containing models")
+    parser.add_argument("--skip-modules", action="store_true", help="Skip module structure creation")
+    parser.add_argument("--controller-only", action="store_true", help="Start only the controller")
+    parser.add_argument("--worker-only", action="store_true", help="Start only the model worker")
+    parser.add_argument("--gradio-only", action="store_true", help="Start only the Gradio interface")
+    args = parser.parse_args()
+    
+    # Update paths based on arguments
+    global EXTRACTION_DIR, MODELS_DIR, LLAMA_OMNI2_MODEL_PATH, COSYVOICE_PATH
+    EXTRACTION_DIR = args.extraction_dir
+    MODELS_DIR = args.models_dir
+    LLAMA_OMNI2_MODEL_PATH = f"{MODELS_DIR}/{LLAMA_OMNI2_MODEL_NAME}"
+    COSYVOICE_PATH = f"{MODELS_DIR}/cosy2_decoder"
+    
+    # Set NO_DOWNLOAD environment variable if --no-model-download is specified
+    if args.no_model_download:
+        os.environ["NO_DOWNLOAD"] = "1"
+        global NO_DOWNLOAD
+        NO_DOWNLOAD = True
+        logger.info("Modo NO_DOWNLOAD ativado via linha de comando")
+    
+    print("=== LLaMA-Omni2 Direct Launcher ===")
+    print(f"Extraction directory: {EXTRACTION_DIR}")
+    print(f"Models directory: {MODELS_DIR}")
+    print(f"Downloading models: {'No' if NO_DOWNLOAD else 'Yes'}")
+
+    # Ensure models are available
+    ensure_models_available()
+    
+    # Download dependencies if needed
+    if not args.skip_download:
+        download_dependencies()
+    
+    # Create module structure if needed
+    if not args.skip_modules:
+        ensure_module_structure(EXTRACTION_DIR)
+    
+    # Start the controller if needed
+    controller_process = None
+    if not args.worker_only and not args.gradio_only:
+        controller_process = start_controller()
+        # Give the controller time to start up
+        time.sleep(5)
+    
+    # Start the model worker if needed
+    worker_process = None
+    if not args.controller_only and not args.gradio_only:
+        worker_process = start_model_worker()
+        # Give the worker time to start up
+        time.sleep(5)
+    
+    # Start the Gradio interface if needed
+    gradio_process = None
+    if not args.controller_only and not args.worker_only:
+        gradio_process = start_gradio_server()
+    
+    # Keep the main process running to maintain subprocesses
     try:
-        # Wait for Gradio process to finish
-        gradio_process.wait()
+        print("Press Ctrl+C to exit...")
+        while True:
+            time.sleep(1)
     except KeyboardInterrupt:
-        print("\nReceived keyboard interrupt. Shutting down...")
-    finally:
-        # Cleanup
-        for process, name in [
-            (gradio_process, "Gradio server"),
-            (model_worker_process, "Model worker"),
-            (controller_process, "Controller")
-        ]:
-            if process and process.poll() is None:
-                print(f"Shutting down {name}...")
-                process.terminate()
-                try:
-                    process.wait(timeout=30)
-                except subprocess.TimeoutExpired:
-                    print(f"{name} did not terminate gracefully. Killing...")
-                    process.kill()
-    
-    print("All processes have been shut down.")
-    return 0
+        print("Shutting down...")
+        if controller_process:
+            controller_process.terminate()
+        if worker_process:
+            worker_process.terminate()
+        if gradio_process:
+            gradio_process.terminate()
+        print("Shutdown complete")
 
 if __name__ == "__main__":
     sys.exit(main()) 

model_downloader.py

@@ -0,0 +1,219 @@
+#!/usr/bin/env python3
+"""
+Model Downloader para LLaMA-Omni2
+---------------------------------
+Este script gerencia o download automático dos modelos necessários para o LLaMA-Omni2.
+Os modelos serão baixados apenas quando necessário durante a inicialização.
+"""
+
+import os
+import sys
+import logging
+import huggingface_hub
+from huggingface_hub import snapshot_download, hf_hub_download
+from pathlib import Path
+import torch
+import shutil
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Configurações de modelos
+MODELS_DIR = os.environ.get("MODELS_DIR", "models")
+HF_TOKEN = os.environ.get("HF_TOKEN", None)
+
+# Modo sem download (NO_DOWNLOAD=1)
+NO_DOWNLOAD = os.environ.get("NO_DOWNLOAD", "0").lower() in ("1", "true", "yes")
+
+# Mensagem de debug para verificar o status da variável
+logger.info(f"Inicializando model_downloader.py com NO_DOWNLOAD={NO_DOWNLOAD} (valor da env: {os.environ.get('NO_DOWNLOAD', 'não definido')})")
+
+# Modelos necessários
+MODEL_CONFIGS = {
+    "speech_encoder": {
+        "repo_id": "openai/whisper-large-v3",
+        "local_dir": os.path.join(MODELS_DIR, "speech_encoder", "whisper-large-v3"),
+        "files": None,  # None significa baixar o modelo completo
+    },
+    "cosy2_decoder": {
+        "repo_id": "ICTNLP/cosy2_decoder",
+        "local_dir": os.path.join(MODELS_DIR, "cosy2_decoder"),
+        "files": [
+            "flow.decoder.estimator.fp32.onnx",
+            "flow.decoder.estimator.fp16.A10.plan",
+            "flow.encoder.fp32.zip",
+            "flow.decoder.estimator.fp16.Volta.plan",
+            "hift.pt",
+            "campplus.onnx",
+            "cosyvoice.yaml",
+        ],
+    },
+    "llama_omni2": {
+        "repo_id": "ICTNLP/LLaMA-Omni2-0.5B",
+        "local_dir": os.path.join(MODELS_DIR, "LLaMA-Omni2-0.5B"),
+        "files": None,  # None significa baixar o modelo completo
+    }
+}
+
+def ensure_model_dir():
+    """Garante que o diretório models existe"""
+    if NO_DOWNLOAD:
+        logger.info("Modo NO_DOWNLOAD ativado. Pulando criação de diretórios.")
+        return
+        
+    os.makedirs(MODELS_DIR, exist_ok=True)
+    for model_config in MODEL_CONFIGS.values():
+        os.makedirs(model_config["local_dir"], exist_ok=True)
+
+def is_model_downloaded(model_key):
+    """Verifica se um modelo já foi baixado"""
+    # No modo sem download, sempre retorna False para pular a verificação
+    if NO_DOWNLOAD:
+        logger.info(f"Modo NO_DOWNLOAD ativado. Pulando verificação para {model_key}.")
+        return False
+        
+    config = MODEL_CONFIGS[model_key]
+    local_dir = config["local_dir"]
+    
+    # Se não temos uma lista específica de arquivos, verificar apenas se o diretório existe
+    if config["files"] is None:
+        # Verificar se o diretório existe e tem arquivos
+        if os.path.exists(local_dir) and any(os.listdir(local_dir)):
+            logger.info(f"Modelo {model_key} já parece estar baixado em {local_dir}")
+            return True
+        return False
+    
+    # Verificar se todos os arquivos específicos existem
+    for file in config["files"]:
+        file_path = os.path.join(local_dir, file)
+        if not os.path.exists(file_path):
+            logger.info(f"Arquivo {file} não encontrado para o modelo {model_key}")
+            return False
+    
+    logger.info(f"Todos os arquivos para o modelo {model_key} já estão disponíveis em {local_dir}")
+    return True
+
+def download_model(model_key):
+    """Baixa um modelo específico do Hugging Face Hub"""
+    # Verificar o modo sem download
+    if NO_DOWNLOAD:
+        logger.warning(f"Modo NO_DOWNLOAD ativado. Pulando download de {model_key}")
+        return False
+        
+    config = MODEL_CONFIGS[model_key]
+    repo_id = config["repo_id"]
+    local_dir = config["local_dir"]
+    files = config["files"]
+    
+    try:
+        logger.info(f"Baixando modelo {model_key} do repo {repo_id}...")
+        
+        # Se temos uma lista específica de arquivos, baixar um por um
+        if files is not None:
+            for file in files:
+                file_path = os.path.join(local_dir, file)
+                
+                # Pular se o arquivo já existe
+                if os.path.exists(file_path):
+                    logger.info(f"Arquivo {file} já existe, pulando download")
+                    continue
+                
+                logger.info(f"Baixando arquivo {file} para {file_path}")
+                try:
+                    hf_hub_download(
+                        repo_id=repo_id,
+                        filename=file,
+                        local_dir=local_dir,
+                        local_dir_use_symlinks=False,
+                        token=HF_TOKEN
+                    )
+                except Exception as e:
+                    logger.warning(f"Erro ao baixar arquivo {file}: {e}. Tentando continuar.")
+        else:
+            # Baixar o modelo completo
+            snapshot_download(
+                repo_id=repo_id,
+                local_dir=local_dir,
+                local_dir_use_symlinks=False,
+                token=HF_TOKEN
+            )
+        
+        logger.info(f"Modelo {model_key} baixado com sucesso para {local_dir}")
+        return True
+    except Exception as e:
+        logger.error(f"Erro ao baixar modelo {model_key}: {e}")
+        return False
+
+def cleanup_model_dir(model_key):
+    """Remove arquivos incompletos ou corruptos de um diretório de modelo"""
+    # Verificar o modo sem download
+    if NO_DOWNLOAD:
+        logger.info(f"Modo NO_DOWNLOAD ativado. Pulando limpeza de diretório para {model_key}.")
+        return True
+        
+    config = MODEL_CONFIGS[model_key]
+    local_dir = config["local_dir"]
+    
+    try:
+        # Procurar por arquivos .incomplete e removê-los
+        for root, dirs, files in os.walk(local_dir):
+            for file in files:
+                if file.endswith(".incomplete"):
+                    file_path = os.path.join(root, file)
+                    logger.info(f"Removendo arquivo incompleto: {file_path}")
+                    os.remove(file_path)
+        
+        return True
+    except Exception as e:
+        logger.error(f"Erro ao limpar diretório do modelo {model_key}: {e}")
+        return False
+
+def download_all_models():
+    """Baixa todos os modelos configurados, se necessário"""
+    # Verificar o modo sem download
+    if NO_DOWNLOAD:
+        logger.warning("Modo NO_DOWNLOAD ativado. Nenhum modelo será baixado.")
+        return
+
+    ensure_model_dir()
+    
+    for model_key in MODEL_CONFIGS:
+        if not is_model_downloaded(model_key):
+            logger.info(f"Iniciando download do modelo {model_key}")
+            cleanup_model_dir(model_key)
+            download_model(model_key)
+        else:
+            logger.info(f"Modelo {model_key} já está disponível localmente")
+
+def download_model_if_needed(model_key):
+    """Baixa um modelo específico se ele não estiver disponível"""
+    # Verificar o modo sem download
+    if NO_DOWNLOAD:
+        logger.info(f"Modo NO_DOWNLOAD ativado. Usando repo_id diretamente para {model_key}")
+        return False
+    
+    ensure_model_dir()
+    
+    if model_key not in MODEL_CONFIGS:
+        logger.error(f"Modelo {model_key} não está configurado para download")
+        return False
+    
+    if not is_model_downloaded(model_key):
+        logger.info(f"Modelo {model_key} não encontrado localmente. Iniciando download...")
+        cleanup_model_dir(model_key)
+        return download_model(model_key)
+    else:
+        logger.info(f"Modelo {model_key} já está disponível localmente")
+        return True
+
+def get_model_repo_id(model_key):
+    """Retorna o repo_id do modelo para uso direto sem download"""
+    if model_key not in MODEL_CONFIGS:
+        logger.error(f"Modelo {model_key} não está configurado")
+        return None
+    return MODEL_CONFIGS[model_key]["repo_id"]
+
+if __name__ == "__main__":
+    # Se executado diretamente, baixar todos os modelos
+    download_all_models() 

no_download.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Script para iniciar aplicações no modo sem download.
+Este script define explicitamente a variável NO_DOWNLOAD=1 no ambiente Python,
+garantindo que nenhum modelo seja baixado.
+"""
+
+import os
+import sys
+import subprocess
+import logging
+
+# Configurar logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("no_download")
+
+# Definir a variável NO_DOWNLOAD no ambiente
+os.environ["NO_DOWNLOAD"] = "1"
+logger.info(f"Variável NO_DOWNLOAD definida como: {os.environ.get('NO_DOWNLOAD')}")
+
+# Verificar argumentos de linha de comando
+if len(sys.argv) < 2:
+    logger.info("Nenhum script especificado. Executando app.py por padrão.")
+    target_script = "app.py"
+else:
+    target_script = sys.argv[1]
+    logger.info(f"Executando script: {target_script}")
+
+# Lista de argumentos extras
+args = sys.argv[2:]
+
+# Exibir informações
+print("=" * 70)
+print(f"Executando {target_script} no modo SEM DOWNLOAD (NO_DOWNLOAD=1)")
+print("Os modelos serão usados diretamente do Hugging Face Hub, sem baixar localmente")
+print("=" * 70)
+
+# Executar o script alvo com os mesmos argumentos
+try:
+    # Criar um dicionário de ambiente com NO_DOWNLOAD definido
+    env = os.environ.copy()
+    env["NO_DOWNLOAD"] = "1"
+    
+    # Construir o comando
+    command = [sys.executable, target_script] + args
+    logger.info(f"Executando comando: {' '.join(command)}")
+    
+    # Execute o comando com o ambiente modificado
+    process = subprocess.Popen(command, env=env)
+    process.wait()
+    
+    sys.exit(process.returncode)
+except Exception as e:
+    logger.error(f"Erro ao executar {target_script}: {e}")
+    sys.exit(1) 

run_without_downloads.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+# Script para executar o LLaMA-Omni2 sem baixar modelos localmente
+
+# Definir a variável de ambiente NO_DOWNLOAD
+export NO_DOWNLOAD=1
+
+# Verificar se a variável foi definida
+echo "Verificando variável de ambiente NO_DOWNLOAD..."
+echo "NO_DOWNLOAD=$NO_DOWNLOAD"
+
+# Adicionar modo de depuração para verificar o funcionamento
+export PYTHONVERBOSE=1
+export PYTHONPATH=$(pwd):$PYTHONPATH
+
+# Criar arquivo temporário de verificação
+python -c "
+import os
+with open('env_check.txt', 'w') as f:
+    f.write(f'NO_DOWNLOAD={os.environ.get(\"NO_DOWNLOAD\", \"não definido\")}')
+"
+
+# Mostrar o conteúdo do arquivo de verificação
+echo "Conteúdo do arquivo de verificação:"
+cat env_check.txt
+
+# Executar a aplicação
+echo "Executando LLaMA-Omni2 no modo sem download (NO_DOWNLOAD=1)"
+echo "Os modelos serão usados diretamente do Hugging Face Hub, sem baixar localmente"
+echo "======================================================================"
+
+# Verificar qual aplicação iniciar
+if [ "$1" == "app" ] || [ "$1" == "" ]; then
+    echo "Iniciando app.py..."
+    # Verificar se a variável está disponível para o Python
+    python -c "import os; print('NO_DOWNLOAD environment variable:', os.environ.get('NO_DOWNLOAD', 'not set'))"
+    # Executar com a variável de ambiente explícita
+    NO_DOWNLOAD=1 python app.py
+elif [ "$1" == "launcher" ]; then
+    echo "Iniciando launcher..."
+    python -c "import os; print('NO_DOWNLOAD environment variable:', os.environ.get('NO_DOWNLOAD', 'not set'))"
+    # Usar a opção de linha de comando
+    NO_DOWNLOAD=1 python launch_llama_omni2.py --no-model-download
+elif [ "$1" == "audio" ]; then
+    echo "Iniciando interface de áudio..."
+    python -c "import os; print('NO_DOWNLOAD environment variable:', os.environ.get('NO_DOWNLOAD', 'not set'))"
+    NO_DOWNLOAD=1 python audio_interface.py
+else
+    echo "Uso: $0 [app|launcher|audio]"
+    echo "  app      - Inicia app.py (padrão)"
+    echo "  launcher - Inicia launch_llama_omni2.py"
+    echo "  audio    - Inicia audio_interface.py"
+fi
+
+# Limpar arquivo temporário
+rm -f env_check.txt