SuperAPI AI Directory
Partner中文AI newsFavorites
Skillsproblem-doc-model-selector

problem-doc-model-selector

Writing & research

View repository

Updated 10-16 09:05

About this skill

Automatic Competition Problem Document Parsing and Model Selection

Global Workflow Collaboration Constraints (Long-Conversation Drift Prevention)

  • This skill must not be used as an isolated entry point. When the user requests a complete paper, Word generation, process continuation, or the stage is uncertain, first return to paper-workflow-orchestrator to determine the current S0-S8 stage.
  • Before starting or continuing the formal task of this skill, you must run: 
    python .claude/skills/paper-workflow-orchestrator/scripts/workflow_guard.py --skill problem-doc-model-selector
  • If the output is [WORKFLOW FAIL] or reports status != "PASS", stop this skill and backfill the prerequisite stages according to the failure items in paper_output/qa/workflow_guard_report.json ; do not continue from memory.
  • This skill only writes the paper_output/ artifacts within its own contract scope; after completion you must return to paper-workflow-orchestrator to determine the next step, and use context-memory-keeper to record completed artifacts, blockers, and the next step.
  • In a long conversation, if the context grows long, the stage is uncertain, or the user invokes skills separately, first run: 
    python .claude/skills/paper-workflow-orchestrator/scripts/workflow_guard.py --status
    then read paper_output/qa/workflow_guard_report.json、paper_output/preflight_report.json、paper_output/input_manifest.json、paper_output/results/run_manifest.json and this skill's upstream JSON contract, and continue according to the recommended_skill and next_action in the report.
  • Before continuing the workflow, you must treat paper_output/context/workflow_memory.json as the long-term breakpoint record; if its current_step、next_step、recommended_skill is inconsistent with workflow_guard.py --status , the guard report prevails.
  • After completing this skill's artifacts each time, first return to paper-workflow-orchestrator or run workflow_guard.py --status, then update the workflow memory: 
    python .claude/skills/context-memory-keeper/scripts/update_workflow_memory.py
    after updating, read paper_output/context/workflow_memory.json / .mdto confirm that the next step and recommended skill have been recorded.

Execution Contract

  • Upstream input:problem_files/ the competition problem PDF/Word/TXT and attachment data in it.
  • Must output:paper_output/step1/problem_analysis.json, as well as A_题意对齐.md、B_论文大纲.md、C_评分点对齐表.md、D_模型路线.json。
  • Downstream handoff:modeling-paper-rubric-and-model-selector reads problem_analysis.json to generate the model route; the complete workflow is chained together by paper-workflow-orchestrator .
  • Recommended next step: after completing the problem analysis, proceed to modeling-paper-rubric-and-model-selector; if the user's goal is a complete paper, return to paper-workflow-orchestrator to determine subsequent stages.
  • Failure fallback: if problem_files/ is empty, stop and prompt to supply the competition problem; if part of the document cannot be parsed, retain the parseable content and record the missing field profile in the output.

Goal

  • Input the competition problem PDF/Word document or problem statement text, automatically extract the task type, data conditions, and constraints of "each question", and output a problem-tailored model selection and validation route.
  • Generate scoring-friendly deliverables: a one-page problem alignment, paper outline, scoring-point alignment table, and model route (baseline/improvement/validation/risks).

Stage Transitions

  • After parsing is complete, do not stop at a vague question of "are you satisfied"; instead, explain the generated problem contract and give the next recommended stage.
  • If the user's intent is a complete paper, after outputting A/B/C/D return to paper-workflow-orchestrator, and let the main entry point decide whether to continue generating the model route, data plan, QA, and main text.
  • No Laziness Allowed: you must output all four parts A/B/C/D in full; none may be omitted.

When to Apply

  • When the user provides a competition problem PDF/Word or problem statement text and needs to quickly determine the model/method to adopt for each question and formulate an experimental validation plan.
  • When you are unsure about the interpretation of the problem, uncertain about the modeling approach, or need suggestions for aligning the paper structure with scoring points.

Input

  • Competition problem document path or full problem statement (supports PDF, DOCX, TXT).
  • Optional: attachment data file paths, highlights or limitations you want to emphasize.

Output

  • A One-page problem alignment: for each question, provide input/output, evaluation metrics, key constraints, and verifiable methods.
  • B Paper outline: abstract, problem restatement, assumptions, notations, data description, model, solution, results, validation, conclusion, limitations, references.
  • C Scoring point alignment table: scoring point → evidence form (charts/experiments/validation) → paper location.
  • D Model selection and roadmap: for each question, task type, minimum viable baseline, improvement roadmap, validation plan, risks and alternatives.
  • E Data requirement configuration (optional): if the problem is found to require external data (such as population, meteorological, economic data), automatically generate or update the data_requirements.jsonin the root directory, so that authoritative-data-harvester can automatically obtain it.
  • Machine-readable contract:paper_output/step1/problem_analysis.json, including fields such as documents、data_files、questions、recommended_models、validation_plan、figure_suggestions , for QA, micro-unit generation, and the master orchestrator to continue reading.

Directory conventions (aligned with the project globally)

  • Competition problems and attachments should be placed uniformly in problem_files/。
  • It is recommended to archive the four types of output of this skill to paper_output/step1/(for example paper_output/step1/A_题意对齐.md , etc.), for reference by subsequent skills.
  • Also generate paper_output/step1/D_模型路线.json, used to retain the model roadmap, validation methods, and suggested figures for each question.

Script entry point (recommended)

This skill has a built-in structured analysis script:

python .claude/skills/problem-doc-model-selector/scripts/analyze_problem.py

This script scans problem_files/, reads TXT/Markdown/DOCX/PDF competition problem text, and performs lightweight field profiling on CSV/XLSX/XLS attachments. On success, it writes paper_output/step1/problem_analysis.json, and subsequently quality-assurance-auditor will prioritize using it to generate dynamic tasks.json。

Before/after linkage

  • Subsequent work usually starts with:data-cleaning-and-visualization(data cleaning and visualization).
  • To continue to the paper draft: return to paper-workflow-orchestrator。

Constraints (must be followed)

  • Memory Interaction (required):
    • Before starting, check whether memoryskill.md contains external literature/data indexes (such as references provided by g-sci), and incorporate them into the basis for model selection.
    • After completing the analysis, you must call context-memory-keeper, and update the "core task type", "data conditions", and "model selection conclusion" to memoryskill.md in the Short-term Workbench . This is the key for subsequent paper-generation skills to obtain context.
  • External data check (required):
    • If the analysis finds that the problem depends on external public data (such as "collect relevant data" or "attachment data is insufficient"), you must generate data_requirements.json and write it to the root directory.
    • The configuration content should include an explicit url(if known) or a manual_search prompt, and set active to true。
  • The problem alignment and model roadmap output by this skill must be able to be located and referenced by subsequent writing; it is recommended to archive them fixedly to paper_output/step1/。
  • If the user's goal is "the final paper can be submitted", after this skill is completed you must not directly enter the paper-generation stage; you must first ensure the data specifications are usable: enter data-cleaning-and-visualization or supplement authoritative-data-harvester。
  • If the user does not want to proceed step by step, they must return to paper-workflow-orchestrator to execute the complete workflow, avoiding the discontinuity of "parsing completed but main text not generated".

Workflow

  1. Document reading
    • PDF: Prefer PyMuPDF, otherwise pdfplumber; retain figure and table captions and section numbering.
    • Word: python-docx; retain paragraph and table structures.
    • Cleaning: Remove headers and footers, merge line breaks, standardize units (cm⁻¹, %, etc.).
  2. Problem statement parsing
    • Rule-based extraction of "Question 1/Question 2/Question 3..." and "attachment description/units/key parameters".
    • Identify task type: prediction/classification/evaluation/optimization/clustering/simulation/mechanistic modeling.
    • Extract constraints and boundaries: incidence angle, hierarchical relationships, unit conventions, feasible region.
  3. Data condition parsing
    • Attachment file names and fields: column names, units, sample size, range, missing value ratio.
    • Result specifications: require reflectance, thickness, error, ranking, or resource allocation, etc.
  4. Model selection engine (rules first, combined with prompt-based decision-making)
    • Prediction type: moving average/exponential smoothing/regression/ARIMA → tree models/LSTM.
    • Classification type: logistic regression/naive Bayes → random forest/gradient boosting, use cost-sensitive for imbalance.
    • Evaluation and ranking: normalization + weighted sum → entropy weighting/CRITIC/AHP/TOPSIS/VIKOR.
    • Optimization and scheduling: linear/integer programming → multi-objective and heuristics (genetic/annealing).
    • Clustering: K-means/hierarchical → GMM/DBSCAN (noise and non-convex shapes).
    • Mechanistic/simulation: differential/difference/system dynamics; contrast with data-driven approaches.
    • Physical/engineering modeling: establish equations based on domain knowledge (e.g., heat conduction, fluid mechanics, circuit analysis, optical propagation), use least squares or optimization algorithms for parameter inversion and model correction.
  5. Validation and robustness
    • Metrics: RMSE/MAE/AUC/F1/MAPE/silhouette coefficient/constraint satisfaction rate.
    • Cross-validation/rolling backtesting/hold-out method; ablation experiments and sensitivity analysis.
    • Extreme/boundary scenarios and unit convention consistency checks.

Decision logic quick reference

  • Appearance of "prediction/estimate the future/trend/parameter estimation" → prediction type.
  • Appearance of "classification/whether/risk level/identification" → classification type.
  • Appearance of "comprehensive evaluation/ranking/weights/scoring" → evaluation and ranking.
  • Appearance of "resource allocation/path/site selection/cost minimization/profit maximization" → optimization and scheduling.
  • Appearance of "grouping/profiling/similarity/pattern discovery" → clustering.
  • Appearance of "mechanism/simulation/dynamics/differential equations" → mechanistic/simulation.
  • Appearance of "physical processes/chemical reactions/signal transmission/mechanical structures" → physical/engineering modeling.

Output template

  • A Problem alignment: input, output, metrics, constraints, validation for each question.
  • B Outline: list chapters and sections in a scoring-friendly order.
  • C Scoring alignment: mapping table of scoring points and evidence.
  • D Model roadmap: task type/baseline/improvement/validation/risks and alternatives.

Usage example

  • Input: competition problem file path c:\path\to\赛题.pdf or the full text of the problem statement.
  • Behavior: read the document → extract each question → identify the task type and data conditions → output the four categories of results A/B/C/D and the recommended model.
  • Automatic suggestions:
    • Baseline: choose the simplest classical model (e.g., linear regression, K-means, shortest path algorithm).
    • Improvement: higher-order models introduced to address the baseline's shortcomings (e.g., nonlinearity, noise, multiple objectives) (e.g., XGBoost, improved genetic algorithm, hybrid model).
    • Validation: metric calculation, residual analysis, cross-validation, sensitivity analysis.

Anti-deviation check

  • Each question must provide quantifiable output and verifiable metrics.
  • Unify symbols and units, and keep metric definitions consistent.
  • At least one baseline comparison and evidence of improvement (improvement or more reasonable).
  • Conclusions and figures/tables correspond question by question; do not "do a lot but fail to answer the question."

When not to use this skill

  • When it is already clear that only a specific algorithm needs to be implemented or a single code snippet needs to be modified (direct implementation is faster).