machine-learning-foundations

어떤 스킬인가요?

Machine Learning Foundations workflows for quantitative research, implementation, and production controls. use when tasks involve feature pipelines, generalization control, and model-monitoring discipline.

설치 방법

프로젝트 폴더에서 아래 명령어를 실행하고, 설치할 에이전트를 선택하세요.

설치 명령을 직접 실행해야 적용됩니다. 지원 에이전트와 필요한 권한·라이선스는 제작자의 안내를 확인하세요.

스킬 원문 파일

interface:
  display_name: "Machine Learning Foundations"
  short_description: "feature pipelines, generalization control, and model-monitoring discipline"
  default_prompt: "build machine learning foundations workflows for feature pipelines, generalization control, and model-monitoring discipline with concrete diagnostics, limits, and rollout controls."

# Machine Learning Foundations playbook

## mission
Run machine learning foundations workflows for feature pipelines, generalization control, and model-monitoring discipline with reproducible diagnostics and controlled release criteria.

## required input schema
- `timestamp`
- `target_value`
- `prediction_value`
- `residual_value`
- `parameter_value`
- `objective_value`
- `calibration_error`
- `simulation_count`
- `train_loss`
- `validation_loss`

## validation checklist
- residual diagnostics and autocorrelation by horizon.
- parameter stability across rolling and expanding windows.
- numerical convergence behavior and solver tolerance sensitivity.
- forecast calibration and distributional fit checks.
- generalization gap under rolling retraining
- feature drift and leakage diagnostics

## release controls
- enforce parameter-bound and convergence-failure safeguards.
- enforce rollback to baseline models on instability.
- enforce monitoring for drift and structural-break detection.

## delivery package
- objective, mandate constraints, and benchmark definition
- data lineage, assumptions, and preprocessing decisions
- model or process specification with parameter settings
- diagnostic results, stress tests, and failure analysis
- production rollout, fallback criteria, and ownership

# diagnostics for machine learning foundations.

import argparse
import json

import pandas as pd


required_columns = ('timestamp', 'target_value', 'prediction_value', 'residual_value', 'parameter_value', 'objective_value', 'calibration_error', 'simulation_count', 'train_loss', 'validation_loss')
numeric_columns = ('target_value', 'prediction_value', 'residual_value', 'parameter_value', 'objective_value', 'calibration_error', 'simulation_count', 'drift_score', 'train_loss', 'validation_loss')


def summarize(data_frame):
    working_frame = data_frame.copy()
    summary = {
        "rows": int(len(working_frame)),
        "columns": list(working_frame.columns),
    }

    available_numeric_columns = []
    for column_name in numeric_columns:
        if column_name in working_frame.columns:
            converted_series = pd.to_numeric(working_frame[column_name], errors="coerce")
            working_frame[column_name] = converted_series
            if converted_series.notna().any():
                available_numeric_columns.append(column_name)

    for column_name in available_numeric_columns:
        column_series = working_frame[column_name].dropna()
        summary[f"{column_name}_mean"] = float(column_series.mean()) if not column_series.empty else float("nan")
        summary[f"{column_name}_std"] = float(column_series.std(ddof=1)) if len(column_series) > 1 else float("nan")
        summary[f"{column_name}_p95"] = float(column_series.quantile(0.95)) if not column_series.empty else float("nan")

    if {"target_value", "prediction_value"}.issubset(working_frame.columns):
        aligned_frame = working_frame[["target_value", "prediction_value"]].dropna()
        residual_series = aligned_frame["prediction_value"] - aligned_frame["target_value"]
        summary["mae"] = float(residual_series.abs().mean()) if not residual_series.empty else float("nan")
        summary["rmse"] = float((residual_series.pow(2).mean()) ** 0.5) if not residual_series.empty else float("nan")
        summary["prediction_target_corr"] = float(aligned_frame["prediction_value"].corr(aligned_frame["target_value"])) if len(aligned_frame) > 1 else float("nan")

    return summary


def parse_arguments():
    parser = argparse.ArgumentParser(description="diagnostics for machine learning foundations")
    parser.add_argument("input_csv", help="input csv file")
    parser.add_argument("--output", help="optional json output file")
    return parser.parse_args()


def main():
    arguments = parse_arguments()
    data_frame = pd.read_csv(arguments.input_csv)

    missing_columns = [column_name for column_name in required_columns if column_name not in data_frame.columns]
    if missing_columns:
        raise SystemExit("missing required columns: " + ", ".join(missing_columns))

    data_frame["timestamp"] = pd.to_datetime(data_frame["timestamp"], errors="coerce")
    data_frame = data_frame.dropna(subset=["timestamp"])

    payload = json.dumps(summarize(data_frame), indent=2, sort_keys=True)
    if arguments.output:
        with open(arguments.output, "w", encoding="utf-8") as output_file:
            output_file.write(payload + "\n")
    print(payload)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

---
name: machine-learning-foundations
description: "Machine Learning Foundations workflows for quantitative research, implementation, and production controls. use when tasks involve feature pipelines, generalization control, and model-monitoring discipline."
---

# Machine Learning Foundations
## objective
Execute machine learning foundations work with reproducible research, explicit controls, and deployable outputs.

## workflow
1. define assumptions, governing equations, and boundary conditions.
2. estimate parameters with reproducible calibration settings.
3. validate residual structure, numerical stability, and convergence behavior.
4. stress model behavior across regime changes and parameter perturbations.
5. release only when out-of-sample accuracy and stability remain within limits.

## required diagnostics
- residual diagnostics and autocorrelation by horizon.
- parameter stability across rolling and expanding windows.
- numerical convergence behavior and solver tolerance sensitivity.
- forecast calibration and distributional fit checks.
- generalization gap under rolling retraining
- feature drift and leakage diagnostics

## risk controls
- enforce parameter-bound and convergence-failure safeguards.
- enforce rollback to baseline models on instability.
- enforce monitoring for drift and structural-break detection.

## outputs
- run `python scripts/machine_learning_foundations_diagnostics.py input.csv --output diagnostics.json` and keep the json artifact.
- write an implementation memo using `references/machine-learning-foundations-playbook.md` with assumptions, tests, limits, and rollout plan.

## resources
- use `scripts/machine_learning_foundations_diagnostics.py` for deterministic diagnostics.
- use `references/machine-learning-foundations-playbook.md` for the domain-specific checklist and delivery structure.