feat: add LLM label classification

ai/ai.py

@@ -0,0 +1,34 @@
+import requests
+import json
+import os
+
+
+url = 'https://internlm-chat.intern-ai.org.cn/puyu/api/v1/chat/completions'
+header = {
+    'Content-Type': 'application/json',
+    "Authorization": f"Bearer {os.environ['INTERNLM_API_KEY']}"
+}
+
+
+def complete(messages, model="internlm3-latest", temperature=None, top_p=None):
+    data = {
+        "model": model,
+        "messages": messages
+    }
+    if temperature is not None:
+        data["temperature"] = temperature
+    if top_p is not None:
+        data["top_p"] = top_p
+
+    res = requests.post(url, headers=header, data=json.dumps(data))
+    if res.status_code == 200:
+        return res.json()["choices"][0]['message']["content"]
+    else:
+        return None
+
+
+if __name__ == "__main__":
+    response = complete(
+        messages=[{"role": "user", "content": "你好~"}]
+    )
+    print(response)

ai/classify_paper.py

@@ -0,0 +1,382 @@
+import time
+from typing import List, Dict, Optional
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from threading import Lock
+from typing import List, Dict, Any
+import json
+
+try:
+    from .ai import complete
+except ImportError:
+    from ai import complete
+
+
+paper_types: Dict[str, str] = {
+    "CV": "computer vision, any paper that deals with image, video, point cloud or 3D model data",
+    "NLP": "natural language processing",
+    "LLM": "large language model, if a paper has this label, also include the NLP label",
+    "RO": "robotics",
+    "ML": "machine learning, use this label only when the paper is not specific to any of the above categories",
+}
+
+type_sort_order = ["ML", "CV", "NLP", "LLM", "RO"]
+
+system_prompt = """
+You are a professional AI researcher. You are helping users to organize their papers.
+""".strip()
+
+user_prompt = "\n\n".join([
+    """
+You are given a list of papers. You need to classify each paper into one of the following categories:
+""".strip(),
+
+    chr(10).join(map(lambda x: f"- {x}: {paper_types[x]}", paper_types.keys())),
+
+    """
+You will be given several papers at a time. For each paper, you need to classify it into one of the categories above.
+
+You should output in the following format with a code block:
+""".strip(),
+    """
+```json
+[
+    {
+        "index": 1,
+        "category": ["RO"]
+    },
+    {
+        "index": 2,
+        "category": ["ML"]
+    },
+    {
+        "index": 3,
+        "category": ["LLM", "NLP"]
+    }
+]
+```
+""".strip(),
+    """
+The followings are the papers you need to classify:
+"""
+])
+
+
+def build_paper(index: int, title: str, abstract: str = None) -> str:
+
+    if abstract is None:
+        return f"{index}. {title}"
+
+    return f"{index}. {title}\n\n{abstract}"
+
+
+def get_classify_prompt(papers: List[Dict[str, str]]) -> str:
+    prompt = []
+
+    for index, paper in enumerate(papers, start=1):
+        prompt.append(build_paper(paper["index"] if "index" in paper else index, paper["title"], paper["abstract"] if "abstract" in paper else None))
+
+    return user_prompt + "\n\n" + "\n\n".join(prompt)
+
+
+def parse_response(response: str) -> List[Dict[str, List[str]]] | None:
+    # 匹配code block
+    response = response.strip()
+    if not response.startswith("```") or not response.endswith("```"):
+        return None
+
+    # 删除response的第一行和最后一行
+    response = "\n".join(response.split("\n")[1:-1])
+
+    try:
+        data = json.loads(response)
+    except json.JSONDecodeError:
+        return None
+
+    for paper in data:
+        if "index" not in paper or "category" not in paper:
+            return None
+
+        if not isinstance(paper["index"], int) or not isinstance(paper["category"], list):
+            return None
+
+        for category in paper["category"]:
+            if category not in paper_types:
+                return None
+
+    # sort the categories
+    for paper in data:
+        if "LLM" in paper["category"] and "NLP" not in paper["category"]:
+            paper["category"].append("NLP")
+
+    # sort the categories
+    for paper in data:
+        paper["category"].sort(key=lambda x: type_sort_order.index(x))
+
+    return data
+
+
+def get_classification(papers: List[Dict[str, str]]) -> List[Dict[str, List[str]]] | None:
+    prompt = get_classify_prompt(papers)
+
+    for _ in range(3):
+        try:
+            print("Request sent")
+            response = complete([{"role": "system", "content": system_prompt}, {"role": "user", "content": prompt}])
+
+            if response is not None:
+                return parse_response(response)
+        except:
+            pass
+
+
+class TokenBucket:
+    def __init__(self):
+        self.tokens = 200
+        self.last_update = time.time()
+        self.lock = Lock()
+
+    def acquire(self, n: int) -> bool:
+        with self.lock:
+            current_time = time.time()
+            elapsed = current_time - self.last_update
+            if elapsed >= 60:
+                added_tokens = int(elapsed // 60) * 200
+                self.tokens = min(self.tokens + added_tokens, 200)
+                self.last_update += 60 * (elapsed // 60)
+            if self.tokens >= n:
+                self.tokens -= n
+                return True
+            return False
+
+
+token_bucket = TokenBucket()
+
+
+class PaperCache:
+    def __init__(self):
+        self.cache = {}
+        self.lock = Lock()
+
+    def get(self, paper):
+        key = (paper['title'], paper.get('abstract'))
+        with self.lock:
+            return self.cache.get(key)
+
+    def set(self, paper, result):
+        key = (paper['title'], paper.get('abstract'))
+        with self.lock:
+            self.cache[key] = result
+
+
+paper_cache = PaperCache()
+
+
+def classify_papers(papers: List[Dict[str, str]]) -> Optional[List[Dict[str, List[str]]]]:
+    print(f"Classifying {len(papers)} papers")
+
+    cached_results = []
+    uncached_papers = []
+
+    # 为 papers 添加index
+    for index, paper in enumerate(papers, start=1):
+        paper['index'] = index
+
+    for paper in papers:
+        cached_result = paper_cache.get(paper)
+        if cached_result is not None:
+            cached_results.append(cached_result)
+        else:
+            uncached_papers.append(paper)
+
+    if not uncached_papers:
+        return cached_results
+
+    batches = [uncached_papers[i:i+10] for i in range(0, len(uncached_papers), 10)]
+    num_batches = len(batches)
+    if num_batches == 0:
+        return cached_results
+
+    if not token_bucket.acquire(num_batches):
+        return None
+
+    try:
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [executor.submit(get_classification, batch) for batch in batches]
+            results = []
+            for future in as_completed(futures):
+                batch_result = future.result()
+                if batch_result is None:
+                    for f in futures:
+                        f.cancel()
+                    return None
+                for paper, result in zip(uncached_papers, batch_result):
+                    paper_cache.set(paper, result)
+                results.extend(batch_result)
+            results.sort(key=lambda x: x['index'])
+            return cached_results + results
+    except Exception:
+        return None
+
+
+if __name__ == "__main__":
+    from rich import print
+    import time
+
+    start = time.time()
+
+    print(classify_papers([
+        {
+            "title": "OmniHuman-1: Rethinking the Scaling-Up of One-Stage Conditioned Human Animation Models",
+            "abstract": "End-to-end human animation, such as audio-driven talking human generation, has undergone notable advancements in the recent few years. However, existing methods still struggle to scale up as large general video generation models, limiting their potential in real applications. In this paper, we propose OmniHuman, a Diffusion Transformer-based framework that scales up data by mixing motion-related conditions into the training phase. To this end, we introduce two training principles for these mixed conditions, along with the corresponding model architecture and inference strategy. These designs enable OmniHuman to fully leverage data-driven motion generation, ultimately achieving highly realistic human video generation. More importantly, OmniHuman supports various portrait contents (face close-up, portrait, half-body, full-body), supports both talking and singing, handles human-object interactions and challenging body poses, and accommodates different image styles. Compared to existing end-to-end audio-driven methods, OmniHuman not only produces more realistic videos, but also offers greater flexibility in inputs. It also supports multiple driving modalities (audio-driven, video-driven and combined driving signals). Video samples are provided on the ttfamily project page (https://omnihuman-lab.github.io)"
+        },
+        {
+            "title": "SmolLM2: When Smol Goes Big -- Data-Centric Training of a Small Language Model",
+            "abstract": "While large language models have facilitated breakthroughs in many applications of artificial intelligence, their inherent largeness makes them computationally expensive and challenging to deploy in resource-constrained settings. In this paper, we document the development of SmolLM2, a state-of-the-art \"small\" (1.7 billion parameter) language model (LM). To attain strong performance, we overtrain SmolLM2 on ~11 trillion tokens of data using a multi-stage training process that mixes web text with specialized math, code, and instruction-following data. We additionally introduce new specialized datasets (FineMath, Stack-Edu, and SmolTalk) at stages where we found existing datasets to be problematically small or low-quality. To inform our design decisions, we perform both small-scale ablations as well as a manual refinement process that updates the dataset mixing rates at each stage based on the performance at the previous stage. Ultimately, we demonstrate that SmolLM2 outperforms other recent small LMs including Qwen2.5-1.5B and Llama3.2-1B. To facilitate future research on LM development as well as applications of small LMs, we release both SmolLM2 as well as all of the datasets we prepared in the course of this project."
+        },
+        {
+            "title": "Generating Multi-Image Synthetic Data for Text-to-Image Customization",
+            "abstract": "Customization of text-to-image models enables users to insert custom concepts and generate the concepts in unseen settings. Existing methods either rely on costly test-time optimization or train encoders on single-image training datasets without multi-image supervision, leading to worse image quality. We propose a simple approach that addresses both limitations. We first leverage existing text-to-image models and 3D datasets to create a high-quality Synthetic Customization Dataset (SynCD) consisting of multiple images of the same object in different lighting, backgrounds, and poses. We then propose a new encoder architecture based on shared attention mechanisms that better incorporate fine-grained visual details from input images. Finally, we propose a new inference technique that mitigates overexposure issues during inference by normalizing the text and image guidance vectors. Through extensive experiments, we show that our model, trained on the synthetic dataset with the proposed encoder and inference algorithm, outperforms existing tuning-free methods on standard customization benchmarks.",
+        },
+        {'title': 's1: Simple test-time scaling'},
+        {'title': 'Reward-Guided Speculative Decoding for Efficient LLM Reasoning'},
+        {'title': 'MatAnyone: Stable Video Matting with Consistent Memory Propagation'},
+        {'title': 'Self-supervised Quantized Representation for Seamlessly Integrating Knowledge Graphs with Large Language Models'},
+        {'title': 'Scalable-Softmax Is Superior for Attention'},
+        {'title': 'PixelWorld: Towards Perceiving Everything as Pixels'},
+        {'title': 'DINO-WM: World Models on Pre-trained Visual Features enable Zero-shot Planning'},
+        {'title': 'Constitutional Classifiers: Defending against Universal Jailbreaks across Thousands of Hours of Red Teaming'},
+        {'title': 'SAeUron: Interpretable Concept Unlearning in Diffusion Models with Sparse Autoencoders'},
+        {'title': 'Zero-Shot Novel View and Depth Synthesis with Multi-View Geometric Diffusion'},
+        {'title': 'The Surprising Agreement Between Convex Optimization Theory and Learning-Rate Scheduling for Large Model Training'},
+        {'title': 'Fast Encoder-Based 3D from Casual Videos via Point Track Processing'},
+        {'title': 'Unraveling the Capabilities of Language Models in News Summarization'},
+        {'title': 'Trading Inference-Time Compute for Adversarial Robustness'},
+        {'title': 'INT: Instance-Specific Negative Mining for Task-Generic Promptable Segmentation'},
+        {'title': 'ChunkKV: Semantic-Preserving KV Cache Compression for Efficient Long-Context LLM Inference'},
+        {'title': 'VideoJAM: Joint Appearance-Motion Representations for Enhanced Motion Generation in Video Models'},
+        {'title': 'Inverse Bridge Matching Distillation'},
+        {'title': 'ACECODER: Acing Coder RL via Automated Test-Case Synthesis'},
+        {'title': 'Satori: Reinforcement Learning with Chain-of-Action-Thought Enhances LLM Reasoning via Autoregressive Search'},
+        {'title': 'QLASS: Boosting Language Agent Inference via Q-Guided Stepwise Search'},
+        {'title': 'Concept Steerers: Leveraging K-Sparse Autoencoders for Controllable Generations'},
+        {'title': 'Can LLMs Maintain Fundamental Abilities under KV Cache Compression?'},
+        {'title': 'Rethinking Mixture-of-Agents: Is Mixing Different Large Language Models Beneficial?'},
+        {'title': 'COCONut-PanCap: Joint Panoptic Segmentation and Grounded Captions for Fine-Grained Understanding and Generation'},
+        {'title': 'Text-to-CAD Generation Through Infusing Visual Feedback in Large Language Models'},
+        {'title': 'Generating Multi-Image Synthetic Data for Text-to-Image Customization'},
+        {'title': 'Sample, Scrutinize and Scale: Effective Inference-Time Search by Scaling Verification'},
+        {'title': 'Federated Sketching LoRA: On-Device Collaborative Fine-Tuning of Large Language Models'},
+        {'title': 'Activation Approximations Can Incur Safety Vulnerabilities Even in Aligned LLMs: Comprehensive Analysis and Defense'},
+        {'title': 'SmolLM2: When Smol Goes Big -- Data-Centric Training of a Small Language Model'},
+        {'title': 'Demystifying Long Chain-of-Thought Reasoning in LLMs'},
+        {'title': 'LIMO: Less is More for Reasoning'},
+        {'title': 'TwinMarket: A Scalable Behavioral and Social Simulation for Financial Markets'},
+        {'title': 'LayerTracer: Cognitive-Aligned Layered SVG Synthesis via Diffusion Transformer'},
+        {'title': 'Boosting Multimodal Reasoning with MCTS-Automated Structured Thinking'},
+        {'title': 'Token Assorted: Mixing Latent and Text Tokens for Improved Language Model Reasoning'},
+        {'title': 'Large Language Model Guided Self-Debugging Code Generation'},
+        {'title': 'Jailbreaking with Universal Multi-Prompts'},
+        {'title': 'A Probabilistic Inference Approach to Inference-Time Scaling of LLMs using Particle-Based Monte Carlo Methods'},
+        {'title': 'On Teacher Hacking in Language Model Distillation'},
+        {'title': 'Riddle Me This! Stealthy Membership Inference for Retrieval-Augmented Generation'},
+        {'title': 'Activation-Informed Merging of Large Language Models'},
+        {'title': 'HackerRank-ASTRA: Evaluating Correctness & Consistency of Large Language Models on cross-domain multi-file project problems'},
+        {'title': 'Analyze Feature Flow to Enhance Interpretation and Steering in Language Models'},
+        {'title': 'Gold-medalist Performance in Solving Olympiad Geometry with AlphaGeometry2'},
+        {'title': 'DynVFX: Augmenting Real Videos with Dynamic Content'},
+        {'title': 'UltraIF: Advancing Instruction Following from the Wild'},
+        {'title': 'Great Models Think Alike and this Undermines AI Oversight'},
+        {'title': 'ConceptAttention: Diffusion Transformers Learn Highly Interpretable Features'},
+        {'title': 'Ola: Pushing the Frontiers of Omni-Modal Language Model with Progressive Modality Alignment'},
+        {'title': 'Weak-to-Strong Diffusion with Reflection'},
+        {'title': 'MAGA: MAssive Genre-Audience Reformulation to Pretraining Corpus Expansion'},
+        {'title': 'MotionLab: Unified Human Motion Generation and Editing via the Motion-Condition-Motion Paradigm'},
+        {'title': 'BOLT: Bootstrap Long Chain-of-Thought in Language Models without Distillation'},
+        {'title': 'ScoreFlow: Mastering LLM Agent Workflows via Score-based Preference Optimization'},
+        {'title': 'Llasa: Scaling Train-Time and Inference-Time Compute for Llama-based Speech Synthesis'},
+        {'title': 'MotionCanvas: Cinematic Shot Design with Controllable Image-to-Video Generation'},
+        {'title': 'PILAF: Optimal Human Preference Sampling for Reward Modeling'},
+        {'title': 'Beyond Prompt Content: Enhancing LLM Performance via Content-Format Integrated Prompt Optimization'},
+        {'title': 'ChartCitor: Multi-Agent Framework for Fine-Grained Chart Visual Attribution'},
+        {'title': 'Towards Physical Understanding in Video Generation: A 3D Point Regularization Approach'},
+        {'title': 'PlotGen: Multi-Agent LLM-based Scientific Data Visualization via Multimodal Feedback'},
+        {'title': 'Enhancing Code Generation for Low-Resource Languages: No Silver Bullet'},
+        {'title': 'Learning Real-World Action-Video Dynamics with Heterogeneous Masked Autoregression'},
+        {'title': 'Speak Easy: Eliciting Harmful Jailbreaks from LLMs with Simple Interactions'},
+        {'title': 'OmniHuman-1: Rethinking the Scaling-Up of One-Stage Conditioned Human Animation Models'},
+        {'title': 'The Differences Between Direct Alignment Algorithms are a Blur'},
+        {'title': 'Process Reinforcement through Implicit Rewards'},
+        {'title': 'Preference Leakage: A Contamination Problem in LLM-as-a-judge'},
+        {'title': 'AlignVLM: Bridging Vision and Language Latent Spaces for Multimodal Understanding'},
+        {'title': 'SafeRAG: Benchmarking Security in Retrieval-Augmented Generation of Large Language Model'},
+        {'title': 'SliderSpace: Decomposing the Visual Capabilities of Diffusion Models'},
+    ]))
+
+    print(classify_papers([
+        {'title': 'Federated Sketching LoRA: On-Device Collaborative Fine-Tuning of Large Language Models'},
+        {'title': 'Activation Approximations Can Incur Safety Vulnerabilities Even in Aligned LLMs: Comprehensive Analysis and Defense'},
+        {'title': 'SmolLM2: When Smol Goes Big -- Data-Centric Training of a Small Language Model'},
+        {'title': 'Demystifying Long Chain-of-Thought Reasoning in LLMs'},
+        {'title': 'LIMO: Less is More for Reasoning'},
+        {'title': 'TwinMarket: A Scalable Behavioral and Social Simulation for Financial Markets'},
+        {'title': 'LayerTracer: Cognitive-Aligned Layered SVG Synthesis via Diffusion Transformer'},
+        {'title': 'Boosting Multimodal Reasoning with MCTS-Automated Structured Thinking'},
+        {'title': 'Token Assorted: Mixing Latent and Text Tokens for Improved Language Model Reasoning'},
+        {'title': 'Large Language Model Guided Self-Debugging Code Generation'},
+        {'title': 'Jailbreaking with Universal Multi-Prompts'},
+        {'title': 'A Probabilistic Inference Approach to Inference-Time Scaling of LLMs using Particle-Based Monte Carlo Methods'},
+        {'title': 'On Teacher Hacking in Language Model Distillation'},
+        {'title': 'Riddle Me This! Stealthy Membership Inference for Retrieval-Augmented Generation'},
+        {'title': 'Activation-Informed Merging of Large Language Models'},
+        {'title': 'HackerRank-ASTRA: Evaluating Correctness & Consistency of Large Language Models on cross-domain multi-file project problems'},
+        {'title': 'Analyze Feature Flow to Enhance Interpretation and Steering in Language Models'},
+        {'title': 'Gold-medalist Performance in Solving Olympiad Geometry with AlphaGeometry2'},
+        {'title': 'DynVFX: Augmenting Real Videos with Dynamic Content'},
+        {'title': 'UltraIF: Advancing Instruction Following from the Wild'},
+        {'title': 'Great Models Think Alike and this Undermines AI Oversight'},
+        {'title': 'ConceptAttention: Diffusion Transformers Learn Highly Interpretable Features'},
+        {'title': 'Ola: Pushing the Frontiers of Omni-Modal Language Model with Progressive Modality Alignment'},
+        {'title': 'Weak-to-Strong Diffusion with Reflection'},
+        {'title': 'MAGA: MAssive Genre-Audience Reformulation to Pretraining Corpus Expansion'},
+        {'title': 'MotionLab: Unified Human Motion Generation and Editing via the Motion-Condition-Motion Paradigm'},
+        {'title': 'BOLT: Bootstrap Long Chain-of-Thought in Language Models without Distillation'},
+        {'title': 'ScoreFlow: Mastering LLM Agent Workflows via Score-based Preference Optimization'},
+        {'title': 'Llasa: Scaling Train-Time and Inference-Time Compute for Llama-based Speech Synthesis'},
+        {'title': 'MotionCanvas: Cinematic Shot Design with Controllable Image-to-Video Generation'},
+        {'title': 'PILAF: Optimal Human Preference Sampling for Reward Modeling'},
+        {'title': 'Beyond Prompt Content: Enhancing LLM Performance via Content-Format Integrated Prompt Optimization'},
+        {'title': 'ChartCitor: Multi-Agent Framework for Fine-Grained Chart Visual Attribution'},
+        {'title': 'Towards Physical Understanding in Video Generation: A 3D Point Regularization Approach'},
+        {'title': 'PlotGen: Multi-Agent LLM-based Scientific Data Visualization via Multimodal Feedback'},
+        {'title': 'Enhancing Code Generation for Low-Resource Languages: No Silver Bullet'},
+        {'title': 'Learning Real-World Action-Video Dynamics with Heterogeneous Masked Autoregression'},
+        {'title': 'Speak Easy: Eliciting Harmful Jailbreaks from LLMs with Simple Interactions'},
+        {'title': 'OmniHuman-1: Rethinking the Scaling-Up of One-Stage Conditioned Human Animation Models'},
+        {'title': 'The Differences Between Direct Alignment Algorithms are a Blur'},
+        {'title': 'Process Reinforcement through Implicit Rewards'},
+        {'title': 'Preference Leakage: A Contamination Problem in LLM-as-a-judge'},
+        {'title': 'AlignVLM: Bridging Vision and Language Latent Spaces for Multimodal Understanding'},
+        {'title': 'SafeRAG: Benchmarking Security in Retrieval-Augmented Generation of Large Language Model'},
+        {'title': 'SliderSpace: Decomposing the Visual Capabilities of Diffusion Models'},
+        {'title': 'MM-IQ: Benchmarking Human-Like Abstraction and Reasoning in Multimodal Models'},
+        {'title': 'DeepRAG: Thinking to Retrieval Step by Step for Large Language Models'},
+        {'title': 'Scaling Embedding Layers in Language Models'},
+        {'title': 'MakeAnything: Harnessing Diffusion Transformers for Multi-Domain Procedural Sequence Generation'},
+        {'title': 'AIN: The Arabic INclusive Large Multimodal Model'},
+        {'title': 'FastKV: KV Cache Compression for Fast Long-Context Processing with Token-Selective Propagation'},
+        {'title': 'ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning'},
+        {'title': 'The Jumping Reasoning Curve? Tracking the Evolution of Reasoning Performance in GPT-[n] and o-[n] Models on Multimodal Puzzles'},
+        {'title': 'RandLoRA: Full-rank parameter-efficient fine-tuning of large models'},
+        {'title': 'Almost Surely Safe Alignment of Large Language Models at Inference-Time'},
+        {'title': 'Improving Transformer World Models for Data-Efficient RL'},
+        {'title': 'PhD Knowledge Not Required: A Reasoning Challenge for Large Language Models'},
+        {'title': 'Improved Training Technique for Latent Consistency Models'},
+        {'title': 'LongDPO: Unlock Better Long-form Generation Abilities for LLMs via Critique-augmented Stepwise Information'},
+        {'title': 'Learning to Generate Unit Tests for Automated Debugging'},
+        {'title': 'Lifelong Sequential Knowledge Editing without Model Degradation'},
+        {'title': 'A Study on the Performance of U-Net Modifications in Retroperitoneal Tumor Segmentation'},
+        {'title': 'Language Models Prefer What They Know: Relative Confidence Estimation via Confidence Preferences'},
+        {'title': 'Current Pathology Foundation Models are unrobust to Medical Center Differences'}
+    ]))
+
+    print(f"Time taken: {time.time() - start}")

css/table.css

@@ -31,16 +31,10 @@
     text-decoration: underline !important;
 }
 
-.paper-table td:nth-child(2),
-.paper-table td:nth-child(3),
-.paper-table td:nth-child(4),
-.paper-table td:nth-child(5) {
+.paper-table td:not(:first-child) {
     text-align: center;
 }
 
-.paper-table th:nth-child(2),
-.paper-table th:nth-child(3),
-.paper-table th:nth-child(4),
-.paper-table th:nth-child(5) {
+.paper-table th:not(:first-child) {
     text-align: center;
 }

fetch_paper.py

@@ -1,4 +1,5 @@
-from parser import parse_article
+from parser import parse_article, Article
+from ai.classify_paper import classify_papers
 import os
 import requests
 import datetime
@@ -8,6 +9,8 @@ from rich import print
 from date import Date
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
+from typing import List, Dict
+
 
 API_URL = "https://huggingface.co/api/daily_papers"
 
@@ -63,7 +66,7 @@ def fetch_papers_with_date(date: datetime):
 
 
 def fetch_papers_with_daterange(start_date: Date, end_date: Date):
-    articles = []
+    articles: List[Article] = []
     current_date = start_date
     dates = []
 
@@ -91,14 +94,26 @@ def fetch_papers_with_daterange(start_date: Date, end_date: Date):
 
     # articles = [article for article in articles if (start_date <= Date(article.publishedAt.isoformat().split('T')[0]) <= end_date)]
 
-    unique_articles = {}
+    unique_articles: Dict[str, Article] = {}
     for article in articles:
         if article.paper.id not in unique_articles:
             unique_articles[article.paper.id] = article
 
     print(f"Unique articles: {len(unique_articles)}")
 
-    return list(unique_articles.values())
+    unique_articles: List[Article] = list(unique_articles.values())
+
+    preprocessed_articles = list(map(lambda article: {
+        "title": article.title,
+        "abstract": article.paper.summary,
+    }, unique_articles))
+
+    classified_articles = classify_papers(preprocessed_articles)
+
+    for i, article in enumerate(unique_articles):
+        article.paper.label = classified_articles[i]["category"]
+
+    return unique_articles
 
 
 if __name__ == "__main__":

interface.py

@@ -17,6 +17,7 @@ def format_author(author):
     return "Anonymous author"
 
 
+# 底部论文介绍
 def format_paper_info(article):
     """Generate HTML content for paper display"""
     if not article.paper:
@@ -77,6 +78,7 @@ def generate_table_html(papers):
             '<th>👍 Upvotes</th>'
             '<th>💬 Comments</th>'
             '<th>📅 Date</th>'
+            '<th>Label</th>'
             '<th></th>'
             '</tr></thead><tbody>']
 
@@ -86,6 +88,7 @@ def generate_table_html(papers):
         comments = article.numComments or 0
         date = article.paper.publishedAt.strftime("%Y-%m-%d") if article.paper.publishedAt else "Unknown"
         paper_id = article.paper.id
+        label = ", ".join(article.paper.label) or ""
 
         # 构造 arXiv abs 链接
         arxiv_abs_link = f"https://huggingface.co/papers/{paper_id}"
@@ -96,6 +99,7 @@ def generate_table_html(papers):
             <td>{upvotes}</td>
             <td>{comments}</td>
             <td>{date}</td>
+            <td>{label}</td>
             <td><a href="javascript:void(0)" onclick="showDetail('{paper_id}')" class="sf-button" style="margin: 0">Details{assets.SVG_LINK}</a></td>
         </tr>
         """
@@ -134,6 +138,8 @@ def query_papers(start_date_str: str, end_date_str: str, sort_method: str):  # A
             papers = sort_by_date(papers, reverse=False)
         elif sort_method == "Sort by date descending":
             papers = sort_by_date(papers, reverse=True)
+        elif sort_method == "Sort by label":
+            papers = sorted(papers, key=lambda x: ", ".join(x.paper.label))
 
         return generate_table_html(papers), build_html(papers)
     except Exception as e:
@@ -141,14 +147,6 @@ def query_papers(start_date_str: str, end_date_str: str, sort_method: str):  # A
         return "<p>⚠️ Query failed, please check the date format (YYYY-MM-DD)</p>", "<p>⚠️ Query failed, please check the date format (YYYY-MM-DD)</p>"
 
 
-def show_detail(paper_id, papers):
-    """Show paper details"""
-    if not papers:
-        return "Please perform a query first"
-
-    return build_html(papers)
-
-
 # CSS 样式（可放入单独文件）
 custom_css = """
 .detail-area { margin-top: 20px; padding: 20px; border: 1px solid #ddd; border-radius: 5px; }
@@ -194,13 +192,13 @@ def create_interface():
         # Main interface
         gr.HTML("<div style='text-align: center'><h1>📚 Hugging Face Weekly Paper</h1></div>")
         gr.HTML("""<div style='text-align: center'>
-                <span style="">
-                    🔗 <a href='https://larkcommunity.feishu.cn/wiki/HSSTwsq7JiDur0kJrvjcnFZfnTe'>参与本项目贡献</a>
-                </span>
-                <span style="margin-left: 1rem">
-                    Sponser: <a href='https://internlm.intern-ai.org.cn/api/document'>InternLM</a>
-                </span>
-                </div>""")
+            <span style="">
+                🔗 <a href='https://larkcommunity.feishu.cn/wiki/HSSTwsq7JiDur0kJrvjcnFZfnTe'>Contribute to this project</a>
+            </span>
+            <span style="margin-left: 1rem">
+                Sponsor: <a href='https://internlm.intern-ai.org.cn/api/document'>InternLM</a>
+            </span>
+            </div>""")
 
         # Query control area
         with gr.Row():
@@ -228,6 +226,7 @@ def create_interface():
                     "Sort by upvotes ascending",
                     "Sort by comments ascending",
                     "Sort by date ascending",
+                    "Sort by label",
                 ],
                 value="Sort by upvotes descending",
             )

parser.py

@@ -21,6 +21,7 @@ class Paper:
     summary: Optional[str] = None
     upvotes: Optional[int] = None
     discussionId: Optional[str] = None
+    label: Optional[List[str]] = None
 
 
 @dataclass