Update app.py

app.py

@@ -1,5 +1,39 @@
 import gradio as gr
 import os
+import re
+
+def validate_token(token):
+    """토큰 형식 유효성 검사"""
+    if not token:
+        return False
+    # 허깅페이스 토큰은 보통 hf_로 시작하고 알파벳과 숫자로 구성
+    return bool(re.match(r'^hf_[a-zA-Z0-9]{34,}$', token))
+
+def safe_tokenizer_load(model_name, hf_token=None):
+    """안전한 토크나이저 로딩"""
+    from transformers import AutoTokenizer
+    
+    # 다양한 로딩 전략 시도
+    strategies = [
+        {"trust_remote_code": True, "use_fast": False},
+        {"trust_remote_code": True, "use_fast": True},
+        {"trust_remote_code": False, "use_fast": False},
+        {"trust_remote_code": False, "use_fast": True},
+    ]
+    
+    for strategy in strategies:
+        try:
+            tokenizer_kwargs = strategy.copy()
+            if hf_token and hf_token.strip():
+                tokenizer_kwargs["token"] = hf_token.strip()
+            
+            tokenizer = AutoTokenizer.from_pretrained(model_name, **tokenizer_kwargs)
+            return tokenizer, None
+        except Exception as e:
+            last_error = e
+            continue
+    
+    return None, last_error
 
 def count_tokens(model_name, text, hf_token=None):
     """토큰 수를 계산하는 함수"""
@@ -7,50 +41,94 @@ def count_tokens(model_name, text, hf_token=None):
         if not model_name or not text:
             return "모델명과 텍스트를 모두 입력해주세요."
         
-        # transformers 임포트를 함수 내부에서 처리
-        from transformers import AutoTokenizer
-        
-        # 토크나이저 로드 (토큰이 있으면 사용)
-        tokenizer_kwargs = {"trust_remote_code": True}
+        # 토큰 검증
         if hf_token and hf_token.strip():
-            tokenizer_kwargs["token"] = hf_token.strip()
+            token = hf_token.strip()
+            if not validate_token(token):
+                return "❌ 토큰 형식이 올바르지 않습니다. 허깅페이스 토큰은 'hf_'로 시작해야 합니다."
         
-        tokenizer = AutoTokenizer.from_pretrained(model_name, **tokenizer_kwargs)
+        # 안전한 토크나이저 로딩
+        tokenizer, error = safe_tokenizer_load(model_name, hf_token)
+        if tokenizer is None:
+            raise error
         
-        # 토큰화
-        tokens = tokenizer.encode(text)
-        token_count = len(tokens)
+        # 패딩 토큰이 없는 경우 추가
+        if tokenizer.pad_token is None:
+            if tokenizer.eos_token:
+                tokenizer.pad_token = tokenizer.eos_token
+            elif tokenizer.unk_token:
+                tokenizer.pad_token = tokenizer.unk_token
         
-        # 토큰 디코딩 (선택사항 - 토큰들을 보여주기 위해)
+        # 토큰화 - 여러 방법 시도
         try:
-            decoded_tokens = [tokenizer.decode([token]) for token in tokens]
+            tokens = tokenizer.encode(text, add_special_tokens=True)
         except:
-            decoded_tokens = ["토큰 디코딩 실패"]
+            # 더 안전한 방법으로 시도
+            tokens = tokenizer.encode(text, add_special_tokens=False)
+        
+        token_count = len(tokens)
+        
+        # 토큰 디코딩 (안전하게 처리)
+        decoded_tokens = []
+        for i, token in enumerate(tokens[:50]):  # 처음 50개만
+            try:
+                decoded = tokenizer.decode([token])
+                if decoded.strip() == '':
+                    decoded_tokens.append(f"<empty_{token}>")
+                elif decoded.strip() == tokenizer.pad_token:
+                    decoded_tokens.append(f"<pad_{token}>")
+                elif decoded.strip() == tokenizer.eos_token:
+                    decoded_tokens.append(f"<eos_{token}>")
+                elif decoded.strip() == tokenizer.bos_token:
+                    decoded_tokens.append(f"<bos_{token}>")
+                else:
+                    decoded_tokens.append(repr(decoded))
+            except:
+                decoded_tokens.append(f"<token_{token}>")
         
         result = f"✅ 토큰 수: {token_count}\n\n"
-        result += f"토큰들: {decoded_tokens[:50]}"  # 처음 50개만 표시
-        if len(decoded_tokens) > 50:
-            result += f"\n... (총 {len(decoded_tokens)}개 토큰 중 50개만 표시)"
+        result += f"모델: {model_name}\n"
+        result += f"텍스트 길이: {len(text)} 글자\n"
+        result += f"토크나이저 타입: {type(tokenizer).__name__}\n\n"
+        result += f"토큰들 (처음 50개):\n{decoded_tokens}"
+        
+        if len(tokens) > 50:
+            result += f"\n\n... (총 {len(tokens)}개 토큰 중 50개만 표시)"
         
         return result
         
     except Exception as e:
-        error_msg = f"❌ 오류 발생: {str(e)}\n\n"
+        error_str = str(e)
+        error_msg = f"❌ 오류 발생: {error_str}\n\n"
         
-        if "gated repo" in str(e):
-            error_msg += "🔐 이 모델은 접근 권���이 필요합니다:\n"
+        if "401" in error_str and "Unauthorized" in error_str:
+            error_msg += "🔐 인증 오류:\n"
+            error_msg += "1. 허깅페이스 토큰이 올바른지 확인하세요\n"
+            error_msg += "2. 토큰이 'hf_'로 시작하는지 확인하세요\n"
+            error_msg += "3. 해당 모델에 대한 접근 권한이 있는지 확인하세요\n"
+            error_msg += f"4. 모델 페이지 방문: https://huggingface.co/{model_name}\n"
+        elif "gated repo" in error_str:
+            error_msg += "🔐 접근 제한된 모델:\n"
             error_msg += f"1. https://huggingface.co/{model_name} 에서 접근 권한을 요청하세요\n"
-            error_msg += "2. 허깅페이스 토큰을 입력하세요\n"
-            error_msg += "3. 토큰 생성: https://huggingface.co/settings/tokens\n\n"
-        elif "does not exist" in str(e) or "not found" in str(e):
+            error_msg += "2. 승인 후 유효한 허깅페이스 토큰을 입력하세요\n"
+        elif "does not exist" in error_str or "not found" in error_str:
             error_msg += "📝 모델을 찾을 수 없습니다:\n"
             error_msg += "1. 모델명을 확인해주세요\n"
-            error_msg += "2. 공개 모델 예시: 'klue/bert-base', 'beomi/KcELECTRA-base', 'gpt2'\n\n"
+            error_msg += "2. 공개 모델 예시: 'klue/bert-base', 'beomi/KcELECTRA-base', 'gpt2'\n"
+        elif "data did not match any variant" in error_str:
+            error_msg += "⚠️ 모델 파일 구조 문제:\n"
+            error_msg += "1. 이 모델은 현재 지원되지 않는 형식입니다\n"
+            error_msg += "2. 다른 모델을 시도해보세요\n"
+            error_msg += "3. 추천 모델: 'gpt2', 'microsoft/DialoGPT-medium', 'klue/bert-base'\n"
+        elif "Tokenizer class" in error_str:
+            error_msg += "🔧 토크나이저 클래스 문제:\n"
+            error_msg += "1. 이 모델은 최신 transformers 라이브러리가 필요할 수 있습니다\n"
+            error_msg += "2. 다른 모델을 시도해보세요\n"
         else:
             error_msg += "🔧 가능한 해결 방법:\n"
             error_msg += "1. 모델명을 확인해주세요\n"
             error_msg += "2. 네트워크 연결을 확인해주세요\n"
-            error_msg += "3. 필요시 허깅페이스 토큰을 입력해주세요\n"
+            error_msg += "3. 다른 모델을 시도해보세요\n"
         
         return error_msg
 
@@ -60,22 +138,55 @@ def check_model_access(model_name, hf_token=None):
         if not model_name:
             return "모델명을 입력해주세요."
         
-        from transformers import AutoTokenizer
-        
-        tokenizer_kwargs = {"trust_remote_code": True}
         if hf_token and hf_token.strip():
-            tokenizer_kwargs["token"] = hf_token.strip()
+            token = hf_token.strip()
+            if not validate_token(token):
+                return "❌ 토큰 형식이 올바르지 않습니다. 허깅페이스 토큰은 'hf_'로 시작해야 합니다."
+        
+        # 안전한 토크나이저 로딩
+        tokenizer, error = safe_tokenizer_load(model_name, hf_token)
+        if tokenizer is None:
+            raise error
+        
+        # 토크나이저 정보 표시
+        vocab_size = getattr(tokenizer, 'vocab_size', "알 수 없음")
+        model_max_length = getattr(tokenizer, 'model_max_length', "알 수 없음")
+        
+        result = f"✅ {model_name} 모델 접근 가능합니다!\n\n"
+        result += f"토크나이저 정보:\n"
+        result += f"- 어휘 크기: {vocab_size}\n"
+        result += f"- 최대 길이: {model_max_length}\n"
+        result += f"- 토크나이저 타입: {type(tokenizer).__name__}\n"
         
-        tokenizer = AutoTokenizer.from_pretrained(model_name, **tokenizer_kwargs)
-        return f"✅ {model_name} 모델 접근 가능합니다!"
+        # 특수 토큰 정보
+        special_tokens = []
+        if hasattr(tokenizer, 'pad_token') and tokenizer.pad_token:
+            special_tokens.append(f"PAD: {tokenizer.pad_token}")
+        if hasattr(tokenizer, 'eos_token') and tokenizer.eos_token:
+            special_tokens.append(f"EOS: {tokenizer.eos_token}")
+        if hasattr(tokenizer, 'bos_token') and tokenizer.bos_token:
+            special_tokens.append(f"BOS: {tokenizer.bos_token}")
+        if hasattr(tokenizer, 'unk_token') and tokenizer.unk_token:
+            special_tokens.append(f"UNK: {tokenizer.unk_token}")
+        
+        if special_tokens:
+            result += f"- 특수 토큰: {', '.join(special_tokens)}"
+        
+        return result
         
     except Exception as e:
-        if "gated repo" in str(e):
-            return f"🔐 {model_name}은 접근 권한이 필요한 모델입니다. 토큰을 입력해주세요."
-        elif "does not exist" in str(e):
+        error_str = str(e)
+        
+        if "401" in error_str and "Unauthorized" in error_str:
+            return f"🔐 {model_name}: 인증 오류입니다. 토큰을 확인하거나 모델 접근 권한을 요청하세요."
+        elif "gated repo" in error_str:
+            return f"🔐 {model_name}은 접근 권한이 필요한 모델입니다."
+        elif "does not exist" in error_str:
             return f"❌ {model_name} 모델을 찾을 수 없습니다."
+        elif "data did not match any variant" in error_str:
+            return f"⚠️ {model_name} 모델은 현재 지원되지 않는 형식입니다."
         else:
-            return f"❌ 오류: {str(e)}"
+            return f"❌ 오류: {error_str}"
 
 # Gradio 인터페이스 생성
 def create_interface():
@@ -100,7 +211,8 @@ def create_interface():
                 text_input = gr.Textbox(
                     label="텍스트",
                     placeholder="토큰 수를 계산할 텍스트를 입력하세요...",
-                    lines=5
+                    lines=5,
+                    value="안녕하세요! 이것은 테스트 텍스트입니다."
                 )
                 
                 with gr.Row():
@@ -110,57 +222,63 @@ def create_interface():
             with gr.Column():
                 output = gr.Textbox(
                     label="결과",
-                    lines=10,
+                    lines=15,
                     show_copy_button=True
                 )
         
         # 모델 카테고리별 예시
         with gr.Tabs():
-            with gr.TabItem("공개 모델 (토큰 불필요)"):
-                gr.Markdown("### 자유롭게 사용 가능한 모델들:")
+            with gr.TabItem("✅ 안정적인 모델"):
+                gr.Markdown("### 확실히 작동하는 모델들:")
                 with gr.Row():
-                    public_models = [
+                    stable_models = [
                         "klue/bert-base",
                         "beomi/KcELECTRA-base", 
                         "gpt2",
-                        "microsoft/DialoGPT-medium"
+                        "microsoft/DialoGPT-medium",
+                        "distilbert-base-uncased",
+                        "t5-small"
                     ]
                     
-                    for model in public_models:
+                    for model in stable_models:
                         btn = gr.Button(model, size="sm")
                         btn.click(lambda x=model: x, outputs=model_input)
             
-            with gr.TabItem("제한된 모델 (토큰 필요)"):
-                gr.Markdown("### 접근 권한이 필요한 모델들:")
-                gr.Markdown("⚠️ 이 모델들은 허깅페이스 토큰이 필요합니다")
+            with gr.TabItem("⚠️ 문제가 있을 수 있는 모델"):
+                gr.Markdown("### 지원되지 않거나 문제가 있을 수 있는 모델들:")
+                gr.Markdown("이 모델들은 현재 버전에서 작동하지 않을 수 있습니다.")
                 with gr.Row():
-                    gated_models = [
+                    problematic_models = [
+                        "google/gemma-3-12b-it",
                         "meta-llama/Llama-2-7b-hf",
-                        "google/gemma-7b",
                         "mistralai/Mistral-7B-v0.1"
                     ]
                     
-                    for model in gated_models:
+                    for model in problematic_models:
                         btn = gr.Button(model, size="sm")
                         btn.click(lambda x=model: x, outputs=model_input)
         
-        # 토큰 가이드
-        with gr.Accordion("🔑 허깅페이스 토큰 가이드", open=False):
+        # 사용법 가이드
+        with gr.Accordion("📖 사용법 가이드", open=False):
             gr.Markdown("""
+            ### 기본 사용법:
+            1. **모델명 입력**: 허깅페이스 모델명 (예: klue/bert-base)
+            2. **텍스트 입력**: 토큰 수를 계산할 텍스트
+            3. **계산 버튼 클릭**: 결과 확인
+            
             ### 토큰이 필요한 경우:
-            1. **Gated 모델**: Meta Llama, Google Gemma 등
-            2. **비공개 모델**: 개인이나 조직의 private 모델
+            - Gated 모델 (Meta Llama, Google Gemma 등)
+            - 비공개 모델
             
-            ### 토큰 생성 방법:
-            1. [허깅페이스 토큰 페이지](https://huggingface.co/settings/tokens) 접속
-            2. "New token" 클릭
-            3. "Read" 권한으로 토큰 생성
-            4. 생성된 토큰을 위의 "허깅페이스 토큰" 필드에 입력
+            ### 토큰 생성:
+            1. [허깅페이스 토큰 페이지](https://huggingface.co/settings/tokens) 방문
+            2. "New token" 생성 (Read 권한)
+            3. 토큰을 위의 필드에 입력
             
-            ### 모델 접근 권한 요청:
-            1. 사용하려는 모델 페이지 방문
-            2. "Request access" 버튼 클릭
-            3. 승인 후 토큰과 함께 ���용
+            ### 문제 해결:
+            - 모델이 지원되지 않는 경우 다른 모델 시도
+            - 네트워크 문제 시 잠시 후 재시도
+            - 안정적인 모델 탭의 모델들 사용 권장
             """)
         
         # 이벤트 핸들러
@@ -176,7 +294,6 @@ def create_interface():
             outputs=output
         )
         
-        # 엔터키로도 실행 가능하게
         text_input.submit(
             count_tokens,
             inputs=[model_input, text_input, token_input],