Update app.py

app.py

@@ -1,304 +1,91 @@
 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
+from transformers import AutoTokenizer
 
 def count_tokens(model_name, text, hf_token=None):
-    """토큰 수를 계산하는 함수"""
+    """토큰 수 계산"""
     try:
         if not model_name or not text:
             return "모델명과 텍스트를 모두 입력해주세요."
         
-        # 토큰 검증
-        if hf_token and 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
-        
-        # 패딩 토큰이 없는 경우 추가
-        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:
-            tokens = tokenizer.encode(text, add_special_tokens=True)
-        except:
-            # 더 안전한 방법으로 시도
-            tokens = tokenizer.encode(text, add_special_tokens=False)
+        # 토크나이저 로드
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name, 
+            token=hf_token.strip() if hf_token and hf_token.strip() else None
+        )
         
+        # 토큰 인코딩
+        tokens = tokenizer.encode(text)
         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"✅ 토큰 수: {token_count}\n"
         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개만 표시)"
+        result += f"텍스트 길이: {len(text)} 글자"
         
         return result
         
     except Exception as e:
-        error_str = str(e)
-        error_msg = f"❌ 오류 발생: {error_str}\n\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"
-        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"
-        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"
-        
-        return error_msg
+        return f"❌ 오류: {str(e)}"
 
-def check_model_access(model_name, hf_token=None):
-    """모델 접근 가능 여부 확인"""
+def check_model(model_name, hf_token=None):
+    """모델 접근 확인"""
     try:
         if not model_name:
             return "모델명을 입력해주세요."
         
-        if hf_token and 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"
-        
-        # 특수 토큰 정보
-        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)}"
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            token=hf_token.strip() if hf_token and hf_token.strip() else None
+        )
         
-        return result
+        return f"✅ {model_name} 모델 접근 가능!"
         
     except Exception as 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"❌ 오류: {error_str}"
+        return f"❌ 오류: {str(e)}"
 
-# Gradio 인터페이스 생성
+# Gradio 인터페이스
 def create_interface():
-    with gr.Blocks(title="토큰 계산기", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# 🔢 허깅페이스 모델 토큰 계산기")
-        gr.Markdown("허깅페이스에 올라온 모델의 토크나이저를 사용해 텍스트의 토큰 수를 계산합니다.")
+    with gr.Blocks(title="토큰 계산기") as demo:
+        gr.Markdown("# 🔢 토큰 계산기")
         
         with gr.Row():
             with gr.Column():
                 model_input = gr.Textbox(
                     label="모델명",
-                    placeholder="예: klue/bert-base, beomi/KcELECTRA-base, gpt2",
-                    value="klue/bert-base"
+                    placeholder="예: gpt2, klue/bert-base",
+                    value="gpt2"
                 )
                 
                 token_input = gr.Textbox(
-                    label="허깅페이스 토큰 (선택사항)",
-                    placeholder="gated 모델 사용시 필요 (hf_xxx...)",
+                    label="HF 토큰 (선택사항)",
                     type="password"
                 )
                 
                 text_input = gr.Textbox(
                     label="텍스트",
-                    placeholder="토큰 수를 계산할 텍스트를 입력하세요...",
                     lines=5,
-                    value="안녕하세요! 이것은 테스트 텍스트입니다."
+                    value="안녕하세요! 테스트 텍스트입니다."
                 )
                 
                 with gr.Row():
-                    check_btn = gr.Button("모델 접근 확인", variant="secondary")
-                    calculate_btn = gr.Button("토큰 수 계산", variant="primary")
+                    check_btn = gr.Button("모델 확인")
+                    calc_btn = gr.Button("토큰 계산", variant="primary")
             
             with gr.Column():
-                output = gr.Textbox(
-                    label="결과",
-                    lines=15,
-                    show_copy_button=True
-                )
-        
-        # 모델 카테고리별 예시
-        with gr.Tabs():
-            with gr.TabItem("✅ 안정적인 모델"):
-                gr.Markdown("### 확실히 작동하는 모델들:")
-                with gr.Row():
-                    stable_models = [
-                        "klue/bert-base",
-                        "beomi/KcELECTRA-base", 
-                        "gpt2",
-                        "microsoft/DialoGPT-medium",
-                        "distilbert-base-uncased",
-                        "t5-small"
-                    ]
-                    
-                    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.Row():
-                    problematic_models = [
-                        "google/gemma-3-12b-it",
-                        "meta-llama/Llama-2-7b-hf",
-                        "mistralai/Mistral-7B-v0.1"
-                    ]
-                    
-                    for model in problematic_models:
-                        btn = gr.Button(model, size="sm")
-                        btn.click(lambda x=model: x, outputs=model_input)
+                output = gr.Textbox(label="결과", lines=10)
         
-        # 사용법 가이드
-        with gr.Accordion("📖 사용법 가이드", open=False):
-            gr.Markdown("""
-            ### 기본 사용법:
-            1. **모델명 입력**: 허깅페이스 모델명 (예: klue/bert-base)
-            2. **텍스트 입력**: 토큰 수를 계산할 텍스트
-            3. **계산 버튼 클릭**: 결과 확인
-            
-            ### 토큰이 필요한 경우:
-            - Gated 모델 (Meta Llama, Google Gemma 등)
-            - 비공개 모델
-            
-            ### 토큰 생성:
-            1. [허깅페이스 토큰 페이지](https://huggingface.co/settings/tokens) 방문
-            2. "New token" 생성 (Read 권한)
-            3. 토큰을 위의 필드에 입력
-            
-            ### 문제 해결:
-            - 모델이 지원되지 않는 경우 다른 모델 시도
-            - 네트워크 문제 시 잠시 후 재시도
-            - 안정적인 모델 탭의 모델들 사용 권장
-            """)
+        # 추천 모델
+        gr.Markdown("### 추천 모델")
+        with gr.Row():
+            models = ["gpt2", "klue/bert-base", "microsoft/DialoGPT-medium"]
+            for model in models:
+                btn = gr.Button(model, size="sm")
+                btn.click(lambda x=model: x, outputs=model_input)
         
         # 이벤트 핸들러
-        check_btn.click(
-            check_model_access,
-            inputs=[model_input, token_input],
-            outputs=output
-        )
-        
-        calculate_btn.click(
-            count_tokens,
-            inputs=[model_input, text_input, token_input],
-            outputs=output
-        )
-        
-        text_input.submit(
-            count_tokens,
-            inputs=[model_input, text_input, token_input],
-            outputs=output
-        )
+        check_btn.click(check_model, [model_input, token_input], output)
+        calc_btn.click(count_tokens, [model_input, text_input, token_input], output)
+        text_input.submit(count_tokens, [model_input, text_input, token_input], output)
     
     return demo