Remove server code, keep LoRA adapter only

audio_processing/__init__.py

@@ -1,4 +0,0 @@
-# audio_processing package
-from .effect_chain import EffectChain
-
-__all__ = ["EffectChain"]

audio_processing/effect_chain.py

@@ -1,161 +0,0 @@
-"""
-Effect Chain - Pedalboard 기반 오디오 이펙트 처리
-=================================================
-"""
-
-import numpy as np
-import soundfile as sf
-from typing import Dict, List, Optional
-from pedalboard import (
-    Pedalboard, 
-    Compressor, 
-    Gain,
-    HighShelfFilter,
-    LowShelfFilter,
-    PeakFilter,
-    Delay,
-    Reverb,
-    Distortion,
-    Limiter
-)
-
-
-class EffectChain:
-    """Pedalboard 기반 이펙트 체인"""
-    
-    def __init__(self, sample_rate: int = 44100):
-        self.sample_rate = sample_rate
-        
-        self.available_effects = [
-            "eq_peak1", "eq_peak2", 
-            "eq_lowshelf", "eq_highshelf",
-            "distortion", "delay", "compressor",
-            "reverb", "limiter"
-        ]
-    
-    def get_available_effects(self) -> List[str]:
-        """사용 가능한 이펙트 목록"""
-        return self.available_effects
-    
-    def _build_pedalboard(self, params: Dict[str, float]) -> Pedalboard:
-        """파라미터로 Pedalboard 구성"""
-        
-        effects = []
-        
-        # Compressor (항상 적용)
-        effects.append(Compressor(
-            threshold_db=-18.0,
-            ratio=2.0,
-            attack_ms=10.0,
-            release_ms=100.0
-        ))
-        
-        # EQ Peak 1
-        freq1 = params.get("eq_peak1.params.freq", 1000.0)
-        gain1 = params.get("eq_peak1.params.gain", 0.0)
-        q1 = params.get("eq_peak1.params.q", 1.0)
-        if abs(gain1) > 0.1:
-            effects.append(PeakFilter(
-                cutoff_frequency_hz=max(20, min(20000, freq1)),
-                gain_db=max(-12, min(12, gain1)),
-                q=max(0.1, min(10, q1))
-            ))
-        
-        # EQ Peak 2
-        freq2 = params.get("eq_peak2.params.freq", 4000.0)
-        gain2 = params.get("eq_peak2.params.gain", 0.0)
-        q2 = params.get("eq_peak2.params.q", 1.0)
-        if abs(gain2) > 0.1:
-            effects.append(PeakFilter(
-                cutoff_frequency_hz=max(20, min(20000, freq2)),
-                gain_db=max(-12, min(12, gain2)),
-                q=max(0.1, min(10, q2))
-            ))
-        
-        # Low Shelf
-        freq_low = params.get("eq_lowshelf.params.freq", 200.0)
-        gain_low = params.get("eq_lowshelf.params.gain", 0.0)
-        if abs(gain_low) > 0.1:
-            effects.append(LowShelfFilter(
-                cutoff_frequency_hz=max(20, min(2000, freq_low)),
-                gain_db=max(-12, min(12, gain_low)),
-                q=0.707
-            ))
-        
-        # High Shelf
-        freq_high = params.get("eq_highshelf.params.freq", 8000.0)
-        gain_high = params.get("eq_highshelf.params.gain", 0.0)
-        if abs(gain_high) > 0.1:
-            effects.append(HighShelfFilter(
-                cutoff_frequency_hz=max(1000, min(20000, freq_high)),
-                gain_db=max(-12, min(12, gain_high)),
-                q=0.707
-            ))
-        
-        # Distortion
-        dist_amount = params.get("distortion_amount", 0.0)
-        if dist_amount > 0.01:
-            effects.append(Distortion(
-                drive_db=max(0, min(20, dist_amount * 100))
-            ))
-        
-        # Delay
-        delay_time = params.get("delay.delay_time", 0.02)
-        delay_feedback = params.get("delay.feedback", 0.3)
-        delay_mix = params.get("delay.mix", 0.2)
-        if delay_mix > 0.01:
-            effects.append(Delay(
-                delay_seconds=max(0.01, min(1.0, delay_time)),
-                feedback=max(0.0, min(0.9, delay_feedback)),
-                mix=max(0.0, min(1.0, delay_mix))
-            ))
-        
-        # Limiter (항상 마지막에)
-        effects.append(Limiter(threshold_db=-1.0))
-        
-        return Pedalboard(effects)
-    
-    def process(
-        self, 
-        input_path: str, 
-        output_path: str, 
-        parameters: Dict[str, float]
-    ) -> bool:
-        """오디오 파일 처리"""
-        try:
-            # 오디오 로드
-            audio, sr = sf.read(input_path)
-            
-            # 모노/스테레오 처리
-            if len(audio.shape) == 1:
-                audio = audio.reshape(-1, 1)
-            
-            # float32로 변환
-            audio = audio.astype(np.float32)
-            
-            # Pedalboard 구성
-            board = self._build_pedalboard(parameters)
-            
-            # 처리
-            processed = board(audio, sr)
-            
-            # Wet/Dry 믹스
-            wet_mix = parameters.get("final_wet_mix", 0.5)
-            wet_mix = max(0.0, min(1.0, wet_mix))
-            
-            # 길이 맞추기
-            min_len = min(len(audio), len(processed))
-            output = audio[:min_len] * (1 - wet_mix) + processed[:min_len] * wet_mix
-            
-            # 클리핑 방지
-            output = np.clip(output, -1.0, 1.0)
-            
-            # 저장
-            sf.write(output_path, output, sr)
-            
-            print(f"[EffectChain] ✅ 처리 완료: {output_path}")
-            return True
-            
-        except Exception as e:
-            print(f"[EffectChain] ❌ 처리 실패: {e}")
-            raise e

main.py

@@ -1,250 +0,0 @@
-"""
-MagicPath AI Vocal Effects Server - DiffVox LLM 통합 버전
-=========================================================
-"""
-
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, JSONResponse
-from pathlib import Path
-import tempfile
-import os
-import uuid
-import base64
-import logging
-from datetime import datetime
-
-# 로깅 설정
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-print(f"\n===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====\n")
-
-# 내부 모듈
-from models.ai_effector import AIEffector
-from audio_processing.effect_chain import EffectChain
-
-# ============================================
-# 설정
-# ============================================
-
-# 학습된 모델 경로 - repo_id와 subfolder 분리!
-MODEL_REPO_ID = os.environ.get("DIFFVOX_MODEL_REPO", "heybaeheef/KU_SW_Academy")
-MODEL_SUBFOLDER = os.environ.get("DIFFVOX_MODEL_SUBFOLDER", "checkpoints")
-BASE_MODEL_NAME = os.environ.get("BASE_MODEL_NAME", "Qwen/Qwen3-8B")
-AUDIO_FEATURE_DIM = int(os.environ.get("AUDIO_FEATURE_DIM", "64"))
-USE_HUGGINGFACE = os.environ.get("USE_HUGGINGFACE", "true").lower() == "true"
-
-# 임시 파일 저장 경로
-TEMP_DIR = Path(tempfile.gettempdir()) / "magicpath"
-TEMP_DIR.mkdir(exist_ok=True)
-
-# ============================================
-# FastAPI 앱 초기화
-# ============================================
-
-app = FastAPI(
-    title="MagicPath AI Vocal Effects",
-    description="AI-powered vocal effect processing server (DiffVox LLM 통합)",
-    version="2.0.0"
-)
-
-# CORS 설정
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# 전역 객체 초기화
-print("=" * 60)
-print("MagicPath AI Vocal Effects Server v2.0")
-print("=" * 60)
-print(f"Model Repo: {MODEL_REPO_ID}")
-print(f"Model Subfolder: {MODEL_SUBFOLDER}")
-print(f"Base Model: {BASE_MODEL_NAME}")
-print(f"Audio Feature Dim: {AUDIO_FEATURE_DIM}")
-print(f"Use Hugging Face: {USE_HUGGINGFACE}")
-print("=" * 60)
-
-ai_effector = AIEffector(
-    model_repo_id=MODEL_REPO_ID,
-    model_subfolder=MODEL_SUBFOLDER,
-    base_model_name=BASE_MODEL_NAME,
-    audio_feature_dim=AUDIO_FEATURE_DIM,
-    use_huggingface=USE_HUGGINGFACE
-)
-effect_chain = EffectChain()
-
-
-# ============================================
-# API 엔드포인트
-# ============================================
-
-@app.get("/")
-async def root():
-    """서버 정보"""
-    return {
-        "status": "running",
-        "message": "MagicPath AI Vocal Effects Server v2.0 (DiffVox LLM)",
-        "ai_model_loaded": ai_effector.is_loaded(),
-        "model_repo": MODEL_REPO_ID,
-        "model_subfolder": MODEL_SUBFOLDER,
-        "endpoints": {
-            "POST /process": "오디오 파일 처리 후 반환",
-            "POST /predict": "파라미터만 예측 (JSON)",
-            "POST /process_with_params": "오디오 처리 + 파라미터 반환",
-            "GET /health": "서버 상태 확인"
-        }
-    }
-
-
-@app.get("/health")
-async def health_check():
-    """서버 및 모델 상태 확인"""
-    return {
-        "status": "healthy",
-        "ai_model_loaded": ai_effector.is_loaded(),
-        "supported_effects": effect_chain.get_available_effects(),
-        "model_repo": MODEL_REPO_ID,
-        "base_model": BASE_MODEL_NAME
-    }
-
-
-@app.post("/predict")
-async def predict_parameters(
-    audio: UploadFile = File(..., description="Dry 보컬 오디오 파일"),
-    prompt: str = Form("", description="텍스트 명령 (예: 'warm', 'bright')")
-):
-    """AI 모델로 이펙터 파라미터 예측"""
-    try:
-        input_path = TEMP_DIR / f"{uuid.uuid4()}_{audio.filename}"
-        with open(input_path, "wb") as f:
-            content = await audio.read()
-            f.write(content)
-        
-        parameters = ai_effector.predict(
-            audio_path=str(input_path),
-            text_prompt=prompt
-        )
-        
-        os.remove(input_path)
-        
-        return JSONResponse(content={
-            "status": "success",
-            "prompt": prompt,
-            "ai_model_used": ai_effector.is_loaded(),
-            "parameters": parameters
-        })
-        
-    except Exception as e:
-        logger.error(f"Predict error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/process")
-async def process_audio(
-    audio: UploadFile = File(..., description="Dry 보컬 오디오 파일"),
-    prompt: str = Form("", description="텍스트 명령 (예: 'warm', 'bright')")
-):
-    """AI가 예측한 파라미터로 실제 오디오 처리"""
-    input_path = None
-    output_path = None
-    
-    try:
-        file_id = str(uuid.uuid4())
-        input_path = TEMP_DIR / f"{file_id}_input_{audio.filename}"
-        output_path = TEMP_DIR / f"{file_id}_output.wav"
-        
-        with open(input_path, "wb") as f:
-            content = await audio.read()
-            f.write(content)
-        
-        parameters = ai_effector.predict(
-            audio_path=str(input_path),
-            text_prompt=prompt
-        )
-        
-        effect_chain.process(
-            input_path=str(input_path),
-            output_path=str(output_path),
-            parameters=parameters
-        )
-        
-        os.remove(input_path)
-        
-        return FileResponse(
-            path=str(output_path),
-            media_type="audio/wav",
-            filename=f"processed_{audio.filename.rsplit('.', 1)[0]}.wav",
-            background=None
-        )
-        
-    except Exception as e:
-        logger.error(f"Process error: {e}")
-        if input_path and Path(input_path).exists():
-            os.remove(input_path)
-        if output_path and Path(output_path).exists():
-            os.remove(output_path)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@app.post("/process_with_params")
-async def process_audio_with_params(
-    audio: UploadFile = File(..., description="Dry 보컬 오디오 파일"),
-    prompt: str = Form("", description="텍스트 명령")
-):
-    """오디오 처리 + 사용된 파라미터도 함께 반환"""
-    input_path = None
-    output_path = None
-    
-    try:
-        file_id = str(uuid.uuid4())
-        input_path = TEMP_DIR / f"{file_id}_input_{audio.filename}"
-        output_path = TEMP_DIR / f"{file_id}_output.wav"
-        
-        with open(input_path, "wb") as f:
-            content = await audio.read()
-            f.write(content)
-        
-        parameters = ai_effector.predict(
-            audio_path=str(input_path),
-            text_prompt=prompt
-        )
-        
-        effect_chain.process(
-            input_path=str(input_path),
-            output_path=str(output_path),
-            parameters=parameters
-        )
-        
-        os.remove(input_path)
-        
-        with open(output_path, "rb") as f:
-            audio_base64 = base64.b64encode(f.read()).decode('utf-8')
-        
-        os.remove(output_path)
-        
-        return JSONResponse(content={
-            "status": "success",
-            "prompt": prompt,
-            "ai_model_used": ai_effector.is_loaded(),
-            "parameters": parameters,
-            "audio_base64": audio_base64,
-            "audio_format": "wav"
-        })
-        
-    except Exception as e:
-        logger.error(f"Process with params error: {e}")
-        if input_path and Path(input_path).exists():
-            os.remove(input_path)
-        if output_path and Path(output_path).exists():
-            os.remove(output_path)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

models/__init__.py

@@ -1,4 +0,0 @@
-# models package
-from .ai_effector import AIEffector
-
-__all__ = ["AIEffector"]

models/ai_effector.py

@@ -1,330 +0,0 @@
-"""
-AI Effector - DiffVox LLM 기반 이펙트 파라미터 예측
-===================================================
-"""
-
-import os
-import json
-import re
-import torch
-import numpy as np
-from typing import Dict, List, Optional, Any
-from pathlib import Path
-import warnings
-
-warnings.filterwarnings("ignore")
-
-# 기본 파라미터 (모델 로드 실패 시 사용)
-DEFAULT_PARAMETERS = {
-    "eq_peak1.params.freq": 1000.0,
-    "eq_peak1.params.gain": 0.0,
-    "eq_peak1.params.q": 1.0,
-    "eq_peak2.params.freq": 4000.0,
-    "eq_peak2.params.gain": 0.0,
-    "eq_peak2.params.q": 1.0,
-    "eq_lowshelf.params.freq": 200.0,
-    "eq_lowshelf.params.gain": 0.0,
-    "eq_lowshelf.params.q": 0.707,
-    "eq_highshelf.params.freq": 8000.0,
-    "eq_highshelf.params.gain": 0.0,
-    "eq_highshelf.params.q": 0.707,
-    "distortion_amount": 0.0,
-    "delay.delay_time": 0.02,
-    "delay.feedback": 0.3,
-    "delay.mix": 0.2,
-    "final_wet_mix": 0.5
-}
-
-# 스타일 프리셋 (AI 없이도 작동)
-STYLE_PRESETS = {
-    "warm": {
-        "eq_lowshelf.params.gain": 3.0,
-        "eq_highshelf.params.gain": -1.0,
-        "distortion_amount": 0.05,
-    },
-    "bright": {
-        "eq_highshelf.params.gain": 4.0,
-        "eq_peak2.params.gain": 2.0,
-        "eq_lowshelf.params.gain": -1.0,
-    },
-    "vintage": {
-        "eq_lowshelf.params.gain": 2.0,
-        "eq_highshelf.params.gain": -2.0,
-        "distortion_amount": 0.1,
-        "delay.mix": 0.15,
-    },
-    "modern": {
-        "eq_peak1.params.gain": 2.0,
-        "eq_peak2.params.gain": 3.0,
-        "eq_highshelf.params.gain": 2.0,
-    },
-    "spacious": {
-        "delay.delay_time": 0.05,
-        "delay.feedback": 0.4,
-        "delay.mix": 0.35,
-    },
-    "dry": {
-        "final_wet_mix": 0.2,
-        "delay.mix": 0.0,
-    },
-    "saturated": {
-        "distortion_amount": 0.15,
-        "eq_lowshelf.params.gain": 1.0,
-    }
-}
-
-
-class AudioEncoder:
-    """간소화된 오디오 인코더 (CLAP 대체)"""
-    
-    def __init__(self, output_dim: int = 64):
-        self.output_dim = output_dim
-        self.sr = 44100
-        
-    def get_audio_features(self, audio_path: str) -> List[float]:
-        """오디오에서 특징 추출 (간소화 버전)"""
-        try:
-            import librosa
-            
-            y, sr = librosa.load(audio_path, sr=self.sr, duration=5.0)
-            
-            # 기본 특징 추출
-            features = []
-            
-            # MFCC (20개)
-            mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=20)
-            features.extend(np.mean(mfcc, axis=1).tolist())
-            
-            # Spectral features
-            spectral_centroid = np.mean(librosa.feature.spectral_centroid(y=y, sr=sr))
-            spectral_bandwidth = np.mean(librosa.feature.spectral_bandwidth(y=y, sr=sr))
-            spectral_rolloff = np.mean(librosa.feature.spectral_rolloff(y=y, sr=sr))
-            
-            features.extend([spectral_centroid / 10000, spectral_bandwidth / 10000, spectral_rolloff / 10000])
-            
-            # RMS energy
-            rms = np.mean(librosa.feature.rms(y=y))
-            features.append(float(rms))
-            
-            # Zero crossing rate
-            zcr = np.mean(librosa.feature.zero_crossing_rate(y))
-            features.append(float(zcr))
-            
-            # Chroma (12개)
-            chroma = librosa.feature.chroma_stft(y=y, sr=sr)
-            features.extend(np.mean(chroma, axis=1).tolist())
-            
-            # Pad or truncate to output_dim
-            if len(features) < self.output_dim:
-                features.extend([0.0] * (self.output_dim - len(features)))
-            else:
-                features = features[:self.output_dim]
-            
-            return features
-            
-        except Exception as e:
-            print(f"[AudioEncoder] 특징 추출 실패: {e}")
-            return [0.0] * self.output_dim
-
-
-class AIEffector:
-    """AI 기반 이펙터 파라미터 예측"""
-    
-    def __init__(
-        self,
-        model_repo_id: str = "heybaeheef/KU_SW_Academy",
-        model_subfolder: str = "checkpoints",
-        base_model_name: str = "Qwen/Qwen3-8B",
-        audio_feature_dim: int = 64,
-        use_huggingface: bool = True
-    ):
-        self.model_repo_id = model_repo_id
-        self.model_subfolder = model_subfolder
-        self.base_model_name = base_model_name
-        self.audio_feature_dim = audio_feature_dim
-        self.use_huggingface = use_huggingface
-        
-        self.model = None
-        self.tokenizer = None
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        
-        # 오디오 인코더
-        self.audio_encoder = AudioEncoder(output_dim=audio_feature_dim)
-        
-        # 모델 로드 시도
-        self._load_model()
-    
-    def _load_model(self):
-        """모델 로드"""
-        try:
-            from transformers import AutoModelForCausalLM, AutoTokenizer
-            from peft import PeftModel
-            
-            print(f"[AIEffector] 모델 로딩 시작...")
-            print(f"  - Base Model: {self.base_model_name}")
-            print(f"  - Adapter Repo: {self.model_repo_id}")
-            print(f"  - Adapter Subfolder: {self.model_subfolder}")
-            
-            # 토크나이저 로드
-            self.tokenizer = AutoTokenizer.from_pretrained(
-                self.base_model_name,
-                trust_remote_code=True
-            )
-            if self.tokenizer.pad_token is None:
-                self.tokenizer.pad_token = self.tokenizer.eos_token
-            
-            # 베이스 모델 로드
-            base_model = AutoModelForCausalLM.from_pretrained(
-                self.base_model_name,
-                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                device_map="auto" if torch.cuda.is_available() else None,
-                trust_remote_code=True,
-                low_cpu_mem_usage=True
-            )
-            
-            # LoRA 어댑터 로드 (subfolder 파라미터 사용!)
-            if self.use_huggingface:
-                print(f"[AIEffector] Hugging Face에서 LoRA 어댑터 로딩...")
-                self.model = PeftModel.from_pretrained(
-                    base_model,
-                    self.model_repo_id,
-                    subfolder=self.model_subfolder,  # 핵심 수정!
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                )
-            else:
-                # 로컬 경로 사용
-                local_path = os.path.join(self.model_repo_id, self.model_subfolder)
-                print(f"[AIEffector] 로컬에서 LoRA 어댑터 로딩: {local_path}")
-                self.model = PeftModel.from_pretrained(
-                    base_model,
-                    local_path,
-                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                )
-            
-            self.model.eval()
-            print(f"[AIEffector] ✅ 모델 로드 성공!")
-            
-        except Exception as e:
-            print(f"[AIEffector] ❌ 모델 로드 실패: {e}")
-            print(f"[AIEffector] 폴백 모드로 전환 (프리셋 기반)")
-            self.model = None
-            self.tokenizer = None
-    
-    def is_loaded(self) -> bool:
-        """모델 로드 여부"""
-        return self.model is not None
-    
-    def _apply_preset(self, prompt: str) -> Dict[str, float]:
-        """프롬프트에서 프리셋 매칭"""
-        params = DEFAULT_PARAMETERS.copy()
-        prompt_lower = prompt.lower()
-        
-        for style_name, style_params in STYLE_PRESETS.items():
-            if style_name in prompt_lower:
-                params.update(style_params)
-        
-        return params
-    
-    def _format_prompt(self, text_prompt: str, audio_features: List[float]) -> str:
-        """LLM 입력 프롬프트 포맷팅"""
-        # 오디오 특징을 간결하게 표현
-        audio_summary = ", ".join([f"{v:.3f}" for v in audio_features[:8]])
-        
-        prompt = f"""You are an audio effect parameter predictor.
-
-Input:
-- Text description: {text_prompt}
-- Audio features (first 8): [{audio_summary}]
-
-Output the effect parameters as JSON:
-```json
-{{
-    "eq_peak1.params.freq": <float>,
-    "eq_peak1.params.gain": <float>,
-    "eq_peak1.params.q": <float>,
-    "eq_peak2.params.freq": <float>,
-    "eq_peak2.params.gain": <float>,
-    "eq_peak2.params.q": <float>,
-    "eq_lowshelf.params.freq": <float>,
-    "eq_lowshelf.params.gain": <float>,
-    "eq_lowshelf.params.q": <float>,
-    "eq_highshelf.params.freq": <float>,
-    "eq_highshelf.params.gain": <float>,
-    "eq_highshelf.params.q": <float>,
-    "distortion_amount": <float>,
-    "delay.delay_time": <float>,
-    "delay.feedback": <float>,
-    "delay.mix": <float>,
-    "final_wet_mix": <float>
-}}
-```
-
-JSON output:"""
-        
-        return prompt
-    
-    def _parse_output(self, output_text: str) -> Dict[str, float]:
-        """LLM 출력에서 파라미터 추출"""
-        try:
-            # JSON 블록 찾기
-            json_match = re.search(r'\{[^{}]*\}', output_text, re.DOTALL)
-            if json_match:
-                params = json.loads(json_match.group())
-                
-                # 유효성 검사 및 기본값 병합
-                result = DEFAULT_PARAMETERS.copy()
-                for key, value in params.items():
-                    if key in result and isinstance(value, (int, float)):
-                        result[key] = float(value)
-                
-                return result
-        except Exception as e:
-            print(f"[AIEffector] 출력 파싱 실패: {e}")
-        
-        return DEFAULT_PARAMETERS.copy()
-    
-    def predict(self, audio_path: str, text_prompt: str = "") -> Dict[str, float]:
-        """파라미터 예측"""
-        
-        # 모델이 없으면 프리셋 사용
-        if not self.is_loaded():
-            print(f"[AIEffector] 프리셋 모드 사용 (prompt: {text_prompt})")
-            return self._apply_preset(text_prompt)
-        
-        try:
-            # 오디오 특징 추출
-            audio_features = self.audio_encoder.get_audio_features(audio_path)
-            
-            # 프롬프트 생성
-            prompt = self._format_prompt(text_prompt, audio_features)
-            
-            # 토큰화
-            inputs = self.tokenizer(
-                prompt,
-                return_tensors="pt",
-                truncation=True,
-                max_length=1024
-            ).to(self.device)
-            
-            # 생성
-            with torch.no_grad():
-                outputs = self.model.generate(
-                    **inputs,
-                    max_new_tokens=256,
-                    do_sample=False,
-                    temperature=0.1,
-                    pad_token_id=self.tokenizer.pad_token_id
-                )
-            
-            # 디코딩
-            output_text = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-            
-            # 파싱
-            params = self._parse_output(output_text)
-            
-            print(f"[AIEffector] ✅ AI 예측 완료")
-            return params
-            
-        except Exception as e:
-            print(f"[AIEffector] 예측 실패: {e}, 프리셋으로 폴백")
-            return self._apply_preset(text_prompt)

requirements.txt

@@ -1,23 +0,0 @@
-# MagicPath Server - DiffVox LLM 통합 버전
-# ==========================================
-
-# 웹 서버
-fastapi>=0.104.0
-uvicorn>=0.24.0
-python-multipart>=0.0.6
-
-# 오디오 처리
-soundfile>=0.12.0
-pedalboard>=0.8.0
-librosa>=0.10.0
-numpy>=1.24.0
-
-# AI 모델
-torch>=2.2.0
-transformers>=4.36.0
-peft>=0.7.0
-huggingface_hub>=0.20.0
-accelerate>=0.25.0
-
-# 추가 의존성
-scipy>=1.10.0