Update app.py

app.py

@@ -2,22 +2,21 @@ import gradio as gr
 import spaces
 import torch
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import torch.nn.functional as F
-import torch.nn as nn
 import re
 import requests
 from urllib.parse import urlparse
 import xml.etree.ElementTree as ET
 
+# 모델 경로와 디바이스 설정
 model_path = r'ssocean/NAIP'
 device = 'cuda' if torch.cuda.is_available() else 'cpu'
 
-global model, tokenizer
+# 전역 변수로 모델·토크나이저 선언
 model = None
 tokenizer = None
 
 def fetch_arxiv_paper(arxiv_input):
-    """Fetch paper details from arXiv URL or ID using requests."""
+    """arXiv URL 또는 ID로부터 제목과 요약(fetch)"""
     try:
         if 'arxiv.org' in arxiv_input:
             parsed = urlparse(arxiv_input)
@@ -25,67 +24,57 @@ def fetch_arxiv_paper(arxiv_input):
         else:
             arxiv_id = arxiv_input.strip()
         api_url = f'http://export.arxiv.org/api/query?id_list={arxiv_id}'
-        response = requests.get(api_url)
-        if response.status_code != 200:
-            return {"title": "", "abstract": "", "success": False, "message": "Error fetching paper from arXiv API"}
-        root = ET.fromstring(response.text)
-        ns = {'arxiv': 'http://www.w3.org/2005/Atom'}
-        entry = root.find('.//arxiv:entry', ns)
+        resp = requests.get(api_url)
+        if resp.status_code != 200:
+            return {"title":"", "abstract":"", "success":False, "message":"arXiv API 에러"}
+        root = ET.fromstring(resp.text)
+        ns = {'atom': 'http://www.w3.org/2005/Atom'}
+        entry = root.find('.//atom:entry', ns)
         if entry is None:
-            return {"title": "", "abstract": "", "success": False, "message": "Paper not found"}
-        title = entry.find('arxiv:title', ns).text.strip()
-        abstract = entry.find('arxiv:summary', ns).text.strip()
-        return {"title": title, "abstract": abstract, "success": True, "message": "Paper fetched successfully!"}
+            return {"title":"", "abstract":"", "success":False, "message":"논문을 찾을 수 없습니다"}
+        title = entry.find('atom:title', ns).text.strip()
+        abstract = entry.find('atom:summary', ns).text.strip()
+        return {"title": title, "abstract": abstract, "success": True, "message": "성공적으로 가져왔습니다!"}
     except Exception as e:
-        return {"title": "", "abstract": "", "success": False, "message": f"Error fetching paper: {e}"}
+        return {"title":"", "abstract":"", "success":False, "message":f"오류: {e}"}
 
 @spaces.GPU(duration=60, enable_queue=True)
 def predict(title, abstract):
-    title = title.replace("\n", " ").strip().replace("''", "'")
-    abstract = abstract.replace("\n", " ").strip().replace("''", "'")
+    """논문 제목과 요약을 받아 0~1 사이의 impact score 예측"""
     global model, tokenizer
+
+    # 최초 호출 시 모델·토크나이저 로드
     if model is None:
-        # 1) 전부 float32 로드
-        try:
-            model = AutoModelForSequenceClassification.from_pretrained(
-                model_path,
-                num_labels=1,
-                device_map=None,
-                torch_dtype=torch.float32,
-                load_in_8bit=False,
-                load_in_4bit=False,
-                low_cpu_mem_usage=False
-            )
-        except Exception as e:
-            print(f"첫 로딩 실패, 재시도: {e}")
-            model = AutoModelForSequenceClassification.from_pretrained(
-                model_path,
-                num_labels=1,
-                torch_dtype=torch.float32
-            )
-        # 2) device에 올려보기 (unsupported error 무시)
-        try:
-            model.to(device)
-        except ValueError as e:
-            print(f"model.to() 무시: {e}")
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_path,
+            num_labels=1,
+            quantization_config=None,   # bitsandbytes 양자화 완전 비활성화
+            torch_dtype=torch.float32,  # 전부 float32
+            device_map=None,            # accelerate dispatch 비활성
+            low_cpu_mem_usage=False
+        )
         tokenizer = AutoTokenizer.from_pretrained(model_path)
+        model.to(device)
         model.eval()
 
+    # 입력 텍스트 구성
     text = (
-        f"Given a certain paper, Title: {title}\n"
-        f"Abstract: {abstract}.\n"
-        "Predict its normalized academic impact (between 0 and 1):"
+        f"Given a certain paper,\n"
+        f"Title: {title.strip()}\n"
+        f"Abstract: {abstract.strip()}\n"
+        f"Predict its normalized academic impact (0~1):"
     )
+
     try:
-        inputs = tokenizer(text, return_tensors="pt")
+        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=1024)
         inputs = {k: v.to(device) for k, v in inputs.items()}
         with torch.no_grad():
             outputs = model(**inputs)
         prob = torch.sigmoid(outputs.logits).item()
-        score = min(1.0, prob + 0.05)
+        score = min(1.0, prob + 0.05)  # +0.05 보정, 최대 1.0
         return round(score, 4)
     except Exception as e:
-        print(f"Prediction error: {e}")
+        print("Prediction error:", e)
         return 0.0
 
 def get_grade_and_emoji(score):
@@ -99,40 +88,18 @@ def get_grade_and_emoji(score):
     if score >= 0.300: return "CC ✏️"
     return "C 📑"
 
-example_papers = [
-    {
-        "title": "Attention Is All You Need",
-        "abstract": "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks that include an encoder and a decoder. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train.",
-        "score": 0.982,
-        "note": "💫 Revolutionary paper that introduced the Transformer architecture, fundamentally changing NLP and deep learning."
-    },
-    {
-        "title": "Language Models are Few-Shot Learners",
-        "abstract": "Recent work has demonstrated substantial gains on many NLP tasks and benchmarks by pre-training on a large corpus of text followed by fine-tuning on a specific task. While typically task-agnostic in architecture, this method still requires task-specific fine-tuning datasets of thousands or tens of thousands of examples. By contrast, humans can generally perform a new language task from only a few examples or from simple instructions - something which current NLP systems still largely struggle to do. Here we show that scaling up language models greatly improves task-agnostic, few-shot performance, sometimes even reaching competitiveness with prior state-of-the-art fine-tuning approaches.",
-        "score": 0.956,
-        "note": "🚀 Groundbreaking GPT-3 paper that demonstrated the power of large language models."
-    },
-    {
-        "title": "An Empirical Study of Neural Network Training Protocols",
-        "abstract": "This paper presents a comparative analysis of different training protocols for neural networks across various architectures. We examine the effects of learning rate schedules, batch size selection, and optimization algorithms on model convergence and final performance. Our experiments span multiple datasets and model sizes, providing practical insights for deep learning practitioners.",
-        "score": 0.623,
-        "note": "📚 Solid research paper with useful findings but more limited scope and impact."
-    }
-]
-
 def validate_input(title, abstract):
-    title = title.replace("\n", " ").strip().replace("''", "'")
-    abstract = abstract.replace("\n", " ").strip().replace("''", "'")
+    """제목·요약 글자 수 및 비영어 문자 검사"""
     non_latin = re.compile(r'[^\u0000-\u007F]')
     if len(title.split()) < 3:
-        return False, "The title must be at least 3 words long."
+        return False, "제목은 최소 3단어 이상이어야 합니다."
     if len(abstract.split()) < 50:
-        return False, "The abstract must be at least 50 words long."
+        return False, "요약은 최소 50단어 이상이어야 합니다."
     if non_latin.search(title):
-        return False, "Title에 영어 외 문자가 포함되어 있습니다."
+        return False, "제목에 영어 외 문자가 포함되었습니다."
     if non_latin.search(abstract):
-        return False, "Abstract에 영어 외 문자가 포함되어 있습니다."
-    return True, "Inputs are valid!"
+        return False, "요약에 영어 외 문자가 포함되었습니다."
+    return True, "입력 유효합니다."
 
 def update_button_status(title, abstract):
     valid, msg = validate_input(title, abstract)
@@ -142,12 +109,13 @@ def update_button_status(title, abstract):
 
 def process_arxiv_input(arxiv_input):
     if not arxiv_input.strip():
-        return "", "", "Please enter an arXiv URL or ID"
-    result = fetch_arxiv_paper(arxiv_input)
-    if result["success"]:
-        return result["title"], result["abstract"], result["message"]
-    return "", "", result["message"]
+        return "", "", "URL 또는 ID를 입력하세요"
+    res = fetch_arxiv_paper(arxiv_input)
+    if res["success"]:
+        return res["title"], res["abstract"], res["message"]
+    return "", "", res["message"]
 
+# CSS 정의
 css = """
 .gradio-container {
     font-family: 'Arial', sans-serif;
@@ -216,53 +184,41 @@ css = """
 }
 """
 
+# Gradio UI 구성
 with gr.Blocks(theme=gr.themes.Default(), css=css) as iface:
     gr.Markdown(
         """
-        # Papers Impact: AI-Powered Research Impact Predictor 
+        # Papers Impact: AI-Powered Research Impact Predictor
         ## https://discord.gg/openfreeai
-        """
-    )
+        """)
     gr.HTML("""<a href="https://visitorbadge.io/status?path=https%3A%2F%2FVIDraft-PaperImpact.hf.space">
 <img src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2FVIDraft-PaperImpact.hf.space&countColor=%23263759" />
 </a>""")
 
     with gr.Row():
         with gr.Column(elem_classes="input-section"):
-            with gr.Group(elem_classes="arxiv-input"):
-                gr.Markdown("### 📑 Import from arXiv")
-                arxiv_input = gr.Textbox(
-                    lines=1,
-                    placeholder="Enter arXiv URL or ID (e.g., 2501.09751)",
-                    label="arXiv Paper URL/ID",
-                    value="https://arxiv.org/pdf/2502.07316"
-                )
-                gr.Markdown("""
-                <p class="arxiv-note">
-                Click input field to use example paper or browse papers at 
-                <a href="https://arxiv.org" target="_blank" class="arxiv-link">arxiv.org</a>
-                </p>
-                """)
-                fetch_button = gr.Button("🔍 Fetch Paper Details", variant="secondary")
-            
-            gr.Markdown("### 📝 Or Enter Paper Details Manually")
+            gr.Markdown("### 📑 arXiv에서 불러오기")
+            arxiv_input = gr.Textbox(
+                lines=1,
+                placeholder="arXiv URL 또는 ID",
+                label="arXiv URL/ID")
+            fetch_btn = gr.Button("🔍 불러오기", variant="secondary")
+
+            gr.Markdown("### 📝 직접 입력")
             title_input = gr.Textbox(
                 lines=2,
-                placeholder="Enter Paper Title (minimum 3 words)...",
-                label="Paper Title"
-            )
+                placeholder="논문 제목 (최소 3단어)",
+                label="제목")
             abstract_input = gr.Textbox(
                 lines=5,
-                placeholder="Enter Paper Abstract (minimum 50 words)...",
-                label="Paper Abstract"
-            )
-            validation_status = gr.Textbox(label="✔️ Validation Status", interactive=False)
-            submit_button = gr.Button("🎯 Predict Impact", interactive=False, variant="primary")
-        
+                placeholder="논문 요약 (최소 50단어)",
+                label="요약")
+            status = gr.Textbox(label="✔️ 입력 상태", interactive=False)
+            submit_btn = gr.Button("🎯 예측하기", interactive=False, variant="primary")
+
         with gr.Column(elem_classes="result-section"):
-            with gr.Group():
-                score_output = gr.Number(label="🎯 Impact Score")
-                grade_output = gr.Textbox(label="🏆 Grade", elem_classes="grade-display")
+            score_out = gr.Number(label="🎯 Impact Score")
+            grade_out = gr.Textbox(label="🏆 Grade", elem_classes="grade-display")
 
     with gr.Row(elem_classes="methodology-section"):
         gr.Markdown(
@@ -283,44 +239,60 @@ with gr.Blocks(theme=gr.themes.Default(), css=css) as iface:
             | Grade | Score Range | Description | Indicator |
             |-------|-------------|-------------|-----------|
             | AAA | 0.900-1.000 | Exceptional Impact | 🌟 |
-            | AA | 0.800-0.899 | Very High Impact | ⭐ |
-            | A | 0.650-0.799 | High Impact | ✨ |
-            | BBB | 0.600-0.649 | Above Average Impact | 🔵 |
-            | BB | 0.550-0.599 | Moderate Impact | 📘 |
-            | B | 0.500-0.549 | Average Impact | 📖 |
-            | CCC | 0.400-0.499 | Below Average Impact | 📝 |
-            | CC | 0.300-0.399 | Low Impact | ✏️ |
-            | C | < 0.299 | Limited Impact | 📑 |
+            | AA  | 0.800-0.899 | Very High Impact  | ⭐ |
+            | A   | 0.650-0.799 | High Impact       | ✨ |
+            | BBB | 0.600-0.649 | Above Average     | 🔵 |
+            | BB  | 0.550-0.599 | Moderate Impact   | 📘 |
+            | B   | 0.500-0.549 | Average Impact    | 📖 |
+            | CCC | 0.400-0.499 | Below Average     | 📝 |
+            | CC  | 0.300-0.399 | Low Impact        | ✏️ |
+            | C   | <0.299      | Limited Impact    | 📑 |
             """
         )
 
     with gr.Row(elem_classes="example-section"):
         gr.Markdown("### 📋 Example Papers")
+        example_papers = [
+            {
+                "title": "Attention Is All You Need",
+                "abstract": "The dominant sequence transduction models are based on complex recurrent or convolutional neural networks that include an encoder and a decoder. The best performing models also connect the encoder and decoder through an attention mechanism. We propose a new simple network architecture, the Transformer, based solely on attention mechanisms, dispensing with recurrence and convolutions entirely. Experiments on two machine translation tasks show these models to be superior in quality while being more parallelizable and requiring significantly less time to train.",
+                "score": 0.982,
+                "note": "💫 Revolutionary paper that introduced the Transformer architecture, fundamentally changing NLP and deep learning."
+            },
+            {
+                "title": "Language Models are Few-Shot Learners",
+                "abstract": "Recent work has demonstrated substantial gains on many NLP tasks and benchmarks by pre-training on a large corpus of text followed by fine-tuning on a specific task. While typically task-agnostic in architecture, this method still requires task-specific fine-tuning datasets of thousands or tens of thousands of examples. By contrast, humans can generally perform a new language task from only a few examples or from simple instructions - something which current NLP systems still largely struggle to do. Here we show that scaling up language models greatly improves task-agnostic, few-shot performance, sometimes even reaching competitiveness with prior state-of-the-art fine-tuning approaches.",
+                "score": 0.956,
+                "note": "🚀 Groundbreaking GPT-3 paper that demonstrated the power of large language models."
+            },
+            {
+                "title": "An Empirical Study of Neural Network Training Protocols",
+                "abstract": "This paper presents a comparative analysis of different training protocols for neural networks across various architectures. We examine the effects of learning rate schedules, batch size selection, and optimization algorithms on model convergence and final performance. Our experiments span multiple datasets and model sizes, providing practical insights for deep learning practitioners.",
+                "score": 0.623,
+                "note": "📚 Solid research paper with useful findings but more limited scope and impact."
+            }
+        ]
         for paper in example_papers:
             gr.Markdown(
                 f"""
                 #### {paper['title']}
-                **Score**: {paper.get('score', 'N/A')} | **Grade**: {get_grade_and_emoji(paper.get('score', 0))}
+                **Score**: {paper['score']} | **Grade**: {get_grade_and_emoji(paper['score'])}
                 {paper['abstract']}
                 *{paper['note']}*
                 ---
                 """
             )
 
-    title_input.change(update_button_status, [title_input, abstract_input], [validation_status, submit_button])
-    abstract_input.change(update_button_status, [title_input, abstract_input], [validation_status, submit_button])
-    fetch_button.click(process_arxiv_input, [arxiv_input], [title_input, abstract_input, validation_status])
+    # 이벤트 핸들러 연결
+    title_input.change(update_button_status, [title_input, abstract_input], [status, submit_btn])
+    abstract_input.change(update_button_status, [title_input, abstract_input], [status, submit_btn])
+    fetch_btn.click(process_arxiv_input, [arxiv_input], [title_input, abstract_input, status])
 
-    def process_prediction(title, abstract):
-        score = predict(title, abstract)
-        grade = get_grade_and_emoji(score)
-        return score, grade
+    def run_predict(t, a):
+        s = predict(t, a)
+        return s, get_grade_and_emoji(s)
 
-    submit_button.click(
-        process_prediction,
-        inputs=[title_input, abstract_input],
-        outputs=[score_output, grade_output]
-    )
+    submit_btn.click(run_predict, [title_input, abstract_input], [score_out, grade_out])
 
 if __name__ == "__main__":
     iface.launch()