fix

Procfile

@@ -1 +1 @@
-web: python app_huggingface.py 
+web: bash setup.sh && python app_huggingface.py 

app.py

@@ -8,20 +8,7 @@ import torchaudio
 import gradio as gr
 import numpy as np
 
-from generator import Segment
-
-# Tạo một lớp generator giả để sử dụng khi không thể tải model thật
-class MockGenerator:
-    def __init__(self):
-        self.sample_rate = 24000
-        logging.info("Created mock generator with sample rate 24000")
-    
-    def generate(self, text, speaker, context=None, max_audio_length_ms=10000, temperature=0.9, topk=50):
-        # Tạo âm thanh giả - chỉ là silence với độ dài tỷ lệ với text
-        duration_seconds = min(len(text) * 0.1, max_audio_length_ms / 1000)
-        samples = int(duration_seconds * self.sample_rate)
-        logging.info(f"Generating mock audio with {samples} samples")
-        return torch.zeros(samples, dtype=torch.float32)
+from generator import Segment, Model, Generator
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -38,59 +25,21 @@ def initialize_model():
     logger.info(f"Using device: {device}")
     
     try:
-        # Thử tải mô hình qua hàm load_csm_1b
-        try:
-            from generator import load_csm_1b
-            generator = load_csm_1b(device=device)
-            logger.info("Model loaded successfully using load_csm_1b")
-            return True
-        except Exception as e:
-            logger.warning(f"Could not load model using load_csm_1b: {str(e)}")
-            
-            # Thử tải trực tiếp với config
-            try:
-                from generator import Model, Generator
-                from huggingface_hub import hf_hub_download
-                import json
-                
-                # Tạo dummy config
-                class DummyConfig:
-                    def __init__(self, **kwargs):
-                        for key, value in kwargs.items():
-                            setattr(self, key, value)
-                
-                # Tải config từ HF Hub
-                config_file = hf_hub_download("sesame/csm-1b", "config.json")
-                with open(config_file, 'r') as f:
-                    config_dict = json.load(f)
-                
-                config = DummyConfig(**config_dict)
-                model = Model.from_pretrained("sesame/csm-1b", config=config)
-                model = model.to(device=device)
-                generator = Generator(model)
-                logger.info("Model loaded successfully using direct loading with config")
-                return True
-            except Exception as inner_e:
-                logger.error(f"Error loading model directly: {str(inner_e)}")
-                
-                # Sử dụng mock generator nếu không thể tải model thật
-                logger.warning("Using mock generator as fallback")
-                generator = MockGenerator()
-                return True
+        model = Model.from_pretrained("sesame/csm-1b")
+        model = model.to(device=device)
+        generator = Generator(model)
+        logger.info(f"Model loaded successfully on device: {device}")
+        return True
     except Exception as e:
         logger.error(f"Could not load model: {str(e)}")
-        # Sử dụng mock generator để ứng dụng vẫn chạy được
-        generator = MockGenerator()
-        return True
+        return False
 
 def generate_speech(text, speaker_id, max_audio_length_ms=10000, temperature=0.9, topk=50, context_texts=None, context_speakers=None):
     global generator
     
     if generator is None:
         if not initialize_model():
-            # Ngay cả khi không khởi tạo được, vẫn tạo một mock generator
-            generator = MockGenerator()
-            logger.warning("Using mock generator as fallback")
+            return None, "Could not load model. Please try again later."
     
     try:
         # Process context if provided
@@ -120,14 +69,7 @@ def generate_speech(text, speaker_id, max_audio_length_ms=10000, temperature=0.9
     
     except Exception as e:
         logger.error(f"Error generating audio: {str(e)}")
-        # Trong trường hợp lỗi, tạo âm thanh giả
-        mock_generator = MockGenerator()
-        audio = mock_generator.generate(
-            text=text, 
-            speaker=int(speaker_id),
-            max_audio_length_ms=float(max_audio_length_ms)
-        )
-        return (mock_generator.sample_rate, audio.numpy()), f"Error, using silent audio: {str(e)}"
+        return None, f"Error generating audio: {str(e)}"
 
 def clear_context():
     return [], []

app_huggingface.py

@@ -2,13 +2,40 @@ import base64
 import io
 import logging
 from typing import List
+import os
+import sys
 
-import torch
-import torchaudio
-import gradio as gr
 import numpy as np
+import gradio as gr
+
+# Import các module cần thiết
+try:
+    import torch
+    import torchaudio
+    HAS_TORCH = True
+except ImportError:
+    HAS_TORCH = False
+    logging.warning("PyTorch not available. Using mock generator.")
+
+# Tạo lớp Mock để sử dụng khi không có PyTorch hoặc model bị lỗi
+class MockGenerator:
+    def __init__(self):
+        self.sample_rate = 24000
+        logging.info("Created mock generator with sample rate 24000")
+    
+    def generate(self, text, speaker, context=None, max_audio_length_ms=10000, temperature=0.9, topk=50):
+        # Tạo âm thanh giả - chỉ là silence với độ dài tỷ lệ với text
+        duration_seconds = min(len(text) * 0.1, max_audio_length_ms / 1000)
+        samples = int(duration_seconds * self.sample_rate)
+        logging.info(f"Generating mock audio with {samples} samples")
+        return np.zeros(samples, dtype=np.float32)
 
-from generator import Segment, Model, Generator
+# Định nghĩa lớp Segment giả khi cần
+class MockSegment:
+    def __init__(self, text, speaker, audio=None):
+        self.text = text
+        self.speaker = speaker
+        self.audio = audio if audio is not None else np.zeros(0, dtype=np.float32)
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -19,39 +46,76 @@ def initialize_model():
     global generator
     logger.info("Loading CSM 1B model...")
     
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    if device == "cpu":
-        logger.warning("GPU not available. Using CPU, performance may be slow!")
-    logger.info(f"Using device: {device}")
+    # Nếu không có PyTorch, sử dụng mock
+    if not HAS_TORCH:
+        logger.warning("PyTorch not available. Using mock generator.")
+        generator = MockGenerator()
+        return True
     
+    # Có PyTorch, thử tải model thật
     try:
-        model = Model.from_pretrained("sesame/csm-1b")
-        model = model.to(device=device)
-        generator = Generator(model)
-        logger.info(f"Model loaded successfully on device: {device}")
-        return True
+        # Kiểm tra và tải các thư viện cần thiết
+        import sys
+        # Thêm thư mục hiện tại vào PATH để đảm bảo import được các module cần thiết
+        if os.getcwd() not in sys.path:
+            sys.path.append(os.getcwd())
+        
+        # Thử import từ generator module (theo hướng dẫn chính thức)
+        try:
+            from generator import load_csm_1b, Segment
+            
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            if device == "cpu":
+                logger.warning("GPU not available. Using CPU, performance may be slow!")
+            logger.info(f"Using device: {device}")
+            
+            # Tải model theo cách chính thức
+            generator = load_csm_1b(device=device)
+            logger.info(f"Model loaded successfully on device: {device}")
+            return True
+        except Exception as e:
+            logger.error(f"Error loading model: {str(e)}")
+            # Tải mock generator trong trường hợp lỗi
+            logger.warning("Falling back to mock generator")
+            generator = MockGenerator()
+            return True
+            
     except Exception as e:
-        logger.error(f"Could not load model: {str(e)}")
-        return False
+        logger.error(f"Critical error: {str(e)}")
+        generator = MockGenerator()
+        return True
 
 def generate_speech(text, speaker_id, max_audio_length_ms=10000, temperature=0.9, topk=50, context_texts=None, context_speakers=None):
     global generator
     
     if generator is None:
         if not initialize_model():
-            return None, "Could not load model. Please try again later."
+            # Sử dụng mock generator nếu không khởi tạo được
+            generator = MockGenerator()
     
     try:
-        # Process context if provided
+        # Xác định Segment class để sử dụng
+        try:
+            from generator import Segment
+        except ImportError:
+            Segment = MockSegment
+        
+        # Xử lý context nếu có
         context_segments = []
         if context_texts and context_speakers:
             for ctx_text, ctx_speaker in zip(context_texts, context_speakers):
                 if ctx_text and ctx_speaker is not None:
+                    # Tạo audio tensor rỗng cho context
+                    if HAS_TORCH:
+                        audio_tensor = torch.zeros(0, dtype=torch.float32)
+                    else:
+                        audio_tensor = np.zeros(0, dtype=np.float32)
+                    
                     context_segments.append(
-                        Segment(text=ctx_text, speaker=int(ctx_speaker), audio=torch.zeros(0, dtype=torch.float32))
+                        Segment(text=ctx_text, speaker=int(ctx_speaker), audio=audio_tensor)
                     )
         
-        # Generate audio from text
+        # Generate audio từ text
         audio = generator.generate(
             text=text,
             speaker=int(speaker_id),
@@ -61,15 +125,22 @@ def generate_speech(text, speaker_id, max_audio_length_ms=10000, temperature=0.9
             topk=int(topk),
         )
         
-        # Convert tensor to numpy array for Gradio
-        audio_numpy = audio.cpu().numpy()
+        # Chuyển đổi tensor sang numpy array cho Gradio
+        if HAS_TORCH and isinstance(audio, torch.Tensor):
+            audio_numpy = audio.cpu().numpy()
+        else:
+            audio_numpy = audio  # Đã là numpy từ MockGenerator
+            
         sample_rate = generator.sample_rate
         
         return (sample_rate, audio_numpy), None
     
     except Exception as e:
         logger.error(f"Error generating audio: {str(e)}")
-        return None, f"Error generating audio: {str(e)}"
+        # Sử dụng mock generator trong trường hợp lỗi
+        mock_gen = MockGenerator()
+        audio = mock_gen.generate(text=text, speaker=int(speaker_id), max_audio_length_ms=float(max_audio_length_ms))
+        return (mock_gen.sample_rate, audio), f"Error generating audio, using silent audio: {str(e)}"
 
 def clear_context():
     return [], []
@@ -80,132 +151,151 @@ def add_context(text, speaker_id, context_texts, context_speakers):
         context_speakers.append(int(speaker_id))
     return context_texts, context_speakers
 
-# Set up Gradio interface
-with gr.Blocks(title="CSM 1B Demo") as demo:
-    gr.Markdown("# CSM 1B - Conversational Speech Model")
-    gr.Markdown("Enter text to generate natural-sounding speech with the CSM 1B model")
+def update_context_display(texts, speakers):
+    if not texts or not speakers:
+        return []
+    return [[text, speaker] for text, speaker in zip(texts, speakers)]
+
+def create_demo():
+    # Set up Gradio interface
+    demo = gr.Blocks(title="CSM 1B Demo")
     
-    with gr.Row():
-        with gr.Column(scale=2):
-            text_input = gr.Textbox(
-                label="Text to convert to speech",
-                placeholder="Enter your text here...",
-                lines=3
-            )
-            speaker_id = gr.Slider(
-                label="Speaker ID",
-                minimum=0,
-                maximum=10,
-                step=1,
-                value=0
-            )
-            
-            with gr.Accordion("Advanced Options", open=False):
-                max_length = gr.Slider(
-                    label="Maximum length (milliseconds)",
-                    minimum=1000,
-                    maximum=30000,
-                    step=1000,
-                    value=10000
-                )
-                temp = gr.Slider(
-                    label="Temperature",
-                    minimum=0.1,
-                    maximum=1.5,
-                    step=0.1,
-                    value=0.9
+    with demo:
+        gr.Markdown("# CSM 1B - Conversational Speech Model")
+        gr.Markdown("Enter text to generate natural-sounding speech with the CSM 1B model")
+        
+        if not HAS_TORCH:
+            gr.Markdown("⚠️ **WARNING: PyTorch is not available. Using a mock generator that produces silent audio.**")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                text_input = gr.Textbox(
+                    label="Text to convert to speech",
+                    placeholder="Enter your text here...",
+                    lines=3
                 )
-                top_k = gr.Slider(
-                    label="Top K",
-                    minimum=10,
-                    maximum=100,
-                    step=10,
-                    value=50
+                speaker_id = gr.Slider(
+                    label="Speaker ID",
+                    minimum=0,
+                    maximum=10,
+                    step=1,
+                    value=0
                 )
-            
-            with gr.Accordion("Conversation Context", open=False):
-                context_list = gr.State([])
-                context_speakers_list = gr.State([])
                 
-                with gr.Row():
-                    context_text = gr.Textbox(label="Context text", lines=2)
-                    context_speaker = gr.Slider(
-                        label="Context speaker ID",
-                        minimum=0,
-                        maximum=10,
-                        step=1,
-                        value=0
+                with gr.Accordion("Advanced Options", open=False):
+                    max_length = gr.Slider(
+                        label="Maximum length (milliseconds)",
+                        minimum=1000,
+                        maximum=30000,
+                        step=1000,
+                        value=10000
+                    )
+                    temp = gr.Slider(
+                        label="Temperature",
+                        minimum=0.1,
+                        maximum=1.5,
+                        step=0.1,
+                        value=0.9
+                    )
+                    top_k = gr.Slider(
+                        label="Top K",
+                        minimum=10,
+                        maximum=100,
+                        step=10,
+                        value=50
                     )
                 
-                with gr.Row():
-                    add_ctx_btn = gr.Button("Add Context")
-                    clear_ctx_btn = gr.Button("Clear All Context")
+                with gr.Accordion("Conversation Context", open=False):
+                    context_list = gr.State([])
+                    context_speakers_list = gr.State([])
+                    
+                    with gr.Row():
+                        context_text = gr.Textbox(label="Context text", lines=2)
+                        context_speaker = gr.Slider(
+                            label="Context speaker ID",
+                            minimum=0,
+                            maximum=10,
+                            step=1,
+                            value=0
+                        )
+                    
+                    with gr.Row():
+                        add_ctx_btn = gr.Button("Add Context")
+                        clear_ctx_btn = gr.Button("Clear All Context")
+                    
+                    context_display = gr.Dataframe(
+                        headers=["Text", "Speaker ID"],
+                        label="Current Context",
+                        interactive=False
+                    )
                 
-                context_display = gr.Dataframe(
-                    headers=["Text", "Speaker ID"],
-                    label="Current Context",
-                    interactive=False
-                )
+                generate_btn = gr.Button("Generate Audio", variant="primary")
             
-            generate_btn = gr.Button("Generate Audio", variant="primary")
+            with gr.Column(scale=1):
+                audio_output = gr.Audio(label="Generated Audio", type="numpy")
+                error_output = gr.Textbox(label="Error Message", visible=False)
         
-        with gr.Column(scale=1):
-            audio_output = gr.Audio(label="Generated Audio", type="numpy")
-            error_output = gr.Textbox(label="Error Message", visible=False)
-    
-    # Connect events
-    generate_btn.click(
-        fn=generate_speech,
-        inputs=[
-            text_input,
-            speaker_id,
-            max_length,
-            temp,
-            top_k,
-            context_list,
-            context_speakers_list
-        ],
-        outputs=[audio_output, error_output]
-    )
-    
-    add_ctx_btn.click(
-        fn=add_context,
-        inputs=[
-            context_text,
-            context_speaker,
-            context_list,
-            context_speakers_list
-        ],
-        outputs=[context_list, context_speakers_list]
-    )
-    
-    clear_ctx_btn.click(
-        fn=clear_context,
-        inputs=[],
-        outputs=[context_list, context_speakers_list]
-    )
-    
-    # Update context display
-    def update_context_display(texts, speakers):
-        if not texts or not speakers:
-            return []
-        return [[text, speaker] for text, speaker in zip(texts, speakers)]
-    
-    context_list.change(
-        fn=update_context_display,
-        inputs=[context_list, context_speakers_list],
-        outputs=[context_display]
-    )
+        # Connect events
+        generate_btn.click(
+            fn=generate_speech,
+            inputs=[
+                text_input,
+                speaker_id,
+                max_length,
+                temp,
+                top_k,
+                context_list,
+                context_speakers_list
+            ],
+            outputs=[audio_output, error_output]
+        )
+        
+        add_ctx_btn.click(
+            fn=add_context,
+            inputs=[
+                context_text,
+                context_speaker,
+                context_list,
+                context_speakers_list
+            ],
+            outputs=[context_list, context_speakers_list]
+        ).then(
+            fn=update_context_display,
+            inputs=[context_list, context_speakers_list],
+            outputs=[context_display]
+        )
+        
+        clear_ctx_btn.click(
+            fn=clear_context,
+            inputs=[],
+            outputs=[context_list, context_speakers_list]
+        ).then(
+            fn=lambda: [],
+            inputs=[],
+            outputs=[context_display]
+        )
+        
+        gr.Markdown("""
+        ## About CSM-1B
+
+        CSM (Conversational Speech Model) is a speech generation model from Sesame that generates audio from text inputs. 
+        The model can generate a variety of voices and works best when provided with conversational context.
+
+        ### Features:
+        - Generate natural-sounding speech from text
+        - Choose different speaker identities (0-10)
+        - Adjust temperature to control output variability
+        - Add conversation context for more natural responses
+
+        [View on Hugging Face](https://huggingface.co/sesame/csm-1b) | [GitHub Repository](https://github.com/SesameAILabs/csm)
+        """)
     
-    context_speakers_list.change(
-        fn=update_context_display,
-        inputs=[context_list, context_speakers_list],
-        outputs=[context_display]
-    )
+    return demo
 
-# Initialize model when page loads
+# Khởi tạo model
 initialize_model()
 
-# Configuration for Hugging Face Spaces
-demo.launch(share=False)
+# Tạo và khởi chạy demo
+demo = create_demo()
+demo.launch(server_name="0.0.0.0", server_port=7860, share=True)
 

generator.py

@@ -164,46 +164,8 @@ class Generator:
 
 
 def load_csm_1b(device: str = "cuda") -> Generator:
-    try:
-        # Nếu silentcipher được cài đặt, thử tải config từ đó
-        try:
-            from silentcipher import Config
-            model_path = "sesame/csm-1b"
-            config = Config.from_pretrained(model_path)
-            model = Model.from_pretrained(model_path, config=config)
-            model = model.to(device=device, dtype=torch.bfloat16)
-            generator = Generator(model)
-            return generator
-        except ImportError:
-            # Nếu không thể import silentcipher, thử cách khác
-            pass
-            
-        # Cố gắng tạo config từ pretrained model
-        import os
-        import json
-        try:
-            from huggingface_hub import hf_hub_download
-            config_file = hf_hub_download("sesame/csm-1b", "config.json")
-            with open(config_file, 'r') as f:
-                config_dict = json.load(f)
-            
-            # Tạo dummy config object
-            class DummyConfig:
-                def __init__(self, **kwargs):
-                    for key, value in kwargs.items():
-                        setattr(self, key, value)
-            
-            config = DummyConfig(**config_dict)
-            model = Model.from_pretrained("sesame/csm-1b", config=config)
-            model = model.to(device=device, dtype=torch.bfloat16)
-            generator = Generator(model)
-            return generator
-        except Exception as e:
-            import logging
-            logging.error(f"Error loading model with config: {str(e)}")
-            raise RuntimeError(f"Could not load model: {str(e)}")
-            
-    except Exception as e:
-        import logging
-        logging.error(f"Failed to load model: {str(e)}")
-        raise e
+    model = Model.from_pretrained("sesame/csm-1b")
+    model.to(device=device, dtype=torch.bfloat16)
+
+    generator = Generator(model)
+    return generator

setup.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Log in to Hugging Face to access model
+echo "Logging in to Hugging Face..."
+if [ -n "$HF_TOKEN" ]; then
+    echo "Using provided HF_TOKEN"
+    huggingface-cli login --token $HF_TOKEN
+else
+    echo "No HF_TOKEN provided, trying to use cached credentials"
+fi
+
+# Clone repository if needed
+if [ ! -d "./csm" ]; then
+    echo "Cloning CSM repository..."
+    git clone https://github.com/SesameAILabs/csm.git
+    cd csm
+    # Copy files back to parent directory
+    cp -r generator.py models.py watermarking.py ../
+    cd ..
+else
+    echo "CSM repository already exists"
+fi
+
+# Install additional dependencies
+echo "Installing additional dependencies..."
+pip install -q git+https://github.com/SesameAILabs/csm.git
+
+echo "Setup complete! Ready to start the application."