科研 Skill
文献计量学分析
scientometrics
Runs bibliometric analysis including h-index, citation counts, co-authorship and co-citation networks, and VOSviewer-compatible output. Use when evaluating a publication record.
SKILL.md
Scientometrics
TL;DR — Bibliometric analysis via the OpenAlex API. Compute author h-index and citation counts, build co-authorship networks with NetworkX, run co-citation and bibliographic coupling analyses, identify research fronts, and export VOSviewer-compatible edge/node files.
1. Overview
What Problem Does This Skill Solve?
Scientometrics provides quantitative methods for understanding how science evolves, who the key players are, and which research fronts are emerging. Manual analysis is tedious and error-prone. This Skill automates the full pipeline:
- Author-level metrics — h-index, total citations, career publication count
- Journal impact — field-normalized citation counts from the OpenAlex works endpoint
- Co-authorship networks — graph construction, centrality, community detection
- Co-citation analysis — which papers are frequently cited together
- Bibliographic coupling — which papers share many references
- Research front identification — fast-growing citation clusters
- VOSviewer export — ready-to-open
.txtfiles for interactive visualization
Applicable Scenarios
| Scenario | Entry Point |
|---|---|
| Evaluate a researcher before collaboration | get_author_metrics(orcid) |
| Map the intellectual structure of a field | build_coauthorship_network(topic, years) |
| Find seminal papers for a literature review | identify_research_fronts(topic) |
| Visualize a network in VOSviewer | export_vosviewer_network(G) |
| Benchmark journal standing | get_journal_impact(issn) |
Key Limitations
- OpenAlex author disambiguation is imperfect; prefer ORCID-based lookups when available.
- Citation counts lag by ~2 weeks from the live OpenAlex index.
- Co-authorship graphs for very large topics (>50 000 papers) require pagination and may take several minutes to build.
- VOSviewer export uses the simple pair-wise weight format; large networks (>5 000 nodes) may be slow to open in VOSviewer.
2. Environment Setup
# Create and activate a dedicated environment
conda create -n scientometrics python=3.11 -y
conda activate scientometrics
# Install all dependencies
pip install requests pandas networkx matplotlib numpy scipy
# Optional: set a polite-pool email for OpenAlex (improves response speed)
export OPENALEX_EMAIL="researcher@university.edu"
Verify the installation:
import requests, pandas, networkx, matplotlib, numpy, scipy
print("All scientometrics dependencies OK")
print(f"NetworkX version: {networkx.__version__}")
3. Core Implementation
3.1 Shared Utilities
import os
import time
import requests
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from typing import Optional, List, Dict, Tuple
from collections import defaultdict
OPENALEX_BASE = "https://api.openalex.org"
DEFAULT_EMAIL = os.getenv("OPENALEX_EMAIL", "researcher@example.com")
def _oa_get(endpoint: str, params: dict, retries: int = 3) -> dict:
"""
Thin wrapper around OpenAlex GET with retry logic.
Args:
endpoint: API endpoint path, e.g. '/works' or '/authors/A1234'.
params: Query parameters dict.
retries: Number of retry attempts on transient errors.
Returns:
Parsed JSON response dict.
"""
url = OPENALEX_BASE + endpoint
params.setdefault("mailto", DEFAULT_EMAIL)
for attempt in range(retries):
try:
resp = requests.get(url, params=params, timeout=30)
resp.raise_for_status()
return resp.json()
except requests.HTTPError as exc:
if exc.response.status_code == 429:
time.sleep(2 ** attempt)
else:
raise
raise RuntimeError(f"Failed after {retries} retries: {url}")
def reconstruct_abstract(inverted_index: Optional[dict]) -> str:
"""Reconstruct plain-text abstract from OpenAlex inverted index."""
if not inverted_index:
return ""
max_pos = max(pos for positions in inverted_index.values() for pos in positions)
words = [""] * (max_pos + 1)
for word, positions in inverted_index.items():
for pos in positions:
words[pos] = word
return " ".join(words)
3.2 Author Metrics
def get_author_metrics(
orcid: Optional[str] = None,
openalex_author_id: Optional[str] = None,
) -> dict:
"""
Fetch comprehensive metrics for a researcher from OpenAlex.
Provide either an ORCID (preferred) or an OpenAlex author ID (e.g. 'A1234567890').
Args:
orcid: ORCID identifier, e.g. '0000-0002-1234-5678'.
openalex_author_id: OpenAlex author ID string, e.g. 'A1234567890'.
Returns:
Dict with keys: name, orcid, openalex_id, works_count, cited_by_count,
h_index, i10_index, top_venues, years_active, works_df.
"""
if orcid:
data = _oa_get(f"/authors/orcid:{orcid}", {})
elif openalex_author_id:
data = _oa_get(f"/authors/{openalex_author_id}", {})
else:
raise ValueError("Provide either orcid or openalex_author_id.")
author_id = data["id"].split("/")[-1]
# Fetch all works by this author
works = _fetch_all_works(
filter_str=f"author.id:{author_id}",
select="doi,title,publication_year,cited_by_count,primary_location",
max_results=5000,
)
# Compute derived metrics
h_index = compute_h_index(works)
citation_counts = [w.get("cited_by_count", 0) for w in works]
i10_index = sum(1 for c in citation_counts if c >= 10)
venues = [
(w.get("primary_location") or {}).get("source", {}) or {}
for w in works
]
venue_names = [v.get("display_name", "") for v in venues if v.get("display_name")]
from collections import Counter
top_venues = Counter(venue_names).most_common(5)
years = [w.get("publication_year") for w in works if w.get("publication_year")]
years_active = (min(years), max(years)) if years else (None, None)
works_df = pd.DataFrame([{
"doi": (w.get("doi") or "").replace("https://doi.org/", ""),
"title": w.get("title", ""),
"year": w.get("publication_year"),
"citations": w.get("cited_by_count", 0),
"venue": ((w.get("primary_location") or {}).get("source") or {}).get("display_name", ""),
} for w in works])
return {
"name": data.get("display_name", ""),
"orcid": data.get("orcid", ""),
"openalex_id": author_id,
"works_count": data.get("works_count", len(works)),
"cited_by_count": data.get("cited_by_count", sum(citation_counts)),
"h_index": h_index,
"i10_index": i10_index,
"top_venues": top_venues,
"years_active": years_active,
"works_df": works_df,
}
def compute_h_index(works: List[dict]) -> int:
"""
Compute the h-index from a list of OpenAlex work objects.
Args:
works: List of work dicts; each must have a 'cited_by_count' key.
Returns:
Integer h-index value.
"""
citations = sorted(
[w.get("cited_by_count", 0) for w in works], reverse=True
)
h = 0
for i, c in enumerate(citations, start=1):
if c >= i:
h = i
else:
break
return h
def _fetch_all_works(
filter_str: str,
select: str,
max_results: int = 2000,
) -> List[dict]:
"""Paginate through /works endpoint and return all matching work dicts."""
per_page = 200
page = 1
collected = []
while len(collected) < max_results:
data = _oa_get("/works", {
"filter": filter_str,
"select": select,
"per-page": per_page,
"page": page,
})
results = data.get("results", [])
if not results:
break
collected.extend(results)
meta = data.get("meta", {})
total = meta.get("count", 0)
if page * per_page >= min(total, max_results):
break
page += 1
time.sleep(0.1)
return collected[:max_results]
3.3 Co-Authorship Network
def build_coauthorship_network(
topic: str,
years: Tuple[int, int] = (2018, 2024),
max_papers: int = 1000,
min_edge_weight: int = 2,
) -> nx.Graph:
"""
Build a co-authorship network for a research topic from OpenAlex.
Each node is an author; edge weight equals the number of papers co-authored
within the specified year range.
Args:
topic: Search query string for the topic.
years: Tuple (from_year, to_year) inclusive.
max_papers: Maximum papers to fetch (impacts runtime).
min_edge_weight: Minimum co-authored papers to include an edge.
Returns:
NetworkX Graph with node attributes: name, works_count, citations;
and edge attribute: weight.
"""
filter_str = (
f"default.search:{topic},"
f"publication_year:{years[0]}-{years[1]}"
)
works = _fetch_all_works(
filter_str=filter_str,
select="id,title,authorships,cited_by_count",
max_results=max_papers,
)
edge_weights: Dict[Tuple[str, str], int] = defaultdict(int)
node_attrs: Dict[str, dict] = {}
for work in works:
authorships = work.get("authorships", [])
author_ids = []
for a in authorships:
author = a.get("author") or {}
aid = (author.get("id") or "").split("/")[-1]
aname = author.get("display_name", "")
if aid:
author_ids.append(aid)
if aid not in node_attrs:
node_attrs[aid] = {
"name": aname,
"works_count": 0,
"citations": 0,
}
node_attrs[aid]["works_count"] += 1
node_attrs[aid]["citations"] += work.get("cited_by_count", 0)
# Add edge for every pair of co-authors
for i in range(len(author_ids)):
for j in range(i + 1, len(author_ids)):
a, b = sorted([author_ids[i], author_ids[j]])
edge_weights[(a, b)] += 1
G = nx.Graph()
for aid, attrs in node_attrs.items():
G.add_node(aid, **attrs)
for (a, b), weight in edge_weights.items():
if weight >= min_edge_weight:
G.add_edge(a, b, weight=weight)
print(
f"Co-authorship network: {G.number_of_nodes()} authors, "
f"{G.number_of_edges()} edges (min_weight={min_edge_weight})"
)
return G
def plot_coauthorship_network(
G: nx.Graph,
top_n: int = 50,
output_path: Optional[str] = None,
) -> plt.Figure:
"""
Visualize the largest connected component of a co-authorship network.
Nodes are sized by citation count; edges by co-authorship weight.
Community detection uses the Louvain algorithm via networkx.
Args:
G: Co-authorship graph from build_coauthorship_network().
top_n: Show only the top-N authors by citations for clarity.
output_path: Optional file path to save the figure (PNG/PDF/SVG).
Returns:
Matplotlib Figure object.
"""
# Select top-N authors by citations
citations = nx.get_node_attributes(G, "citations")
top_nodes = sorted(citations, key=citations.get, reverse=True)[:top_n]
subG = G.subgraph(top_nodes).copy()
# Community detection
try:
from networkx.algorithms.community import greedy_modularity_communities
communities = list(greedy_modularity_communities(subG))
node_community = {}
for idx, comm in enumerate(communities):
for node in comm:
node_community[node] = idx
except Exception:
node_community = {n: 0 for n in subG.nodes()}
pos = nx.spring_layout(subG, seed=42, k=0.5)
node_sizes = [max(50, citations.get(n, 0) / 10) for n in subG.nodes()]
node_colors = [node_community.get(n, 0) for n in subG.nodes()]
edge_widths = [subG[u][v]["weight"] * 0.5 for u, v in subG.edges()]
names = nx.get_node_attributes(subG, "name")
fig, ax = plt.subplots(figsize=(14, 10))
nx.draw_networkx_edges(subG, pos, width=edge_widths, alpha=0.3, ax=ax)
nx.draw_networkx_nodes(
subG, pos, node_size=node_sizes,
node_color=node_colors, cmap=cm.tab20, alpha=0.85, ax=ax,
)
nx.draw_networkx_labels(
subG, pos,
labels={n: names.get(n, n)[:20] for n in subG.nodes()},
font_size=6, ax=ax,
)
ax.set_title(f"Co-authorship Network (top {top_n} authors by citations)")
ax.axis("off")
fig.tight_layout()
if output_path:
fig.savefig(output_path, dpi=150)
print(f"Saved network plot to {output_path}")
return fig
3.4 Co-Citation and Bibliographic Coupling
def compute_cocitation_matrix(
works: List[dict],
top_n: int = 100,
) -> pd.DataFrame:
"""
Compute a co-citation matrix: how often two papers are cited together.
Co-citation strength(A, B) = number of papers in the corpus that cite both A and B.
Args:
works: List of work dicts with 'referenced_works' field from OpenAlex.
top_n: Return only the top-N most co-cited pairs as a DataFrame.
Returns:
DataFrame with columns: paper_a, paper_b, cocitation_count.
"""
# Build inverted index: reference -> set of citing papers
citing: Dict[str, set] = defaultdict(set)
for work in works:
work_id = work.get("id", "")
for ref in work.get("referenced_works", []):
citing[ref].add(work_id)
# Count co-citations for all pairs of references
ref_list = list(citing.keys())
cocitation: Dict[Tuple[str, str], int] = defaultdict(int)
for citing_work_id in set().union(*citing.values()):
refs_cited_by_this = [r for r, citers in citing.items() if citing_work_id in citers]
for i in range(len(refs_cited_by_this)):
for j in range(i + 1, len(refs_cited_by_this)):
a, b = sorted([refs_cited_by_this[i], refs_cited_by_this[j]])
cocitation[(a, b)] += 1
rows = [
{"paper_a": a, "paper_b": b, "cocitation_count": cnt}
for (a, b), cnt in cocitation.items()
]
df = pd.DataFrame(rows).sort_values("cocitation_count", ascending=False).head(top_n)
return df.reset_index(drop=True)
def compute_bibliographic_coupling(
works: List[dict],
top_n: int = 100,
) -> pd.DataFrame:
"""
Compute bibliographic coupling strength between pairs of papers.
Coupling(A, B) = number of references shared by both A and B.
Args:
works: List of work dicts with 'referenced_works' from OpenAlex.
top_n: Return only the top-N strongest coupled pairs.
Returns:
DataFrame with columns: paper_a, paper_b, shared_references.
"""
work_refs: Dict[str, set] = {}
for work in works:
wid = work.get("id", "")
refs = set(work.get("referenced_works", []))
if refs:
work_refs[wid] = refs
work_ids = list(work_refs.keys())
coupling_rows = []
for i in range(len(work_ids)):
for j in range(i + 1, len(work_ids)):
a, b = work_ids[i], work_ids[j]
shared = len(work_refs[a] & work_refs[b])
if shared > 0:
coupling_rows.append({"paper_a": a, "paper_b": b, "shared_references": shared})
df = pd.DataFrame(coupling_rows)
if df.empty:
return df
return df.sort_values("shared_references", ascending=False).head(top_n).reset_index(drop=True)
3.5 Research Front Identification
def identify_research_fronts(
topic: str,
years: Tuple[int, int] = (2020, 2024),
max_papers: int = 500,
top_fronts: int = 10,
) -> pd.DataFrame:
"""
Identify emerging research fronts for a topic by finding fast-growing
citation clusters using year-over-year citation acceleration.
Args:
topic: Search query string.
years: Year range to consider.
max_papers: Maximum papers to analyse.
top_fronts: Number of research fronts (papers) to return.
Returns:
DataFrame of papers sorted by citation acceleration (citations_per_year).
"""
filter_str = (
f"default.search:{topic},"
f"publication_year:{years[0]}-{years[1]}"
)
works = _fetch_all_works(
filter_str=filter_str,
select="id,doi,title,publication_year,cited_by_count,abstract_inverted_index",
max_results=max_papers,
)
current_year = 2026
rows = []
for w in works:
pub_year = w.get("publication_year") or current_year
age = max(1, current_year - pub_year)
citations = w.get("cited_by_count", 0)
rows.append({
"openalex_id": (w.get("id") or "").split("/")[-1],
"doi": (w.get("doi") or "").replace("https://doi.org/", ""),
"title": w.get("title", ""),
"year": pub_year,
"citations": citations,
"citations_per_year": round(citations / age, 2),
"abstract": reconstruct_abstract(w.get("abstract_inverted_index")),
})
df = pd.DataFrame(rows)
df = df.sort_values("citations_per_year", ascending=False).head(top_fronts)
return df.reset_index(drop=True)
3.6 VOSviewer Export
def export_vosviewer_network(
G: nx.Graph,
output_map: str = "vosviewer_map.txt",
output_network: str = "vosviewer_network.txt",
) -> None:
"""
Export a NetworkX graph to VOSviewer-compatible map and network files.
The map file contains node labels and weights; the network file contains
edge pairs with weights. Both use tab-separated format expected by VOSviewer.
Args:
G: NetworkX Graph with node attribute 'name' and optional
'citations' (used as node weight).
output_map: Path for the VOSviewer map (nodes) file.
output_network: Path for the VOSviewer network (edges) file.
"""
# Build integer ID mapping (VOSviewer uses 1-indexed integers)
nodes = list(G.nodes())
node_to_int = {n: i + 1 for i, n in enumerate(nodes)}
names = nx.get_node_attributes(G, "name")
citations = nx.get_node_attributes(G, "citations")
with open(output_map, "w", encoding="utf-8") as f_map:
f_map.write("id\tlabel\tweight\n")
for node in nodes:
nid = node_to_int[node]
label = names.get(node, node)
weight = citations.get(node, 1)
f_map.write(f"{nid}\t{label}\t{weight}\n")
with open(output_network, "w", encoding="utf-8") as f_net:
f_net.write("from\tto\tstrength\n")
for u, v, data in G.edges(data=True):
uid = node_to_int[u]
vid = node_to_int[v]
strength = data.get("weight", 1)
f_net.write(f"{uid}\t{vid}\t{strength}\n")
print(
f"VOSviewer export: {len(nodes)} nodes -> {output_map}, "
f"{G.number_of_edges()} edges -> {output_network}"
)
def get_journal_impact(
issn: str,
from_year: int = 2019,
to_year: int = 2024,
) -> dict:
"""
Retrieve journal-level publication and citation statistics from OpenAlex.
Args:
issn: ISSN of the journal (e.g. '0028-0836' for Nature).
from_year: Start of citation window.
to_year: End of citation window.
Returns:
Dict with keys: display_name, issn, works_count, cited_by_count,
mean_citations_per_paper, top_cited_papers.
"""
source_data = _oa_get(f"/sources/issn:{issn}", {})
source_id = source_data.get("id", "").split("/")[-1]
display_name = source_data.get("display_name", "")
works = _fetch_all_works(
filter_str=f"primary_location.source.id:{source_id},publication_year:{from_year}-{to_year}",
select="doi,title,publication_year,cited_by_count",
max_results=2000,
)
citation_counts = [w.get("cited_by_count", 0) for w in works]
mean_cit = round(np.mean(citation_counts), 2) if citation_counts else 0
top_cited = sorted(works, key=lambda w: w.get("cited_by_count", 0), reverse=True)[:10]
top_df = pd.DataFrame([{
"title": w.get("title", ""),
"year": w.get("publication_year"),
"citations": w.get("cited_by_count", 0),
} for w in top_cited])
return {
"display_name": display_name,
"issn": issn,
"works_count": len(works),
"cited_by_count": sum(citation_counts),
"mean_citations_per_paper": mean_cit,
"top_cited_papers": top_df,
}
4. End-to-End Examples
Example 1 — Map the Research Landscape of "Transformer Neural Networks" 2018-2024
# Step 1: Identify research fronts
fronts = identify_research_fronts(
topic="transformer neural networks",
years=(2018, 2024),
max_papers=500,
top_fronts=15,
)
print("Top research fronts (by citations/year):")
print(fronts[["title", "year", "citations", "citations_per_year"]].to_string())
# Step 2: Build co-authorship network for this topic
G = build_coauthorship_network(
topic="transformer neural networks",
years=(2018, 2024),
max_papers=1000,
min_edge_weight=2,
)
# Step 3: Key network statistics
print(f"\nNetwork density: {nx.density(G):.4f}")
print(f"Average clustering coefficient: {nx.average_clustering(G):.4f}")
top_by_degree = sorted(nx.degree_centrality(G).items(), key=lambda x: x[1], reverse=True)[:5]
names = nx.get_node_attributes(G, "name")
print("\nTop 5 authors by degree centrality:")
for node, centrality in top_by_degree:
print(f" {names.get(node, node)}: {centrality:.4f}")
# Step 4: Visualize
fig = plot_coauthorship_network(G, top_n=50, output_path="transformer_coauthorship.png")
# Step 5: Export to VOSviewer
export_vosviewer_network(G, "transformer_map.txt", "transformer_network.txt")
# Step 6: Fetch author metrics for the highest-centrality author
top_author_id = top_by_degree[0][0]
metrics = get_author_metrics(openalex_author_id=top_author_id)
print(f"\nTop author: {metrics['name']}")
print(f" h-index: {metrics['h_index']}")
print(f" Total citations: {metrics['cited_by_count']}")
print(f" Active years: {metrics['years_active'][0]}–{metrics['years_active'][1]}")
print(f" Top venues: {metrics['top_venues']}")
Example 2 — Analyze Collaboration Patterns of a Specific Research Group
# Suppose we have a list of ORCID identifiers for a research group
group_orcids = [
"0000-0002-1234-5678", # replace with real ORCIDs
"0000-0001-9876-5432",
"0000-0003-1111-2222",
]
# Step 1: Collect metrics for each author
group_metrics = []
for orcid in group_orcids:
try:
m = get_author_metrics(orcid=orcid)
group_metrics.append(m)
print(f"{m['name']}: h={m['h_index']}, citations={m['cited_by_count']}")
except Exception as e:
print(f"Could not fetch ORCID {orcid}: {e}")
# Step 2: Build a group-level summary DataFrame
summary = pd.DataFrame([{
"name": m["name"],
"orcid": m["orcid"],
"works_count": m["works_count"],
"cited_by_count": m["cited_by_count"],
"h_index": m["h_index"],
"i10_index": m["i10_index"],
"active_from": m["years_active"][0],
"active_to": m["years_active"][1],
} for m in group_metrics])
print("\nResearch Group Summary:")
print(summary.to_string())
summary.to_csv("group_metrics.csv", index=False)
# Step 3: Check journal impact for journals where group publishes most
all_venues = []
for m in group_metrics:
all_venues.extend(m["works_df"]["venue"].dropna().tolist())
from collections import Counter
top_venues_overall = Counter(all_venues).most_common(5)
print("\nTop publication venues for the group:")
for venue, count in top_venues_overall:
print(f" {venue}: {count} papers")
# Step 4: Plot per-author citation distribution
fig, axes = plt.subplots(1, len(group_metrics), figsize=(5 * len(group_metrics), 4))
if len(group_metrics) == 1:
axes = [axes]
for ax, m in zip(axes, group_metrics):
citations = m["works_df"]["citations"].clip(upper=500)
ax.hist(citations, bins=30, color="#4C72B0", edgecolor="white")
ax.set_title(m["name"][:25])
ax.set_xlabel("Citations per paper")
ax.set_ylabel("Count")
fig.suptitle("Citation Distributions — Research Group")
fig.tight_layout()
fig.savefig("group_citation_distributions.png", dpi=150)
print("Saved group_citation_distributions.png")
5. Common Errors and Troubleshooting
| Error | Cause | Fix |
|---|---|---|
404 Not Found on /authors/orcid:... | ORCID not indexed in OpenAlex | Try /authors?filter=orcid:... search |
| Empty co-authorship graph | min_edge_weight too high for sparse field | Lower to min_edge_weight=1 |
KeyError: 'referenced_works' | Field not in select clause | Add referenced_works to the select parameter |
| Slow pagination (>5 min) | Large topic with many results | Reduce max_papers or use date ranges to split queries |
| VOSviewer shows no map | File uses wrong separator | Ensure tab (\t) delimiter; do not open .txt as a map file manually |
nx.average_clustering hangs | Very large graph | Call on subgraph: G.subgraph(list(G.nodes())[:500]) |
6. Performance Tips
- Parallel author lookups: Use
concurrent.futures.ThreadPoolExecutorwhen fetching metrics for multiple authors — each call is independent. - Cache raw work lists: Pickle the list returned by
_fetch_all_works()so downstream analyses (co-citation, coupling) can re-run instantly. - Sparse graph storage: For networks with >10 000 nodes use
nx.Graph()with explicit edge pruning; avoid dense adjacency matrices. - Incremental VOSviewer updates: Append new nodes/edges to existing map/network files rather than rebuilding from scratch each week.
7. References and Further Reading
- OpenAlex documentation: https://docs.openalex.org/
- NetworkX documentation: https://networkx.org/documentation/stable/
- VOSviewer software: https://www.vosviewer.com/
- Scientometrics primer (Waltman 2016): https://doi.org/10.1007/s11192-016-1943-4
- Co-citation analysis methodology: https://doi.org/10.1002/asi.4630240406
- Bibliographic coupling (Kessler 1963): https://doi.org/10.1002/asi.5090140103
8. Changelog
| Version | Date | Change |
|---|---|---|
| 1.0.0 | 2026-03-17 | Initial release — author metrics, co-authorship network, co-citation, bibliographic coupling, VOSviewer export |
示例提示词
帮我统计这位学者的h指数和共被引网络用于学术评价。
所属插件
安装该插件会一并获得同领域的 54 个 Skill / MCP。
同插件的其他科研 Skill
- 智能体资源节约守则Applies token- and context-saving habits for tool choice, PDF handling, persistent memory, and privacy checks. Use at the start of sessions with many files or PDFs, or multi-session work.
- 英文论文双语精读器把英文论文转成中英对照精读档并生成离线双语阅读器,标注要点并输出读书笔记。精读单篇英文论文、要中英对照阅读时使用。
- 研究方法比较论证Compares quantitative, qualitative, and mixed research methods against what each can and cannot answer to build a methods table. Use when justifying a method choice in a thesis.
- 复杂系统分析方法Analyzes complex systems with power-law fitting, Hurst exponent, fractal dimension, agent-based modeling, and entropy measures. Use for nonlinear or complex-system data.
- 研究环境容器化部署Builds Docker and Singularity containers for reproducible computation and HPC deployment of research environments. Use when packaging an analysis pipeline for reuse or HPC.
- DVC数据版本管理Sets up DVC for dataset and pipeline versioning, remote storage, and experiment comparison in reproducible ML research workflows. Use when tracking large datasets or ML experiment runs.
- 期刊级统计图表绘制Creates publication-quality multi-panel figures with matplotlib, seaborn, or ggplot2 using colorblind-safe palettes and journal export settings. Use when preparing figures for a paper.
- 综述模块拆解规划Breaks a refined literature-review question into 3-5 non-overlapping modules to build a reading map, outline, or search plan. Use when structuring a literature review.
- 学位论文答辩教练模拟学位口试委员提问并提供承认回应证据三段式答辩框架与模拟问答。准备论文口试或研讨会问答环节时使用。
- 实验设计与样本量规划Designs rigorous experiments covering sample-size calculation, randomization strategy, pre-registration, and A/B test duration estimation. Use when planning an experiment or A/B test.
- 管理实验设计架构为管理与商学情境实验规划组间组内设计、对抗平衡与操弄检核,并产出设计书与情境材料模板。做商学实验设计时使用。
- 科研经费申请撰写Structures research grant proposals including NSF/NIH Specific Aims, budget justification, ERC narrative sections, and biosketch formatting. Use when drafting a funding application.
- 人类可读文档撰写规范Guides writing human-facing docs like README, PLAN, survey notes, and reviewer-response drafts with a clear two-tier structure. Use for text a human collaborator will read.
- 知识图谱与SPARQL检索Builds knowledge graphs and runs SPARQL queries over RDF and Wikidata for entity linking in research and library data. Use when modeling research entities as a linked graph.
- LaTeX论文写作与排版Writes, compiles, and submits LaTeX papers covering IMRaD structure, key packages, bibliography management, and arXiv preparation. Use when authoring or debugging a LaTeX manuscript.
- 文献比较矩阵构建器把一批PDF整理成含撤稿查核与APA7书目的文献资料库,并生成横向比较矩阵表。整理综述前要比较文献时使用。
- 跨库学术文献检索Searches OpenAlex, Semantic Scholar, and arXiv for academic literature with deduplication, citation snowballing, and BibTeX export. Use when collecting papers for a review or topic.
- 文献调研语料库维护Finds, verifies, and maintains a literature corpus from arXiv, OpenAlex, Crossref, and related databases with BibTeX entries and per-paper notes. Use when sourcing references for a paper.
- 文献综述研究缺口定位Converts a literature-review synthesis into a concrete, defensible research gap and future-research direction. Use when writing a conclusion or thesis contribution section.
- 文献矛盾结论梳理Analyzes conflicting findings across papers and explains disagreement by sample, method, or context differences for a stronger synthesis. Use when review sources disagree.
- 效应量汇总元分析Pools effect sizes across studies with fixed and random-effects models, heterogeneity tests, forest and funnel plots, and subgroup analysis. Use to synthesize quantitative study results.
- 缺失数据处理Diagnoses missing-data mechanisms such as MCAR, MAR, or MNAR and applies multiple imputation or deletion with sensitivity analysis. Use when a dataset has missing values.
- 混合方法研究设计Designs mixed-methods studies integrating qualitative coding, triangulation, content analysis, and QCA with inter-rater reliability checks. Use when combining qual and quant data.
- 科研机器学习流程Applies machine learning to research questions with scikit-learn pipelines, AutoML, SHAP explainability, and nested cross-validation. Use when building a predictive model for a study.
常见问题
文献计量学分析能做什么?
Runs bibliometric analysis including h-index, citation counts, co-authorship and co-citation networks, and VOSviewer-compatible output. Use when evaluating a publication record。
如何安装文献计量学分析?
在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「文献计量学分析」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。
文献计量学分析需要哪些权限?
该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。
文献计量学分析经过官方审核吗?
是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。