Pipelines de Fonctionnalités pour le ML

Construisez des pipelines de fonctionnalités ML et des feature stores — jointures temporelles correctes pour éviter les fuites de labels, parité hors ligne/en ligne, fraîcheur des fonctionnalités et backfills, matérialisation avec des outils comme Feast. À utiliser lors de l'ingénierie de fonctionnalités pour le ML, pour prévenir le skew train/serve ou les fuites de données, pour mettre en place un feature store, ou pour effectuer des backfills de fonctionnalités historiques pour l'entraînement.

Qu'est-ce que Pipelines de Fonctionnalités pour le ML ?

Ce skill guide le développeur dans la construction de pipelines de fonctionnalités ML robustes, en mettant l'accent sur la prévention des fuites de labels et du skew train/serve. Il détaille les bonnes pratiques pour les jointures temporelles (point-in-time correct), la parité hors ligne/en ligne, la fraîcheur des données et la matérialisation idempotente. Il est conçu pour des plateformes comme Feast et s'applique à tout workflow d'ingénierie de fonctionnalités utilisant des entrepôts de données ou des flux en streaming. Le skill fournit des patterns concrets (SQL, définition unique, planification de matérialisation) et identifie les pièges courants comme les fuites de labels, le skew train/serve ou les backfills non reproductibles. Il ne doit pas être utilisé pour des agrégations générales ou de la modélisation non liée aux fonctionnalités ML.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Unknown-333/awesome-data-engineering-skills/tree/main/skills/building-feature-pipelines

Installed? Explore more Recherche et analyse de données skills: affaan-m/uspto-database, affaan-m/scholar-evaluation, affaan-m/literature-review · View all 6 →

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Construction de Pipelines de Fonctionnalités

Quand l'utiliser

  • Ingénierie de fonctionnalités pour des modèles ML à partir de données d'entrepôt/stream.
  • Prévention des fuites de labels et du skew train/serve.
  • Mise en place d'un feature store, service en ligne, ou backfills historiques.
  • Ne PAS utiliser pour la modélisation/agrégation générale (utiliser les compétences dbt/Spark), sauf si cela alimente des fonctionnalités ML.

Workflow

- [ ] Définir chaque fonctionnalité avec une clé d'entité et un horodatage d'événement
- [ ] Construire des ensembles d'entraînement avec des jointures temporelles correctes (as-of le moment du label)
- [ ] Partager UNE SEULE définition pour le hors ligne (entraînement) et le en ligne (service)
- [ ] Définir la fraîcheur/la matérialisation pour les fonctionnalités en ligne
- [ ] Backfiller les fonctionnalités historiques de manière idempotente pour l'entraînement
  1. Correction temporelle. Joindre les fonctionnalités en fonction de l'horodatage de chaque label — utiliser uniquement les données connues avant l'heure de prédiction. Cela évite la fuite de labels, le bug de fonctionnalité le plus nuisible.
  2. Parité hors ligne/en ligne. Calculer une fonctionnalité de la même manière pour l'entraînement (hors ligne, batch) et le service (en ligne, faible latence). Une logique divergente provoque un skew train/serve et une dégradation silencieuse en production.
  3. Fraîcheur. Les fonctionnalités en ligne doivent être matérialisées selon un calendrier qui respecte la tolérance au vieillissement du modèle.
  4. Backfills idempotents. Recalculer les fonctionnalités historiques doit être reproductible (voir designing-backfills-and-replays).

Patterns

Jointure temporelle (as-of) — choisir la valeur de fonctionnalité la plus récente strictement avant chaque événement de label :

SELECT l.entity_id, l.label_ts, f.value AS feature
FROM labels l
LEFT JOIN features f
  ON f.entity_id = l.entity_id
 AND f.event_ts <= l.label_ts          -- uniquement données passées ; pas de fuite
QUALIFY ROW_NUMBER() OVER (
  PARTITION BY l.entity_id, l.label_ts ORDER BY f.event_ts DESC) = 1;

Définition unique, deux chemins — définir la fonctionnalité une fois (par ex. Feast FeatureView) ; matérialiser vers un store hors ligne pour l'entraînement et un store en ligne pour le service, afin que les deux utilisent une logique identique.

Fraîcheur + matérialisation — planifier la matérialisation en ligne ; surveiller la fraîcheur des fonctionnalités comme tout SLA de jeu de données (implementing-pipeline-observability).

Pièges courants

  • Fuite de labels — joindre des fonctionnalités calculées après l'horodatage du label gonfle les métriques hors ligne et s'effondre en production ; toujours utiliser une jointure as-of.
  • Skew train/serve — les implémentations hors ligne et en ligne séparées dérivent ; partager une seule définition.
  • Fonctionnalités en ligne obsolètes — le modèle sert sur des valeurs anciennes ; définir et surveiller la fraîcheur.
  • Backfills non reproductibles — historique d'entraînement incohérent ; rendre le recalcul des fonctionnalités idempotent.
  • Absence de clés d'entité/d'horodatage — les fonctionnalités ne peuvent pas être jointes correctement dans le temps ; exiger les deux.
  • Fonctionnalités non versionnées — une redéfinition silencieuse casse la comparabilité des modèles ; versionner les définitions de fonctionnalités.

Individual skills in this repo

This repo contains 9 individual skills — each has its own dedicated page.

Unknown-333/authoring-airflow-dags

Write production-grade Apache Airflow DAGs using the TaskFlow API — idempotent tasks, correct scheduling and catchup, retries/SLAs, connections/variables, and avoiding top-level code. Use when creating or reviewing Airflow DAGs, scheduling pipelines, wiring task dependencies, configuring retries/backfills, or fixing non-idempotent tasks.

Unknown-333/building-dagster-assets

Build Dagster pipelines using software-defined assets — asset dependencies, partitions, resources and IO managers, asset checks, and schedules/sensors. Use when creating Dagster assets or jobs, modeling data as assets, adding partitions or backfills, wiring resources/IO managers, or migrating from task-based orchestration to assets.

Unknown-333/building-dbt-models

Build well-structured dbt models — staging/intermediate/marts layers, ref() and source(), materializations, and incremental models with the right strategy. Use when creating or refactoring dbt models, choosing table vs view vs incremental, structuring a dbt project, or writing incremental logic.

Unknown-333/building-iceberg-tables

Design and operate Apache Iceberg tables — partitioning and hidden partitioning, partition/schema evolution, snapshots and time travel, compaction and small-file cleanup, and MERGE/upsert for lakehouse tables on Spark, Flink, Trino, or Snowflake. Use when creating or maintaining Iceberg tables, choosing partitioning, evolving schema/partitions, or fixing small-file and metadata bloat.

Unknown-333/building-ingestion-pipelines

Build batch and incremental data ingestion (extract-load) pipelines — full vs incremental extraction, change data capture (CDC), watermarks and high-water marks, API pagination and rate limits, and choosing managed EL tools (Fivetran, Airbyte) vs custom code. Use when ingesting data from databases, APIs, files, or SaaS into a warehouse/lake, or designing incremental extraction and CDC.

Unknown-333/building-kafka-consumers

Build reliable Apache Kafka consumers and producers — consumer groups and partition assignment, offset commit strategy, at-least-once vs exactly-once, idempotent/transactional producers, rebalancing, and dead-letter handling. Use when writing Kafka consumers/producers, configuring offset commits or consumer groups, tuning throughput, or handling rebalances and poison messages.

Unknown-333/debugging-data-pipelines

Systematically root-cause data pipeline failures and data incidents — job errors, wrong or missing data, duplicates, and freshness misses — by tracing lineage upstream, isolating the failing stage, reconciling against source, and planning a safe fix and backfill. Use when a pipeline fails, numbers look wrong, data is missing or duplicated, a dashboard is stale, or a stakeholder reports a data discrepancy.

Unknown-333/designing-backfills-and-replays

Plan and run safe data backfills and replays — idempotent reprocessing of historical windows, partition-by-partition execution, isolating backfill compute from production, verifying results, and avoiding double-counting or changed history. Use when backfilling a new or fixed model, reprocessing after a bug, replaying events, or loading history for a new pipeline without corrupting existing data.

Unknown-333/designing-data-contracts

Define and enforce data contracts between producers and consumers — explicit schema, semantics, ownership, SLAs, and versioning — to prevent silent upstream changes from breaking downstream pipelines. Use when a producer schema change could break consumers, defining an interface between teams/services and the warehouse, or adding schema enforcement at ingestion.

Skills associés