Auto commit at 08-2025-08 3:40:22

app.py

@@ -1,21 +1,24 @@
+# 파일: app.py (최종 수정본)
+
 import gradio as gr
 import os
 import traceback
 from transformers import AutoTokenizer, AutoModelForCausalLM, AutoImageProcessor
 import torch
-import fitz  # PyMuPDF
+import fitz
 from PIL import Image
 from typing import Optional, List
 
-# --- 1. 전역 변수 및 환경 설정 ---
+# --- 1 & 2. 전역 변수, 환경 설정, 모델 로딩 (기존 코드와 동일) ---
+# (이 부분은 수정할 필요 없이 그대로 두시면 됩니다)
+# ... (생략) ...
+# --- 1 & 2. 전역 변수, 환경 설정, 모델 로딩 (기존 코드와 동일) ---
 tokenizer = None
 model = None
-image_processor = None  # 이미지 프로세서 전역 변수 추가
+image_processor = None
 MODEL_LOADED = False
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-
 IS_LOCAL = os.path.exists('.env') or os.path.exists('../.env') or os.getenv('IS_LOCAL') == 'true'
-
 try:
     from dotenv import load_dotenv
     if IS_LOCAL:
@@ -23,58 +26,43 @@ try:
         print("✅ .env 파일 로드됨")
 except ImportError:
     print("⚠️ python-dotenv가 설치되지 않음")
-
 HF_TOKEN = os.getenv("HF_TOKEN")
 MODEL_NAME_SERVER = os.getenv("MODEL_NAME", "gbrabbit/lily-math-model")
 MODEL_PATH_LOCAL = "../lily_llm_core/models/kanana_1_5_v_3b_instruct"
 MODEL_PATH = MODEL_PATH_LOCAL if IS_LOCAL else MODEL_NAME_SERVER
-
 print(f"============== 시스템 환경 정보 ==============")
 print(f"🔍 실행 환경: {'로컬' if IS_LOCAL else '서버'}")
 print(f"🔍 모델 경로: {MODEL_PATH}")
 print(f"🔍 사용 디바이스: {DEVICE.upper()}")
 print("==========================================")
-
-
-# --- 2. 핵심 로직: 모델 및 프로세서 로딩 ---
 try:
     print("🔧 모델 로딩 시작...")
     from modeling import KananaVForConditionalGeneration
-
     if IS_LOCAL:
         if not os.path.exists(MODEL_PATH):
             raise FileNotFoundError(f"로컬 모델 경로를 찾을 수 없습니다: {MODEL_PATH}")
-        
         tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True, local_files_only=True)
         model = KananaVForConditionalGeneration.from_pretrained(
-            MODEL_PATH, torch_dtype=torch.float16, trust_remote_code=True, local_files_only=True,
+            MODEL_PATH, torch_dtype=torch.bfloat16, trust_remote_code=True, local_files_only=True,
         ).to(DEVICE)
-        # 이미지 프로세서 로드 (로컬)
         image_processor = AutoImageProcessor.from_pretrained(MODEL_PATH, trust_remote_code=True, local_files_only=True)
         print("✅ 로컬 모델 및 이미지 프로세서 로딩 완료!")
-
-    else: # 서버 환경
+    else:
         if not HF_TOKEN:
             raise ValueError("서버 환경에서는 Hugging Face 토큰(HF_TOKEN)이 반드시 필요합니다.")
-
         tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, token=HF_TOKEN, trust_remote_code=True)
         model = KananaVForConditionalGeneration.from_pretrained(
-            MODEL_PATH, token=HF_TOKEN, torch_dtype=torch.float16, trust_remote_code=True,
-        ).to(DEVICE)
-        # 이미지 프로세서 로드 (서버)
+            MODEL_PATH, token=HF_TOKEN, torch_dtype=torch.float16, trust_remote_code=True, device_map="auto"
+        )
         image_processor = AutoImageProcessor.from_pretrained(MODEL_PATH, token=HF_TOKEN, trust_remote_code=True)
         print("✅ 서버 모델 및 이미지 프로세서 로딩 완료!")
-
     MODEL_LOADED = True
-
 except Exception as e:
     print(f"❌ 모델 로딩 실패: {e}")
     traceback.print_exc()
     MODEL_LOADED = False
 
-
-# --- 3. 파일 처리 및 응답 생성 로직 ---
-
+# --- 3. 응답 생성 로직 (기존 코드와 동일) ---
 def extract_text_from_pdf(pdf_file_path):
     try:
         doc = fitz.open(pdf_file_path)
@@ -86,140 +74,100 @@ def extract_text_from_pdf(pdf_file_path):
         return f"PDF 파일을 읽는 중 오류가 발생했습니다: {e}"
 
 def generate_response(prompt_template: str, message: str, files: Optional[List] = None):
-    if not MODEL_LOADED:
-        return "❌ 모델이 로드되지 않았습니다."
-
+    if not MODEL_LOADED: return "❌ 모델이 로드되지 않았습니다."
     try:
-        all_pixel_values = []
-        all_image_metas = []
-        file_texts = []
-
-        # 1. 업로드된 파일들 처리 (이미지/PDF 분리)
+        all_pixel_values, all_image_metas, file_texts = [], [], []
         if files:
             for file in files:
-                file_path = file.name
-                file_extension = os.path.splitext(file_path)[1].lower()
-
-                if file_extension == '.pdf':
-                    file_texts.append(extract_text_from_pdf(file_path))
+                file_path, file_extension = file.name, os.path.splitext(file.name)[1].lower()
+                if file_extension == '.pdf': file_texts.append(extract_text_from_pdf(file_path))
                 elif file_extension in ['.png', '.jpg', '.jpeg']:
                     pil_image = Image.open(file_path).convert('RGB')
                     processed_data = image_processor(pil_image)
-                    
-                    pixel_values = processed_data["pixel_values"]
-                    image_metas = processed_data["image_meta"]
-                    
-                    all_pixel_values.append(pixel_values)
-                    all_image_metas.append(image_metas)
-
-        # 2. 프롬프트 구성
+                    all_pixel_values.append(processed_data["pixel_values"])
+                    all_image_metas.append(processed_data["image_meta"])
         image_tokens = "<image>" * len(all_pixel_values)
         pdf_content = "\n\n".join(file_texts)
         full_message = message + (f"\n{image_tokens}" if image_tokens else "") + (f"\n\n[첨부된 PDF 내용]:\n{pdf_content}" if pdf_content else "")
         full_prompt = prompt_template.format(message=full_message)
-
-        # 3. 토크나이징 및 `image_metas` 결합
         if all_image_metas:
-            # 여러 이미지의 메타데이터를 하나로 합침
-            combined_metas = {}
-            for key in all_image_metas[0].keys():
-                combined_metas[key] = [meta[key] for meta in all_image_metas]
-            
-            # `encode_prompt`는 Kanana 모델의 토크나이저에 내장된 커스텀 함수로 가정
+            combined_metas = {key: [meta[key] for meta in all_image_metas] for key in all_image_metas[0]}
             inputs = tokenizer.encode_prompt(prompt=full_prompt, image_meta=combined_metas)
-
-            # 값이 텐서인 경우에만 배치 차원을 추가하고 디바이스로 보냅니다.
-            inputs = {
-                k: (v.unsqueeze(0).to(model.device) if torch.is_tensor(v) else v)
-                for k, v in inputs.items()
-            }
+            inputs = {k: (v.unsqueeze(0).to(model.device) if torch.is_tensor(v) else v) for k, v in inputs.items()}
         else:
             inputs = tokenizer(full_prompt, return_tensors="pt").to(model.device)
-        
-        # 4. 생성 파라미터 준비
         generation_args = {
-            "max_new_tokens": 256, "temperature": 0.7, "do_sample": True,
-            "pad_token_id": tokenizer.eos_token_id, "eos_token_id": tokenizer.eos_token_id
+            "max_new_tokens": 32, 
+            "temperature": 0.8, 
+            "do_sample": True, 
+            "pad_token_id": tokenizer.eos_token_id, 
+            "eos_token_id": tokenizer.eos_token_id,
+            "top_p": 0.95,
         }
-
-        # 5. 모델 추론 (멀티모달 / 텍스트 전용 분기)
         with torch.no_grad():
             if all_pixel_values:
-                print(f"🖼️ 이미지 {len(all_pixel_values)}개 포함, 멀티모달 모드로 생성")
-                # pixel_values와 image_metas를 `generate` 함수에 직접 전달
-                outputs = model.generate(
-                    **inputs,
-                    pixel_values=all_pixel_values,
-                    image_metas=combined_metas,
-                    **generation_args
-                )
+                outputs = model.generate(**inputs, pixel_values=all_pixel_values, image_metas=combined_metas, **generation_args)
             else:
-                print("📄 텍스트만으로 생성")
                 outputs = model.generate(**inputs, **generation_args)
-        
-        # 6. 결과 디코딩
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        # 응답에서 프롬프트 부분 제거
-        assistant_response = response.split("<|im_start|>assistant\n")[-1].strip()
-        
-        return assistant_response
-
+        return response.split("<|im_start|>assistant\n")[-1].strip()
     except Exception as e:
-        print(f"❌ 응답 생성 중 오류 발생: {e}")
-        traceback.print_exc()
-        return f"오류가 발생했습니다: {e}"
+        print(f"❌ 응답 생성 중 오류 발생: {e}"); traceback.print_exc(); return f"오류가 발생했습니다: {e}"
 
-# --- 4. Gradio UI 및 실행 ---
+
+# --- 4. Gradio UI 및 실행 (최종 수정) ---
 with gr.Blocks(title="Lily LLM System", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🧮 Lily LLM System")
     gr.Markdown("이미지, PDF, 텍스트를 이해하고 답변하는 멀티모달 AI 시스템입니다.")
     
-    with gr.Tabs():
+    with gr.Tabs():                
         with gr.Tab("💬 채팅"):
             chat_prompt = "<|im_start|>user\n{message}<|im_end|>\n<|im_start|>assistant\n"
-            chatbot = gr.Chatbot(height=500, label="대화창", elem_id="chatbot", type="messages")
-            
-            with gr.Row():
-                file_input = gr.File(
-                    label="파일 업로드 (다중 선택 가능)",
-                    file_count="multiple", # 다중 파일 업로드 활성화
-                    file_types=[".pdf", ".png", ".jpg", ".jpeg"]
-                )
+            chatbot = gr.Chatbot(height=320, label="대화창", elem_id="chatbot", type="messages")
+
             with gr.Row():
-                msg = gr.Textbox(
-                    label="메시지 입력",
-                    placeholder="파일을 업로드하고 질문하거나, 텍스트로만 대화할 수 있습니다.",
-                    lines=3,
-                    show_label=False,
-                    scale=7
-                )
+                msg = gr.Textbox(label="메시지 입력", placeholder="메시지를 입력하세요", lines=3, show_label=False, scale=4)
+                file_input = gr.File(label="파일 업로드", file_count="multiple", file_types=[".pdf", ".png", ".jpg", ".jpeg"], scale=1)
                 send_btn = gr.Button("전송", variant="primary", scale=1)
             
+            # ✅ 1. respond 함수가 'files'를 세 번째 인자로 받도록 수정
             def respond(message, chat_history, files):
                 if not message.strip() and not files:
-                    # 입력이 없으면 아무 작업도 하지 않고 현재 상태를 그대로 반환
-                    return "", chat_history
+                    return "", chat_history, None # files 출력도 비워줌
                 
                 bot_message = generate_response(chat_prompt, message, files)
                 
-                # 'messages' 타입에 맞는 딕셔너리 형태로 대화 기록 추가
                 chat_history.append({"role": "user", "content": message})
                 chat_history.append({"role": "assistant", "content": bot_message})
                 
-                return "", chat_history
-            
-            send_btn.click(respond, inputs=[msg, chatbot, file_input], outputs=[msg, chatbot])
-            msg.submit(respond, inputs=[msg, chatbot, file_input], outputs=[msg, chatbot])
+                # ✅ 2. 출력의 개수를 inputs와 맞추기 위해 file_input도 반환값에 추가
+                return "", chat_history, None
+                        
+            # ✅ 3. click과 submit의 inputs 리스트에 'file_input' 추가
+            send_btn.click(
+                respond, 
+                inputs=[msg, chatbot, file_input], 
+                outputs=[msg, chatbot, file_input], # 출력에도 file_input 추가
+                api_name="chat", # api_name은 슬래시 없이 사용
+                # queue=False
+            )
+            msg.submit(
+                respond, 
+                inputs=[msg, chatbot, file_input], 
+                outputs=[msg, chatbot, file_input], # 출력에도 file_input 추가
+                api_name="chat", 
+                # queue=False
+            )
             
         with gr.Tab("⚙️ 시스템 정보"):
             gr.Markdown(f"**실행 환경**: `{'로컬' if IS_LOCAL else '서버'}`")
             gr.Markdown(f"**모델 경로**: `{MODEL_PATH}`")
             gr.Markdown(f"**모델 상태**: `{'✅ 로드됨' if MODEL_LOADED else '❌ 로드 실패'}`")
 
-if __name__ == "__main__":
+if __name__ == "__main__":    
     if IS_LOCAL:
-        print("\n🚀 로컬 서버를 시작합니다. http://localhost:8006")
-        demo.launch(server_name="localhost", server_port=8006, share=False)
+        print("\n🚀 로컬 서버를 시작합니다. http://127.0.0.1:8006")
+        demo.launch(server_name="127.0.0.1", server_port=8006, share=False)
     else:
         print("\n🚀 서버를 시작합니다...")
         demo.launch()

test_input.py

@@ -1,100 +0,0 @@
-import os
-from gradio_client import Client, file
-
-# --- 설정 ---
-# 로컬 Gradio 서버 주소 (app.py 실행 시 터미널에 표시되는 주소)
-SERVER_URL = "http://localhost:8006/"
-
-def run_chat_test(client):
-    """일반 채팅 탭의 기능을 테스트합니다."""
-    print("\n--- 💬 일반 채팅 테스트 시작 ---")
-    
-    test_message = "안녕하세요! 오늘 날씨는 어떤가요?"
-    chat_history = []  # 초기 대화 내역은 비어있음
-    
-    print(f"보내는 메시지: '{test_message}'")
-    
-    # `respond` 함수 호출 (API 엔드포인트 인덱스: 0)
-    # 입력: (메시지, 채팅 내역, 파일)
-    # 출력: (비워진 텍스트 박스, 갱신된 채팅 내역)
-    result = client.predict(
-        test_message,
-        chat_history,
-        None,  # 파일 없음
-        fn_index=0
-    )
-    
-    # 갱신된 채팅 내역에서 마지막 응답(봇 메시지)을 추출
-    updated_history = result[1]
-    bot_response = updated_history[-1]['content']
-    
-    print("✅ 테스트 성공!")
-    print(f"🤖 받은 응답: '{bot_response}'")
-
-def run_math_test(client):
-    """수학 문제 해결 탭의 기능을 테스트합니다."""
-    print("\n--- 🧮 수학 문제 해결 테스트 시작 ---")
-    
-    test_problem = "두 개의 연속된 짝수의 합이 34일 때, 두 짝수는 무엇인가요?"
-    
-    print(f"보내는 문제: '{test_problem}'")
-    
-    # 수학 문제 해결 함수 호출 (API 엔드포인트 인덱스: 1)
-    # 입력: (수학 문제, 파일)
-    # 출력: (결과 텍스트)
-    result = client.predict(
-        test_problem,
-        None,  # 파일 없음
-        fn_index=1
-    )
-    
-    print("✅ 테스트 성공!")
-    print(f"🤖 받은 응답 (일부): '{result[:200]}...'")
-
-def run_file_test(client):
-    """파일 업로드 기능을 테스트합니다."""
-    print("\n--- 📁 파일 업로드 채팅 테스트 시작 ---")
-
-    # 테스트용 임시 텍스트 파일 생성
-    temp_file_path = "test_document.txt"
-    with open(temp_file_path, "w", encoding="utf-8") as f:
-        f.write("이 파일은 테스트를 위해 생성되었습니다.\n")
-        f.write("파일의 핵심 내용은 '대한민국의 수도는 서울이다' 입니다.")
-    
-    print(f"업로드할 파일: '{temp_file_path}'")
-    test_message = "업로드한 파일의 핵심 내용이 뭐야?"
-    print(f"보내는 메시지: '{test_message}'")
-
-    # `file()` 함수를 사용하여 파일을 서버에 업로드 가능한 형태로 변환
-    result = client.predict(
-        test_message,
-        [], # 채팅 내역 없음
-        file(temp_file_path),
-        fn_index=0
-    )
-
-    # 임시 파일 삭제
-    os.remove(temp_file_path)
-
-    bot_response = result[1][-1]['content']
-    print("✅ 테스트 성공!")
-    print(f"🤖 받은 응답: '{bot_response}'")
-
-
-if __name__ == "__main__":
-    print(f"Gradio 서버({SERVER_URL})에 연결을 시도합니다...")
-    
-    try:
-        # 서버에 클라이언트로 연결
-        client = Client(SERVER_URL, verbose=False)
-        print("✅ 서버 연결 성공!")
-        
-        # 테스트 실행
-        run_chat_test(client)
-        run_math_test(client)
-        # run_file_test(client) # 파일 테스트는 필요시 주석 해제하여 사용
-
-    except Exception as e:
-        print(f"\n❌ 테스트 실패: 서버에 연결할 수 없거나 오류가 발생했습니다.")
-        print("먼저 다른 터미널에서 'python app.py'를 실행했는지 확인해주세요.")
-        print(f"오류 상세 정보: {e}")

test_text.py

@@ -1,100 +0,0 @@
-import os
-from gradio_client import Client, file
-
-# --- 설정 ---
-# 로컬 Gradio 서버 주소 (app.py 실행 시 터미널에 표시되는 주소)
-SERVER_URL = "http://localhost:8006/"
-
-def run_chat_test(client):
-    """일반 채팅 탭의 기능을 테스트합니다."""
-    print("\n--- 💬 일반 채팅 테스트 시작 ---")
-    
-    test_message = "안녕하세요! 오늘 날씨는 어떤가요?"
-    chat_history = []  # 초기 대화 내역은 비어있음
-    
-    print(f"보내는 메시지: '{test_message}'")
-    
-    # `respond` 함수 호출 (API 엔드포인트 인덱스: 0)
-    # 입력: (메시지, 채팅 내역, 파일)
-    # 출력: (비워진 텍스트 박스, 갱신된 채팅 내역)
-    result = client.predict(
-        test_message,
-        chat_history,
-        None,  # 파일 없음
-        fn_index=0
-    )
-    
-    # 갱신된 채팅 내역에서 마지막 응답(봇 메시지)을 추출
-    updated_history = result[1]
-    bot_response = updated_history[-1]['content']
-    
-    print("✅ 테스트 성공!")
-    print(f"🤖 받은 응답: '{bot_response}'")
-
-def run_math_test(client):
-    """수학 문제 해결 탭의 기능을 테스트합니다."""
-    print("\n--- 🧮 수학 문제 해결 테스트 시작 ---")
-    
-    test_problem = "두 개의 연속된 짝수의 합이 34일 때, 두 짝수는 무엇인가요?"
-    
-    print(f"보내는 문제: '{test_problem}'")
-    
-    # 수학 문제 해결 함수 호출 (API 엔드포인트 인덱스: 1)
-    # 입력: (수학 문제, 파일)
-    # 출력: (결과 텍스트)
-    result = client.predict(
-        test_problem,
-        None,  # 파일 없음
-        fn_index=1
-    )
-    
-    print("✅ 테스트 성공!")
-    print(f"🤖 받은 응답 (일부): '{result[:200]}...'")
-
-def run_file_test(client):
-    """파일 업로드 기능을 테스트합니다."""
-    print("\n--- 📁 파일 업로드 채팅 테스트 시작 ---")
-
-    # 테스트용 임시 텍스트 파일 생성
-    temp_file_path = "test_document.txt"
-    with open(temp_file_path, "w", encoding="utf-8") as f:
-        f.write("이 파일은 테스트를 위해 생성되었습니다.\n")
-        f.write("파일의 핵심 내용은 '대한민국의 수도는 서울이다' 입니다.")
-    
-    print(f"업로드할 파일: '{temp_file_path}'")
-    test_message = "업로드한 파일의 핵심 내용이 뭐야?"
-    print(f"보내는 메시지: '{test_message}'")
-
-    # `file()` 함수를 사용하여 파일을 서버에 업로드 가능한 형태로 변환
-    result = client.predict(
-        test_message,
-        [], # 채팅 내역 없음
-        file(temp_file_path),
-        fn_index=0
-    )
-
-    # 임시 파일 삭제
-    os.remove(temp_file_path)
-
-    bot_response = result[1][-1]['content']
-    print("✅ 테스트 성공!")
-    print(f"🤖 받은 응답: '{bot_response}'")
-
-
-if __name__ == "__main__":
-    print(f"Gradio 서버({SERVER_URL})에 연결을 시도합니다...")
-    
-    try:
-        # 서버에 클라이언트로 연결
-        client = Client(SERVER_URL, verbose=False)
-        print("✅ 서버 연결 성공!")
-        
-        # 테스트 실행
-        run_chat_test(client)
-        run_math_test(client)
-        # run_file_test(client) # 파일 테스트는 필요시 주석 해제하여 사용
-
-    except Exception as e:
-        print(f"\n❌ 테스트 실패: 서버에 연결할 수 없거나 오류가 발생했습니다.")
-        print("먼저 다른 터미널에서 'python app.py'를 실행했는지 확인해주세요.")
-        print(f"오류 상세 정보: {e}")

test_tokenizer.py

@@ -1,159 +0,0 @@
-import os
-import traceback
-from typing import Optional
-from transformers import AutoTokenizer
-import torch
-
-# 환경 변수 로드
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-    print("✅ .env 파일 로드됨")
-except ImportError:
-    print("⚠️ python-dotenv가 설치되지 않음")
-
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-# 환경 감지
-IS_LOCAL = os.path.exists('../.env') or 'LOCAL_TEST' in os.environ
-print(f"🔍 환경: {'로컬' if IS_LOCAL else '서버'}")
-
-# 환경에 따른 모델 경로 설정
-if IS_LOCAL:
-    # 로컬 모델 경로 (hearth_llm_model 폴더 사용)
-    MODEL_PATH = "../lily_llm_core/models/kanana_1_5_v_3b_instruct"
-    print(f"🔍 로컬 모델 경로: {MODEL_PATH}")
-    print(f"🔍 경로 존재: {os.path.exists(MODEL_PATH)}")
-else:
-    # 서버에서는 Hugging Face 모델 사용
-    MODEL_PATH = os.getenv("MODEL_NAME", "gbrabbit/lily-math-model")
-    print(f"🔍 서버 모델: {MODEL_PATH}")
-
-print(f"🔍 토큰: {'✅ 설정됨' if HF_TOKEN else '❌ 설정되지 않음'}")
-
-# 토크나이저 테스트
-print("\n🔧 토크나이저 테스트 시작...")
-
-try:
-    print("📤 토크나이저 로딩 중...")
-    print(f"   MODEL_PATH: {MODEL_PATH}")
-    print(f"   IS_LOCAL: {IS_LOCAL}")
-    print(f"   trust_remote_code: True")
-    print(f"   use_fast: False")
-    
-    if IS_LOCAL:
-        tokenizer = AutoTokenizer.from_pretrained(
-            MODEL_PATH,
-            trust_remote_code=True,            
-        )
-    else:
-        tokenizer = AutoTokenizer.from_pretrained(
-            MODEL_PATH,
-            token=HF_TOKEN,
-            trust_remote_code=True,            
-        )
-    
-    print(f"✅ 토크나이저 로딩 완료")
-    print(f"   타입: {type(tokenizer)}")
-    print(f"   값: {tokenizer}")
-    print(f"   hasattr('encode'): {hasattr(tokenizer, 'encode')}")
-    print(f"   hasattr('__call__'): {hasattr(tokenizer, '__call__')}")
-    
-    # 토크나이저 테스트
-    test_input = "안녕하세요"
-    print(f"\n🔤 토크나이저 테스트: '{test_input}'")
-    
-    test_tokens = tokenizer(test_input, return_tensors="pt")
-    print(f"   ✅ 토크나이저 호출 성공")
-    print(f"   input_ids shape: {test_tokens['input_ids'].shape}")
-    print(f"   attention_mask shape: {test_tokens['attention_mask'].shape}")
-    
-    # 디코딩 테스트
-    decoded = tokenizer.decode(test_tokens['input_ids'][0], skip_special_tokens=True)
-    print(f"   디코딩 결과: '{decoded}'")
-    
-except Exception as e:
-    print(f"❌ 토크나이저 테스트 실패: {e}")
-    print(f"   오류 타입: {type(e).__name__}")
-    traceback.print_exc()
-
-# 모델 테스트
-print("\n🔧 모델 테스트 시작...")
-
-try:
-    print("📤 모델 로딩 중...")
-    from modeling import KananaVForConditionalGeneration
-    
-    if IS_LOCAL:
-        model = KananaVForConditionalGeneration.from_pretrained(
-            MODEL_PATH,
-            torch_dtype=torch.float16,
-            trust_remote_code=True,
-            device_map=None,
-            low_cpu_mem_usage=True
-        )
-    else:
-        model = KananaVForConditionalGeneration.from_pretrained(
-            MODEL_PATH,
-            token=HF_TOKEN,
-            torch_dtype=torch.float16,
-            trust_remote_code=True,
-            device_map=None,
-            low_cpu_mem_usage=True
-        )
-    
-    print(f"✅ 모델 로딩 완료")
-    # print(f"   타입: {type(model)}")
-    # print(f"   디바이스: {next(model.parameters()).device}")
-    
-    # 모델 테스트
-    test_input = "안녕하세요"
-    formatted_prompt = f"<|im_start|>user\n{test_input}<|im_end|>\n<|im_start|>assistant\n"
-    max_length: Optional[int] = None
-    
-    inputs = tokenizer(
-        formatted_prompt, 
-        return_tensors="pt",
-        padding=True,
-        truncation=True,
-        max_length=512
-    )
-    
-    print(f"\n🤖 모델 추론 테스트: '{test_input}'")
-    
-    # Kanana용 생성 설정
-    max_new_tokens = max_length or 100
-                    
-    with torch.no_grad():
-        outputs = model.generate(
-            input_ids=inputs["input_ids"],
-            attention_mask=inputs["attention_mask"],
-            max_new_tokens=max_new_tokens,                        
-            repetition_penalty=1.1,
-            no_repeat_ngram_size=2,
-            pad_token_id=tokenizer.eos_token_id,
-            eos_token_id=tokenizer.eos_token_id,
-            use_cache=True
-        )
-    
-    print(f"   ✅ 모델 호출 성공")
-    print(f"   outputs 타입: {type(outputs)}")
-    print(f"   outputs shape: {outputs.shape}")
-
-    # 디코딩 테스트
-    # model.generate()의 출력은 전체 시퀀스이므로 바로 디코딩합니다.
-    # outputs[0]은 배치 중 첫 번째 결과를 의미합니다.
-    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    
-    # 입력 프롬프트를 응답에서 제거 (선택사항)
-    assistant_response = response.split("<|im_start|>assistant\n")[-1]
-    
-    print(f"   생성된 전체 텍스트: '{response}'")
-    print(f"   어시스턴트 응답: '{assistant_response.strip()}'")
-    
-except Exception as e:
-    print(f"❌ 모델 테스트 실패: {e}")
-    print(f"   오류 타입: {type(e).__name__}")
-    traceback.print_exc()
-
-print("\n✅ 테스트 완료!")