Add working Transformers-based demo

- Replace API-based inference with local Transformers models
- Use DeepSeek R1 7B for on-device inference
- Add CUDA/MPS/CPU auto-detection
- Update requirements.txt with torch and transformers
- Add .gitignore for Python artifacts

🤖 Generated with Claude Code

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.pyo
+*.bak
+*.incomplete
+.DS_Store
+*.log

app.py

@@ -1,302 +1,101 @@
 """
 NullAI - HuggingFace Spaces Gradio App
-Multi-Domain Knowledge Reasoning System
-
-無料でGPU推論を提供するHuggingFace Spacesデプロイ用
 """
 import gradio as gr
-import os
-import json
-from typing import Optional, List, Dict, Any
-import asyncio
-
-# HuggingFace Inference API使用（無料枠あり）
-from huggingface_hub import InferenceClient
-
-# 環境変数からトークン取得（オプション）
-HF_TOKEN = os.getenv("HF_TOKEN", None)
-
-# 推論クライアント
-client = InferenceClient(token=HF_TOKEN) if HF_TOKEN else InferenceClient()
-
-# ドメイン定義
-DOMAINS = {
-    "medical": {"name": "Medical", "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "icon": "🏥"},
-    "legal": {"name": "Legal", "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "icon": "⚖️"},
-    "economics": {"name": "Economics", "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "icon": "📊"},
-    "programming": {"name": "Programming", "model": "Qwen/Qwen2.5-Coder-7B-Instruct", "icon": "💻"},
-    "science": {"name": "Science", "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B", "icon": "🔬"},
-    "general": {"name": "General", "model": "mistralai/Mistral-7B-Instruct-v0.3", "icon": "🌐"},
-}
-
-# 利用可能なモデル
-MODELS = {
-    "DeepSeek R1 7B": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
-    "Qwen2.5 Coder 7B": "Qwen/Qwen2.5-Coder-7B-Instruct",
-    "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
-    "Llama 3.1 8B": "meta-llama/Llama-3.1-8B-Instruct",
-    "Gemma 2 9B": "google/gemma-2-9b-it",
-}
-
-# 検証マークの状態管理（デモ用）
-verification_store = {}
-
-
-def get_system_prompt(domain: str) -> str:
-    """ドメイン固有のシステムプロンプトを生成"""
-    prompts = {
-        "medical": """You are an expert medical knowledge assistant. Provide accurate, evidence-based medical information.
-Always recommend consulting healthcare professionals for personal medical decisions.
-Include relevant citations when possible.""",
-
-        "legal": """You are an expert legal knowledge assistant. Provide accurate legal information based on general legal principles.
-Always recommend consulting licensed attorneys for specific legal advice.
-Clarify which jurisdiction the information applies to.""",
-
-        "economics": """You are an expert economics and finance assistant. Provide accurate economic analysis and financial information.
-Include relevant economic theories and data when applicable.
-Note that this is not financial advice.""",
-
-        "programming": """You are an expert programming assistant. Provide accurate, well-documented code solutions.
-Follow best practices and explain the reasoning behind your solutions.
-Include error handling and edge cases when relevant.""",
-
-        "science": """You are an expert science assistant covering physics, chemistry, biology, and related fields.
-Provide accurate scientific explanations with proper terminology.
-Reference established scientific principles and recent research when applicable.""",
-
-        "general": """You are a helpful knowledge assistant. Provide accurate, well-reasoned answers.
-Be clear about the confidence level of your responses.
-Cite sources when possible."""
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = None
+tokenizer = None
+device = None
+DEFAULT_MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"
+
+def load_model():
+    global model, tokenizer, device
+    if model is not None:
+        return
+    print(f"Loading {DEFAULT_MODEL}...")
+    device = "cuda" if torch.cuda.is_available() else ("mps" if torch.backends.mps.is_available() else "cpu")
+    print(f"Using device: {device}")
+    tokenizer = AutoTokenizer.from_pretrained(DEFAULT_MODEL, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        DEFAULT_MODEL,
+        torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+        device_map="auto" if device == "cuda" else None,
+        trust_remote_code=True
+    )
+    if device != "cuda":
+        model = model.to(device)
+    model.eval()
+    print("Model loaded!")
+
+def get_prompt(domain, question):
+    domains = {
+        "medical": "You are a medical expert. Provide accurate medical information.",
+        "legal": "You are a legal expert. Provide accurate legal information.",
+        "general": "You are a helpful assistant. Provide accurate answers."
     }
-    return prompts.get(domain, prompts["general"])
+    sys_prompt = domains.get(domain, domains["general"])
+    return f"System: {sys_prompt}\n\nUser: {question}\n\nAssistant:"
 
-
-def generate_response(
-    question: str,
-    domain: str,
-    temperature: float = 0.7,
-    max_tokens: int = 1024,
-    is_expert: bool = False,
-    expert_name: str = "",
-    custom_model: str = None
-) -> tuple:
-    """
-    質問に対する回答を生成
-
-    Returns:
-        (response, thinking, confidence, verification_status)
-    """
+def generate(question, domain, temp, max_len, progress=gr.Progress()):
     if not question.strip():
-        return "Please enter a question.", "", 0.0, "none"
-
-    domain_info = DOMAINS.get(domain, DOMAINS["general"])
-    # カスタムモデルが指定されていればそれを使用
-    model_name = MODELS.get(custom_model, domain_info["model"]) if custom_model else domain_info["model"]
-    system_prompt = get_system_prompt(domain)
-
-    # プロンプト構築
-    full_prompt = f"""<|system|>
-{system_prompt}
-</s>
-<|user|>
-{question}
-</s>
-<|assistant|>
-Let me think about this step by step.
-
-"""
-
+        return "Please enter a question.", "Error"
     try:
-        # HuggingFace Inference API呼び出し
-        response = client.text_generation(
-            full_prompt,
-            model=model_name,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-            do_sample=temperature > 0,
-            return_full_text=False
-        )
-
-        # 思考プロセスと回答を分離
-        thinking = ""
-        answer = response
-
-        if "<thinking>" in response and "</thinking>" in response:
-            start = response.find("<thinking>") + len("<thinking>")
-            end = response.find("</thinking>")
-            thinking = response[start:end].strip()
-            answer = response[end + len("</thinking>"):].strip()
-
-        # 信頼度計算（簡易版）
-        confidence = 0.7
-        if len(answer) > 200:
-            confidence += 0.1
-        if "reference" in answer.lower() or "source" in answer.lower():
-            confidence += 0.1
-        confidence = min(confidence, 0.95)
-
-        # 検証ステータス
-        verification = "none"
-        if is_expert and expert_name:
-            verification = "expert"
-            # 検証情報を保存
-            verification_store[hash(question)] = {
-                "expert_name": expert_name,
-                "verified_at": "now",
-                "type": "expert"
-            }
-
-        return answer, thinking, confidence, verification
-
+        progress(0.1, desc="Loading model...")
+        load_model()
+        progress(0.3, desc="Generating...")
+        prompt = get_prompt(domain, question)
+        inputs = tokenizer(prompt, return_tensors="pt").to(device)
+        with torch.no_grad():
+            outputs = model.generate(
+                **inputs,
+                max_new_tokens=max_len,
+                temperature=temp,
+                do_sample=True if temp > 0 else False,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Extract assistant response
+        if "Assistant:" in response:
+            response = response.split("Assistant:")[-1].strip()
+        progress(1.0, desc="Done!")
+        return response, f"✅ Generated ({len(outputs[0])} tokens)"
     except Exception as e:
-        return f"Error: {str(e)}", "", 0.0, "error"
-
-
-def format_verification_badge(status: str, expert_name: str = "") -> str:
-    """検証バッジのHTML生成"""
-    badges = {
-        "expert": f'<span style="background:#4caf50;color:white;padding:2px 8px;border-radius:12px;font-size:12px;">✓ Expert Verified by {expert_name}</span>',
-        "community": '<span style="background:#2196f3;color:white;padding:2px 8px;border-radius:12px;font-size:12px;">👥 Community Reviewed</span>',
-        "none": '<span style="background:#9e9e9e;color:white;padding:2px 8px;border-radius:12px;font-size:12px;">⚠ Unverified</span>',
-        "error": '<span style="background:#f44336;color:white;padding:2px 8px;border-radius:12px;font-size:12px;">❌ Error</span>'
-    }
-    return badges.get(status, badges["none"])
-
-
-# Gradio Interface
-with gr.Blocks(
-    title="NullAI - Multi-Domain Knowledge System",
-    theme=gr.themes.Soft(),
-    css="""
-    .container { max-width: 900px; margin: auto; }
-    .badge { display: inline-block; margin: 4px; }
-    """
-) as demo:
-    gr.Markdown("""
-    # 🧠 NullAI
-    ### Multi-Domain Knowledge Reasoning System
-
-    Expert-verified knowledge with transparent verification status.
-    Select a domain and ask your question below.
-    """)
+        return f"Error: {str(e)}", "❌ Error occurred"
 
+with gr.Blocks(title="NullAI Demo") as demo:
+    gr.Markdown("# 🧠 NullAI - Multi-Domain Knowledge Reasoning\n\nPowered by DeepSeek R1")
+    
     with gr.Row():
-        with gr.Column(scale=2):
-            domain_dropdown = gr.Dropdown(
-                choices=[(f"{v['icon']} {v['name']}", k) for k, v in DOMAINS.items()],
-                value="general",
-                label="Domain",
-                info="Select the knowledge domain"
-            )
-
-            question_input = gr.Textbox(
-                label="Your Question",
-                placeholder="Enter your question here...",
-                lines=3
-            )
-
-            with gr.Accordion("Advanced Settings", open=False):
-                model_dropdown = gr.Dropdown(
-                    choices=["Auto (Best for Domain)"] + list(MODELS.keys()),
-                    value="Auto (Best for Domain)",
-                    label="Model Selection",
-                    info="Choose a specific model or use Auto for domain-optimized selection"
-                )
-
-                temperature_slider = gr.Slider(
-                    minimum=0.0,
-                    maximum=1.0,
-                    value=0.7,
-                    step=0.1,
-                    label="Temperature"
-                )
-                max_tokens_slider = gr.Slider(
-                    minimum=256,
-                    maximum=2048,
-                    value=1024,
-                    step=128,
-                    label="Max Tokens"
-                )
-
-            with gr.Accordion("Expert Verification (Optional)", open=False):
-                is_expert_checkbox = gr.Checkbox(
-                    label="I am a verified expert",
-                    value=False
-                )
-                expert_name_input = gr.Textbox(
-                    label="Expert Name / ORCID",
-                    placeholder="e.g., Dr. Smith (0000-0001-2345-6789)"
-                )
-
-            submit_btn = gr.Button("Submit", variant="primary")
-
-        with gr.Column(scale=3):
-            verification_html = gr.HTML(
-                value=format_verification_badge("none"),
-                label="Verification Status"
-            )
-
-            response_output = gr.Textbox(
-                label="Response",
-                lines=10,
-                interactive=False
-            )
-
-            with gr.Accordion("Thinking Process", open=False):
-                thinking_output = gr.Textbox(
-                    label="Model's Reasoning",
-                    lines=5,
-                    interactive=False
-                )
-
-            confidence_output = gr.Number(
-                label="Confidence Score",
-                precision=2
-            )
-
-    # Event handlers
-    def process_question(question, domain, model_choice, temp, max_tok, is_expert, expert_name):
-        # "Auto"が選択された場合はNoneを渡す
-        custom_model = None if model_choice == "Auto (Best for Domain)" else model_choice
-
-        answer, thinking, confidence, status = generate_response(
-            question, domain, temp, max_tok, is_expert, expert_name, custom_model
+        domain = gr.Dropdown(
+            choices=["general", "medical", "legal"],
+            value="general",
+            label="Domain"
         )
-        badge_html = format_verification_badge(status, expert_name if is_expert else "")
-        return answer, thinking, confidence, badge_html
-
+        temp = gr.Slider(0.1, 1.0, value=0.7, label="Temperature")
+        max_len = gr.Slider(64, 1024, value=512, step=64, label="Max Tokens")
+    
+    question = gr.Textbox(label="Question", placeholder="Enter your question...", lines=3)
+    submit_btn = gr.Button("Generate", variant="primary")
+    
+    response = gr.Textbox(label="Response", lines=10)
+    status = gr.Textbox(label="Status")
+    
     submit_btn.click(
-        fn=process_question,
-        inputs=[
-            question_input,
-            domain_dropdown,
-            model_dropdown,
-            temperature_slider,
-            max_tokens_slider,
-            is_expert_checkbox,
-            expert_name_input
+        fn=generate,
+        inputs=[question, domain, temp, max_len],
+        outputs=[response, status]
+    )
+    
+    gr.Examples(
+        examples=[
+            ["What is machine learning?", "general", 0.7, 256],
+            ["Explain heart disease symptoms", "medical", 0.7, 512],
         ],
-        outputs=[
-            response_output,
-            thinking_output,
-            confidence_output,
-            verification_html
-        ]
+        inputs=[question, domain, temp, max_len]
     )
 
-    gr.Markdown("""
-    ---
-    ### About NullAI
-
-    NullAI is a multi-domain knowledge reasoning system with:
-    - **55+ specialized domains** (medical, legal, programming, etc.)
-    - **Expert verification** via ORCID authentication
-    - **Transparent confidence scores** for all responses
-    - **Open-source models** (no external API dependencies)
-
-    [GitHub](https://github.com/your-repo) | [Documentation](https://your-docs-url)
-    """)
-
 if __name__ == "__main__":
     demo.launch()
+

requirements.txt

@@ -1,2 +1,7 @@
 gradio>=4.0.0
+torch>=2.0.0
+transformers>=4.36.0
+accelerate>=0.20.0
 huggingface_hub>=0.20.0
+sentencepiece>=0.1.99
+protobuf>=3.20.0