[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6XGJZG4BHDS0V1HVRMHJ74N":3,"skill-same:01M6XGJZG4BHDS0V1HVRMHJ74N":75},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":41,"linkOnly":42,"markdownContent":43,"markdownBody":44,"frontMatter":45,"refName":55,"commitSha":56,"skillDirectory":57,"forksCount":14,"repositoryHtmlUrl":58,"repositoryHomepageUrl":6,"ownerHtmlUrl":59,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":60,"install":61,"resources":74},"01M6XGJZG4BHDS0V1HVRMHJ74N","autoregressive-neural-pde-solver",null,"Training patterns for autoregressive neural PDE solvers (FNO, DeepONet, CNO). Covers rollout training, noise injection for stability, multi-component loss functions (H1, frequency-sensitive, boundary-aware), per-channel normalization for coupled multi-variable systems, and the PDEBench nRMSE metric. Use when training any neural operator that predicts time-dependent PDE solutions.","fadrienne\u002FMyGitHub","fadrienne","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F197874571?v=4","01M6X64V8VWCRSMFZ4EPS2BWXG","Francesca Adrienne","01M6X64VD5MW4F9PHDWQKS7ZAF",0,"MIT","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fopenscience\u002Fbackend\u002Fcli\u002Fskills\u002Fphysics\u002Fautoregressive-neural-pde-solver\u002FSKILL.md",[],[19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40],"solver","pde solver","autoregressive neural pde solver","pde","Neural","when","training","DeepONet","operator","Loss Function","FNO","Autoregressive","Neural Operator","solutions","rollout","metric","component","synthetic","injection","physics","time","patterns","2026-11-10 10:12:30",false,"---\nname: autoregressive-neural-pde-solver\ndescription: Training patterns for autoregressive neural PDE solvers (FNO, DeepONet, CNO). Covers rollout training, noise injection for stability, multi-component loss functions (H1, frequency-sensitive, boundary-aware), per-channel normalization for coupled multi-variable systems, and the PDEBench nRMSE metric. Use when training any neural operator that predicts time-dependent PDE solutions.\ncategory: physics\nversion: 1.0.0\nauthor: Synthetic Sciences\nlicense: MIT\ntags: [Neural Operator, Autoregressive, PDE, Rollout, FNO, Loss Function, Normalization]\ndependencies: [\"torch>=2.1.0\", \"numpy>=1.24.0\"]\n---\n\n# Autoregressive Neural PDE Solvers — Training Patterns\n\n## When to Use\n- Training any neural operator (FNO, DeepONet, CNO, etc.) to predict time-dependent PDE solutions\n- The model predicts one (or few) timesteps ahead, then feeds predictions back as input\n- Multi-variable PDE systems (compressible NS, MHD, multi-species reaction, etc.)\n- Problems where single-step accuracy is insufficient — rollout stability matters\n\n## Core Principle: Train How You Infer\n\nThe single biggest mistake in neural PDE solving is training on single-step predictions but inferring with multi-step rollout. The model never learns to handle its own errors.\n\n```python\n# WRONG: Teacher forcing (single-step)\nfor t in range(T):\n    pred = model(ground_truth[:, :, t])  # Always sees perfect input\n    loss += mse(pred, ground_truth[:, :, t+1])\n# At inference, errors compound exponentially because model never saw noisy inputs\n\n# RIGHT: Autoregressive rollout training\ninp = initial_condition  # shape: [B, X, init_steps, C]\nfor t in range(init_steps, T_total):\n    pred = model(inp)  # Sees its OWN previous predictions\n    loss += mse(pred, ground_truth[:, :, t:t+1, :])\n    inp = torch.cat([inp[:, :, 1:, :], pred], dim=-2)  # Shift window, append prediction\n# Model learns to be robust to its own prediction errors\n```\n\n## Data Layout Convention\n\nFor spectral operators (FNO), use spatial-first layout:\n```python\n# Standard: [N_samples, X_spatial, T_timesteps, C_channels]\n# NOT: [N_samples, T_timesteps, X_spatial, C_channels]\n\n# When loading from [N, T, X] or [N, T, X, C]:\ndata = np.transpose(raw[:, ::stride_t, ::stride_x], (0, 2, 1))       # 3D\ndata = np.transpose(raw[:, ::stride_t, ::stride_x, :], (0, 2, 1, 3)) # 4D\n```\n\n## Noise Injection for Rollout Stability\n\nDuring autoregressive training, add small noise to predictions before feeding back. This prevents the model from relying on artificially clean inputs.\n\n```python\nNOISE_STD = 1e-3  # Smooth problems\nNOISE_STD = 5e-3  # Shock\u002Fdiscontinuity problems\n\n# During training only:\nif model.training and NOISE_STD > 0:\n    noisy_pred = pred + NOISE_STD * torch.randn_like(pred)\n    inp = torch.cat([inp[:, :, 1:, :], noisy_pred], dim=-2)\nelse:\n    inp = torch.cat([inp[:, :, 1:, :], pred], dim=-2)\n```\n\n**Guidance for noise level:**\n- σ = 0 for very smooth, well-resolved problems\n- σ = 1e-3 for moderately complex dynamics\n- σ = 5e-3 for shock-dominated or chaotic problems\n- Too much noise smears sharp features; too little doesn't help stability\n\n## Multi-Component Loss Functions\n\n### Sobolev H1 Loss (Spatial Gradient Penalty)\nPenalizes errors in spatial derivatives — critical for steep gradients, reaction fronts, shocks.\n\n```python\ndef h1_loss(pred, target):\n    \"\"\"Penalize spatial gradient errors.\"\"\"\n    grad_pred = pred[:, 1:, :] - pred[:, :-1, :]\n    grad_tgt = target[:, 1:, :] - target[:, :-1, :]\n    return F.mse_loss(grad_pred, grad_tgt)\n\n# Usage: loss = mse_loss + 0.05 * h1_loss(pred, target)\n```\n\n### Frequency-Sensitive Loss\nPartition Fourier spectrum into bands with increasing weights — upweights high-frequency content.\n\n```python\ndef frequency_loss(pred, target, weights=[1.0, 2.0, 4.0]):\n    \"\"\"Higher weight on high-frequency errors.\"\"\"\n    pred_ft = torch.fft.rfft(pred, dim=1)\n    tgt_ft = torch.fft.rfft(target, dim=1)\n    n = pred_ft.shape[1]\n    bin_size = n \u002F\u002F len(weights)\n    loss = 0.0\n    for i, w in enumerate(weights):\n        s, e = i * bin_size, (i+1) * bin_size if i \u003C len(weights)-1 else n\n        loss += w * torch.abs(pred_ft[:, s:e] - tgt_ft[:, s:e]).mean()\n    return loss\n\n# Usage: loss = mse_loss + 0.1 * frequency_loss(pred, target)\n```\n\n### Boundary-Aware Loss (for non-periodic BCs)\nUpweight loss near domain boundaries where spectral methods struggle.\n\n```python\nspatial_dim = pred.shape[1]\nbw = int(0.1 * spatial_dim)  # 10% boundary region\nweight = torch.ones(spatial_dim, device=pred.device)\nweight[:bw] = 2.0; weight[-bw:] = 2.0\nweight = weight \u002F weight.mean()  # Normalize\n\n# Use element-wise: loss = (weight * (pred - target)**2).mean()\n```\n\n### Recommended Combinations\n\n| Problem Type | MSE | H1 (weight) | Freq (weight) | Noise σ | Boundary |\n|---|---|---|---|---|---|\n| Smooth (advection, diffusion) | ✓ | — | — | — | — |\n| Reaction-diffusion | ✓ | 0.1 | — | 1e-3 | — |\n| Shocks (Burgers, Euler) | ✓ | 0.05 | 0.1 | 5e-3 | — |\n| Non-periodic BCs | ✓ | 0.05 | — | 1e-3 | 2× at edges |\n| Multi-variable coupled | ✓ | 0.05 | — | 1e-3 | — |\n\n## Per-Channel Normalization for Multi-Variable Systems\n\nWhen PDE variables have different scales (e.g., density ~O(6), velocity ~O(0.5), pressure ~O(59)), the loss is dominated by the largest-scale variable.\n\n```python\n# Compute from TRAINING set only\nch_mean = train_data.mean(dim=(0, 1, 2))  # [C]\nch_std = train_data.std(dim=(0, 1, 2)) + 1e-8  # [C]\n\n# Normalize all data\ndata_normalized = (data - ch_mean) \u002F ch_std\n\n# Denormalize for evaluation (handles CPU\u002FGPU mismatch)\ndef denormalize(x):\n    return x * ch_std.to(x.device) + ch_mean.to(x.device)\n\n# IMPORTANT: Compute nRMSE in ORIGINAL scale, not normalized\npreds_orig = denormalize(preds)\ntargets_orig = denormalize(targets)\n```\n\n## nRMSE Metric (Standard PDE Benchmark Definition)\n\n**WARNING:** Multiple valid nRMSE formulas exist and can differ by up to 5-10%. Always compute BOTH and verify you beat baselines under both.\n\n```python\ndef calc_nrmse_pertimestep(preds, targets, init_step=10):\n    \"\"\"Per-timestep RMSE\u002FRMS, averaged over (N, C, T). Common in code implementations.\"\"\"\n    p = preds[:, :, init_step:, :].permute(0, 3, 1, 2)   # [N, C, X, T]\n    tg = targets[:, :, init_step:, :].permute(0, 3, 1, 2)\n    err = torch.sqrt(torch.mean((p - tg)**2, dim=2))  # RMSE per (sample, channel, time)\n    nrm = torch.sqrt(torch.mean(tg**2, dim=2)) + 1e-20\n    return torch.mean(err \u002F nrm).item()\n\ndef calc_nrmse_frobenius(preds, targets, init_step=10):\n    \"\"\"Per-sample Frobenius norm ratio. Canonical PDEBench definition.\"\"\"\n    p = preds[:, :, init_step:, :]\n    tg = targets[:, :, init_step:, :]\n    per_sample = torch.sqrt(((p - tg)**2).sum(dim=(1,2,3))) \u002F \\\n                 (torch.sqrt((tg**2).sum(dim=(1,2,3))) + 1e-20)\n    return per_sample.mean().item()\n\n# Report BOTH in results.json:\n# {\"nrmse_pertimestep\": X, \"nrmse_frobenius\": Y, \"metric_note\": \"Both beat baseline\"}\n```\n\n## Train\u002FVal\u002FTest Split (Critical for Methods Papers)\n\n```python\nN_TRAIN, N_VAL, N_TEST = 8000, 1000, 1000\ntrain_data = data[:N_TRAIN]\nval_data = data[N_TRAIN:N_TRAIN+N_VAL]      # Checkpoint selection\ntest_data = data[N_TRAIN+N_VAL:]              # Final metric (evaluated ONCE)\n\n# During training: evaluate on val_loader for model selection\n# After training: evaluate on test_loader ONCE for final reported number\n```\n\n## Common Pitfalls\n\n| Pitfall | Symptom | Fix |\n|---|---|---|\n| Teacher forcing during training | Good train loss, terrible rollout | Use autoregressive training |\n| Data layout [N,T,X] not [N,X,T] | Model doesn't converge | Transpose before creating DataLoader |\n| No per-channel normalization | One variable dominates loss | Normalize each channel independently |\n| Missing noise injection | Rollout diverges after ~10 steps | Add σ=1e-3 noise during training |\n| Model selection on test set | Optimistic reported metrics | Use separate validation split |\n| Accumulating loss with retain_graph | GPU OOM | loss.backward() once after full rollout |\n","# Autoregressive Neural PDE Solvers — Training Patterns\n\n## When to Use\n- Training any neural operator (FNO, DeepONet, CNO, etc.) to predict time-dependent PDE solutions\n- The model predicts one (or few) timesteps ahead, then feeds predictions back as input\n- Multi-variable PDE systems (compressible NS, MHD, multi-species reaction, etc.)\n- Problems where single-step accuracy is insufficient — rollout stability matters\n\n## Core Principle: Train How You Infer\n\nThe single biggest mistake in neural PDE solving is training on single-step predictions but inferring with multi-step rollout. The model never learns to handle its own errors.\n\n```python\n# WRONG: Teacher forcing (single-step)\nfor t in range(T):\n    pred = model(ground_truth[:, :, t])  # Always sees perfect input\n    loss += mse(pred, ground_truth[:, :, t+1])\n# At inference, errors compound exponentially because model never saw noisy inputs\n\n# RIGHT: Autoregressive rollout training\ninp = initial_condition  # shape: [B, X, init_steps, C]\nfor t in range(init_steps, T_total):\n    pred = model(inp)  # Sees its OWN previous predictions\n    loss += mse(pred, ground_truth[:, :, t:t+1, :])\n    inp = torch.cat([inp[:, :, 1:, :], pred], dim=-2)  # Shift window, append prediction\n# Model learns to be robust to its own prediction errors\n```\n\n## Data Layout Convention\n\nFor spectral operators (FNO), use spatial-first layout:\n```python\n# Standard: [N_samples, X_spatial, T_timesteps, C_channels]\n# NOT: [N_samples, T_timesteps, X_spatial, C_channels]\n\n# When loading from [N, T, X] or [N, T, X, C]:\ndata = np.transpose(raw[:, ::stride_t, ::stride_x], (0, 2, 1))       # 3D\ndata = np.transpose(raw[:, ::stride_t, ::stride_x, :], (0, 2, 1, 3)) # 4D\n```\n\n## Noise Injection for Rollout Stability\n\nDuring autoregressive training, add small noise to predictions before feeding back. This prevents the model from relying on artificially clean inputs.\n\n```python\nNOISE_STD = 1e-3  # Smooth problems\nNOISE_STD = 5e-3  # Shock\u002Fdiscontinuity problems\n\n# During training only:\nif model.training and NOISE_STD > 0:\n    noisy_pred = pred + NOISE_STD * torch.randn_like(pred)\n    inp = torch.cat([inp[:, :, 1:, :], noisy_pred], dim=-2)\nelse:\n    inp = torch.cat([inp[:, :, 1:, :], pred], dim=-2)\n```\n\n**Guidance for noise level:**\n- σ = 0 for very smooth, well-resolved problems\n- σ = 1e-3 for moderately complex dynamics\n- σ = 5e-3 for shock-dominated or chaotic problems\n- Too much noise smears sharp features; too little doesn't help stability\n\n## Multi-Component Loss Functions\n\n### Sobolev H1 Loss (Spatial Gradient Penalty)\nPenalizes errors in spatial derivatives — critical for steep gradients, reaction fronts, shocks.\n\n```python\ndef h1_loss(pred, target):\n    \"\"\"Penalize spatial gradient errors.\"\"\"\n    grad_pred = pred[:, 1:, :] - pred[:, :-1, :]\n    grad_tgt = target[:, 1:, :] - target[:, :-1, :]\n    return F.mse_loss(grad_pred, grad_tgt)\n\n# Usage: loss = mse_loss + 0.05 * h1_loss(pred, target)\n```\n\n### Frequency-Sensitive Loss\nPartition Fourier spectrum into bands with increasing weights — upweights high-frequency content.\n\n```python\ndef frequency_loss(pred, target, weights=[1.0, 2.0, 4.0]):\n    \"\"\"Higher weight on high-frequency errors.\"\"\"\n    pred_ft = torch.fft.rfft(pred, dim=1)\n    tgt_ft = torch.fft.rfft(target, dim=1)\n    n = pred_ft.shape[1]\n    bin_size = n \u002F\u002F len(weights)\n    loss = 0.0\n    for i, w in enumerate(weights):\n        s, e = i * bin_size, (i+1) * bin_size if i \u003C len(weights)-1 else n\n        loss += w * torch.abs(pred_ft[:, s:e] - tgt_ft[:, s:e]).mean()\n    return loss\n\n# Usage: loss = mse_loss + 0.1 * frequency_loss(pred, target)\n```\n\n### Boundary-Aware Loss (for non-periodic BCs)\nUpweight loss near domain boundaries where spectral methods struggle.\n\n```python\nspatial_dim = pred.shape[1]\nbw = int(0.1 * spatial_dim)  # 10% boundary region\nweight = torch.ones(spatial_dim, device=pred.device)\nweight[:bw] = 2.0; weight[-bw:] = 2.0\nweight = weight \u002F weight.mean()  # Normalize\n\n# Use element-wise: loss = (weight * (pred - target)**2).mean()\n```\n\n### Recommended Combinations\n\n| Problem Type | MSE | H1 (weight) | Freq (weight) | Noise σ | Boundary |\n|---|---|---|---|---|---|\n| Smooth (advection, diffusion) | ✓ | — | — | — | — |\n| Reaction-diffusion | ✓ | 0.1 | — | 1e-3 | — |\n| Shocks (Burgers, Euler) | ✓ | 0.05 | 0.1 | 5e-3 | — |\n| Non-periodic BCs | ✓ | 0.05 | — | 1e-3 | 2× at edges |\n| Multi-variable coupled | ✓ | 0.05 | — | 1e-3 | — |\n\n## Per-Channel Normalization for Multi-Variable Systems\n\nWhen PDE variables have different scales (e.g., density ~O(6), velocity ~O(0.5), pressure ~O(59)), the loss is dominated by the largest-scale variable.\n\n```python\n# Compute from TRAINING set only\nch_mean = train_data.mean(dim=(0, 1, 2))  # [C]\nch_std = train_data.std(dim=(0, 1, 2)) + 1e-8  # [C]\n\n# Normalize all data\ndata_normalized = (data - ch_mean) \u002F ch_std\n\n# Denormalize for evaluation (handles CPU\u002FGPU mismatch)\ndef denormalize(x):\n    return x * ch_std.to(x.device) + ch_mean.to(x.device)\n\n# IMPORTANT: Compute nRMSE in ORIGINAL scale, not normalized\npreds_orig = denormalize(preds)\ntargets_orig = denormalize(targets)\n```\n\n## nRMSE Metric (Standard PDE Benchmark Definition)\n\n**WARNING:** Multiple valid nRMSE formulas exist and can differ by up to 5-10%. Always compute BOTH and verify you beat baselines under both.\n\n```python\ndef calc_nrmse_pertimestep(preds, targets, init_step=10):\n    \"\"\"Per-timestep RMSE\u002FRMS, averaged over (N, C, T). Common in code implementations.\"\"\"\n    p = preds[:, :, init_step:, :].permute(0, 3, 1, 2)   # [N, C, X, T]\n    tg = targets[:, :, init_step:, :].permute(0, 3, 1, 2)\n    err = torch.sqrt(torch.mean((p - tg)**2, dim=2))  # RMSE per (sample, channel, time)\n    nrm = torch.sqrt(torch.mean(tg**2, dim=2)) + 1e-20\n    return torch.mean(err \u002F nrm).item()\n\ndef calc_nrmse_frobenius(preds, targets, init_step=10):\n    \"\"\"Per-sample Frobenius norm ratio. Canonical PDEBench definition.\"\"\"\n    p = preds[:, :, init_step:, :]\n    tg = targets[:, :, init_step:, :]\n    per_sample = torch.sqrt(((p - tg)**2).sum(dim=(1,2,3))) \u002F \\\n                 (torch.sqrt((tg**2).sum(dim=(1,2,3))) + 1e-20)\n    return per_sample.mean().item()\n\n# Report BOTH in results.json:\n# {\"nrmse_pertimestep\": X, \"nrmse_frobenius\": Y, \"metric_note\": \"Both beat baseline\"}\n```\n\n## Train\u002FVal\u002FTest Split (Critical for Methods Papers)\n\n```python\nN_TRAIN, N_VAL, N_TEST = 8000, 1000, 1000\ntrain_data = data[:N_TRAIN]\nval_data = data[N_TRAIN:N_TRAIN+N_VAL]      # Checkpoint selection\ntest_data = data[N_TRAIN+N_VAL:]              # Final metric (evaluated ONCE)\n\n# During training: evaluate on val_loader for model selection\n# After training: evaluate on test_loader ONCE for final reported number\n```\n\n## Common Pitfalls\n\n| Pitfall | Symptom | Fix |\n|---|---|---|\n| Teacher forcing during training | Good train loss, terrible rollout | Use autoregressive training |\n| Data layout [N,T,X] not [N,X,T] | Model doesn't converge | Transpose before creating DataLoader |\n| No per-channel normalization | One variable dominates loss | Normalize each channel independently |\n| Missing noise injection | Rollout diverges after ~10 steps | Add σ=1e-3 noise during training |\n| Model selection on test set | Optimistic reported metrics | Use separate validation split |\n| Accumulating loss with retain_graph | GPU OOM | loss.backward() once after full rollout |\n",{"name":5,"tags":46,"author":50,"license":15,"version":51,"category":38,"description":7,"dependencies":52},[31,30,47,48,29,28,49],"PDE","Rollout","Normalization","Synthetic Sciences","1.0.0",[53,54],"torch>=2.1.0","numpy>=1.24.0","main","4aa39efd1cdab0b4657ecee16c92a92011a5b10f","openscience\u002Fbackend\u002Fcli\u002Fskills\u002Fphysics\u002Fautoregressive-neural-pde-solver","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub","https:\u002F\u002Fgithub.com\u002Ffadrienne","2026-10-28 00:43:09",{"source":8,"skillName":5,"commands":62,"prompt":72,"zipAvailable":73},[63,66,69],{"tool":64,"command":65},"npx","npx skills add fadrienne\u002FMyGitHub --skill autoregressive-neural-pde-solver",{"tool":67,"command":68},"bunx","bunx skills add fadrienne\u002FMyGitHub --skill autoregressive-neural-pde-solver",{"tool":70,"command":71},"pnpm","pnpm dlx skills add fadrienne\u002FMyGitHub --skill autoregressive-neural-pde-solver","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fopenscience\u002Fbackend\u002Fcli\u002Fskills\u002Fphysics\u002Fautoregressive-neural-pde-solver\u002FSKILL.md",true,[],[76,107,134,168,195,222],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":87,"publishedAt":41},"01M7167B28PK20HP7R7ZED2DY0","statistical-power","Sample size calculation, power analysis, and effect size conversion for scientific studies. Use BEFORE data collection (a priori) to determine required N, or after (post-hoc) to compute achieved power. Covers parametric tests (t-test, ANOVA, chi-square, proportions, correlation, regression), simulation-based power for complex\u002Fclustered\u002Fnested designs, and power curves. Use this skill when someone asks 'how many samples do I need', 'what is my power', 'what effect size can I detect', or any variant. Pairs with \u002Fexperimental-design (choose design first, then compute power) and \u002Fstatistical-analysis (analyze data after collection).","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fscientific-agent-skills\u002Fskills\u002Fstatistical-power\u002FSKILL.md",[82],{"categoryNo":83,"categoryName":84,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[88,89,90,91,92,93,94,95,24,96,97,98,99,100,101,102,103,104,105,106],"power","statistical power","effect","scipy","regression","choose","design","uv","Bash","collection","analysis","calculation","ANOVA","conversion","analyze","t-test","chi-square","simulation","sample",{"skillNo":108,"name":109,"nameZh":6,"description":110,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":111,"categories":112,"keywords":116,"publishedAt":41},"01M71677EBCM8EPCE9BZCK8505","statistical-analysis","Guided statistical analysis with test selection and reporting. Use when you need help choosing appropriate tests for your data, assumption checking, power analysis, and APA-formatted results. Best for academic research reporting, test selection guidance. For implementing specific models programmatically use statsmodels.","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fscientific-agent-skills\u002Fskills\u002Fstatistical-analysis\u002FSKILL.md",[113],{"categoryNo":114,"categoryName":115,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000008","测试与质量",[98,117,88,118,119,120,24,121,122,123,124,125,126,127,128,129,130,131,132,133],"statistical analysis","academic research","implementing","selection","you","reporting","data","for","tests","use","with","test","research","results","statsmodels","models","help",{"skillNo":135,"name":136,"nameZh":6,"description":137,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":138,"categories":139,"keywords":149,"publishedAt":41},"01M71673R93XAHFH81DBNVNG7H","scientific-writing","Core skill for the deep research and writing tool. Write scientific manuscripts in full paragraphs (never bullet points). Use two-stage process with (1) section outlines with key points using research-lookup then (2) convert to flowing prose. IMRAD structure, citations (APA\u002FAMA\u002FVancouver), figures\u002Ftables, reporting guidelines (CONSORT\u002FSTROBE\u002FPRISMA), for research papers and journal submissions.","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fscientific-agent-skills\u002Fskills\u002Fscientific-writing\u002FSKILL.md",[140,143,144],{"categoryNo":141,"categoryName":142,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000018","写作与文案",{"categoryNo":83,"categoryName":84,"taxonomyType":85,"taxonomyTypeDesc":86},{"categoryNo":145,"categoryName":146,"taxonomyType":147,"taxonomyTypeDesc":148},"01JBSEEDCAT000000000000036","内容创作者","PROFESSION","适用职业",[150,151,152,153,154,155,156,157,158,159,96,160,161,162,163,164,165,166,122,167],"writing","scientific","scientific writing","Citations","deep","deep research","never","papers","journal","false","api","prisma","structure","openrouter","Outlines","core skill","read","features",{"skillNo":169,"name":170,"nameZh":6,"description":171,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":172,"categories":173,"keywords":178,"publishedAt":41},"01M7166ZPKXBF4EBPHVTJPQBB1","scientific-visualization","Meta-skill for publication-ready figures. Use when creating journal submission figures requiring multi-panel layouts, significance annotations, error bars, colorblind-safe palettes, and specific journal formatting (Nature, Science, Cell). Orchestrates matplotlib\u002Fseaborn\u002Fplotly with publication styles. For quick exploration use seaborn or plotly directly.","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fscientific-agent-skills\u002Fskills\u002Fscientific-visualization\u002FSKILL.md",[174,177],{"categoryNo":175,"categoryName":176,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000013","分析与可视化",{"categoryNo":83,"categoryName":84,"taxonomyType":85,"taxonomyTypeDesc":86},[179,151,180,181,182,183,184,185,186,158,24,187,188,189,190,191,192,193,124,194],"visualization","scientific visualization","error","ready","quick","exploration","meta-skill","Meta","safe","plotly","annotations","formatting","Publication","figures","panel","submission",{"skillNo":196,"name":197,"nameZh":6,"description":198,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":199,"categories":200,"keywords":207,"publishedAt":41},"01M7166VXJWQSSC3RQZP60WBGR","research-code","Debug, profile, review, and restructure Python research and analysis code. Use when analysis scripts crash, produce wrong results, run too slowly, or need a correctness review. Covers: reading tracebacks and diagnosing root causes, hypothesis-driven debugging, reviewing code for common statistical\u002Fnumerical errors, profiling data pipelines, improving reproducibility (seeds, environments, determinism), and structuring analysis scripts for sharing. Distinct from \u002Fexploratory-data-analysis (which understands data) and \u002Fstatistical-analysis (which chooses and runs tests) — this skill focuses on the code itself.","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fscientific-agent-skills\u002Fskills\u002Fresearch-code\u002FSKILL.md",[201,204],{"categoryNo":202,"categoryName":203,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000021","资料检索与研究",{"categoryNo":205,"categoryName":206,"taxonomyType":147,"taxonomyTypeDesc":148},"01JBSEEDCAT000000000000030","开发工程师",[208,209,129,210,211,212,213,95,214,24,96,98,215,216,217,218,219,220,166,221],"code","research code","which","memory","data-analysis","errors","debugging","common","review","data pipelines","run","scripts","line","write",{"skillNo":223,"name":224,"nameZh":6,"description":225,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":226,"licenseFileUrl":6,"sourceHtmlUrl":227,"categories":228,"keywords":235,"publishedAt":41},"01M7166CF5HSR7SVZYZFWTDX55","markdown-mermaid-writing","Comprehensive markdown and Mermaid diagram writing skill. Use when creating any scientific document, report, analysis, or visualization. Establishes text-based diagrams as the default documentation standard with full style guides (markdown + mermaid), 24 diagram type references, and 9 document templates.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Ffadrienne\u002FMyGitHub\u002Fblob\u002Fmain\u002Fscientific-agent-skills\u002Fskills\u002Fmarkdown-mermaid-writing\u002FSKILL.md",[229,232,233,234],{"categoryNo":230,"categoryName":231,"taxonomyType":85,"taxonomyTypeDesc":86},"01JBSEEDCAT000000000000002","文档处理",{"categoryNo":141,"categoryName":142,"taxonomyType":85,"taxonomyTypeDesc":86},{"categoryNo":83,"categoryName":84,"taxonomyType":85,"taxonomyTypeDesc":86},{"categoryNo":145,"categoryName":146,"taxonomyType":147,"taxonomyTypeDesc":148},[150,236,237,238,239,240,179,241,242,24,96,98,243,244,245,246,247,248,151,166],"markdown mermaid writing","mermaid","markdown","community","diagrams","project","default","team","guides","text","documentation","references","diagram"]