Update app.py

app.py

@@ -7,10 +7,8 @@ import torch
 import logging
 import numpy as np
 import re
-import sys  # sys 모듈 추가
 from concurrent.futures import ThreadPoolExecutor
 from functools import lru_cache
-from datetime import datetime
 
 # 로깅 설정
 logging.basicConfig(
@@ -22,28 +20,24 @@ logging.basicConfig(
     ]
 )
 
+################################
+# 기존에 정의된 함수 및 로직들  #
+################################
+
 def optimize_gpu_settings():
     if torch.cuda.is_available():
-        # GPU 메모리 관리 최적화
         torch.backends.cuda.matmul.allow_tf32 = True
         torch.backends.cudnn.benchmark = True
         torch.backends.cudnn.enabled = True
         torch.backends.cudnn.deterministic = False
-        
-        # L40S에 최적화된 메모리 설정
         torch.cuda.empty_cache()
         torch.cuda.set_device(0)
-        
-        # CUDA 스트림 최적화
         torch.cuda.Stream(0)
-        
-        # 메모리 할당 최적화
         os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'max_split_size_mb:512'
         
         logging.info(f"Using GPU: {torch.cuda.get_device_name(0)}")
         logging.info(f"Available GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB")
         
-        # L40S 특화 설정
         if 'L40S' in torch.cuda.get_device_name(0):
             torch.cuda.set_per_process_memory_fraction(0.95)
 
@@ -65,7 +59,6 @@ def analyze_lyrics(lyrics, repeat_chorus=2):
     }
     last_section = None
 
-    # 마지막 섹션 태그 찾기
     for i, line in enumerate(lines):
         if '[verse]' in line.lower() or '[chorus]' in line.lower() or '[bridge]' in line.lower():
             last_section = i
@@ -73,9 +66,8 @@ def analyze_lyrics(lyrics, repeat_chorus=2):
     for i, line in enumerate(lines):
         lower_line = line.lower()
         
-        # 섹션 태그 처리
         if '[verse]' in lower_line:
-            if current_section:  # 이전 섹션의 라인들 저장
+            if current_section:  
                 section_lines[current_section].extend(lines[last_section_start:i])
             current_section = 'verse'
             sections['verse'] += 1
@@ -96,58 +88,50 @@ def analyze_lyrics(lyrics, repeat_chorus=2):
             last_section_start = i + 1
             continue
 
-    # 마지막 섹션의 라인들 추가
-    if current_section and last_section_start < len(lines):
+    if current_section and 'last_section_start' in locals() and last_section_start < len(lines):
         section_lines[current_section].extend(lines[last_section_start:])
 
-    # 코러스 반복 처리
     if sections['chorus'] > 0 and repeat_chorus > 1:
         original_chorus = section_lines['chorus'][:]
         for _ in range(repeat_chorus - 1):
             section_lines['chorus'].extend(original_chorus)
 
-    # 섹션별 라인 수 확인 로깅
-    logging.info(f"Section line counts - Verse: {len(section_lines['verse'])}, "
-                f"Chorus: {len(section_lines['chorus'])}, "
-                f"Bridge: {len(section_lines['bridge'])}")
+    logging.info(
+        f"Section line counts - Verse: {len(section_lines['verse'])}, "
+        f"Chorus: {len(section_lines['chorus'])}, "
+        f"Bridge: {len(section_lines['bridge'])}"
+    )
 
     return sections, (sections['verse'] + sections['chorus'] + sections['bridge']), len(lines), section_lines
 
 def calculate_generation_params(lyrics):
     sections, total_sections, total_lines, section_lines = analyze_lyrics(lyrics)
     
-    # 기본 시간 계산 (초 단위)
     time_per_line = {
-        'verse': 4,    # verse는 한 줄당 4초
-        'chorus': 6,   # chorus는 한 줄당 6초
-        'bridge': 5    # bridge는 한 줄당 5초
+        'verse': 4,
+        'chorus': 6,
+        'bridge': 5
     }
     
-    # 각 섹션별 예상 시간 계산 (마지막 섹션 포함)
     section_durations = {}
     for section_type in ['verse', 'chorus', 'bridge']:
         lines_count = len(section_lines[section_type])
         section_durations[section_type] = lines_count * time_per_line[section_type]
     
-    # 전체 시간 계산 (여유 시간 추가)
     total_duration = sum(duration for duration in section_durations.values())
-    total_duration = max(60, int(total_duration * 1.2))  # 20% 여유 시간 추가
+    total_duration = max(60, int(total_duration * 1.2))
     
-    # 토큰 계산 (마지막 섹션을 위한 추가 토큰)
     base_tokens = 3000
     tokens_per_line = 200
-    extra_tokens = 1000  # 마지막 섹션을 위한 추가 토큰
-    
+    extra_tokens = 1000
     total_tokens = base_tokens + (total_lines * tokens_per_line) + extra_tokens
     
-    # 세그먼트 수 계산 (마지막 섹션을 위한 추가 세그먼트)
     if sections['chorus'] > 0:
-        num_segments = 4  # 코러스가 있는 경우 4개 세그먼트
+        num_segments = 4
     else:
-        num_segments = 3  # 코러스가 없는 경우 3개 세그먼트
-    
-    # 토큰 수 제한 (더 큰 제한)
-    max_tokens = min(12000, total_tokens)  # 최대 토큰 수 증가
+        num_segments = 3
+
+    max_tokens = min(12000, total_tokens)
     
     return {
         'max_tokens': max_tokens,
@@ -201,101 +185,35 @@ def install_flash_attn():
         logging.warning(f"Failed to install flash-attn: {e}")
         return False
 
-
-# 전역 변수로 경로 설정
-APP_DIR = os.path.abspath(os.path.dirname(__file__))
-INFERENCE_DIR = os.path.join(APP_DIR, "inference")
-INFER_SCRIPT = os.path.join(INFERENCE_DIR, "infer.py")
-
 def initialize_system():
     optimize_gpu_settings()
     
-    try:
-        # 절대 경로 설정
-        app_dir = os.path.abspath(os.path.dirname(__file__))
-        inference_dir = os.path.join(app_dir, "inference")
-        
-        # 기본 디렉토리 구조 생성
-        os.makedirs(inference_dir, exist_ok=True)
-        os.makedirs(os.path.join(inference_dir, "models"), exist_ok=True)
-        os.makedirs(os.path.join(inference_dir, "xcodec_mini_infer"), exist_ok=True)
-        
-        # 작업 디렉토리 변경
-        os.chdir(inference_dir)
-        logging.info(f"Working directory changed to: {os.getcwd()}")
-        
-        from huggingface_hub import snapshot_download, hf_hub_download
+    with ThreadPoolExecutor(max_workers=4) as executor:
+        futures = []
+        futures.append(executor.submit(install_flash_attn))
         
-        # models 모듈 파일 다운로드 및 설정
-        models_dir = os.path.join(inference_dir, "models")
-        os.makedirs(models_dir, exist_ok=True)
+        from huggingface_hub import snapshot_download
         
-        # __init__.py 생성
-        with open(os.path.join(models_dir, "__init__.py"), "w") as f:
-            f.write("")
-        
-        # soundstream_hubert_new.py 다운로드
-        try:
-            soundstream_file = hf_hub_download(
-                repo_id="m-a-p/xcodec_mini_infer",
-                filename="models/soundstream_hubert_new.py",
-                cache_dir=os.path.join(inference_dir, "cache"),
-                force_download=True
-            )
-            shutil.copy2(soundstream_file, os.path.join(models_dir, "soundstream_hubert_new.py"))
-        except Exception as e:
-            logging.error(f"Failed to download soundstream_hubert_new.py: {e}")
-            raise
-        
-        # xcodec_mini_infer 모델 다운로드
-        snapshot_download(
+        folder_path = './inference/xcodec_mini_infer'
+        os.makedirs(folder_path, exist_ok=True)
+        logging.info(f"Created folder at: {folder_path}")
+
+        futures.append(executor.submit(
+            snapshot_download,
             repo_id="m-a-p/xcodec_mini_infer",
-            local_dir=os.path.join(inference_dir, "xcodec_mini_infer"),
-            force_download=True
-        )
-        
-        # YuE 모델들 다운로드
-        models = [
-            "m-a-p/YuE-s1-7B-anneal-jp-kr-cot",
-            "m-a-p/YuE-s1-7B-anneal-en-cot",
-            "m-a-p/YuE-s1-7B-anneal-zh-cot",
-            "m-a-p/YuE-s2-1B-general"
-        ]
-        
-        for model in models:
-            model_name = model.split('/')[-1]
-            snapshot_download(
-                repo_id=model,
-                local_dir=os.path.join(inference_dir, "models", model_name),
-                force_download=True
-            )
-        
-        # PYTHONPATH 설정
-        if inference_dir not in sys.path:
-            sys.path.insert(0, inference_dir)
+            local_dir="./inference/xcodec_mini_infer",
+            resume_download=True
+        ))
         
-        # 파일 존재 확인
-        required_files = [
-            os.path.join(models_dir, "__init__.py"),
-            os.path.join(models_dir, "soundstream_hubert_new.py"),
-            os.path.join(inference_dir, "xcodec_mini_infer", "config.json"),
-            os.path.join(inference_dir, "xcodec_mini_infer", "vocal_decoder.pth"),
-            os.path.join(inference_dir, "xcodec_mini_infer", "inst_decoder.pth")
-        ]
-        
-        for file_path in required_files:
-            if not os.path.exists(file_path):
-                raise FileNotFoundError(f"Required file not found: {file_path}")
-            else:
-                file_size = os.path.getsize(file_path)
-                logging.info(f"Verified {os.path.basename(file_path)}: {file_size} bytes")
-        
-        logging.info("System initialization completed successfully")
-        
-    except Exception as e:
-        logging.error(f"Initialization error: {e}")
-        raise
+        for future in futures:
+            future.result()
 
+    try:
+        os.chdir("./inference")
+        logging.info(f"Working directory changed to: {os.getcwd()}")
+    except FileNotFoundError as e:
+        logging.error(f"Directory error: {e}")
+        raise
 
 @lru_cache(maxsize=100)
 def get_cached_file_path(content_hash, prefix):
@@ -338,33 +256,62 @@ def get_audio_duration(file_path):
         logging.error(f"Failed to get audio duration: {e}")
         return None
 
+def optimize_model_selection(lyrics, genre):
+    model_path = detect_and_select_model(lyrics)
+    params = calculate_generation_params(lyrics)
+    
+    has_chorus = params['sections']['chorus'] > 0
+    
+    model_config = {
+        "m-a-p/YuE-s1-7B-anneal-en-cot": {
+            "max_tokens": params['max_tokens'],
+            "temperature": 0.8,
+            "batch_size": 16,
+            "num_segments": params['num_segments'],
+            "estimated_duration": params['estimated_duration']
+        },
+        "m-a-p/YuE-s1-7B-anneal-jp-kr-cot": {
+            "max_tokens": params['max_tokens'],
+            "temperature": 0.7,
+            "batch_size": 16,
+            "num_segments": params['num_segments'],
+            "estimated_duration": params['estimated_duration']
+        },
+        "m-a-p/YuE-s1-7B-anneal-zh-cot": {
+            "max_tokens": params['max_tokens'],
+            "temperature": 0.7,
+            "batch_size": 16,
+            "num_segments": params['num_segments'],
+            "estimated_duration": params['estimated_duration']
+        }
+    }
+    
+    if has_chorus:
+        for config in model_config.values():
+            config['max_tokens'] = int(config['max_tokens'] * 1.5)
+    
+    return model_path, model_config[model_path], params
+
 def infer(genre_txt_content, lyrics_txt_content, num_segments, max_new_tokens):
     genre_txt_path = None
     lyrics_txt_path = None
     
     try:
-        if not os.path.exists(INFER_SCRIPT):
-            raise FileNotFoundError(f"infer.py not found at: {INFER_SCRIPT}")
-        
         model_path, config, params = optimize_model_selection(lyrics_txt_content, genre_txt_content)
         logging.info(f"Selected model: {model_path}")
         logging.info(f"Lyrics analysis: {params}")
-
         
         has_chorus = params['sections']['chorus'] > 0
         estimated_duration = params.get('estimated_duration', 90)
 
-
         # 세그먼트 및 토큰 수 설정
         if has_chorus:
             actual_max_tokens = min(12000, int(config['max_tokens'] * 1.3))  # 30% 더 많은 토큰
-            actual_num_segments = min(5, params['num_segments'] + 2)  # 추가 세그먼트
+            actual_num_segments = min(5, params['num_segments'] + 2)        # 추가 세그먼트
         else:
             actual_max_tokens = min(10000, int(config['max_tokens'] * 1.2))
             actual_num_segments = min(4, params['num_segments'] + 1)
         
-
-
         logging.info(f"Estimated duration: {estimated_duration} seconds")
         logging.info(f"Has chorus sections: {has_chorus}")
         logging.info(f"Using segments: {actual_num_segments}, tokens: {actual_max_tokens}")
@@ -376,29 +323,21 @@ def infer(genre_txt_content, lyrics_txt_content, num_segments, max_new_tokens):
         os.makedirs(output_dir, exist_ok=True)
         empty_output_folder(output_dir)
 
-
-        python_executable = sys.executable or "python"  # fallback to "python" if sys.executable is not available
-
-
-
-        
         command = [
-            python_executable,
-            INFER_SCRIPT,
+            "python", "infer.py",
             "--stage1_model", model_path,
             "--stage2_model", "m-a-p/YuE-s2-1B-general",
-            "--genre_txt", os.path.abspath(genre_txt_path),
-            "--lyrics_txt", os.path.abspath(lyrics_txt_path),
+            "--genre_txt", genre_txt_path,
+            "--lyrics_txt", lyrics_txt_path,
             "--run_n_segments", str(actual_num_segments),
             "--stage2_batch_size", "16",
-            "--output_dir", os.path.abspath("./output"),
+            "--output_dir", output_dir,
             "--cuda_idx", "0",
             "--max_new_tokens", str(actual_max_tokens),
             "--disable_offload_model"
         ]
+
         env = os.environ.copy()
-        current_dir = os.getcwd()
-        
         if torch.cuda.is_available():
             env.update({
                 "CUDA_VISIBLE_DEVICES": "0",
@@ -406,11 +345,10 @@ def infer(genre_txt_content, lyrics_txt_content, num_segments, max_new_tokens):
                 "PATH": f"/usr/local/cuda/bin:{env.get('PATH', '')}",
                 "LD_LIBRARY_PATH": f"/usr/local/cuda/lib64:{env.get('LD_LIBRARY_PATH', '')}",
                 "PYTORCH_CUDA_ALLOC_CONF": "max_split_size_mb:512",
-                "CUDA_LAUNCH_BLOCKING": "0",
-                "PYTHONPATH": current_dir
+                "CUDA_LAUNCH_BLOCKING": "0"
             })
 
-        # transformers 캐시 마이그레이션 처리
+        # transformers 캐시 마이그레이션 처리 (버전에 따라 동작하지 않을 수 있음)
         try:
             from transformers.utils import move_cache
             move_cache()
@@ -444,7 +382,9 @@ def infer(genre_txt_content, lyrics_txt_content, num_segments, max_new_tokens):
                     logging.info(f"Expected duration: {estimated_duration} seconds")
                     
                     if duration < estimated_duration * 0.8:
-                        logging.warning(f"Generated audio is shorter than expected: {duration:.2f}s < {estimated_duration:.2f}s")
+                        logging.warning(
+                            f"Generated audio is shorter than expected: {duration:.2f}s < {estimated_duration:.2f}s"
+                        )
             except Exception as e:
                 logging.warning(f"Failed to get audio duration: {e}")
             return last_mp3
@@ -464,190 +404,117 @@ def infer(genre_txt_content, lyrics_txt_content, num_segments, max_new_tokens):
                 except Exception as e:
                     logging.warning(f"Failed to remove temporary file {path}: {e}")
 
-def optimize_model_selection(lyrics, genre):
-    model_path = detect_and_select_model(lyrics)
+#####################################
+# 아래부터 Gradio UI 및 main() 부분 #
+#####################################
+
+def update_info(lyrics):
+    """가사 변경 시 추정 정보를 업데이트하는 함수."""
+    if not lyrics:
+        return "No lyrics entered", "No sections detected"
     params = calculate_generation_params(lyrics)
-    
-    has_chorus = params['sections']['chorus'] > 0
-    tokens_per_segment = params['max_tokens'] // params['num_segments']
-    
-    model_config = {
-        "m-a-p/YuE-s1-7B-anneal-en-cot": {
-            "max_tokens": params['max_tokens'],
-            "temperature": 0.8,
-            "batch_size": 16,
-            "num_segments": params['num_segments'],
-            "estimated_duration": params['estimated_duration']
-        },
-        "m-a-p/YuE-s1-7B-anneal-jp-kr-cot": {
-            "max_tokens": params['max_tokens'],
-            "temperature": 0.7,
-            "batch_size": 16,
-            "num_segments": params['num_segments'],
-            "estimated_duration": params['estimated_duration']
-        },
-        "m-a-p/YuE-s1-7B-anneal-zh-cot": {
-            "max_tokens": params['max_tokens'],
-            "temperature": 0.7,
-            "batch_size": 16,
-            "num_segments": params['num_segments'],
-            "estimated_duration": params['estimated_duration']
-        }
-    }
-    
-    if has_chorus:
-        for config in model_config.values():
-            config['max_tokens'] = int(config['max_tokens'] * 1.5)
-    
-    return model_path, model_config[model_path], params
+    duration = params['estimated_duration']
+    sections = params['sections']
+    return (
+        f"Estimated duration: {duration:.1f} seconds",
+        f"Verses: {sections['verse']}, Chorus: {sections['chorus']} (Expected full length including chorus)"
+    )
 
 def main():
-    # 테마 설정
-    theme = gr.themes.Soft(
-        primary_hue="indigo",
-        secondary_hue="purple",
-        neutral_hue="slate",
-        font=["Arial", "sans-serif"]
-    )
-    
-    # CSS 스타일 정의
-    custom_css = """
-    #main-container {
-        max-width: 1200px;
-        margin: auto;
-        padding: 20px;
-    }
-    #header {
-        text-align: center;
-        margin-bottom: 30px;
-        background: linear-gradient(135deg, #6366f1, #a855f7);
-        padding: 20px;
-        border-radius: 15px;
-        color: white;
-    }
-    .input-section {
-        background: #f8fafc;
-        padding: 20px;
-        border-radius: 15px;
-        margin-bottom: 20px;
-        box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
-    }
-    .output-section {
-        background: #f0f9ff;
-        padding: 20px;
-        border-radius: 15px;
-        margin-bottom: 20px;
-        box-shadow: 0 4px 6px -1px rgb(0 0 0 / 0.1);
-    }
-    #generate-btn {
-        background: linear-gradient(135deg, #6366f1, #a855f7);
-        border: none;
-        padding: 15px 30px;
-        border-radius: 10px;
-        color: white;
-        font-weight: bold;
-        cursor: pointer;
-        transition: all 0.3s ease;
-    }
-    #generate-btn:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
-    }
-    .info-box {
-        background: #fff;
-        padding: 15px;
-        border-radius: 10px;
-        border: 1px solid #e2e8f0;
-        margin: 10px 0;
-    }
-    .status-section {
-        background: #fff;
-        padding: 15px;
-        border-radius: 10px;
-        margin-top: 15px;
-        border: 1px solid #e2e8f0;
-    }
-    """
-
-    with gr.Blocks(theme=theme, css=custom_css) as demo:
-        with gr.Column(elem_id="main-container"):
-            # 헤더 섹션
-            with gr.Row(elem_id="header"):
-                gr.Markdown(
-                    """
-                    # 🎵 AI Song Creator 'Open SUNO'
-                    ### Transform Your Lyrics into Complete Songs with Music
-                    Create professional songs from your lyrics in multiple languages
-                    """
+    # 먼저 시스템 초기화 (GPU 최적화, 필요한 모델 다운로드 등)
+    initialize_system()
+
+    with gr.Blocks(css="""
+        /* 전체 배경 및 컨테이너 스타일 */
+        body {
+            background-color: #f5f5f5;
+        }
+        .gradio-container {
+            max-width: 1000px;
+            margin: auto !important;
+            background-color: #ffffff;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+        }
+        /* 텍스트 크기, 마진 조정 */
+        h1, h2, h3 {
+            margin: 0;
+            padding: 0;
+        }
+        p {
+            margin: 5px 0;
+        }
+        /* 예제 블록 스타일 */
+        .gr-examples {
+            background-color: #fafafa;
+            border-radius: 8px;
+            padding: 10px;
+        }
+    """) as demo:
+
+        # 상단 헤더
+        gr.HTML("""
+        <div style="text-align: center; margin-bottom: 1.5rem;">
+            <h1>Open SUNO: Full-Song Generation (Multi-Language Support)</h1>
+            <p style="font-size: 1.1rem; color: #555;">
+                Enter your song details below and let the AI handle the music production!
+            </p>
+        </div>
+        """)
+
+        with gr.Row():
+            # 왼쪽 입력 컬럼
+            with gr.Column():
+                genre_txt = gr.Textbox(
+                    label="Genre",
+                    placeholder="Enter music genre and style descriptions...",
+                    lines=2
+                )
+                lyrics_txt = gr.Textbox(
+                    label="Lyrics (Supports English, Korean, Japanese, Chinese)",
+                    placeholder="Enter song lyrics with [verse], [chorus], [bridge] tags...",
+                    lines=10
                 )
 
-            # 메인 컨텐츠
-            with gr.Row():
-                # 입력 섹션
-                with gr.Column(scale=1, elem_classes="input-section"):
-                    gr.Markdown("### 📝 Input Your Song Details")
-                    genre_txt = gr.Textbox(
-                        label="🎸 Music Genre & Style",
-                        placeholder="e.g., K-pop bright energetic synth dance electronic...",
-                        elem_id="genre-input"
+            # 오른쪽 설정/정보 컬럼
+            with gr.Column():
+                with gr.Box():
+                    gr.Markdown("### Generation Settings")
+                    num_segments = gr.Number(
+                        label="Number of Song Segments (Auto-adjusted)",
+                        value=2,
+                        minimum=1,
+                        maximum=4,
+                        step=1,
+                        interactive=False
                     )
-                    lyrics_txt = gr.Textbox(
-                        label="📝 Lyrics",
-                        placeholder="Enter lyrics with section tags: [verse], [chorus], [bridge]...",
-                        lines=10,
-                        elem_id="lyrics-input"
+                    max_new_tokens = gr.Slider(
+                        label="Max New Tokens (Auto-adjusted)",
+                        minimum=500,
+                        maximum=32000,
+                        step=500,
+                        value=4000,
+                        interactive=False
                     )
-                    
-                    # 정보 표시 섹션
-                    with gr.Row():
-                        with gr.Column(scale=1):
-                            duration_info = gr.Label(
-                                label="⏱️ Estimated Duration",
-                                elem_classes="info-box"
-                            )
-                        with gr.Column(scale=1):
-                            sections_info = gr.Label(
-                                label="📊 Section Analysis",
-                                elem_classes="info-box"
-                            )
-                    
-                    submit_btn = gr.Button(
-                        "🎼 Generate Music",
-                        variant="primary",
-                        elem_id="generate-btn"
-                    )
-
-                # 출력 섹션
-                with gr.Column(scale=1, elem_classes="output-section"):
-                    gr.Markdown("### 🎵 Generated Music")
-                    music_out = gr.Audio(
-                        label="Generated Song",
-                        elem_id="music-output"
-                    )
-                    
-                    # 진행 상태
-                    with gr.Group(elem_classes="status-section"):
-                        gr.Markdown("### 🔄 Generation Status")
-                        num_segments = gr.Number(
-                            label="Song Segments",
-                            value=2,
-                            interactive=False,
-                            visible=False
-                        )
-                        max_new_tokens = gr.Number(
-                            label="Tokens",
-                            value=4000,
-                            interactive=False,
-                            visible=False
-                        )
-
-            # 예제 섹션
-            with gr.Accordion("📖 Examples", open=False):
-                gr.Examples(
-                    examples=[
-                        [
-                            "female blues airy vocal bright vocal piano sad romantic guitar jazz",
-                            """[verse]
+                
+                with gr.Box():
+                    gr.Markdown("### Song Info")
+                    duration_info = gr.Label(label="Estimated Duration")
+                    sections_info = gr.Label(label="Section Information")
+                
+                submit_btn = gr.Button("Generate Music", variant="primary")
+
+        # 생성된 오디오 출력 영역
+        with gr.Box():
+            music_out = gr.Audio(label="Generated Audio")
+        
+        # 예시
+        gr.Examples(
+            examples=[
+                [
+                    "female blues airy vocal bright vocal piano sad romantic guitar jazz",
+                    """[verse]
 In the quiet of the evening, shadows start to fall
 Whispers of the night wind echo through the hall
 Lost within the silence, I hear your gentle voice
@@ -657,67 +524,31 @@ Guiding me back homeward, making my heart rejoice
 Don't let this moment fade, hold me close tonight
 With you here beside me, everything's alright
 Can't imagine life alone, don't want to let you go
-Stay with me forever, let our love just flow"""
-                        ],
-                        [
-                            "K-pop bright energetic synth dance electronic",
-                            """[verse]
+Stay with me forever, let our love just flow
+"""
+                ],
+                [
+                    "K-pop bright energetic synth dance electronic",
+                    """[verse]
 언젠가 마주한 눈빛 속에서
 
 [chorus]
 다시 한 번 내게 말해줘
+"""
+                ]
+            ],
+            inputs=[genre_txt, lyrics_txt],
+            outputs=[]
+        )
 
-[verse]
-어두운 밤을 지날 때마다
-
-[chorus]
-다시 한 번 내게 말해줘"""
-                        ]
-                    ],
-                    inputs=[genre_txt, lyrics_txt]
-                )
-
-            # 도움말 섹션
-            with gr.Accordion("ℹ️ Help & Information", open=False):
-                gr.Markdown(
-                    """
-                    ### 🎵 How to Use
-                    1. **Enter Genre & Style**: Describe the musical style you want
-                    2. **Input Lyrics**: Write your lyrics using section tags
-                    3. **Generate**: Click the Generate button and wait for your music!
-
-                    ### 🌏 Supported Languages
-                    - English
-                    - Korean (한국어)
-                    - Japanese (日本語)
-                    - Chinese (中文)
-
-                    ### ⚡ Tips for Best Results
-                    - Be specific with genre descriptions
-                    - Include emotion and instrument preferences
-                    - Properly tag your lyrics sections
-                    - Include both verse and chorus sections
-                    """
-                )
-
-        def update_info(lyrics):
-            if not lyrics:
-                return "No lyrics entered", "No sections detected"
-            params = calculate_generation_params(lyrics)
-            duration = params['estimated_duration']
-            sections = params['sections']
-            return (
-                f"⏱️ Duration: {duration:.1f} seconds",
-                f"📊 Verses: {sections['verse']}, Chorus: {sections['chorus']}"
-            )
-
-        # 이벤트 핸들러 설정
+        # 가사 변경 시 추정 정보 업데이트
         lyrics_txt.change(
             fn=update_info,
             inputs=[lyrics_txt],
             outputs=[duration_info, sections_info]
         )
-        
+
+        # 버튼 클릭 시 infer 실행
         submit_btn.click(
             fn=infer,
             inputs=[genre_txt, lyrics_txt, num_segments, max_new_tokens],
@@ -726,6 +557,7 @@ Stay with me forever, let our love just flow"""
 
         return demo
 
+
 if __name__ == "__main__":
     demo = main()
     demo.queue(max_size=20).launch(
@@ -735,4 +567,4 @@ if __name__ == "__main__":
         show_api=True,
         show_error=True,
         max_threads=8
-    )
+    )