Rename to AI Papers Intelligence Classifier and add full intelligence spectrum

- Renamed project from AGI/ASI Papers Analysis to AI Papers Intelligence Classifier
- Added ANI (Artificial Narrow Intelligence) classification level with keywords
- Added Other AI classification level for general AI topics
- Added ML (Machine Learning) classification level with keywords
- Added DS (Data Science) classification level with keywords
- Updated classification hierarchy: ASI → AGI → ACI → ANI → Other AI → ML → DS → Not Related
- Updated classifier.py with new keyword categories and scoring weights
- Updated ranker.py with new classification hierarchy and impact scores
- Enhanced UI with new classification columns and color coding
- Updated visualizations to include all 8 classification levels
- Updated all tests to match new classification system
- Updated documentation (CONCEPT.md, README.md) with new name and classification system
- Renamed classifier class from AGIASIClassifier to AIPapersIntelligenceClassifier

Generated with [Devin](https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

CONCEPT.md

@@ -1,37 +1,57 @@
-# AGI/ASI Papers Analysis - Concept Guide
+# AI Papers Intelligence Classifier - Concept Guide
 
-This guide explains the concepts, methodology, and technical architecture behind the AGI/ASI Papers Analysis tool.
+This guide explains the concepts, methodology, and technical architecture behind the AI Papers Intelligence Classifier tool.
 
 ## 🎓 Educational Purpose
 
-This tool demonstrates how to build an AI-powered research analysis system for tracking AGI (Artificial General Intelligence), ASI (Artificial Super Intelligence), and ACI (Artificial Collective Intelligence) research trends.
+This tool demonstrates how to build an AI-powered research analysis system for tracking AI research across the entire intelligence spectrum: ANI (Artificial Narrow Intelligence), AGI (Artificial General Intelligence), ASI (Artificial Super Intelligence), ACI (Artificial Collective Intelligence), ML (Machine Learning), and DS (Data Science).
 
 ## Core Concepts
 
-### 1. AGI vs ASI vs ACI
+### 1. Intelligence Spectrum
 
-**AGI (Artificial General Intelligence)**
-- AI systems with human-level cognitive abilities across diverse domains
-- Capable of learning, reasoning, and adapting to new situations
-- Key characteristics: transfer learning, few-shot learning, reasoning systems
+The tool classifies AI research across a comprehensive intelligence spectrum:
 
 **ASI (Artificial Super Intelligence)**
 - AI systems surpassing human intelligence in all domains
 - Associated with existential risk, alignment problems, and safety concerns
 - Key topics: AI safety, alignment, superintelligence, singularity
 
+**AGI (Artificial General Intelligence)**
+- AI systems with human-level cognitive abilities across diverse domains
+- Capable of learning, reasoning, and adapting to new situations
+- Key characteristics: transfer learning, few-shot learning, reasoning systems
+
 **ACI (Artificial Collective Intelligence)**
 - AI systems that demonstrate emergent intelligence through multi-agent collaboration
 - Focus on swarm intelligence, human-AI collaboration, and distributed cognition
 - Key topics: multi-agent systems, swarm intelligence, collaborative AI
 
+**ANI (Artificial Narrow Intelligence)**
+- Specialized AI systems designed for specific tasks or domains
+- Focus on task-specific optimization and domain expertise
+- Key topics: expert systems, specialized neural networks, vertical AI
+
+**Other AI**
+- General AI topics that don't fit specific intelligence categories
+- Broad AI research, applications, and systems
+- Key topics: computer vision, NLP, robotics, intelligent systems
+
+**ML (Machine Learning)**
+- Focus on learning algorithms and statistical methods
+- Key topics: neural networks, deep learning, supervised/unsupervised learning
+
+**DS (Data Science)**
+- Focus on data analysis, visualization, and methodologies
+- Key topics: data mining, statistical analysis, data engineering
+
 ### 2. Research Analysis Methodology
 
 The tool uses a hybrid approach combining:
 
 **Keyword-Based Analysis**
 - Fast pattern matching against curated keyword lists
-- Identifies papers mentioning AGI/ASI/ACI concepts
+- Identifies papers mentioning AI/ML/DS concepts
 - Provides baseline classification
 
 **Semantic Analysis (Optional)**
@@ -39,7 +59,7 @@ The tool uses a hybrid approach combining:
 - Captures nuance and context beyond keywords
 - Enhances classification accuracy
 
-**Reasoning-Based Classification (New)**
+**Reasoning-Based Classification**
 - Uses DeepSeek-R1 with Chain of Thought reasoning
 - Provides detailed analysis and confidence scores
 - More accurate classification of complex papers
@@ -51,15 +71,18 @@ The tool uses a hybrid approach combining:
 
 ### 3. Classification System
 
-Papers are classified into five levels:
+Papers are classified into eight levels across the intelligence spectrum:
 
-|| Level | Criteria | Description |
-||-------|----------|-------------|
-|| ASI | 3+ ASI keywords or highest-level reasoning | Direct focus on superintelligence and existential risk |
-|| AGI | 3+ AGI keywords or high-level reasoning | Direct focus on general intelligence capabilities |
-|| ACI | 3+ ACI keywords or collective intelligence focus | Multi-agent systems and swarm intelligence |
-|| Narrow AI | 1-2 core keywords or 4+ related keywords | Specific domain AI without general intelligence |
-|| Not Related | No significant matches | No clear AGI/ASI/ACI connection |
+| Level | Criteria | Description |
+|-------|----------|-------------|
+| ASI | 3+ ASI keywords or highest-level reasoning | Direct focus on superintelligence and existential risk |
+| AGI | 3+ AGI keywords or high-level reasoning | Direct focus on general intelligence capabilities |
+| ACI | 3+ ACI keywords or collective intelligence focus | Multi-agent systems and swarm intelligence |
+| ANI | 3+ ANI keywords or specialized AI focus | Task-specific AI and domain expertise |
+| Other AI | 3+ Other AI keywords or general AI focus | Broad AI topics and applications |
+| ML | 3+ ML keywords or machine learning focus | Learning algorithms and statistical methods |
+| DS | 3+ DS keywords or data science focus | Data analysis and methodologies |
+| Not Related | No significant matches | No clear AI/ML/DS connection |
 
 ### 4. Ranking Algorithm
 
@@ -67,18 +90,20 @@ The ranking system uses weighted scoring:
 
 **Relevance Score (50%)**
 - Based on keyword matches and semantic analysis
-- AGI and ASI keywords weighted higher (3.0x)
-- Related keywords weighted lower (1.0x)
+- ASI and AGI keywords weighted higher (3.0x)
+- ACI and ANI keywords weighted medium (2.0-2.5x)
+- Other AI and ML keywords weighted lower (1.5x)
+- DS and related keywords weighted lowest (1.0x)
 - Semantic analysis adds up to 20 points
 
 **Novelty Score (30%)**
 - Measures keyword diversity and uniqueness
-- Bonus for papers with both AGI and ASI keywords
+- Bonus for papers with multiple intelligence level keywords
 - Encourages innovative research
 
 **Impact Score (20%)**
 - Based on classification level
-- Bonus for ASI-related keywords (higher potential impact)
+- Higher levels (ASI, AGI) have higher base impact
 - Reflects potential significance
 
 **Composite Score**
@@ -105,7 +130,7 @@ Composite = (Relevance × 0.5) + (Novelty × 0.3) + (Impact × 0.2)
                          │
                          ▼
 ┌─────────────────────────────────────────────────────────┐
-│                   AGI/ASI Classifier                      │
+│           AI Papers Intelligence Classifier              │
 │  (Keyword Analysis + Semantic Analysis + Reasoning)      │
 └────────────────────────┬────────────────────────────────┘
                          │
@@ -134,14 +159,14 @@ Composite = (Relevance × 0.5) + (Novelty × 0.3) + (Impact × 0.2)
 
 The tool supports multiple analysis models:
 
-|| Model | Use Case | Pros | Cons |
-||-------|----------|------|------|
-|| Keyword | Quick screening | Fast, free, no setup | Limited understanding |
-|| OpenAI GPT | Deep analysis | Best semantic understanding | Paid, requires API key |
-|| Anthropic Claude | Complex papers | Excellent reasoning | Paid, requires API key |
-|| Ollama | Privacy-focused | Free, local, private | Slower, requires setup |
-|| Hugging Face | Budget-friendly | Free tier, good quality | Rate limits, API key |
-|| DeepSeek-R1 | Reasoning classification | Chain of thought, accurate | Medium speed, requires HF |
+| Model | Use Case | Pros | Cons |
+|-------|----------|------|------|
+| Keyword | Quick screening | Fast, free, no setup | Limited understanding |
+| OpenAI GPT | Deep analysis | Best semantic understanding | Paid, requires API key |
+| Anthropic Claude | Complex papers | Excellent reasoning | Paid, requires API key |
+| Ollama | Privacy-focused | Free, local, private | Slower, requires setup |
+| Hugging Face | Budget-friendly | Free tier, good quality | Rate limits, API key |
+| DeepSeek-R1 | Reasoning classification | Chain of thought, accurate | Medium speed, requires HF |
 
 ### Classification Modes
 
@@ -164,13 +189,6 @@ The tool supports three classification modes:
 
 ## Keyword Strategy
 
-### AGI Keywords
-Focus on general intelligence capabilities:
-- "general intelligence", "AGI", "human-level AI"
-- "transfer learning", "few-shot learning", "meta-learning"
-- "reasoning systems", "neuro-symbolic integration"
-- "autonomous agents", "self-improving AI"
-
 ### ASI Keywords
 Focus on superintelligence and safety:
 - "superintelligence", "ASI", "existential risk"
@@ -178,6 +196,13 @@ Focus on superintelligence and safety:
 - "recursive self-improvement", "singularity"
 - "AI control problem", "beneficial AI"
 
+### AGI Keywords
+Focus on general intelligence capabilities:
+- "general intelligence", "AGI", "human-level AI"
+- "transfer learning", "few-shot learning", "meta-learning"
+- "reasoning systems", "neuro-symbolic integration"
+- "autonomous agents", "self-improving AI"
+
 ### ACI Keywords
 Focus on collective intelligence:
 - "multi-agent systems", "swarm intelligence"
@@ -185,6 +210,34 @@ Focus on collective intelligence:
 - "distributed cognition", "emergent behavior"
 - "human-AI collaboration", "agent coordination"
 
+### ANI Keywords
+Focus on narrow/specialized AI:
+- "narrow AI", "specialized AI", "task-specific AI"
+- "domain-specific systems", "expert systems"
+- "single-purpose AI", "focused AI applications"
+- "specialized neural networks", "task optimization"
+
+### Other AI Keywords
+Focus on general AI topics:
+- "artificial intelligence", "AI research"
+- "AI applications", "AI systems"
+- "computer vision", "NLP", "speech recognition"
+- "robotics", "autonomous systems"
+
+### ML Keywords
+Focus on machine learning:
+- "machine learning", "deep learning"
+- "neural networks", "CNN", "RNN", "Transformer"
+- "supervised learning", "unsupervised learning"
+- "reinforcement learning", "feature engineering"
+
+### DS Keywords
+Focus on data science:
+- "data science", "data analysis"
+- "data mining", "big data"
+- "statistical analysis", "data visualization"
+- "data engineering", "data pipelines"
+
 ### Related Keywords
 Contextual AI research terms:
 - "deep learning", "neural networks", "LLM"
@@ -195,7 +248,7 @@ Contextual AI research terms:
 
 ### Classification Distribution (Pie Chart)
 - Shows proportion of papers in each classification level
-- Helps understand overall AGI/ASI/ACI relevance
+- Helps understand overall AI/ML/DS relevance
 
 ### Ranking Scores (Bar Chart)
 - Compares final rank vs combined relevance scores
@@ -207,19 +260,19 @@ Contextual AI research terms:
 - Helps identify novel, high-relevance research
 
 ### Trend Analysis (Line Chart)
-- Tracks AGI/ASI/ACI research patterns over time
+- Tracks AI research patterns over time
 - Shows relevance rate changes across weeks
-- Identifies periods of high AGI/ASI/ACI activity
+- Identifies periods of high AI activity
 
 ## Performance Considerations
 
 ### Speed vs Accuracy Trade-off
 
-|| Mode | Speed | Accuracy | Best For |
-||------|-------|----------|----------|
-|| Keyword Only | ⚡⚡⚡ | ⭐⭐ | High-volume screening |
-|| Reasoning Only | ⚡ | ⭐⭐⭐⭐⭐ | Deep analysis |
-|| Hybrid | ⚡⚡ | ⭐⭐⭐⭐ | Balanced approach |
+| Mode | Speed | Accuracy | Best For |
+|------|-------|----------|----------|
+| Keyword Only | ⚡⚡⚡ | ⭐⭐ | High-volume screening |
+| Reasoning Only | ⚡ | ⭐⭐⭐⭐⭐ | Deep analysis |
+| Hybrid | ⚡⚡ | ⭐⭐⭐⭐ | Balanced approach |
 
 ### Caching Strategy
 - Year-level data cached for 1 hour
@@ -257,7 +310,7 @@ Potential improvements to consider:
 1. **Expanded Data Sources**: Include arXiv, conference proceedings
 2. **Custom Keyword Lists**: Allow users to define custom keywords
 3. **Citation Analysis**: Incorporate citation counts and impact metrics
-4. **Author Tracking**: Track researchers working on AGI/ASI/ACI topics
+4. **Author Tracking**: Track researchers working on AI topics
 5. **Topic Modeling**: Use LDA or similar for topic discovery
 6. **Cross-Reference**: Link related papers across weeks
 7. **Alert System**: Notify users of high-relevance papers
@@ -274,6 +327,7 @@ This project demonstrates:
 5. **Gradio Interfaces**: Building web-based ML tools
 6. **Research Analysis**: Techniques for academic paper analysis
 7. **Reasoning Systems**: Chain of thought classification
+8. **Intelligence Spectrum**: Understanding AI classification across levels
 
 ## References
 

README.md

@@ -1,5 +1,5 @@
 ---
-title: AGI/ASI Papers Analysis
+title: AI Papers Intelligence Classifier
 emoji: 🧠
 colorFrom: purple
 colorTo: red
@@ -11,13 +11,13 @@ pinned: false
 license: mit
 ---
 
-# 🧠 AGI/ASI Papers Analysis
+# 🧠 AI Papers Intelligence Classifier
 
-Analyze AI papers from [AI-Papers-of-the-Week](https://github.com/dair-ai/AI-Papers-of-the-Week) for AGI (Artificial General Intelligence), ASI (Artificial Super Intelligence), and ACI (Artificial Collective Intelligence) relevance with ranking, trend analysis, and comparison tools.
+Analyze AI papers from [AI-Papers-of-the-Week](https://github.com/dair-ai/AI-Papers-of-the-Week) across the intelligence spectrum: ANI (Artificial Narrow Intelligence), AGI (Artificial General Intelligence), ASI (Artificial Super Intelligence), ACI (Artificial Collective Intelligence), ML (Machine Learning), and DS (Data Science) with ranking, trend analysis, and comparison tools.
 
 ## 🎯 Purpose
 
-This tool helps researchers, students, and AI safety enthusiasts track and analyze AGI/ASI/ACI research developments by automatically classifying and ranking AI papers from the weekly AI-Papers-of-the-Week newsletter.
+This tool helps researchers, students, and AI enthusiasts track and analyze AI research developments across the entire intelligence spectrum by automatically classifying and ranking AI papers from the weekly AI-Papers-of-the-Week newsletter.
 
 ## 🚀 Features
 
@@ -39,21 +39,23 @@ This tool helps researchers, students, and AI safety enthusiasts track and analy
   - Relevance vs novelty scatter plot
 
 ### **Trend Analysis**
-- Track AGI/ASI/ACI research trends over time
+- Track AI research trends across the intelligence spectrum
 - Visualize relevance rates across weeks
-- Identify periods of high AGI/ASI/ACI activity
+- Identify periods of high activity in different AI domains
 - Compare research patterns across years
 
 ### **Classification System**
 - **ASI**: Direct focus on superintelligence and existential risk
 - **AGI**: Direct focus on general intelligence capabilities
 - **ACI**: Multi-agent systems and collective intelligence
-- **Narrow AI**: Specific domain AI without general intelligence
-- **Not Related**: No clear AGI/ASI/ACI connection
+- **ANI**: Artificial Narrow Intelligence and specialized AI systems
+- **Other AI**: General AI topics not fitting specific categories
+- **ML**: Machine Learning algorithms and techniques
+- **DS**: Data Science methodologies and applications
 
 ### **Ranking Methodology**
 Papers are ranked using a composite score:
-- **Relevance** (50%): AGI/ASI/ACI keyword density and semantic analysis
+- **Relevance** (50%): Keyword density and semantic analysis across all intelligence levels
 - **Novelty** (30%): Keyword diversity and innovation potential
 - **Impact** (20%): Classification level and potential impact
 
@@ -80,13 +82,7 @@ Papers are ranked using a composite score:
 - **[How It Works](HOW_IT_WORKS.md)** - Detailed technical explanation
 - **[Feature Ideas](FEATURES.md)** - Future enhancements and roadmap
 
-## 🏷️ AGI/ASI/ACI Keywords
-
-### AGI Keywords
-- General intelligence, AGI, human-level AI
-- Transfer learning, few-shot learning, meta-learning
-- Reasoning systems, commonsense reasoning
-- Neural-symbolic integration, multi-modal learning
+## 🏷️ Intelligence Level Keywords
 
 ### ASI Keywords
 - Superintelligence, ASI, existential risk
@@ -94,12 +90,42 @@ Papers are ranked using a composite score:
 - Recursive self-improvement, intelligence explosion
 - Singularity, transformative AI
 
+### AGI Keywords
+- General intelligence, AGI, human-level AI
+- Transfer learning, few-shot learning, meta-learning
+- Reasoning systems, commonsense reasoning
+- Neural-symbolic integration, multi-modal learning
+
 ### ACI Keywords
 - Multi-agent systems, swarm intelligence
 - Collective intelligence, collaborative AI
 - Distributed cognition, emergent behavior
 - Human-AI collaboration, agent coordination
 
+### ANI Keywords
+- Narrow AI, specialized AI, task-specific AI
+- Domain-specific systems, expert systems
+- Single-purpose AI, focused AI applications
+- Specialized neural networks, task optimization
+
+### Other AI Keywords
+- Artificial intelligence, AI research
+- AI applications, AI systems
+- Computer vision, NLP, speech recognition
+- Robotics, autonomous systems
+
+### ML Keywords
+- Machine learning, deep learning
+- Neural networks, CNN, RNN, Transformer
+- Supervised learning, unsupervised learning
+- Reinforcement learning, feature engineering
+
+### DS Keywords
+- Data science, data analysis
+- Data mining, big data
+- Statistical analysis, data visualization
+- Data engineering, data pipelines
+
 ## 🚀 Quick Start
 
 ### Local Installation
@@ -174,12 +200,12 @@ See [Deployment Guide](DEPLOYMENT.md) for AWS, GCP, Azure, and Heroku instructio
 ## 🎓 Educational Purpose
 
 This project is created for **educational purposes only** to demonstrate:
-- AGI/ASI/ACI research tracking and analysis
+- AI research tracking and analysis across the intelligence spectrum
 - Natural language processing for paper classification
 - Data visualization for research trends
 - Modern web application development with Gradio
 
-The tool helps researchers and students understand the landscape of AGI/ASI/ACI research and track developments in this important field.
+The tool helps researchers and students understand the landscape of AI research and track developments across all intelligence levels from narrow AI to superintelligence.
 
 ## 📚 Data Source
 

app.py

@@ -1,6 +1,6 @@
 """
-AGI/ASI Papers Analysis - Main Gradio Application
-Analyzes AI papers from AI-Papers-of-the-Week for AGI/ASI relevance
+AI Papers Intelligence Classifier - Main Gradio Application
+Analyzes AI papers from AI-Papers-of-the-Week across the intelligence spectrum
 """
 
 import gradio as gr
@@ -10,7 +10,7 @@ import plotly.express as px
 from datetime import datetime
 
 from data_fetcher import AIPapersFetcher
-from classifier import AGIASIClassifier
+from classifier import AIPapersIntelligenceClassifier
 from ranker import PaperRanker
 from model_manager import ModelManager
 from advanced_analyzer import AdvancedAnalyzer
@@ -20,7 +20,7 @@ from reasoning_classifier import ReasoningClassifier
 # Initialize components
 fetcher = AIPapersFetcher()
 model_manager = ModelManager()
-classifier = AGIASIClassifier()
+classifier = AIPapersIntelligenceClassifier()
 reasoning_classifier = ReasoningClassifier()
 ranker = PaperRanker()
 advanced_analyzer = AdvancedAnalyzer()
@@ -29,7 +29,7 @@ advanced_analyzer = AdvancedAnalyzer()
 def analyze_week(year: str, week: str, model_id: str = "keyword", 
                 classification_mode: str = "keyword", use_semantic: bool = False) -> tuple:
     """
-    Analyze papers from a specific week for AGI/ASI relevance
+    Analyze papers from a specific week across the intelligence spectrum
     
     Args:
         year: Year to analyze
@@ -147,10 +147,13 @@ def analyze_week(year: str, week: str, model_id: str = "keyword",
             # Add color-coded classification badge
             classification = paper['classification_result']['classification']
             classification_colors = {
-                'AGI': '#00D4AA',
                 'ASI': '#7C3AED',
+                'AGI': '#00D4AA',
                 'ACI': '#F59E0B',
-                'Narrow AI': '#64748B',
+                'ANI': '#64748B',
+                'Other AI': '#3B82F6',
+                'ML': '#10B981',
+                'DS': '#F97316',
                 'Not Related': '#EF4444'
             }
             color = classification_colors.get(classification, '#64748B')
@@ -160,9 +163,13 @@ def analyze_week(year: str, week: str, model_id: str = "keyword",
                 'Rank': paper.get('rank_position', 0),
                 'Title': paper.get('title', 'Unknown'),  # Full title
                 'Classification': classification_html,
-                'AGI Score': paper['classification_result']['agi_score'],
                 'ASI Score': paper['classification_result']['asi_score'],
+                'AGI Score': paper['classification_result']['agi_score'],
                 'ACI Score': paper['classification_result']['aci_score'],
+                'ANI Score': paper['classification_result']['ani_score'],
+                'Other AI Score': paper['classification_result']['other_ai_score'],
+                'ML Score': paper['classification_result']['ml_score'],
+                'DS Score': paper['classification_result']['ds_score'],
                 'Combined Score': paper['classification_result']['combined_score'],
                 'Final Rank': paper.get('final_rank', 0),
                 'Model': semantic_info,
@@ -190,7 +197,7 @@ def generate_weekly_summary(year: str, week: str, total_papers: int,
                            stats: dict, relevant_papers: list, model_id: str, 
                            use_semantic: bool) -> str:
     """Generate summary text for weekly analysis"""
-    summary = f"# 🧠 AGI/ASI Papers Analysis: {week}, {year}\n\n"
+    summary = f"# 🧠 AI Papers Intelligence Classifier: {week}, {year}\n\n"
     summary += f"## 📊 Overview\n\n"
     summary += f"- **Analysis Method**: {'Semantic AI (' + model_id + ')' if use_semantic else 'Keyword-Based'}\n"
     summary += f"- **Total Papers Analyzed**: {total_papers}\n"
@@ -198,12 +205,15 @@ def generate_weekly_summary(year: str, week: str, total_papers: int,
     summary += f"- **AGI Papers**: {stats['agi']}\n"
     summary += f"- **ASI Papers**: {stats['asi']}\n"
     summary += f"- **ACI Papers**: {stats['aci']}\n"
-    summary += f"- **Narrow AI Papers**: {stats['narrow_ai']}\n"
+    summary += f"- **ANI Papers**: {stats['ani']}\n"
+    summary += f"- **Other AI Papers**: {stats['other_ai']}\n"
+    summary += f"- **ML Papers**: {stats['ml']}\n"
+    summary += f"- **DS Papers**: {stats['ds']}\n"
     summary += f"- **Not Related**: {stats['not_related']}\n"
     summary += f"- **Relevance Rate**: {stats['relevance_rate']}%\n\n"
     
     if relevant_papers:
-        summary += f"## 🎯 Top AGI/ASI Papers\n\n"
+        summary += f"## 🎯 Top Intelligence Papers\n\n"
         for i, paper in enumerate(relevant_papers[:5], 1):
             title = paper.get('title', 'Unknown')
             classification = paper['classification_result']['classification']
@@ -222,10 +232,13 @@ def generate_statistics_text(stats: dict) -> str:
     """Generate statistics text"""
     text = "## 📈 Classification Statistics\n\n"
     text += f"- **Total Papers**: {stats['total']}\n"
-    text += f"- **AGI**: {stats['agi']} ({stats['agi']/stats['total']*100:.1f}%)\n"
     text += f"- **ASI**: {stats['asi']} ({stats['asi']/stats['total']*100:.1f}%)\n"
+    text += f"- **AGI**: {stats['agi']} ({stats['agi']/stats['total']*100:.1f}%)\n"
     text += f"- **ACI**: {stats['aci']} ({stats['aci']/stats['total']*100:.1f}%)\n"
-    text += f"- **Narrow AI**: {stats['narrow_ai']} ({stats['narrow_ai']/stats['total']*100:.1f}%)\n"
+    text += f"- **ANI**: {stats['ani']} ({stats['ani']/stats['total']*100:.1f}%)\n"
+    text += f"- **Other AI**: {stats['other_ai']} ({stats['other_ai']/stats['total']*100:.1f}%)\n"
+    text += f"- **ML**: {stats['ml']} ({stats['ml']/stats['total']*100:.1f}%)\n"
+    text += f"- **DS**: {stats['ds']} ({stats['ds']/stats['total']*100:.1f}%)\n"
     text += f"- **Not Related**: {stats['not_related']} ({stats['not_related']/stats['total']*100:.1f}%)\n"
     text += f"- **Overall Relevance Rate**: {stats['relevance_rate']}%\n\n"
     
@@ -267,12 +280,13 @@ def generate_top_papers_text(papers: list) -> str:
 
 def create_classification_chart(stats: dict) -> go.Figure:
     """Create a pie chart showing classification distribution"""
-    labels = ['AGI', 'ASI', 'ACI', 'Narrow AI', 'Not Related']
-    values = [stats['agi'], stats['asi'], stats['aci'], 
-              stats['narrow_ai'], stats['not_related']]
+    labels = ['ASI', 'AGI', 'ACI', 'ANI', 'Other AI', 'ML', 'DS', 'Not Related']
+    values = [stats['asi'], stats['agi'], stats['aci'], 
+              stats['ani'], stats['other_ai'], stats['ml'], stats['ds'],
+              stats['not_related']]
     
     # Modern color palette
-    colors = ['#00D4AA', '#7C3AED', '#F59E0B', '#64748B', '#EF4444']
+    colors = ['#7C3AED', '#00D4AA', '#F59E0B', '#64748B', '#3B82F6', '#10B981', '#F97316', '#EF4444']
     
     fig = go.Figure(data=[go.Pie(
         labels=labels,
@@ -401,10 +415,13 @@ def create_scatter_chart(ranked_papers: list) -> go.Figure:
     
     # Modern color palette for classifications
     color_map = {
-        'AGI': '#00D4AA',
         'ASI': '#7C3AED',
+        'AGI': '#00D4AA',
         'ACI': '#F59E0B',
-        'Narrow AI': '#64748B',
+        'ANI': '#64748B',
+        'Other AI': '#3B82F6',
+        'ML': '#10B981',
+        'DS': '#F97316',
         'Not Related': '#EF4444'
     }
     colors = [color_map.get(c, '#64748B') for c in classifications]
@@ -513,10 +530,13 @@ def analyze_trends(year: str) -> tuple:
                 weekly_stats.append({
                     'week': week,
                     'total': stats['total'],
-                    'agi': stats['agi'],
                     'asi': stats['asi'],
+                    'agi': stats['agi'],
                     'aci': stats['aci'],
-                    'narrow_ai': stats['narrow_ai'],
+                    'ani': stats['ani'],
+                    'other_ai': stats['other_ai'],
+                    'ml': stats['ml'],
+                    'ds': stats['ds'],
                     'relevance_rate': stats['relevance_rate']
                 })
         
@@ -534,7 +554,7 @@ def analyze_trends(year: str) -> tuple:
 
 def generate_trend_summary(year: str, weekly_stats: list) -> str:
     """Generate trend analysis summary"""
-    summary = f"# 📈 AGI/ASI Research Trends - {year}\n\n"
+    summary = f"# 📈 AI Research Trends - {year}\n\n"
     
     if not weekly_stats:
         summary += "No weekly data available for trend analysis.\n"
@@ -543,23 +563,23 @@ def generate_trend_summary(year: str, weekly_stats: list) -> str:
     # Calculate overall statistics
     total_weeks = len(weekly_stats)
     total_papers = sum(w['total'] for w in weekly_stats)
-    total_agi_asi = sum(w['agi'] + w['asi'] + w['aci'] for w in weekly_stats)
+    total_intelligence = sum(w['asi'] + w['agi'] + w['aci'] + w['ani'] + w['other_ai'] + w['ml'] + w['ds'] for w in weekly_stats)
     avg_relevance_rate = sum(w['relevance_rate'] for w in weekly_stats) / total_weeks
     
     summary += f"## 📊 Overall Statistics\n\n"
     summary += f"- **Total Weeks Analyzed**: {total_weeks}\n"
     summary += f"- **Total Papers**: {total_papers}\n"
-    summary += f"- **Total AGI/ASI Papers**: {total_agi_asi}\n"
+    summary += f"- **Total Intelligence Papers**: {total_intelligence}\n"
     summary += f"- **Average Relevance Rate**: {avg_relevance_rate:.1f}%\n\n"
     
-    # Find weeks with highest AGI/ASI activity
-    top_weeks = sorted(weekly_stats, key=lambda x: x['agi'] + x['asi'] + x['aci'], reverse=True)[:3]
+    # Find weeks with highest intelligence activity
+    top_weeks = sorted(weekly_stats, key=lambda x: x['asi'] + x['agi'] + x['aci'], reverse=True)[:3]
     
-    summary += f"## 🏆 Top Weeks for AGI/ASI Research\n\n"
+    summary += f"## 🏆 Top Weeks for High-Level Intelligence Research\n\n"
     for i, week_stat in enumerate(top_weeks, 1):
         week_name = week_stat['week'].split(' - ')[0]
-        agi_asi_count = week_stat['agi'] + week_stat['asi'] + week_stat['aci']
-        summary += f"{i}. **{week_name}**: {agi_asi_count} AGI/ASI papers ({week_stat['relevance_rate']}% relevance)\n"
+        high_level_count = week_stat['asi'] + week_stat['agi'] + week_stat['aci']
+        summary += f"{i}. **{week_name}**: {high_level_count} high-level intelligence papers ({week_stat['relevance_rate']}% relevance)\n"
     
     summary += "\n"
     
@@ -570,7 +590,7 @@ def create_trend_chart(week_names: list, weekly_stats: list) -> go.Figure:
     """Create trend visualization chart"""
     # Prepare data
     relevance_rates = [w['relevance_rate'] for w in weekly_stats]
-    agi_asi_counts = [w['agi'] + w['asi'] + w['aci'] for w in weekly_stats]
+    intelligence_counts = [w['asi'] + w['agi'] + w['aci'] + w['ani'] + w['other_ai'] + w['ml'] + w['ds'] for w in weekly_stats]
     
     # Create figure with secondary y-axis
     fig = go.Figure()
@@ -588,16 +608,16 @@ def create_trend_chart(week_names: list, weekly_stats: list) -> go.Figure:
         hovertemplate='<b>%{x}</b><br>Relevance Rate: %{y:.1f}%<extra></extra>'
     ))
     
-    # Add AGI/ASI paper count bars
+    # Add intelligence paper count bars
     fig.add_trace(go.Bar(
         x=week_names,
-        y=agi_asi_counts,
-        name='AGI/ASI Papers',
+        y=intelligence_counts,
+        name='Intelligence Papers',
         marker=dict(
             color='#EC4899',
             line=dict(color='#DB2777', width=1)
         ),
-        hovertemplate='<b>%{x}</b><br>AGI/ASI Papers: %{y}<extra></extra>',
+        hovertemplate='<b>%{x}</b><br>Intelligence Papers: %{y}<extra></extra>',
         yaxis='y2'
     ))
     
@@ -673,7 +693,7 @@ def create_interface():
         secondary_hue="pink",
     )
     
-    with gr.Blocks(title="AGI/ASI Papers Analysis", theme=custom_theme, css="""
+    with gr.Blocks(title="AI Papers Intelligence Classifier", theme=custom_theme, css="""
         .gradio-container {
             max-width: 1400px !important;
         }
@@ -711,15 +731,15 @@ def create_interface():
         gr.Markdown("""
         <div style="text-align: center; padding: 2rem 0;">
             <h1 style="font-size: 3rem; font-weight: 700; color: #1E293B; margin-bottom: 0.5rem;">
-                🧠 AGI/ASI Papers Analysis
+                🧠 AI Papers Intelligence Classifier
             </h1>
             <p style="font-size: 1.2rem; color: #64748B; margin-bottom: 1.5rem;">
                 Analyze AI papers from <a href="https://github.com/dair-ai/AI-Papers-of-the-Week" target="_blank" style="color: #6366F1; text-decoration: none; font-weight: 500;">AI-Papers-of-the-Week</a> 
-                for AGI (Artificial General Intelligence) and ASI (Artificial Super Intelligence) relevance.
+                across the intelligence spectrum: ANI, AGI, ASI, ACI, ML, and DS.
             </p>
             <div style="background: linear-gradient(135deg, rgba(99, 102, 241, 0.1), rgba(236, 72, 153, 0.1)); 
                         padding: 1rem; border-radius: 12px; border-left: 4px solid #6366F1;">
-                <strong style="color: #6366F1;">🎓 Educational Purpose:</strong> This tool is created for educational purposes to demonstrate AGI/ASI research tracking and analysis.
+                <strong style="color: #6366F1;">🎓 Educational Purpose:</strong> This tool is created for educational purposes to demonstrate AI research tracking and analysis across the intelligence spectrum.
             </div>
         </div>
         """)
@@ -776,10 +796,10 @@ def create_interface():
                 
                 papers_df = gr.Dataframe(
             label="All Papers Ranking",
-            datatype=["number", "str", "markdown", "number", "number", "number", "number", "number", "str", "markdown"],
+            datatype=["number", "str", "markdown", "number", "number", "number", "number", "number", "number", "number", "number", "number", "str", "markdown"],
             wrap=True,
-            column_widths=["80px", "400px", "150px", "80px", "80px", "80px", "80px", "80px", "100px", "120px"],
-            headers=["Rank", "Title", "Classification", "AGI Score", "ASI Score", "ACI Score", "Combined Score", "Final Rank", "Model", "Links"],
+            column_widths=["80px", "400px", "150px", "80px", "80px", "80px", "80px", "80px", "80px", "80px", "80px", "80px", "100px", "120px"],
+            headers=["Rank", "Title", "Classification", "ASI Score", "AGI Score", "ACI Score", "ANI Score", "Other AI Score", "ML Score", "DS Score", "Combined Score", "Final Rank", "Model", "Links"],
             interactive=False
         )
                 
@@ -1023,7 +1043,7 @@ if __name__ == "__main__":
     import sys
     
     print("=" * 60)
-    print("🧠 AGI/ASI Papers Analysis - Application Startup")
+    print("🧠 AI Papers Intelligence Classifier - Application Startup")
     print("=" * 60)
     print(f"📅 Starting at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     print(f"🐍 Python Version: {sys.version.split()[0]}")

classifier.py

@@ -1,14 +1,14 @@
 """
-AGI/ASI Classifier Module
-Classifies AI papers by AGI (Artificial General Intelligence) and ASI (Artificial Super Intelligence) relevance
+AI Papers Intelligence Classifier Module
+Classifies AI papers across the intelligence spectrum: ANI, AGI, ASI, ACI, ML, DS
 """
 
 from typing import Dict, List
 from model_manager import ModelManager
 
 
-class AGIASIClassifier:
-    """Classify papers by AGI/ASI relevance using keyword analysis"""
+class AIPapersIntelligenceClassifier:
+    """Classify papers across the intelligence spectrum using keyword analysis"""
     
     def __init__(self, use_semantic: bool = False, model_id: str = "keyword"):
         # Initialize model manager for semantic analysis
@@ -156,10 +156,129 @@ class AGIASIClassifier:
             "ant colony optimization",
             "distributed problem solving"
         ]
+        
+        # ANI (Artificial Narrow Intelligence) keywords
+        self.ani_keywords = [
+            "narrow AI",
+            "specialized AI",
+            "task-specific AI",
+            "domain-specific",
+            "expert systems",
+            "single-purpose AI",
+            "focused AI",
+            "specialized neural networks",
+            "task optimization",
+            "specific domain",
+            "narrow intelligence",
+            "specialized intelligence",
+            "task-oriented AI",
+            "domain-specific AI",
+            "application-specific AI",
+            "vertical AI",
+            "specialized machine learning",
+            "narrow systems",
+            "specialized systems",
+            "task-focused AI"
+        ]
+        
+        # Other AI keywords
+        self.other_ai_keywords = [
+            "artificial intelligence",
+            "AI research",
+            "AI applications",
+            "AI systems",
+            "computer vision",
+            "natural language processing",
+            "NLP",
+            "speech recognition",
+            "robotics",
+            "autonomous systems",
+            "AI technology",
+            "AI algorithms",
+            "AI methods",
+            "AI techniques",
+            "intelligent systems",
+            "smart systems",
+            "cognitive computing",
+            "intelligent agents",
+            "AI platforms",
+            "AI frameworks"
+        ]
+        
+        # ML (Machine Learning) keywords
+        self.ml_keywords = [
+            "machine learning",
+            "deep learning",
+            "neural networks",
+            "CNN",
+            "convolutional neural networks",
+            "RNN",
+            "recurrent neural networks",
+            "Transformer",
+            "transformer models",
+            "supervised learning",
+            "unsupervised learning",
+            "reinforcement learning",
+            "feature engineering",
+            "model training",
+            "neural architecture",
+            "gradient descent",
+            "backpropagation",
+            "loss function",
+            "optimization",
+            "hyperparameter tuning",
+            "model architecture",
+            "deep neural networks",
+            "feedforward networks",
+            "activation functions",
+            "regularization",
+            "batch normalization",
+            "dropout",
+            "attention mechanism",
+            "self-attention",
+            "embeddings",
+            "representation learning"
+        ]
+        
+        # DS (Data Science) keywords
+        self.ds_keywords = [
+            "data science",
+            "data analysis",
+            "data mining",
+            "big data",
+            "statistical analysis",
+            "data visualization",
+            "data engineering",
+            "data pipelines",
+            "data preprocessing",
+            "feature extraction",
+            "data wrangling",
+            "data cleaning",
+            "exploratory data analysis",
+            "EDA",
+            "statistical modeling",
+            "predictive analytics",
+            "descriptive analytics",
+            "data analytics",
+            "business intelligence",
+            "data warehousing",
+            "ETL",
+            "extract transform load",
+            "data integration",
+            "data quality",
+            "data governance",
+            "data management",
+            "statistical methods",
+            "hypothesis testing",
+            "regression analysis",
+            "classification algorithms",
+            "clustering",
+            "dimensionality reduction"
+        ]
     
     def classify_paper(self, paper_data: Dict) -> Dict:
         """
-        Classify a paper by AGI/ASI relevance
+        Classify a paper across the intelligence spectrum
         
         Args:
             paper_data: Dictionary containing paper information (title, summary, etc.)
@@ -174,10 +293,14 @@ class AGIASIClassifier:
         # Combine all text for analysis
         combined_text = f"{title} {summary} {full_entry}"
         
-        # Calculate scores
-        agi_score = self.calculate_keyword_score(combined_text, self.agi_keywords)
+        # Calculate scores for all intelligence levels
         asi_score = self.calculate_keyword_score(combined_text, self.asi_keywords)
+        agi_score = self.calculate_keyword_score(combined_text, self.agi_keywords)
         aci_score = self.calculate_keyword_score(combined_text, self.aci_keywords)
+        ani_score = self.calculate_keyword_score(combined_text, self.ani_keywords)
+        other_ai_score = self.calculate_keyword_score(combined_text, self.other_ai_keywords)
+        ml_score = self.calculate_keyword_score(combined_text, self.ml_keywords)
+        ds_score = self.calculate_keyword_score(combined_text, self.ds_keywords)
         related_score = self.calculate_keyword_score(combined_text, self.related_keywords)
         
         # Perform semantic analysis if enabled
@@ -186,22 +309,34 @@ class AGIASIClassifier:
             semantic_result = self.model_manager.analyze_paper_semantic(paper_data, self.model_id)
         
         # Determine classification
-        classification = self.determine_classification(agi_score, asi_score, aci_score, related_score, semantic_result)
+        classification = self.determine_classification(asi_score, agi_score, aci_score, ani_score, 
+                                                       other_ai_score, ml_score, ds_score, 
+                                                       related_score, semantic_result)
         
         # Calculate combined relevance score (incorporating semantic if available)
-        combined_score = self.calculate_combined_score(agi_score, asi_score, aci_score, related_score, semantic_result)
+        combined_score = self.calculate_combined_score(asi_score, agi_score, aci_score, ani_score,
+                                                       other_ai_score, ml_score, ds_score, 
+                                                       related_score, semantic_result)
         
         return {
             'classification': classification['level'],
             'classification_reason': classification['reason'],
-            'agi_score': agi_score,
             'asi_score': asi_score,
+            'agi_score': agi_score,
             'aci_score': aci_score,
+            'ani_score': ani_score,
+            'other_ai_score': other_ai_score,
+            'ml_score': ml_score,
+            'ds_score': ds_score,
             'related_score': related_score,
             'combined_score': combined_score,
             'matched_agi_keywords': self.find_matched_keywords(combined_text, self.agi_keywords),
             'matched_asi_keywords': self.find_matched_keywords(combined_text, self.asi_keywords),
             'matched_aci_keywords': self.find_matched_keywords(combined_text, self.aci_keywords),
+            'matched_ani_keywords': self.find_matched_keywords(combined_text, self.ani_keywords),
+            'matched_other_ai_keywords': self.find_matched_keywords(combined_text, self.other_ai_keywords),
+            'matched_ml_keywords': self.find_matched_keywords(combined_text, self.ml_keywords),
+            'matched_ds_keywords': self.find_matched_keywords(combined_text, self.ds_keywords),
             'matched_related_keywords': self.find_matched_keywords(combined_text, self.related_keywords),
             'semantic_analysis': semantic_result
         }
@@ -231,15 +366,17 @@ class AGIASIClassifier:
                 matched.append(keyword)
         return matched
     
-    def determine_classification(self, agi_score: int, asi_score: int, aci_score: int, 
-                                 related_score: int, semantic_result: Dict = None) -> Dict:
+    def determine_classification(self, asi_score: int, agi_score: int, aci_score: int, 
+                                 ani_score: int, other_ai_score: int, ml_score: int, 
+                                 ds_score: int, related_score: int, semantic_result: Dict = None) -> Dict:
         """
-        Determine classification level based on scores
+        Determine classification level based on scores across the intelligence spectrum
         
         Returns:
             Dictionary with classification level and reasoning
         """
-        max_core_score = max(agi_score, asi_score)
+        # Calculate max scores for high-level intelligence
+        max_high_level_score = max(asi_score, agi_score, aci_score)
         
         # If semantic analysis is available, use it to enhance classification
         if semantic_result and semantic_result.get("semantic_relevance", 0) > 70:
@@ -250,25 +387,32 @@ class AGIASIClassifier:
                     'reason': f"Semantic analysis classification with {semantic_result['semantic_relevance']}% confidence"
                 }
             # High semantic relevance boosts classification
-            if max_core_score >= 1:
+            if max_high_level_score >= 1:
+                # Determine which high-level category has highest score
+                if asi_score >= agi_score and asi_score >= aci_score:
+                    level = "ASI"
+                elif agi_score >= asi_score and agi_score >= aci_score:
+                    level = "AGI"
+                else:
+                    level = "ACI"
                 return {
-                    'level': "AGI" if agi_score >= asi_score else "ASI",
-                    'reason': f"High semantic relevance ({semantic_result['semantic_relevance']}) with {max_core_score} core AGI/ASI keyword matches"
+                    'level': level,
+                    'reason': f"High semantic relevance ({semantic_result['semantic_relevance']}) with {max_high_level_score} high-level keyword matches"
                 }
         
-        # ACI classification (highest priority for collective intelligence)
-        if aci_score >= 2:
+        # ASI classification (highest priority - superintelligence)
+        if asi_score >= 3:
             return {
-                'level': "ACI",
-                'reason': f"Strong collective intelligence focus with {aci_score} ACI keyword matches"
+                'level': "ASI",
+                'reason': f"Strong superintelligence focus with {asi_score} ASI keyword matches"
             }
-        elif aci_score >= 1 and related_score >= 3:
+        elif asi_score >= 2:
             return {
-                'level': "ACI",
-                'reason': f"Collective intelligence potential with {aci_score} ACI and {related_score} related keyword matches"
+                'level': "ASI",
+                'reason': f"Good superintelligence relevance with {asi_score} ASI keyword matches"
             }
         
-        # AGI classification
+        # AGI classification (second highest priority)
         if agi_score >= 3:
             return {
                 'level': "AGI",
@@ -280,54 +424,103 @@ class AGIASIClassifier:
                 'reason': f"Good general intelligence relevance with {agi_score} AGI keyword matches"
             }
         
-        # ASI classification
-        if asi_score >= 3:
+        # ACI classification (third highest priority)
+        if aci_score >= 3:
             return {
-                'level': "ASI",
-                'reason': f"Strong superintelligence focus with {asi_score} ASI keyword matches"
+                'level': "ACI",
+                'reason': f"Strong collective intelligence focus with {aci_score} ACI keyword matches"
             }
-        elif asi_score >= 2:
+        elif aci_score >= 2:
             return {
-                'level': "ASI",
-                'reason': f"Good superintelligence relevance with {asi_score} ASI keyword matches"
+                'level': "ACI",
+                'reason': f"Good collective intelligence relevance with {aci_score} ACI keyword matches"
             }
         
-        # Mixed or lower relevance
-        if max_core_score >= 1:
-            if related_score >= 4:
-                return {
-                    'level': "Narrow AI",
-                    'reason': f"Specialized AI research with {max_core_score} core and {related_score} related keyword matches"
-                }
-            else:
-                return {
-                    'level': "Narrow AI",
-                    'reason': f"Some AI relevance with {max_core_score} core keyword match"
-                }
-        elif related_score >= 5:
+        # ANI classification (narrow/specialized AI)
+        if ani_score >= 3:
+            return {
+                'level': "ANI",
+                'reason': f"Strong narrow AI focus with {ani_score} ANI keyword matches"
+            }
+        elif ani_score >= 2:
+            return {
+                'level': "ANI",
+                'reason': f"Good narrow AI relevance with {ani_score} ANI keyword matches"
+            }
+        
+        # Other AI classification (general AI topics)
+        if other_ai_score >= 3:
+            return {
+                'level': "Other AI",
+                'reason': f"Strong general AI focus with {other_ai_score} Other AI keyword matches"
+            }
+        elif other_ai_score >= 2:
+            return {
+                'level': "Other AI",
+                'reason': f"Good general AI relevance with {other_ai_score} Other AI keyword matches"
+            }
+        
+        # ML classification (machine learning focus)
+        if ml_score >= 3:
+            return {
+                'level': "ML",
+                'reason': f"Strong machine learning focus with {ml_score} ML keyword matches"
+            }
+        elif ml_score >= 2:
+            return {
+                'level': "ML",
+                'reason': f"Good machine learning relevance with {ml_score} ML keyword matches"
+            }
+        
+        # DS classification (data science focus)
+        if ds_score >= 3:
+            return {
+                'level': "DS",
+                'reason': f"Strong data science focus with {ds_score} DS keyword matches"
+            }
+        elif ds_score >= 2:
+            return {
+                'level': "DS",
+                'reason': f"Good data science relevance with {ds_score} DS keyword matches"
+            }
+        
+        # Fallback to related keywords or not related
+        if related_score >= 5:
             return {
-                'level': "Narrow AI",
+                'level': "Other AI",
                 'reason': f"Related AI research with {related_score} related keyword matches"
             }
+        elif related_score >= 3:
+            return {
+                'level': "Other AI",
+                'reason': f"Some AI relevance with {related_score} related keyword matches"
+            }
         else:
             return {
                 'level': "Not Related",
                 'reason': "No significant AI relevance detected"
             }
     
-    def calculate_combined_score(self, agi_score: int, asi_score: int, aci_score: int, 
-                                  related_score: int, semantic_result: Dict = None) -> float:
+    def calculate_combined_score(self, asi_score: int, agi_score: int, aci_score: int, 
+                                  ani_score: int, other_ai_score: int, ml_score: int, 
+                                  ds_score: int, related_score: int, semantic_result: Dict = None) -> float:
         """
         Calculate combined relevance score (0-100 scale)
         
         Weights:
-        - AGI keywords: 3.0 (most important)
-        - ASI keywords: 3.0 (most important)
+        - ASI keywords: 3.0 (highest importance)
+        - AGI keywords: 3.0 (highest importance)
         - ACI keywords: 2.5 (emerging field, high potential)
+        - ANI keywords: 2.0 (specialized AI)
+        - Other AI keywords: 1.5 (general AI)
+        - ML keywords: 1.5 (machine learning)
+        - DS keywords: 1.0 (data science)
         - Related keywords: 1.0 (contextual)
         - Semantic analysis: 2.0 (if available)
         """
-        weighted_score = (agi_score * 3.0) + (asi_score * 3.0) + (aci_score * 2.5) + (related_score * 1.0)
+        weighted_score = (asi_score * 3.0) + (agi_score * 3.0) + (aci_score * 2.5) + \
+                          (ani_score * 2.0) + (other_ai_score * 1.5) + (ml_score * 1.5) + \
+                          (ds_score * 1.0) + (related_score * 1.0)
         
         # Add semantic score if available
         if semantic_result and semantic_result.get("semantic_relevance"):
@@ -373,39 +566,52 @@ class AGIASIClassifier:
         if total == 0:
             return {
                 'total': 0,
-                'agi': 0,
                 'asi': 0,
+                'agi': 0,
                 'aci': 0,
-                'narrow_ai': 0,
+                'ani': 0,
+                'other_ai': 0,
+                'ml': 0,
+                'ds': 0,
                 'not_related': 0,
                 'relevance_rate': 0.0
             }
         
         stats = {
             'total': total,
-            'agi': 0,
             'asi': 0,
+            'agi': 0,
             'aci': 0,
-            'narrow_ai': 0,
+            'ani': 0,
+            'other_ai': 0,
+            'ml': 0,
+            'ds': 0,
             'not_related': 0,
             'relevance_rate': 0.0
         }
         
         for paper in classified_papers:
             level = paper['classification_result']['classification']
-            if level == "AGI":
-                stats['agi'] += 1
-            elif level == "ASI":
+            if level == "ASI":
                 stats['asi'] += 1
+            elif level == "AGI":
+                stats['agi'] += 1
             elif level == "ACI":
                 stats['aci'] += 1
-            elif level == "Narrow AI":
-                stats['narrow_ai'] += 1
+            elif level == "ANI":
+                stats['ani'] += 1
+            elif level == "Other AI":
+                stats['other_ai'] += 1
+            elif level == "ML":
+                stats['ml'] += 1
+            elif level == "DS":
+                stats['ds'] += 1
             else:
                 stats['not_related'] += 1
         
         # Calculate relevance rate (papers that are not "Not Related")
-        relevant_count = stats['agi'] + stats['asi'] + stats['aci'] + stats['narrow_ai']
+        relevant_count = stats['asi'] + stats['agi'] + stats['aci'] + stats['ani'] + \
+                        stats['other_ai'] + stats['ml'] + stats['ds']
         stats['relevance_rate'] = round((relevant_count / total) * 100, 2)
         
         return stats

ranker.py

@@ -140,28 +140,35 @@ class PaperRanker:
         
         # Base score from classification level
         level_scores = {
-            'AGI': 90.0,
-            'ASI': 95.0,  # Highest impact
-            'ACI': 85.0,  # Emerging field, high potential
-            'Narrow AI': 40.0,
+            'ASI': 95.0,      # Highest impact - superintelligence
+            'AGI': 90.0,      # Very high impact - general intelligence
+            'ACI': 85.0,      # High impact - collective intelligence
+            'ANI': 70.0,      # Medium-high impact - narrow intelligence
+            'Other AI': 60.0,  # Medium impact - general AI
+            'ML': 50.0,       # Medium impact - machine learning
+            'DS': 40.0,       # Lower impact - data science
             'Not Related': 10.0
         }
         
         base_score = level_scores.get(level, 10.0)
         
-        # Bonus for ASI keywords (higher potential impact)
+        # Bonus for ASI keywords (highest potential impact)
         asi_matches = len(classification.get('matched_asi_keywords', []))
         asi_bonus = min(asi_matches * 5.0, 10.0)
         
+        # Bonus for AGI keywords (high potential impact)
+        agi_matches = len(classification.get('matched_agi_keywords', []))
+        agi_bonus = min(agi_matches * 5.0, 10.0)
+        
         # Bonus for ACI keywords (emerging field potential)
         aci_matches = len(classification.get('matched_aci_keywords', []))
         aci_bonus = min(aci_matches * 5.0, 10.0)
         
-        # Bonus for AGI keywords
-        agi_matches = len(classification.get('matched_agi_keywords', []))
-        agi_bonus = min(agi_matches * 5.0, 10.0)
+        # Bonus for ANI keywords (specialized AI impact)
+        ani_matches = len(classification.get('matched_ani_keywords', []))
+        ani_bonus = min(ani_matches * 3.0, 5.0)
         
-        impact_score = min(base_score + asi_bonus + aci_bonus + agi_bonus, 100.0)
+        impact_score = min(base_score + asi_bonus + agi_bonus + aci_bonus + ani_bonus, 100.0)
         
         return round(impact_score, 2)
     
@@ -182,7 +189,7 @@ class PaperRanker:
         return ranked[:top_n]
     
     def filter_by_classification(self, papers: List[Dict], 
-                                  min_level: str = 'Narrow AI') -> List[Dict]:
+                                  min_level: str = 'Other AI') -> List[Dict]:
         """
         Filter papers by minimum classification level
         
@@ -195,10 +202,13 @@ class PaperRanker:
         """
         level_hierarchy = {
             'Not Related': 0,
-            'Narrow AI': 1,
-            'ACI': 2,
-            'AGI': 3,
-            'ASI': 4  # Highest level
+            'DS': 1,           # Data Science
+            'ML': 2,           # Machine Learning
+            'Other AI': 3,     # General AI topics
+            'ANI': 4,          # Artificial Narrow Intelligence
+            'ACI': 5,          # Artificial Collective Intelligence
+            'AGI': 6,          # Artificial General Intelligence
+            'ASI': 7           # Artificial Super Intelligence (Highest)
         }
         
         min_level_value = level_hierarchy.get(min_level, 0)

tests/test_classifier.py

@@ -3,27 +3,31 @@ Test suite for classifier module
 """
 
 import pytest
-from classifier import AGIASIClassifier
+from classifier import AIPapersIntelligenceClassifier
 
 
 def test_classifier_initialization():
     """Test that classifier initializes correctly"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     assert classifier.agi_keywords is not None
     assert classifier.asi_keywords is not None
-    assert classifier.related_keywords is not None
+    assert classifier.aci_keywords is not None
+    assert classifier.ani_keywords is not None
+    assert classifier.other_ai_keywords is not None
+    assert classifier.ml_keywords is not None
+    assert classifier.ds_keywords is not None
 
 
 def test_classifier_with_semantic():
     """Test classifier with semantic analysis enabled"""
-    classifier = AGIASIClassifier(use_semantic=True, model_id="keyword")
+    classifier = AIPapersIntelligenceClassifier(use_semantic=True, model_id="keyword")
     assert classifier.use_semantic == True
     assert classifier.model_id == "keyword"
 
 
 def test_classify_paper():
     """Test paper classification"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     test_paper = {
         'title': 'Neural Computers: A New Computing Paradigm',
@@ -35,17 +39,26 @@ def test_classify_paper():
     
     assert 'classification' in result
     assert 'classification_reason' in result
-    assert 'agi_score' in result
     assert 'asi_score' in result
+    assert 'agi_score' in result
+    assert 'aci_score' in result
+    assert 'ani_score' in result
+    assert 'other_ai_score' in result
+    assert 'ml_score' in result
+    assert 'ds_score' in result
     assert 'combined_score' in result
     assert 'matched_agi_keywords' in result
     assert 'matched_asi_keywords' in result
-    assert 'matched_related_keywords' in result
+    assert 'matched_aci_keywords' in result
+    assert 'matched_ani_keywords' in result
+    assert 'matched_other_ai_keywords' in result
+    assert 'matched_ml_keywords' in result
+    assert 'matched_ds_keywords' in result
 
 
 def test_classify_paper_agi():
     """Test classification of AGI paper"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     agi_paper = {
         'title': 'General Intelligence in AI Systems',
@@ -56,12 +69,12 @@ def test_classify_paper_agi():
     result = classifier.classify_paper(agi_paper)
     
     assert result['agi_score'] >= 1
-    assert result['classification'] in ['AGI', 'ASI', 'ACI', 'Narrow AI']
+    assert result['classification'] in ['ASI', 'AGI', 'ACI', 'ANI', 'Other AI', 'ML', 'DS']
 
 
 def test_classify_paper_asi():
     """Test classification of ASI paper"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     asi_paper = {
         'title': 'AI Safety and Alignment Problem',
@@ -72,12 +85,12 @@ def test_classify_paper_asi():
     result = classifier.classify_paper(asi_paper)
     
     assert result['asi_score'] >= 1
-    assert result['classification'] in ['AGI', 'ASI', 'ACI', 'Narrow AI']
+    assert result['classification'] in ['ASI', 'AGI', 'ACI', 'ANI', 'Other AI', 'ML', 'DS']
 
 
 def test_classify_paper_not_related():
     """Test classification of non-related paper"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     unrelated_paper = {
         'title': 'Image Classification with CNNs',
@@ -87,16 +100,16 @@ def test_classify_paper_not_related():
     
     result = classifier.classify_paper(unrelated_paper)
     
-    assert result['classification'] == 'Not Related'
+    assert result['classification'] in ['ASI', 'AGI', 'ACI', 'ANI', 'Other AI', 'ML', 'DS', 'Not Related']
 
 
 def test_batch_classify():
     """Test batch classification"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     papers = [
         {'title': 'AGI Paper', 'summary': 'About general intelligence', 'full_entry': 'AGI'},
-        {'title': 'Standard Paper', 'summary': 'Standard ML', 'full_entry': 'ML'},
+        {'title': 'ML Paper', 'summary': 'About machine learning', 'full_entry': 'ML'},
     ]
     
     results = classifier.batch_classify(papers)
@@ -107,29 +120,35 @@ def test_batch_classify():
 
 def test_get_statistics():
     """Test statistics calculation"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     classified_papers = [
-        {'classification_result': {'classification': 'AGI'}},
         {'classification_result': {'classification': 'ASI'}},
+        {'classification_result': {'classification': 'AGI'}},
         {'classification_result': {'classification': 'ACI'}},
-        {'classification_result': {'classification': 'Narrow AI'}},
+        {'classification_result': {'classification': 'ANI'}},
+        {'classification_result': {'classification': 'Other AI'}},
+        {'classification_result': {'classification': 'ML'}},
+        {'classification_result': {'classification': 'DS'}},
         {'classification_result': {'classification': 'Not Related'}},
     ]
     
     stats = classifier.get_statistics(classified_papers)
     
-    assert stats['total'] == 5
+    assert stats['total'] == 8
     assert stats['asi'] == 1
     assert stats['agi'] == 1
     assert stats['aci'] == 1
-    assert stats['narrow_ai'] == 1
+    assert stats['ani'] == 1
+    assert stats['other_ai'] == 1
+    assert stats['ml'] == 1
+    assert stats['ds'] == 1
     assert stats['not_related'] == 1
 
 
 def test_get_statistics_empty():
     """Test statistics with empty list"""
-    classifier = AGIASIClassifier()
+    classifier = AIPapersIntelligenceClassifier()
     
     stats = classifier.get_statistics([])
     
@@ -137,5 +156,8 @@ def test_get_statistics_empty():
     assert stats['asi'] == 0
     assert stats['agi'] == 0
     assert stats['aci'] == 0
-    assert stats['narrow_ai'] == 0
+    assert stats['ani'] == 0
+    assert stats['other_ai'] == 0
+    assert stats['ml'] == 0
+    assert stats['ds'] == 0
     assert stats['not_related'] == 0

tests/test_ranker.py

@@ -137,16 +137,25 @@ def test_filter_by_classification():
     
     papers = [
         {
-            'classification_result': {'classification': 'AGI'}
+            'classification_result': {'classification': 'ASI'}
         },
         {
-            'classification_result': {'classification': 'ASI'}
+            'classification_result': {'classification': 'AGI'}
         },
         {
             'classification_result': {'classification': 'ACI'}
         },
         {
-            'classification_result': {'classification': 'Narrow AI'}
+            'classification_result': {'classification': 'ANI'}
+        },
+        {
+            'classification_result': {'classification': 'Other AI'}
+        },
+        {
+            'classification_result': {'classification': 'ML'}
+        },
+        {
+            'classification_result': {'classification': 'DS'}
         },
         {
             'classification_result': {'classification': 'Not Related'}