Paper Research Assistant

{
  "ownerId": "kn7evxkda3aq9xzahf793yd15h821nan",
  "slug": "paper-research-assistant",
  "version": "1.0.0",
  "publishedAt": 1772614967556
}

{
  "slug": "paper-research-assistant",
  "name": "paper-research-assistant",
  "version": "1.0.0",
  "installedAt": 1776152397490,
  "source": "skillhub"
}

#!/usr/bin/env python3
"""
研读报告生成脚本
根据论文元数据生成结构化研读报告
"""

import argparse
import json
from pathlib import Path
from datetime import datetime


def load_template(template_path: str) -> str:
    """加载报告模板"""
    with open(template_path, 'r', encoding='utf-8') as f:
        return f.read()


def generate_report(metadata: dict, template: str) -> str:
    """生成研读报告"""
    
    # 提取核心贡献（从摘要和引言推断）
    contributions = []
    abstract = metadata.get('abstract', '')
    if 'propose' in abstract.lower():
        contributions.append(abstract.split('propose')[1].split('.')[0].strip() + '.')
    if 'introduce' in abstract.lower():
        contributions.append(abstract.split('introduce')[1].split('.')[0].strip() + '.')
    if not contributions:
        contributions = ['待详细分析论文内容']
    
    # 复现可行性评估
    reproducibility = {
        'code_available': '待确认',
        'dataset_access': '待确认',
        'complexity': '中',
        'estimated_time': '1-2 周'
    }
    
    report = f"""# 论文研读报告

**生成时间：** {datetime.now().strftime('%Y-%m-%d %H:%M')}

## 基本信息

| 项目 | 内容 |
|------|------|
| 标题 | {metadata.get('title', 'N/A')} |
| 类型 | {metadata.get('paper_type', 'N/A')} |
| 关键词 | {', '.join(metadata.get('keywords', [])) or 'N/A'} |

## 摘要

{metadata.get('abstract', 'N/A')}

## 核心贡献

{''.join([f'{i+1}. {c}\\n' for i, c in enumerate(contributions)])}

## 方法论

### 问题定义
待详细分析...

### 核心思路
待详细分析...

### 关键公式
{chr(10).join([f"- 公式 ({f['number']}): {f['content']}" for f in metadata.get('key_formulas', [])]) or '待提取'}

## 实验配置

| 配置项 | 详情 |
|--------|------|
| 数据集 | 待确认 |
| 基线方法 | 待确认 |
| 评估指标 | 待确认 |
| 超参数 | 待确认 |

## 复现可行性评估

- **官方代码：** {reproducibility['code_available']}
- **数据集：** {reproducibility['dataset_access']}
- **计算需求：** GPU (建议 RTX 3090 或更高)
- **预计难度：** {reproducibility['complexity']}
- **预计时间：** {reproducibility['estimated_time']}

## 论文章节结构

{chr(10).join([f"- {s}" for s in metadata.get('sections', [])]) or '待提取'}

## 待澄清问题

1. 论文中是否有未明确说明的实现细节？
2. 是否有未公开的关键超参数？
3. 数据集预处理步骤是否完整描述？

## 下一步行动

- [ ] 查找官方代码仓库
- [ ] 确认可用的数据集来源
- [ ] 搭建基础实验环境
- [ ] 实现核心算法模块
- [ ] 复现关键实验结果

---
*本报告由 paper-research-assistant 自动生成*
"""
    return report


def main():
    parser = argparse.ArgumentParser(description='研读报告生成工具')
    parser.add_argument('--metadata', required=True, help='论文元数据 JSON 文件')
    parser.add_argument('--template', default='references/report_template.md', help='报告模板文件')
    parser.add_argument('--output', required=True, help='输出报告文件路径')
    
    args = parser.parse_args()
    
    # 加载元数据
    with open(args.metadata, 'r', encoding='utf-8') as f:
        metadata = json.load(f)
    
    # 加载模板（如果存在）
    template_path = Path(args.template)
    if template_path.exists():
        template = load_template(str(template_path))
    else:
        template = ""
    
    # 生成报告
    report = generate_report(metadata, template)
    
    # 输出
    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(report)
    
    print(f"报告生成完成：{output_path}")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
论文 PDF 解析脚本
提取论文元数据、摘要、核心章节内容
"""

import argparse
import json
import re
from pathlib import Path

try:
    import fitz  # PyMuPDF
except ImportError:
    print("请安装 PyMuPDF: pip install pymupdf")
    exit(1)


def extract_text_from_pdf(pdf_path: str) -> str:
    """从 PDF 提取全文文本"""
    doc = fitz.open(pdf_path)
    text = ""
    for page in doc:
        text += page.get_text()
    doc.close()
    return text


def extract_metadata(text: str) -> dict:
    """提取论文元数据"""
    lines = text.split('\n')
    metadata = {
        'title': '',
        'authors': [],
        'abstract': '',
        'keywords': [],
        'sections': []
    }
    
    # 提取标题（通常是第一行非空文本）
    for line in lines:
        line = line.strip()
        if line and len(line) > 10:
            metadata['title'] = line
            break
    
    # 提取摘要
    abstract_match = re.search(r'Abstract\s*\n(.*?)(?=\n\s*\n|\n\s*[A-Z]|\Z)', text, re.DOTALL | re.IGNORECASE)
    if abstract_match:
        metadata['abstract'] = abstract_match.group(1).strip()
    
    # 提取关键词
    keywords_match = re.search(r'(?:Keywords?|Index Terms)\s*[:\-]?\s*(.*?)(?=\n\s*\n|\n\s*[A-Z])', text, re.DOTALL | re.IGNORECASE)
    if keywords_match:
        keywords_str = keywords_match.group(1)
        metadata['keywords'] = [k.strip() for k in re.split(r'[;,]', keywords_str) if k.strip()]
    
    # 提取章节标题
    section_pattern = re.compile(r'^\d+\.\s+([A-Z][^\n]+)$', re.MULTILINE)
    metadata['sections'] = section_pattern.findall(text)
    
    return metadata


def identify_paper_type(metadata: dict) -> str:
    """识别论文类型"""
    title = metadata['title'].lower()
    abstract = metadata['abstract'].lower()
    
    if 'survey' in title or 'review' in title or '综述' in title:
        return 'survey'
    elif 'method' in title or 'approach' in title or 'framework' in title:
        return 'method'
    elif 'experiment' in abstract or 'empirical' in abstract:
        return 'experimental'
    else:
        return 'theoretical'


def extract_key_formulas(text: str) -> list:
    """提取关键公式（简单启发式）"""
    formulas = []
    formula_pattern = re.compile(r'\((\d+)\)\s*([^\n]{10,200})', re.MULTILINE)
    for match in formula_pattern.finditer(text):
        formulas.append({
            'number': match.group(1),
            'content': match.group(2).strip()[:100]
        })
    return formulas[:10]


def main():
    parser = argparse.ArgumentParser(description='论文 PDF 解析工具')
    parser.add_argument('--pdf', required=True, help='PDF 文件路径')
    parser.add_argument('--output', required=True, help='输出 JSON 文件路径')
    
    args = parser.parse_args()
    
    pdf_path = Path(args.pdf)
    if not pdf_path.exists():
        print(f"错误：文件不存在 {pdf_path}")
        return
    
    print(f"正在解析：{pdf_path}")
    full_text = extract_text_from_pdf(str(pdf_path))
    metadata = extract_metadata(full_text)
    metadata['paper_type'] = identify_paper_type(metadata)
    metadata['key_formulas'] = extract_key_formulas(full_text)
    metadata['full_text_preview'] = full_text[:5000]
    
    output_path = Path(args.output)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(metadata, f, ensure_ascii=False, indent=2)
    
    print(f"解析完成：{output_path}")
    print(f"标题：{metadata['title']}")
    print(f"类型：{metadata['paper_type']}")


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
复现代码骨架生成脚本
根据论文描述生成 PyTorch/TensorFlow 代码框架
"""

import argparse
import json
from pathlib import Path


def generate_pytorch_scaffold(metadata: dict) -> dict:
    """生成 PyTorch 代码骨架"""
    title = metadata.get('title', 'Model').replace(' ', '_').replace('-', '_')
    
    files = {
        f'{title}/README.md': f"""# {metadata.get('title', 'Paper Implementation')}

Unofficial PyTorch implementation based on the paper.

## Setup

```bash
pip install -r requirements.txt
```

## Usage

```bash
python train.py --config configs/default.yaml
```

## Structure

- `model.py` - Core model architecture
- `train.py` - Training loop
- `evaluate.py` - Evaluation script
- `datasets/` - Dataset loaders
- `configs/` - Configuration files
""",
        
        f'{title}/requirements.txt': """torch>=2.0.0
torchvision>=0.15.0
numpy>=1.24.0
pandas>=2.0.0
tqdm>=4.65.0
yaml>=6.0
""",
        
        f'{title}/model.py': f'''"""
Core model architecture for {metadata.get("title", "Paper")}
"""

import torch
import torch.nn as nn


class {title.replace("_", "")}(nn.Module):
    """
    Main model class implementing the paper method.
    
    TODO: Fill in the architecture based on paper details
    """
    
    def __init__(self, config):
        super().__init__()
        self.config = config
        
        # TODO: Define model layers based on paper
        # Example:
        # self.encoder = nn.Linear(config.input_dim, config.hidden_dim)
        # self.decoder = nn.Linear(config.hidden_dim, config.output_dim)
        
    def forward(self, x):
        """
        Forward pass.
        
        Args:
            x: Input tensor
            
        Returns:
            Output tensor
        """
        # TODO: Implement forward pass based on paper method
        # x = self.encoder(x)
        # x = self.decoder(x)
        return x


def build_model(config):
    """
    Build model from config.
    
    Args:
        config: Configuration dict
        
    Returns:
        Model instance
    """
    return {title.replace("_", "")}(config)
''',
        
        f'{title}/train.py': '''"""
Training loop for paper reproduction.
"""

import argparse
import torch
from torch.utils.data import DataLoader
from tqdm import tqdm
import yaml

from model import build_model
from datasets import get_dataset


def train_epoch(model, dataloader, optimizer, criterion, device):
    """Single training epoch."""
    model.train()
    total_loss = 0
    
    for batch in tqdm(dataloader, desc="Training"):
        x, y = batch
        x, y = x.to(device), y.to(device)
        
        optimizer.zero_grad()
        output = model(x)
        loss = criterion(output, y)
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
    
    return total_loss / len(dataloader)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument('--config', type=str, default='configs/default.yaml')
    parser.add_argument('--epochs', type=int, default=100)
    parser.add_argument('--batch-size', type=int, default=32)
    parser.add_argument('--lr', type=float, default=1e-3)
    args = parser.parse_args()
    
    # Load config
    with open(args.config, 'r') as f:
        config = yaml.safe_load(f)
    
    # Setup device
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    
    # Build model
    model = build_model(config).to(device)
    
    # Setup data
    train_dataset = get_dataset(config, split='train')
    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)
    
    # Setup optimizer
    optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
    criterion = torch.nn.CrossEntropyLoss()
    
    # Training loop
    for epoch in range(args.epochs):
        loss = train_epoch(model, train_loader, optimizer, criterion, device)
        print(f"Epoch {epoch+1}/{args.epochs}, Loss: {loss:.4f}")
    
    # Save model
    torch.save(model.state_dict(), 'checkpoints/final.pth')
    print("Training completed!")


if __name__ == '__main__':
    main()
''',
        
        f'{title}/configs/default.yaml': f"""# Default configuration for {metadata.get('title', 'Model')}

model:
  input_dim: 784
  hidden_dim: 512
  output_dim: 10

training:
  epochs: 100
  batch_size: 32
  learning_rate: 0.001

data:
  dataset: 'mnist'
  data_dir: './data'
""",
        
        f'{title}/datasets/__init__.py': '''"""
Dataset loaders.
"""

from torch.utils.data import Dataset


def get_dataset(config, split='train'):
    """
    Get dataset based on config.
    
    TODO: Implement dataset loading based on paper requirements
    """
    # Example:
    # if config['data']['dataset'] == 'mnist':
    #     return MNISTDataset(config, split)
    return PlaceholderDataset(config, split)


class PlaceholderDataset(Dataset):
    """Placeholder dataset - replace with actual implementation."""
    
    def __init__(self, config, split):
        self.config = config
        self.split = split
        
    def __len__(self):
        return 1000
    
    def __getitem__(self, idx):
        # TODO: Replace with actual data loading
        return torch.zeros(10), torch.tensor(0)
'''
    }
    
    return files


def main():
    parser = argparse.ArgumentParser(description='代码骨架生成工具')
    parser.add_argument('--paper-json', required=True, help='论文元数据 JSON 文件')
    parser.add_argument('--framework', choices=['pytorch', 'tensorflow'], default='pytorch')
    parser.add_argument('--output-dir', required=True, help='输出目录')
    
    args = parser.parse_args()
    
    # 加载元数据
    with open(args.paper_json, 'r', encoding='utf-8') as f:
        metadata = json.load(f)
    
    # 生成代码
    if args.framework == 'pytorch':
        files = generate_pytorch_scaffold(metadata)
    else:
        # TODO: Add TensorFlow scaffold
        print("TensorFlow scaffold not yet implemented")
        return
    
    # 写入文件
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)
    
    for filepath, content in files.items():
        full_path = output_dir / filepath
        full_path.parent.mkdir(parents=True, exist_ok=True)
        with open(full_path, 'w', encoding='utf-8') as f:
            f.write(content)
        print(f"Created: {full_path}")
    
    print(f"\n代码骨架生成完成：{output_dir}")


if __name__ == '__main__':
    main()