@wentorai/research-plugins 1.0.0 → 1.2.0

package/skills/writing/citation/zotero-scholar-guide/SKILL.md

@@ -0,0 +1,294 @@
+---
+name: zotero-scholar-guide
+description: "Save papers with metadata to Zotero via its API programmatically"
+metadata:
+  openclaw:
+    emoji: "📚"
+    category: "writing"
+    subcategory: "citation"
+    keywords: ["zotero", "reference manager", "citation management", "API", "metadata", "bibliography", "paper organization"]
+    source: "https://github.com/zotero/zotero"
+---
+
+# Zotero Scholar Guide
+
+## Overview
+
+Zotero is the most widely used open-source reference manager in academia, offering a powerful combination of local storage, cloud sync, browser integration, and a comprehensive API. While most researchers use Zotero through its desktop application and browser connector, the Zotero API enables programmatic access that is essential for automated research workflows—saving papers from scripts, batch-importing search results, organizing libraries algorithmically, and integrating reference management into custom research pipelines.
+
+This skill covers using the Zotero Web API to create, read, update, and organize library items programmatically. It is designed for researchers who want to automate parts of their reference management workflow: importing papers from arXiv or Semantic Scholar searches directly into Zotero, auto-tagging papers based on content analysis, organizing collections programmatically, and exporting citations in various formats.
+
+The skill complements the existing `zotero-api` skill by focusing specifically on practical scholar workflows—the common patterns a researcher uses when integrating Zotero into their daily literature management.
+
+## Authentication and Setup
+
+### Obtaining API Credentials
+
+1. Log in to your Zotero account at https://www.zotero.org
+2. Navigate to Settings > Feeds/API (https://www.zotero.org/settings/keys)
+3. Click "Create new private key"
+4. Set permissions:
+   - Personal Library: Read/Write access
+   - Default Group Permissions: Read/Write (if you use group libraries)
+   - Allow access to notes (recommended)
+5. Save the API key securely
+
+```bash
+# Store your credentials as environment variables
+export ZOTERO_API_KEY=your-zotero-key   # from zotero.org/settings/keys
+export ZOTERO_USER_ID="your_user_id"  # Found on the API keys page
+```
+
+### Testing Your Connection
+
+```bash
+# Verify API access
+curl -H "Zotero-API-Key: $ZOTERO_API_KEY" \
+  "https://api.zotero.org/users/$ZOTERO_USER_ID/items?limit=5&format=json" \
+  | python3 -m json.tool | head -20
+```
+
+If you see your recent library items, authentication is working correctly.
+
+## Saving Papers to Zotero
+
+### Adding a Single Paper by DOI
+
+The simplest way to add a well-cataloged paper is by DOI. Zotero can resolve DOI metadata automatically:
+
+```python
+import requests
+import os
+
+API_KEY = os.environ["ZOTERO_API_KEY"]
+USER_ID = os.environ["ZOTERO_USER_ID"]
+BASE_URL = f"https://api.zotero.org/users/{USER_ID}"
+HEADERS = {
+    "Zotero-API-Key": API_KEY,
+    "Content-Type": "application/json"
+}
+
+def add_paper_by_doi(doi):
+    """Resolve DOI metadata and add to Zotero."""
+    # Step 1: Get metadata from DOI via Crossref
+    cr_resp = requests.get(
+        f"https://api.crossref.org/works/{doi}",
+        headers={"User-Agent": "ResearchClaw/1.0 (mailto:you@example.edu)"}
+    )
+    cr_data = cr_resp.json()["message"]
+
+    # Step 2: Build Zotero item
+    item = {
+        "itemType": "journalArticle",
+        "title": cr_data.get("title", [""])[0],
+        "creators": [
+            {"creatorType": "author", "firstName": a.get("given", ""),
+             "lastName": a.get("family", "")}
+            for a in cr_data.get("author", [])
+        ],
+        "abstractNote": cr_data.get("abstract", ""),
+        "DOI": doi,
+        "url": f"https://doi.org/{doi}",
+        "date": cr_data.get("published-print", {}).get("date-parts", [[""]])[0][0],
+        "publicationTitle": cr_data.get("container-title", [""])[0],
+        "volume": cr_data.get("volume", ""),
+        "issue": cr_data.get("issue", ""),
+        "pages": cr_data.get("page", ""),
+        "tags": [{"tag": "auto-imported"}]
+    }
+
+    # Step 3: POST to Zotero
+    resp = requests.post(
+        f"{BASE_URL}/items",
+        headers=HEADERS,
+        json=[item]
+    )
+
+    if resp.status_code == 200:
+        print(f"Added: {item['title']}")
+        return resp.json()
+    else:
+        print(f"Error: {resp.status_code} - {resp.text}")
+        return None
+
+# Usage
+add_paper_by_doi("10.1038/s41586-023-06747-5")
+```
+
+### Adding arXiv Papers
+
+arXiv papers often lack DOIs. Use the arXiv API to fetch metadata:
+
+```python
+import feedparser
+
+def add_arxiv_paper(arxiv_id):
+    """Fetch arXiv metadata and add to Zotero."""
+    feed = feedparser.parse(
+        f"http://export.arxiv.org/api/query?id_list={arxiv_id}"
+    )
+    entry = feed.entries[0]
+
+    item = {
+        "itemType": "preprint",
+        "title": entry.title.replace("\n", " "),
+        "creators": [
+            {"creatorType": "author",
+             "firstName": name.rsplit(" ", 1)[0] if " " in name else "",
+             "lastName": name.rsplit(" ", 1)[-1]}
+            for name in [a.name for a in entry.authors]
+        ],
+        "abstractNote": entry.summary.replace("\n", " "),
+        "url": entry.link,
+        "date": entry.published[:10],
+        "repository": "arXiv",
+        "archiveID": f"arXiv:{arxiv_id}",
+        "tags": [
+            {"tag": "arxiv"},
+            {"tag": entry.arxiv_primary_category["term"]}
+        ]
+    }
+
+    resp = requests.post(
+        f"{BASE_URL}/items",
+        headers=HEADERS,
+        json=[item]
+    )
+    if resp.status_code == 200:
+        print(f"Added arXiv paper: {item['title'][:80]}")
+    return resp
+
+# Usage
+add_arxiv_paper("2301.07041")
+```
+
+### Batch Import from Search Results
+
+When you run a literature search and want to import all results into Zotero:
+
+```python
+def batch_import(papers, collection_key=None):
+    """Import a list of paper dicts into Zotero.
+    Zotero API accepts up to 50 items per request.
+    """
+    batch_size = 50
+    for i in range(0, len(papers), batch_size):
+        batch = papers[i:i + batch_size]
+        items = [build_zotero_item(p) for p in batch]
+
+        # Add to specific collection if provided
+        if collection_key:
+            for item in items:
+                item["collections"] = [collection_key]
+
+        resp = requests.post(
+            f"{BASE_URL}/items",
+            headers=HEADERS,
+            json=items
+        )
+        print(f"Batch {i//batch_size + 1}: {resp.status_code}")
+```
+
+## Organizing with Collections and Tags
+
+### Creating Collections Programmatically
+
+```python
+def create_collection(name, parent_key=None):
+    """Create a new Zotero collection."""
+    collection = {
+        "name": name,
+        "parentCollection": parent_key or False
+    }
+    resp = requests.post(
+        f"{BASE_URL}/collections",
+        headers=HEADERS,
+        json=[collection]
+    )
+    if resp.status_code == 200:
+        key = resp.json()["successful"]["0"]["key"]
+        print(f"Created collection '{name}' with key: {key}")
+        return key
+    return None
+
+# Create a hierarchical structure
+lit_review = create_collection("Literature Review 2026")
+methods = create_collection("Methods Papers", parent_key=lit_review)
+results = create_collection("Results Papers", parent_key=lit_review)
+```
+
+### Auto-Tagging Based on Content
+
+```python
+def auto_tag_items(keyword_map):
+    """Tag existing items based on abstract content.
+    keyword_map: dict of {tag: [keywords]}
+    """
+    # Fetch all items
+    items = requests.get(
+        f"{BASE_URL}/items?limit=100&format=json",
+        headers=HEADERS
+    ).json()
+
+    for item in items:
+        abstract = item["data"].get("abstractNote", "").lower()
+        new_tags = list(item["data"].get("tags", []))
+        existing_tag_names = {t["tag"] for t in new_tags}
+
+        for tag, keywords in keyword_map.items():
+            if tag not in existing_tag_names:
+                if any(kw.lower() in abstract for kw in keywords):
+                    new_tags.append({"tag": tag})
+
+        if len(new_tags) > len(item["data"].get("tags", [])):
+            requests.patch(
+                f"{BASE_URL}/items/{item['key']}",
+                headers={**HEADERS, "If-Unmodified-Since-Version": str(item["version"])},
+                json={"tags": new_tags}
+            )
+
+# Usage
+auto_tag_items({
+    "deep-learning": ["deep learning", "neural network", "CNN", "transformer"],
+    "nlp": ["natural language", "text classification", "language model"],
+    "computer-vision": ["image classification", "object detection", "segmentation"]
+})
+```
+
+## Exporting Citations
+
+### Export in Various Formats
+
+```bash
+# Export entire library as BibTeX
+curl -H "Zotero-API-Key: $ZOTERO_API_KEY" \
+  "https://api.zotero.org/users/$ZOTERO_USER_ID/items?format=bibtex&limit=100" \
+  > library.bib
+
+# Export a specific collection as CSL-JSON
+curl -H "Zotero-API-Key: $ZOTERO_API_KEY" \
+  "https://api.zotero.org/users/$ZOTERO_USER_ID/collections/ABCD1234/items?format=csljson" \
+  > collection.json
+
+# Export as RIS (for import into other tools)
+curl -H "Zotero-API-Key: $ZOTERO_API_KEY" \
+  "https://api.zotero.org/users/$ZOTERO_USER_ID/items?format=ris&limit=100" \
+  > library.ris
+```
+
+### Generating a Bibliography
+
+```bash
+# Generate formatted bibliography in APA style
+curl -H "Zotero-API-Key: $ZOTERO_API_KEY" \
+  -H "Content-Type: application/json" \
+  "https://api.zotero.org/users/$ZOTERO_USER_ID/items?format=bib&style=apa&limit=50"
+```
+
+## References
+
+- Zotero Web API v3 documentation: https://www.zotero.org/support/dev/web_api/v3/start
+- Zotero source code: https://github.com/zotero/zotero
+- pyzotero (Python library): https://github.com/urschrei/pyzotero
+- Crossref API: https://api.crossref.org
+- Zotero Better BibTeX plugin: https://retorque.re/zotero-better-bibtex/

package/skills/writing/citation/zotfile-attachment-guide/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: zotfile-attachment-guide
+description: "Guide to ZotFile for Zotero attachment management, renaming, and syncing"
+metadata:
+  openclaw:
+    emoji: "📂"
+    category: "writing"
+    subcategory: "citation"
+    keywords: ["zotero", "zotfile", "attachment", "pdf-management", "file-organization", "sync"]
+    source: "https://github.com/jlegewie/zotfile"
+---
+
+# ZotFile Attachment Management Guide
+
+## Overview
+
+ZotFile is one of the most established Zotero plugins with over 4,000 GitHub stars, providing advanced file management capabilities for PDF attachments and other documents linked to your Zotero library. It handles the critical but often neglected task of organizing, renaming, and synchronizing the actual files that make up a research library.
+
+Without ZotFile, researchers often end up with a chaotic collection of PDFs named with meaningless publisher-generated identifiers, scattered across different directories, and difficult to manage outside of Zotero itself. ZotFile brings order to this chaos by automatically renaming files according to customizable patterns based on bibliographic metadata, moving them to organized directory structures, and managing tablet-based reading workflows.
+
+The plugin is especially valuable for researchers with large libraries who need their PDFs accessible outside Zotero, whether for backup, sharing, or use with other tools. By maintaining a predictable, human-readable file naming and directory structure, ZotFile ensures that your research documents remain organized and accessible regardless of how you access them.
+
+## Installation and Setup
+
+Install ZotFile through the Zotero add-on mechanism:
+
+1. Download the latest `.xpi` file from https://github.com/jlegewie/zotfile/releases
+2. In Zotero, navigate to Tools > Add-ons > gear icon > Install Add-on From File
+3. Select the `.xpi` file and restart Zotero
+
+Configure ZotFile after installation:
+
+- Open Tools > ZotFile Preferences
+- **General Settings**:
+  - Set the source folder for new files (where your browser downloads PDFs)
+  - Set the custom location for linked attachments (e.g., `~/Documents/Research/Papers`)
+  - Choose between "Attach stored copy" (files in Zotero data directory) or "Linked file" (files in custom location)
+
+- **Renaming Rules**:
+  - Configure the filename pattern using wildcards:
+    - `{%a}` - Author last name
+    - `{%y}` - Year
+    - `{%t}` - Title
+    - `{%j}` - Journal abbreviation
+  - Example pattern: `{%a}_{%y}_{%t}` produces `Smith_2024_Deep_Learning_for_Protein.pdf`
+  - Set maximum title length to prevent overly long filenames
+  - Configure treatment of special characters and spaces
+
+- **Tablet Settings** (if using a tablet for reading):
+  - Set the tablet files directory (e.g., a cloud-synced folder)
+  - Configure background file handling
+  - Enable automatic extraction of annotations from returned tablet PDFs
+
+## Core Features
+
+**Automatic File Renaming**: When you add a new item with an attachment to Zotero, ZotFile can automatically rename the PDF based on the item's metadata. This transforms `10.1038_s41586-024-07487-w.pdf` into `Smith_2024_Title_of_Paper.pdf` without any manual intervention.
+
+Renaming patterns support rich formatting:
+
+| Pattern | Output Example | Description |
+|---------|---------------|-------------|
+| `{%a}_{%y}_{%t}` | `Smith_2024_Deep_Learning` | Author, year, title |
+| `{%a}_{%y}_{%j}` | `Smith_2024_Nature` | Author, year, journal |
+| `{%y}/{%a}_{%t}` | `2024/Smith_Deep_Learning` | Year subfolder, author, title |
+| `{%a_zotero}_{%y}` | `SmithAndJones_2024` | Multiple authors |
+
+**Custom File Location**: Move attachments from Zotero's internal storage to a custom directory structure. This is essential for researchers who:
+- Want PDFs accessible from file managers and other applications
+- Need to store files on specific drives with more storage capacity
+- Want a predictable directory structure for scripting and automation
+- Prefer linked files over Zotero-managed storage for portability
+
+**Subfolder Organization**: Create automatic subfolder structures based on metadata:
+- Organize by year: `{%y}/` creates `2024/`, `2023/`, etc.
+- Organize by author: `{%a}/` creates `Smith/`, `Jones/`, etc.
+- Organize by collection: mirror your Zotero collection hierarchy
+- Combine patterns: `{%y}/{%j}/` creates `2024/Nature/`, `2024/Science/`
+
+**Tablet Reading Workflow**: ZotFile manages a bidirectional sync between your Zotero library and a tablet reading folder:
+
+1. Select papers you want to read on your tablet
+2. Right-click > Manage Attachments > Send to Tablet
+3. ZotFile copies PDFs to your configured tablet directory (typically a cloud-synced folder)
+4. Read and annotate on your tablet using your preferred PDF reader
+5. When finished, right-click > Manage Attachments > Get from Tablet
+6. ZotFile retrieves the annotated PDFs and extracts new annotations into Zotero notes
+
+**PDF Annotation Extraction**: ZotFile can extract highlights and text annotations from PDFs and convert them into Zotero notes. This works with annotations made in any PDF reader, not just Zotero's built-in reader. Each annotation includes:
+- The highlighted or annotated text
+- The page number for reference
+- Color coding information
+- Any comments you added
+
+**Batch Operations**: Process your entire library or selected collections at once:
+- Rename all attachments according to current rules
+- Move all files to the custom location
+- Extract annotations from all PDFs
+- Update file links after moving directories
+
+## Research Workflow Best Practices
+
+**Setting Up a New Library**:
+1. Configure ZotFile with your preferred naming pattern and directory
+2. Import your existing PDFs into Zotero with metadata
+3. Select all items and run "Rename and Move Attachments" to normalize everything
+4. Verify the resulting file structure meets your needs
+
+**Daily Workflow**:
+1. Download new papers through your browser
+2. Add them to Zotero (drag and drop or browser connector)
+3. ZotFile automatically renames and moves the PDF
+4. The file appears in your organized directory with a readable name
+
+**Backup Strategy**: With ZotFile managing files in a known directory:
+- Use Time Machine, rsync, or cloud storage to back up the PDF directory
+- Back up the Zotero database separately
+- The combination ensures full recoverability
+
+**Collaboration**: Share your organized PDF directory with collaborators:
+- The human-readable filenames make it easy to find specific papers
+- The directory structure provides intuitive browsing
+- Pair with a shared BibTeX file for complete reference sharing
+
+**Migration from Other Managers**: When switching from Mendeley, EndNote, or other tools:
+1. Export your library to a standard format (BibTeX or RIS)
+2. Import into Zotero
+3. Add your existing PDFs
+4. Run ZotFile renaming to normalize all filenames to your chosen convention
+5. Verify all file links are correct
+
+## Compatibility Notes
+
+ZotFile was originally developed for Zotero 5 and earlier versions. For Zotero 7 users, check the GitHub repository for the latest compatibility information. Some features may be handled natively in newer Zotero versions, while others may require the updated plugin. The Zotero community actively maintains compatibility guides for major plugin migrations.
+
+## References
+
+- GitHub Repository: https://github.com/jlegewie/zotfile
+- ZotFile Documentation: http://zotfile.com
+- Zotero Plugin Directory: https://www.zotero.org/support/plugins
+- Zotero File Management Guide: https://www.zotero.org/support/attaching_files

package/skills/writing/composition/ml-paper-writing/SKILL.md

@@ -0,0 +1,163 @@
+---
+name: ml-paper-writing
+description: "Write ML/AI research papers targeting NeurIPS, ICML, and ICLR venues"
+metadata:
+  openclaw:
+    emoji: "🧠"
+    category: "writing"
+    subcategory: "composition"
+    keywords: ["machine learning", "NeurIPS", "ICML", "ICLR", "AI paper", "deep learning", "conference paper"]
+    source: "https://github.com/karpathy/arxiv-sanity-lite"
+---
+
+# ML Paper Writing
+
+## Overview
+
+Publishing at top machine learning venues—NeurIPS, ICML, ICLR, AAAI, and similar conferences—requires not only strong technical contributions but also clear, persuasive writing that follows community conventions. The reviewing process at these venues is highly competitive (acceptance rates of 15-30%), and the difference between a borderline accept and a borderline reject often comes down to how well the paper communicates its contributions.
+
+This skill provides a comprehensive guide to writing ML/AI research papers that meet the expectations of reviewers at top venues. It covers paper structure, the specific writing conventions of the ML community, common reviewer complaints to avoid, and practical templates for each section.
+
+The guidance here is based on published reviewer guidelines from NeurIPS, ICML, and ICLR, as well as widely-cited advice from established researchers in the field.
+
+## Paper Structure and Section Guide
+
+### Title
+
+Your title should be specific and informative. Avoid generic titles like "A Novel Approach to X." Include:
+- The key technical contribution or method name
+- The problem domain or task
+- Optionally, a hint at the result
+
+**Good examples:**
+- "Attention Is All You Need"
+- "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding"
+- "Scaling Laws for Neural Language Models"
+
+**Avoid:**
+- "A Deep Learning Approach for Better Results" (too vague)
+- "On Some Properties of Neural Networks" (uninformative)
+
+### Abstract (150-250 words)
+
+Structure your abstract as four implicit paragraphs, even if written as a single block:
+
+1. **Context** (1-2 sentences): What problem area are you working in? Why does it matter?
+2. **Gap/Problem** (1-2 sentences): What specific limitation or open question does your work address?
+3. **Approach** (2-3 sentences): What is your method? What is the key insight?
+4. **Results** (2-3 sentences): What are your main empirical results? Include specific numbers (accuracy, speedup, etc.).
+
+### Introduction (1-1.5 pages)
+
+The introduction expands the abstract with more context and should accomplish:
+
+1. Motivate the problem with a concrete example or real-world impact
+2. Summarize the current state of the art and its limitations
+3. State your contributions as a numbered or bulleted list (typically 3-4 points)
+4. Briefly describe the paper's organization
+
+**The contribution list is critical.** Reviewers often decide their initial impression from the contribution bullets. Each contribution should be specific and falsifiable, not vague ("We propose a novel method" is weak; "We propose X, which achieves Y% improvement on Z benchmark" is strong).
+
+### Related Work (0.5-1.5 pages)
+
+In ML papers, Related Work can appear after the Introduction or before the Conclusion. Position it after the Introduction if your method is best understood in the context of prior work; put it near the end if it would interrupt the flow of your technical exposition.
+
+- Organize by theme, not chronologically
+- Explicitly state how your work differs from each group of related methods
+- Be fair and generous—reviewers may be the authors of cited papers
+- Cover the most recent work (last 2 years); missing recent papers is a common reviewer complaint
+
+### Method (2-3 pages)
+
+This is the core of your paper. Structure it as:
+
+1. **Problem formulation**: Define notation, input/output, and the objective mathematically
+2. **Method overview**: A high-level description (ideally with a figure showing the architecture or pipeline)
+3. **Detailed description**: Each component of your method in its own subsection
+4. **Training procedure**: Loss functions, optimization details, any tricks
+
+**Tips:**
+- Use a method figure (architecture diagram) early in this section
+- Define all notation before first use
+- Use consistent notation throughout (common complaint: variable names change between sections)
+- If your method has multiple components, use an algorithm box (Algorithm 1) to summarize
+
+### Experiments (2-3 pages)
+
+This section must answer: "Does the proposed method work, and why?"
+
+Structure:
+1. **Experimental setup**: Datasets, baselines, evaluation metrics, implementation details
+2. **Main results**: Comparison tables against baselines on standard benchmarks
+3. **Ablation study**: Remove or modify each component of your method to show each one matters
+4. **Analysis**: Qualitative examples, visualization of learned representations, failure cases
+
+**Common reviewer complaints to preempt:**
+- "The baselines are weak/outdated" — Include SOTA methods from the last 1-2 years
+- "Missing ablation study" — Always include one
+- "No error bars/confidence intervals" — Report mean and standard deviation over 3-5 runs
+- "No computational cost comparison" — Report FLOPs, wall-clock time, or parameter counts
+
+### Conclusion
+
+Keep it short (0.5 pages). Summarize contributions, state limitations honestly (reviewers appreciate this), and suggest future directions.
+
+## Writing Style for ML Papers
+
+### Clarity and Precision
+
+- Use active voice: "We propose" not "It is proposed"
+- Define acronyms at first use
+- Keep sentences short—aim for one idea per sentence
+- Use mathematical notation consistently
+- Avoid hedge words unless truly uncertain ("Our method achieves" not "Our method seems to achieve")
+
+### Figures and Tables
+
+- Every figure and table must be referenced in the text
+- Use vector graphics (PDF/SVG) for plots, not rasterized PNG
+- Tables should have clear column headers and the best result should be **bolded**
+- Include a descriptive caption that lets the figure/table stand alone
+
+### Reproducibility Checklist
+
+NeurIPS and ICML now require a reproducibility checklist. Address these in your paper:
+
+- Exact hyperparameters and how they were selected
+- Random seeds used
+- Computational resources (GPU type, training time)
+- Dataset splits and preprocessing details
+- Code availability (link to anonymized repository for review)
+
+## Submission Logistics
+
+### Formatting
+
+- Use the official LaTeX template for your target venue (NeurIPS, ICML, ICLR each have their own)
+- Do not exceed the page limit (typically 8-9 pages for main content, unlimited for references and appendix)
+- Anonymous submission: remove author names, avoid self-identifying references ("In our prior work [Author, 2024]" should be "In prior work [Anonymous, 2024]")
+
+### Supplementary Material
+
+Use the appendix for:
+- Extended proofs
+- Additional experimental results
+- Implementation details and pseudocode
+- Dataset details and preprocessing steps
+
+Reviewers are not required to read the appendix, so the main paper must be self-contained.
+
+### Rebuttal Preparation
+
+After reviews come in, you typically have 1 week for a rebuttal. Prepare by:
+- Running additional experiments that reviewers might request (start before reviews arrive)
+- Having a collaborator re-read the paper to anticipate potential criticisms
+- Drafting template responses for common concerns (computational cost, additional baselines, etc.)
+
+## References
+
+- NeurIPS 2025 Call for Papers and Reviewer Guidelines: https://neurips.cc
+- ICML Author Instructions: https://icml.cc
+- ICLR Submission Guidelines: https://iclr.cc
+- Karpathy's arXiv Sanity: https://github.com/karpathy/arxiv-sanity-lite
+- Liang, P. "How to Write a Good ML Paper" (Stanford CS229 handout)