Initial commit: demo generator 구현

README.md

@@ -1,14 +1,215 @@
 ---
 title: Demo Generator
-emoji: 🌍
-colorFrom: purple
-colorTo: indigo
+emoji: 🎮
+colorFrom: blue
+colorTo: purple
 sdk: gradio
 sdk_version: 5.31.0
 app_file: app.py
 pinned: false
-license: apache-2.0
-short_description: Auto-generate Gradio demos from HF model names
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🎮 Hugging Face Demo Generator
+
+모델명만 입력하면 바로 작동하는 Gradio 데모 Space를 자동으로 생성해주는 도구입니다.
+
+## ✨ 주요 기능
+
+### 🔍 스마트 모델 분석
+- Hugging Face Hub 모델 자동 분석
+- 태스크 타입 및 호환성 자동 감지
+- 지원 가능 여부 즉시 판별
+- 모델 메타데이터 자동 추출
+
+### 🎨 태스크별 최적화된 UI 생성
+- **텍스트 분류**: 결과 시각화 + 예시 버튼
+- **질의응답**: 컨텍스트/질문 분리 인터페이스
+- **텍스트 생성**: 창의성 제어 슬라이더
+- **요약**: 압축률 통계 포함
+- **번역**: 깔끔한 입출력 UI
+- **빈칸 채우기**: [MASK] 예시 제공
+- **개체명 인식**: 위치 정보 포함 결과
+
+### 📦 완전한 배포 패키지
+- `app.py`: 완전 작동하는 Gradio 앱
+- `requirements.txt`: 필요 라이브러리 목록
+- `README.md`: Space 설정 및 문서
+- ZIP 다운로드로 즉시 배포 가능
+
+## 🚀 사용법
+
+### 1️⃣ 모델 분석
+원하는 허깅페이스 모델명을 입력하세요:
+
+**예시 모델들:**
+- `klue/bert-base` (한국어 텍스트 분류)
+- `klue/roberta-large-ynat` (한국어 주제분류)
+- `microsoft/DialoGPT-medium` (대화 생성)
+- `facebook/bart-large-cnn` (요약)
+- `Helsinki-NLP/opus-mt-ko-en` (한영 번역)
+
+### 2️⃣ 데모 설정
+- **제목**: Space에서 보여질 데모 이름
+- **설명**: 데모의 용도와 기능 설명
+
+### 3️⃣ 코드 생성 및 다운로드
+1. **"데모 생성"** 버튼으로 코드 미리보기
+2. **"완전한 패키지 생성"** 버튼으로 ZIP 파일 생성
+3. 다운로드 후 바로 새 Space에 업로드
+
+## 🎯 지원하는 AI 태스크
+
+### 텍스트 분류 (Text Classification)
+감정분석, 주제분류, 스팸 탐지 등의 분류 태스크를 위한 인터페이스
+
+**생성되는 기능:**
+- 텍스트 입력창
+- 분류 결과 시각화
+- 신뢰도 표시
+- 예시 텍스트 버튼
+
+### 질의응답 (Question Answering)
+문서 기반 질의응답 시스템을 위한 인터페이스
+
+**생성되는 기능:**
+- 컨텍스트 입력창
+- 질문 입력창
+- 답변 추출 및 신뢰도 표시
+- 답변 위치 정보
+
+### 텍스트 생성 (Text Generation)
+언어모델을 이용한 텍스트 생성 인터페이스
+
+**생성되는 기능:**
+- 프롬프트 입력창
+- 생성 설정 (길이, 창의성, 다양성)
+- 실시간 텍스트 생성
+- 설정값 표시
+
+### 요약 (Summarization)
+긴 텍스트를 요약하는 인터페이스
+
+**생성되는 기능:**
+- 긴 텍스트 입력창
+- 요약 길이 설정
+- 요약 결과 표시
+- 압축률 통계
+
+### 번역 (Translation)
+언어 간 번역을 위한 인터페이스
+
+**생성되는 기능:**
+- 원문 입력창
+- 번역 결과 표시
+- 문자 수 비교
+- 간단명료한 UI
+
+### 빈칸 채우기 (Fill Mask)
+BERT 스타일 마스크 예측 인터페이스
+
+**생성되는 기능:**
+- [MASK] 토큰 입력창
+- 다중 후보 예측 결과
+- 신뢰도별 순위 표시
+- 예시 문장 제공
+
+### 개체명 인식 (Named Entity Recognition)
+텍스트에서 개체를 인식하는 인터페이스
+
+**생성되는 기능:**
+- 텍스트 입력창
+- 인식된 개체 리스트
+- 개체 유형 및 위치 정보
+- 신뢰도 표시
+
+## 💡 사용 사례
+
+### AI 연구자
+- 논문 발표용 라이브 데모 준비
+- 모델 성능 시연 및 검증
+- 연구 결과 시각적 공유
+
+### 개발자
+- 클라이언트 데모 제작
+- 프로토타입 빠른 검증
+- API 테스트 인터페이스
+
+### 교육자 & 학생
+- 수업용 인터랙티브 도구
+- AI 모델 학습 자료
+- 과제 결과 시연
+
+### 기업
+- 내부 모델 검증 도구
+- stakeholder 프레젠테이션
+- POC (Proof of Concept) 제작
+
+## 🔗 완벽한 AI 개발 워크플로우
+
+이 도구는 다른 도구들과 연계하여 완전한 개발 경험을 제공합니다:
+
+### 1️⃣ 모델 검색
+**[Model Search Tool](https://huggingface.co/spaces/your-username/model-search-tool)**에서 최적의 사전 훈련 모델 탐색
+
+### 2️⃣ 데이터 준비
+**[Dataset Converter](https://huggingface.co/spaces/your-username/dataset-converter)**로 학습 데이터 허깅페이스 포맷 변환
+
+### 3️⃣ 데모 생성
+**Demo Generator**로 모델 시연용 인터랙티브 데모 자동 생성 ← *현재 도구*
+
+### 4️⃣ 문서화
+**[Model Card Generator](https://huggingface.co/spaces/your-username/model-card-generator)**로 전문적인 모델 문서 작성
+
+## 🛠️ 기술적 특징
+
+### 자동 코드 생성
+- 태스크별 최적화된 Gradio 인터페이스
+- 에러 처리 및 사용자 가이드 포함
+- 최신 transformers 라이브러리 활용
+- 반응형 UI 및 예쁜 디자인
+
+### 배포 최적화
+- 허깅페이스 Space 표준 준수
+- 자동 requirements.txt 생성
+- 완전한 README.md 템플릿
+- 한 번의 다운로드로 배포 준비 완료
+
+### 확장성
+- 새로운 태스크 쉽게 추가 가능
+- 커스터마이징 가능한 템플릿
+- 모델 호환성 자동 체크
+
+## 📊 생성 예시
+
+### 입력
+```
+모델명: klue/bert-base
+제목: Korean BERT Demo
+설명: 한국어 텍스트 분류를 위한 BERT 모델
+```
+
+### 출력
+- 완전히 작동하는 Gradio 앱
+- 예시 텍스트 버튼 포함
+- 한국어 최적화 인터페이스
+- 바로 배포 가능한 패키지
+
+## 🎨 UI/UX 최적화
+
+- **직관적 인터페이스**: 비전문가도 쉽게 사용
+- **실시간 피드백**: 즉시 결과 확인 가능
+- **모바일 호환**: 반응형 디자인
+- **접근성**: 명확한 라벨 및 설명
+
+## 🔒 안정성 & 호환성
+
+- **에러 처리**: 강건한 예외 처리
+- **모델 호환성**: 자동 검증 시스템
+- **버전 관리**: 최신 라이브러리 지원
+- **보안**: 안전한 모델 로딩
+
+---
+
+Made with ❤️ for the AI community
+
+*"복잡한 AI 모델을 누구나 쉽게 체험할 수 있는 세상을 만들어갑니다"*

app.py

@@ -0,0 +1,914 @@
+import gradio as gr
+from huggingface_hub import HfApi, model_info
+import tempfile
+import zipfile
+import os
+from datetime import datetime
+
+api = HfApi()
+
+def analyze_model(model_name):
+    """허깅페이스 모델 분석"""
+    if not model_name:
+        return "모델명을 입력해주세요.", None, None
+    
+    try:
+        # 모델 정보 가져오기
+        info = model_info(model_name)
+        
+        # 파이프라인 태스크 확인
+        pipeline_tag = getattr(info, 'pipeline_tag', None)
+        
+        # 모델 타입 분석
+        model_type = "unknown"
+        if hasattr(info, 'config') and info.config:
+            model_type = info.config.get('model_type', 'unknown')
+        
+        # 라이브러리 확인
+        library = getattr(info, 'library_name', 'transformers')
+        
+        # 언어 확인
+        languages = getattr(info, 'language', ['en'])
+        if isinstance(languages, str):
+            languages = [languages]
+        
+        analysis_result = f"""
+## 🔍 모델 분석 결과
+
+### 기본 정보
+- **모델명**: {model_name}
+- **태스크**: {pipeline_tag or 'Unknown'}
+- **모델 타입**: {model_type}
+- **라이브러리**: {library}
+- **언어**: {', '.join(languages[:3])}
+- **다운로드**: {getattr(info, 'downloads', 0):,}회
+
+### 데모 생성 가능 여부
+"""
+        
+        # 지원 가능한 태스크인지 확인
+        supported_tasks = {
+            'text-classification': '✅ 텍스트 분류 데모 생성 가능',
+            'question-answering': '✅ 질의응답 데모 생성 가능', 
+            'text-generation': '✅ 텍스트 생성 데모 생성 가능',
+            'summarization': '✅ 요약 데모 생성 가능',
+            'translation': '✅ 번역 데모 생성 가능',
+            'fill-mask': '✅ 빈칸 채우기 데모 생성 가능',
+            'token-classification': '✅ 개체명 인식 데모 생성 가능'
+        }
+        
+        if pipeline_tag in supported_tasks:
+            analysis_result += supported_tasks[pipeline_tag]
+            demo_possible = True
+        else:
+            analysis_result += f"⚠️ '{pipeline_tag}' 태스크는 아직 지원되지 않습니다."
+            demo_possible = False
+            
+        return analysis_result, info, demo_possible
+        
+    except Exception as e:
+        return f"❌ 모델 분석 실패: {str(e)}\n\n모델명이 정확한지 확인해주세요.", None, False
+
+def generate_demo_code(model_info, model_name, demo_title, demo_description):
+    """태스크별 데모 코드 생성"""
+    
+    if not model_info:
+        return "먼저 모델을 분석해주세요.", None
+    
+    pipeline_tag = getattr(model_info, 'pipeline_tag', None)
+    
+    if not demo_title:
+        demo_title = f"{model_name.split('/')[-1]} Demo"
+    if not demo_description:
+        demo_description = f"Demo for {model_name}"
+    
+    # 태스크별 코드 생성
+    if pipeline_tag == 'text-classification':
+        app_code = generate_text_classification_demo(model_name, demo_title, demo_description)
+    elif pipeline_tag == 'question-answering':
+        app_code = generate_qa_demo(model_name, demo_title, demo_description)
+    elif pipeline_tag == 'text-generation':
+        app_code = generate_text_generation_demo(model_name, demo_title, demo_description)
+    elif pipeline_tag == 'summarization':
+        app_code = generate_summarization_demo(model_name, demo_title, demo_description)
+    elif pipeline_tag == 'translation':
+        app_code = generate_translation_demo(model_name, demo_title, demo_description)
+    elif pipeline_tag == 'fill-mask':
+        app_code = generate_fill_mask_demo(model_name, demo_title, demo_description)
+    elif pipeline_tag == 'token-classification':
+        app_code = generate_token_classification_demo(model_name, demo_title, demo_description)
+    else:
+        return f"❌ '{pipeline_tag}' 태스크는 아직 지원되지 않습니다.", None
+    
+    return app_code, pipeline_tag
+
+def generate_text_classification_demo(model_name, title, description):
+    """텍스트 분류 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드
+classifier = pipeline("text-classification", model="{model_name}")
+
+def classify_text(text):
+    """텍스트 분류 수행"""
+    if not text.strip():
+        return "텍스트를 입력해주세요."
+    
+    try:
+        results = classifier(text)
+        
+        # 결과 포맷팅
+        output = "## 🎯 분류 결과\\n\\n"
+        for i, result in enumerate(results):
+            label = result['label']
+            score = result['score']
+            confidence = f"{score:.1%}"
+            
+            output += f"**{i+1}. {label}**: {confidence}\\n"
+        
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            text_input = gr.Textbox(
+                label="분석할 텍스트",
+                placeholder="여기에 텍스트를 입력하세요...",
+                lines=5
+            )
+            classify_btn = gr.Button("🎯 분류하기", variant="primary")
+            
+            # 예시 버튼들
+            gr.Markdown("### 📝 예시 텍스트")
+            examples = [
+                ["이 영화 정말 재미있어요! 강력 추천합니다."],
+                ["서비스가 너무 별로네요. 실망스럽습니다."],
+                ["그냥 평범한 제품인 것 같아요."]
+            ]
+            
+            example_btns = []
+            for example in examples:
+                btn = gr.Button(example[0][:30] + "...", size="sm")
+                btn.click(lambda x=example[0]: x, outputs=text_input)
+        
+        with gr.Column(scale=1):
+            output = gr.Markdown("텍스트를 입력하고 분류 버튼을 클릭하세요.")
+    
+    classify_btn.click(
+        fn=classify_text,
+        inputs=text_input,
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 텍스트 분류
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def generate_qa_demo(model_name, title, description):
+    """질의응답 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드
+qa_pipeline = pipeline("question-answering", model="{model_name}")
+
+def answer_question(context, question):
+    """질의응답 수행"""
+    if not context.strip() or not question.strip():
+        return "컨텍스트와 질문을 모두 입력해주세요."
+    
+    try:
+        result = qa_pipeline(question=question, context=context)
+        
+        answer = result['answer']
+        score = result['score']
+        confidence = f"{score:.1%}"
+        
+        output = f"""
+## 💡 답변 결과
+
+**답변**: {answer}
+
+**신뢰도**: {confidence}
+
+**시작 위치**: {result.get('start', 'N/A')}
+**끝 위치**: {result.get('end', 'N/A')}
+"""
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column():
+            context_input = gr.Textbox(
+                label="📄 컨텍스트 (배경 정보)",
+                placeholder="답변의 근거가 될 텍스트를 입력하세요...",
+                lines=8
+            )
+            question_input = gr.Textbox(
+                label="❓ 질문",
+                placeholder="질문을 입력하세요...",
+                lines=2
+            )
+            qa_btn = gr.Button("💡 답변 찾기", variant="primary")
+        
+        with gr.Column():
+            output = gr.Markdown("컨텍스트와 질문을 입력하고 버튼을 클릭하세요.")
+    
+    qa_btn.click(
+        fn=answer_question,
+        inputs=[context_input, question_input],
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 질의응답
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def generate_text_generation_demo(model_name, title, description):
+    """텍스트 생성 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드
+generator = pipeline("text-generation", model="{model_name}")
+
+def generate_text(prompt, max_length, temperature, top_p):
+    """텍스트 생성 수행"""
+    if not prompt.strip():
+        return "프롬프트를 입력해주세요."
+    
+    try:
+        results = generator(
+            prompt,
+            max_length=max_length,
+            temperature=temperature,
+            top_p=top_p,
+            num_return_sequences=1,
+            do_sample=True,
+            pad_token_id=generator.tokenizer.eos_token_id
+        )
+        
+        generated_text = results[0]['generated_text']
+        
+        # 원본 프롬프트 제거하고 생성된 부분만 표시
+        if generated_text.startswith(prompt):
+            generated_text = generated_text[len(prompt):]
+        
+        output = f"""
+## ✨ 생성된 텍스트
+
+**입력**: {prompt}
+
+**생성 결과**:
+{generated_text}
+
+---
+*설정: 최대 길이={max_length}, 온도={temperature}, Top-p={top_p}*
+"""
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            prompt_input = gr.Textbox(
+                label="✍️ 프롬프트",
+                placeholder="텍스트 생성을 시작할 문장을 입력하세요...",
+                lines=4
+            )
+            
+            gr.Markdown("### ⚙️ 생성 설정")
+            max_length = gr.Slider(
+                label="최대 길이",
+                minimum=10,
+                maximum=200,
+                value=50,
+                step=10
+            )
+            temperature = gr.Slider(
+                label="Temperature (창의성)",
+                minimum=0.1,
+                maximum=2.0,
+                value=0.7,
+                step=0.1
+            )
+            top_p = gr.Slider(
+                label="Top-p (다양성)",
+                minimum=0.1,
+                maximum=1.0,
+                value=0.9,
+                step=0.1
+            )
+            
+            generate_btn = gr.Button("✨ 텍스트 생성", variant="primary")
+        
+        with gr.Column(scale=2):
+            output = gr.Markdown("프롬프트를 입력하고 생성 버튼을 클릭하세요.")
+    
+    generate_btn.click(
+        fn=generate_text,
+        inputs=[prompt_input, max_length, temperature, top_p],
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 텍스트 생성
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def generate_summarization_demo(model_name, title, description):
+    """요약 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드
+summarizer = pipeline("summarization", model="{model_name}")
+
+def summarize_text(text, max_length, min_length):
+    """텍스트 요약 수행"""
+    if not text.strip():
+        return "요약할 텍스트를 입력해주세요."
+    
+    if len(text.split()) < 10:
+        return "요약하기에는 텍스트가 너무 짧습니다. 더 긴 텍스트를 입력해주세요."
+    
+    try:
+        results = summarizer(
+            text,
+            max_length=max_length,
+            min_length=min_length,
+            do_sample=False
+        )
+        
+        summary = results[0]['summary_text']
+        
+        # 통계 계산
+        original_words = len(text.split())
+        summary_words = len(summary.split())
+        compression_ratio = (1 - summary_words / original_words) * 100
+        
+        output = f"""
+## 📝 요약 결과
+
+**요약문**:
+{summary}
+
+---
+
+### 📊 통계
+- **원문 단어 수**: {original_words:,}개
+- **요약문 단어 수**: {summary_words:,}개  
+- **압축률**: {compression_ratio:.1f}%
+"""
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            text_input = gr.Textbox(
+                label="📄 요약할 텍스트",
+                placeholder="긴 텍스트를 입력하세요...",
+                lines=10
+            )
+            
+            gr.Markdown("### ⚙️ 요약 설정")
+            max_length = gr.Slider(
+                label="최대 요약 길이",
+                minimum=20,
+                maximum=150,
+                value=50,
+                step=10
+            )
+            min_length = gr.Slider(
+                label="최소 요약 길이", 
+                minimum=5,
+                maximum=50,
+                value=10,
+                step=5
+            )
+            
+            summarize_btn = gr.Button("📝 요약하기", variant="primary")
+        
+        with gr.Column(scale=1):
+            output = gr.Markdown("텍스트를 입력하고 요약 버튼을 클릭하세요.")
+    
+    summarize_btn.click(
+        fn=summarize_text,
+        inputs=[text_input, max_length, min_length],
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 텍스트 요약
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def generate_translation_demo(model_name, title, description):
+    """번역 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드
+translator = pipeline("translation", model="{model_name}")
+
+def translate_text(text):
+    """번역 수행"""
+    if not text.strip():
+        return "번역할 텍스트를 입력해주세요."
+    
+    try:
+        results = translator(text)
+        translated = results[0]['translation_text']
+        
+        output = f"""
+## 🌍 번역 결과
+
+**원문**: {text}
+
+**번역문**: {translated}
+
+---
+*문자 수: {len(text)} → {len(translated)}*
+"""
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="🌍 번역할 텍스트",
+                placeholder="번역할 텍스트를 입력하세요...",
+                lines=6
+            )
+            translate_btn = gr.Button("🌍 번역하기", variant="primary")
+        
+        with gr.Column():
+            output = gr.Markdown("텍스트를 입력하고 번역 버튼을 클릭하세요.")
+    
+    translate_btn.click(
+        fn=translate_text,
+        inputs=text_input,
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 번역
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def generate_fill_mask_demo(model_name, title, description):
+    """빈칸 채우기 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드  
+fill_mask = pipeline("fill-mask", model="{model_name}")
+
+def predict_mask(text):
+    """마스크 예측 수행"""
+    if not text.strip():
+        return "텍스트를 입력해주세요."
+    
+    if "[MASK]" not in text:
+        return "텍스트에 [MASK] 토큰을 포함해주세요."
+    
+    try:
+        results = fill_mask(text)
+        
+        output = f"## 🎯 예측 결과\\n\\n**원문**: {text}\\n\\n### 후보들:\\n"
+        
+        for i, result in enumerate(results[:5]):
+            token = result['token_str']
+            score = result['score']
+            sequence = result['sequence']
+            confidence = f"{score:.1%}"
+            
+            output += f"**{i+1}. {token}** ({confidence})\\n"
+            output += f"   *{sequence}*\\n\\n"
+        
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="🎯 [MASK] 예측할 텍스트",
+                placeholder="[MASK] 토큰을 포함한 문장을 입력하세요...",
+                lines=4,
+                value="오늘 날씨가 정말 [MASK]네요."
+            )
+            predict_btn = gr.Button("🎯 예측하기", variant="primary")
+            
+            gr.Markdown("### 📝 예시")
+            examples = [
+                "오늘 날씨가 정말 [MASK]네요.",
+                "이 영화는 [MASK] 재미있어요.",
+                "한국의 수도는 [MASK]입니다."
+            ]
+            
+            for example in examples:
+                btn = gr.Button(example, size="sm")
+                btn.click(lambda x=example: x, outputs=text_input)
+        
+        with gr.Column():
+            output = gr.Markdown("[MASK] 토큰을 포함한 텍스트를 입력하고 예측 버튼을 클릭하세요.")
+    
+    predict_btn.click(
+        fn=predict_mask,
+        inputs=text_input,
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 빈칸 채우기 (Fill Mask)
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def generate_token_classification_demo(model_name, title, description):
+    """개체명 인식 데모 코드 생성"""
+    return f'''import gradio as gr
+from transformers import pipeline
+
+# 모델 로드
+ner_pipeline = pipeline("token-classification", model="{model_name}", aggregation_strategy="simple")
+
+def recognize_entities(text):
+    """개체명 인식 수행"""
+    if not text.strip():
+        return "텍스트를 입력해주세요."
+    
+    try:
+        results = ner_pipeline(text)
+        
+        if not results:
+            return "인식된 개체가 없습니다."
+        
+        output = f"## 🏷️ 개체명 인식 결과\\n\\n**원문**: {text}\\n\\n### 인식된 개체들:\\n"
+        
+        for i, entity in enumerate(results):
+            word = entity['word']
+            label = entity['entity_group']
+            score = entity['score']
+            start = entity['start']
+            end = entity['end']
+            confidence = f"{score:.1%}"
+            
+            output += f"**{i+1}. {word}** → *{label}* ({confidence})\\n"
+            output += f"   위치: {start}-{end}\\n\\n"
+        
+        return output
+    except Exception as e:
+        return f"❌ 오류가 발생했습니다: {{str(e)}}"
+
+# Gradio 인터페이스
+with gr.Blocks(title="{title}", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# {title}")
+    gr.Markdown("{description}")
+    
+    with gr.Row():
+        with gr.Column():
+            text_input = gr.Textbox(
+                label="🏷️ 개체명 인식할 텍스트",
+                placeholder="사람명, 지명, 기관명 등이 포함된 텍스트를 입력하세요...",
+                lines=5,
+                value="삼성전자의 이재용 회장이 서울에서 기자회견을 열었다."
+            )
+            ner_btn = gr.Button("🏷️ 개체명 인식", variant="primary")
+        
+        with gr.Column():
+            output = gr.Markdown("텍스트를 입력하고 인식 버튼을 클릭하세요.")
+    
+    ner_btn.click(
+        fn=recognize_entities,
+        inputs=text_input,
+        outputs=output
+    )
+    
+    gr.Markdown(f"""
+    ### ℹ️ 모델 정보
+    - **모델**: [{model_name}](https://huggingface.co/{model_name})
+    - **태스크**: 개체명 인식 (Named Entity Recognition)
+    - **설명**: {description}
+    """)
+
+if __name__ == "__main__":
+    demo.launch()'''
+
+def create_demo_package(app_code, pipeline_tag, model_name, demo_title, demo_description):
+    """완전한 데모 패키지 생성"""
+    
+    if not app_code:
+        return "먼저 데모 코드를 생성해주세요.", None
+    
+    try:
+        # 임시 디렉토리 생성
+        temp_dir = tempfile.mkdtemp()
+        demo_dir = os.path.join(temp_dir, demo_title.lower().replace(' ', '-'))
+        os.makedirs(demo_dir, exist_ok=True)
+        
+        # 1. app.py 저장
+        with open(os.path.join(demo_dir, "app.py"), 'w', encoding='utf-8') as f:
+            f.write(app_code)
+        
+        # 2. requirements.txt 생성
+        requirements = """gradio
+transformers
+torch
+"""
+        with open(os.path.join(demo_dir, "requirements.txt"), 'w', encoding='utf-8') as f:
+            f.write(requirements)
+        
+        # 3. README.md 생성
+        space_name = demo_title.lower().replace(' ', '-')
+        readme_content = f"""---
+title: {demo_title}
+emoji: 🤖
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 5.31.0
+app_file: app.py
+pinned: false
+models:
+- {model_name}
+---
+
+# {demo_title}
+
+{demo_description}
+
+## 🚀 사용법
+
+이 데모는 [{model_name}](https://huggingface.co/{model_name}) 모델을 사용합니다.
+
+### 태스크: {pipeline_tag}
+
+{get_task_description(pipeline_tag)}
+
+## 🛠️ 로컬 실행
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## 📝 모델 정보
+
+- **모델**: [{model_name}](https://huggingface.co/{model_name})
+- **태스크**: {pipeline_tag}
+- **라이브러리**: transformers
+
+---
+
+*이 데모는 [Demo Generator](https://huggingface.co/spaces/your-username/demo-generator)로 자동 생성되었습니다.*
+"""
+        
+        with open(os.path.join(demo_dir, "README.md"), 'w', encoding='utf-8') as f:
+            f.write(readme_content)
+        
+        # 4. ZIP 파일 생성
+        zip_path = os.path.join(temp_dir, f"{space_name}_demo.zip")
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            for root, dirs, files in os.walk(demo_dir):
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arcname = os.path.relpath(file_path, demo_dir)
+                    zipf.write(file_path, arcname)
+        
+        success_msg = f"""
+## ✅ 데모 생성 완료!
+
+**{demo_title}** 데모가 성공적으로 생성되었습니다!
+
+### 📦 포함된 파일들:
+- `app.py`: 메인 데모 애플리케이션
+- `requirements.txt`: 필요한 라이브러리 목록
+- `README.md`: Space 설명 및 설정
+
+### 🚀 배포 방법:
+1. 아래 ZIP 파일을 다운로드하세요
+2. 허깅페이스에서 새 Space를 생성하세요
+3. 파일들을 업로드하거나 Git으로 push하세요
+4. 자동으로 빌드되고 배포됩니다!
+
+### 🎯 태스크: {pipeline_tag}
+### 🤖 모델: {model_name}
+"""
+        
+        return success_msg, zip_path
+        
+    except Exception as e:
+        return f"❌ 패키지 생성 중 오류가 발생했습니다: {str(e)}", None
+
+def get_task_description(pipeline_tag):
+    """태스크별 설명 반환"""
+    descriptions = {
+        'text-classification': '텍스트를 입력하면 카테고리별로 분류합니다. 감정분석, 주제분류 등에 사용됩니다.',
+        'question-answering': '컨텍스트와 질문을 입력하면 답변을 찾아줍니다.',
+        'text-generation': '주어진 프롬프트를 이어서 텍스트를 생성합니다.',
+        'summarization': '긴 텍스트를 요약해줍니다.',
+        'translation': '텍스트를 다른 언어로 번역합니다.',
+        'fill-mask': '[MASK] 토큰이 포함된 문장에서 빈칸을 채워줍니다.',
+        'token-classification': '텍스트에서 사람명, 지명, 기관명 등의 개체를 인식합니다.'
+    }
+    return descriptions.get(pipeline_tag, '다양한 NLP 태스크를 수행합니다.')
+
+# Gradio 인터페이스
+with gr.Blocks(title="🎮 Demo Generator", theme=gr.themes.Soft()) as demo:
+    
+    # 상태 저장용
+    model_info_state = gr.State()
+    demo_possible_state = gr.State()
+    
+    gr.Markdown("# 🎮 Hugging Face Demo Generator")
+    gr.Markdown("모델명만 입력하면 바로 작동하는 데모 Space를 자동으로 생성해드립니다!")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 🔍 모델 분석")
+            
+            model_name_input = gr.Textbox(
+                label="모델명",
+                placeholder="예: klue/bert-base",
+                info="Hugging Face Hub의 정확한 모델명을 입력하세요"
+            )
+            
+            analyze_btn = gr.Button("🔍 모델 분석", variant="primary")
+            
+            gr.Markdown("### ⚙️ 데모 설정")
+            
+            demo_title = gr.Textbox(
+                label="데모 제목",
+                placeholder="예: Korean BERT Sentiment Demo",
+                value=""
+            )
+            
+            demo_description = gr.Textbox(
+                label="데모 설명",
+                placeholder="예: 한국어 감정 분석을 위한 BERT 모델 데모",
+                lines=3
+            )
+            
+            generate_btn = gr.Button("🎮 데모 생성", variant="secondary")
+            create_package_btn = gr.Button("📦 완전한 패키지 생성", variant="secondary")
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 분석 결과")
+            analysis_output = gr.Markdown("모델명을 입력하고 분석 버튼을 클릭하세요.")
+            
+            gr.Markdown("### 💻 생성된 데모 코드")
+            code_output = gr.Code(language="python", label="app.py")
+            
+            gr.Markdown("### 📦 다운로드")
+            download_file = gr.File(label="완전한 데모 패키지", visible=False)
+    
+    # 이벤트 핸들러
+    def analyze_and_store(model_name):
+        analysis, info, possible = analyze_model(model_name)
+        return analysis, info, possible
+    
+    def generate_and_show_code(info, model_name, title, description):
+        if not info:
+            return "먼저 모델을 분석해주세요."
+        
+        code, task = generate_demo_code(info, model_name, title, description)
+        return code
+    
+    def create_package_and_download(info, model_name, title, description, code):
+        if not info or not code:
+            return "먼저 데모 코드를 생성해주세요.", None
+        
+        pipeline_tag = getattr(info, 'pipeline_tag', 'unknown')
+        result, zip_path = create_demo_package(code, pipeline_tag, model_name, title, description)
+        
+        if zip_path:
+            return result, gr.File(value=zip_path, visible=True)
+        else:
+            return result, None
+    
+    analyze_btn.click(
+        fn=analyze_and_store,
+        inputs=model_name_input,
+        outputs=[analysis_output, model_info_state, demo_possible_state]
+    )
+    
+    generate_btn.click(
+        fn=generate_and_show_code,
+        inputs=[model_info_state, model_name_input, demo_title, demo_description],
+        outputs=code_output
+    )
+    
+    create_package_btn.click(
+        fn=create_package_and_download,
+        inputs=[model_info_state, model_name_input, demo_title, demo_description, code_output],
+        outputs=[analysis_output, download_file]
+    )
+    
+    gr.Markdown("""
+    ### 💡 사용법 가이드
+    
+    #### 1️⃣ 모델 분석
+    - Hugging Face Hub의 정확한 모델명 입력 (예: `klue/bert-base`)
+    - 모델의 태스크와 호환성 자동 확인
+    
+    #### 2️⃣ 데모 설정
+    - **제목**: Space에서 보여질 데모 제목
+    - **설명**: 데모의 용도와 기능 설명
+    
+    #### 3️⃣ 코드 생성
+    - 태스크에 맞는 최적화된 Gradio 인터페이스 자동 생성
+    - 바로 복사해서 사용 가능한 완전한 코드
+    
+    #### 4️⃣ 패키지 다운로드
+    - `app.py`, `requirements.txt`, `README.md` 포함
+    - ZIP 다운로드 후 바로 Space에 업로드 가능
+    
+    ### 🎯 지원하는 태스크
+    
+    - **텍스트 분류**: 감정분석, 주제분류, 언어감지 등
+    - **질의응답**: 문서 기반 QA 시스템
+    - **텍스트 생성**: 언어모델 기반 텍스트 완성
+    - **요약**: 긴 텍스트의 핵심 요약
+    - **번역**: 언어 간 번역
+    - **빈칸 채우기**: BERT 스타일 마스크 예측
+    - **개체명 인식**: 사람명, 지명, 기관명 등 추출
+    
+    ### 🔗 워크플로우 연계
+    
+    이 도구는 다�� 도구들과 완벽하게 연계됩니다:
+    1. **[Model Search Tool](https://huggingface.co/spaces/your-username/model-search-tool)**: 최적 모델 검색
+    2. **[Dataset Converter](https://huggingface.co/spaces/your-username/dataset-converter)**: 데이터 준비
+    3. **Demo Generator**: 데모 생성 ← *현재 도구*
+    4. **[Model Card Generator](https://huggingface.co/spaces/your-username/model-card-generator)**: 문서화
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

equirements.txt

@@ -0,0 +1,4 @@
+gradio
+transformers
+huggingface_hub
+torch