| """Validation functions for ALICE Engine training data (ISO 5259). |
| |
| ISO Compliance: |
| - ISO/IEC 5259:2024 - Data Quality for ML (Lineage, Validation) |
| - ISO/IEC 42001:2023 - AI Management System |
| """ |
|
|
| from typing import Any |
|
|
| import pandas as pd |
| import pandera as pa |
|
|
| from schemas.training_constants import ( |
| ECHIQUIER_JEUNES_HIGH_BOARDS, |
| ECHIQUIER_MIN, |
| ELO_MAX_N4_PLUS, |
| MAX_SAMPLE_VALUES, |
| NIVEAU_HIERARCHY_MAX, |
| NIVEAU_N4, |
| VALID_GAME_SCORES_ADULTES, |
| VALID_GAME_SCORES_JEUNES_HIGH, |
| VALID_GAME_SCORES_JEUNES_LOW, |
| ) |
| from schemas.training_types import ( |
| DataLineage, |
| ErrorSeverity, |
| QualityMetrics, |
| ValidationError, |
| ValidationReport, |
| ) |
|
|
|
|
| def validate_training_data( |
| df: pd.DataFrame, |
| strict: bool = False, |
| lazy: bool = True, |
| ) -> pa.errors.SchemaErrors | None: |
| """Validate training DataFrame against FFE regulatory schema. |
| |
| Args: |
| ---- |
| df: DataFrame to validate |
| strict: Use strict FFE constraints |
| lazy: If True, collect all errors; if False, fail on first error |
| |
| Returns: |
| ------- |
| None if valid, SchemaErrors if invalid (when lazy=True) |
| |
| """ |
| from schemas.training_schemas import TrainingSchemaPermissive, TrainingSchemaStrict |
|
|
| schema = TrainingSchemaStrict if strict else TrainingSchemaPermissive |
| try: |
| schema.validate(df, lazy=lazy) |
| return None |
| except pa.errors.SchemaErrors as err: |
| return err |
|
|
|
|
| def validate_with_report( |
| df: pd.DataFrame, |
| source_path: str = "unknown", |
| strict: bool = False, |
| ) -> ValidationReport: |
| """Validate DataFrame and return ISO 5259 compliant report. |
| |
| Args: |
| ---- |
| df: DataFrame to validate |
| source_path: Path to source file for lineage |
| strict: Use strict FFE constraints |
| |
| Returns: |
| ------- |
| ValidationReport with lineage, metrics, and errors |
| |
| """ |
| from schemas.training_schemas import TrainingSchemaPermissive, TrainingSchemaStrict |
|
|
| lineage = DataLineage.from_dataframe(df, source_path) |
| schema = TrainingSchemaStrict if strict else TrainingSchemaPermissive |
|
|
| is_valid, raw_errors = _run_schema_validation(schema, df) |
| aggregated_errors = _aggregate_errors(raw_errors) |
| metrics = _compute_quality_metrics(df, aggregated_errors) |
|
|
| return ValidationReport( |
| lineage=lineage, |
| metrics=metrics, |
| errors=aggregated_errors, |
| is_valid=is_valid, |
| schema_mode="strict" if strict else "permissive", |
| ) |
|
|
|
|
| def _run_schema_validation( |
| schema: pa.DataFrameSchema, df: pd.DataFrame |
| ) -> tuple[bool, list[ValidationError]]: |
| """Run schema validation and parse errors into structured format.""" |
| try: |
| schema.validate(df, lazy=True) |
| return True, [] |
| except pa.errors.SchemaErrors as err: |
| errors = [] |
| for _, row in err.failure_cases.iterrows(): |
| severity = _classify_error_severity(row["check"], row["column"]) |
| errors.append( |
| ValidationError( |
| column=str(row["column"]) if pd.notna(row["column"]) else "schema", |
| check=str(row["check"]), |
| failure_count=1, |
| severity=severity, |
| sample_values=[row.get("failure_case")], |
| recommendation=_get_recommendation(row["check"]), |
| ) |
| ) |
| return False, errors |
|
|
|
|
| def _compute_quality_metrics(df: pd.DataFrame, errors: list[ValidationError]) -> QualityMetrics: |
| """Compute quality metrics from validation errors.""" |
| error_rows = sum(e.failure_count for e in errors) |
| valid_rows = max(0, len(df) - error_rows) |
| severity_counts = _count_by_severity(errors) |
|
|
| return QualityMetrics( |
| total_rows=len(df), |
| valid_rows=valid_rows, |
| null_percentages={col: df[col].isna().mean() for col in df.columns}, |
| validation_rate=valid_rows / len(df) if len(df) > 0 else 1.0, |
| **severity_counts, |
| ) |
|
|
|
|
| def _count_by_severity(errors: list[ValidationError]) -> dict[str, int]: |
| """Count errors by severity level.""" |
| counts = dict.fromkeys(ErrorSeverity, 0) |
| for e in errors: |
| counts[e.severity] += 1 |
| return { |
| "critical_errors": counts[ErrorSeverity.CRITICAL], |
| "high_errors": counts[ErrorSeverity.HIGH], |
| "medium_errors": counts[ErrorSeverity.MEDIUM], |
| "warnings": counts[ErrorSeverity.WARNING], |
| } |
|
|
|
|
| _CRITICAL_COLUMNS = frozenset({"resultat_blanc", "resultat_noir", "blanc_elo", "noir_elo"}) |
| _SEVERITY_KEYWORDS: list[tuple[frozenset[str], ErrorSeverity]] = [ |
| (frozenset({"dtype", "coerce"}), ErrorSeverity.CRITICAL), |
| (frozenset({"diff_elo", "equipe", "resultat"}), ErrorSeverity.HIGH), |
| (frozenset({"niveau", "competition"}), ErrorSeverity.MEDIUM), |
| ] |
|
|
|
|
| def _classify_error_severity(check: str, column: str) -> ErrorSeverity: |
| """Classify error severity based on check type.""" |
| if column in _CRITICAL_COLUMNS: |
| return ErrorSeverity.CRITICAL |
| check_str = str(check).lower() |
| for keywords, severity in _SEVERITY_KEYWORDS: |
| if any(k in check_str for k in keywords): |
| return severity |
| return ErrorSeverity.WARNING |
|
|
|
|
| def _get_recommendation(check: str) -> str: |
| """Get remediation recommendation for check failure.""" |
| check_str = str(check).lower() |
|
|
| if "diff_elo" in check_str: |
| return "Recalculate diff_elo as blanc_elo - noir_elo" |
| if "equipe" in check_str: |
| return "Verify player team assignment matches match teams" |
| if "resultat" in check_str: |
| return "Check game result encoding matches FFE regulations" |
| if "elo" in check_str: |
| return "Verify Elo rating is within valid range [799, 2900]" |
| if "niveau" in check_str: |
| return "Check competition level encoding" |
|
|
| return "Review data against FFE regulations" |
|
|
|
|
| def _aggregate_errors(errors: list[ValidationError]) -> list[ValidationError]: |
| """Aggregate errors by column and check.""" |
| aggregated: dict[tuple[str, str], ValidationError] = {} |
|
|
| for error in errors: |
| key = (error.column, error.check) |
| if key in aggregated: |
| aggregated[key].failure_count += 1 |
| if len(aggregated[key].sample_values) < MAX_SAMPLE_VALUES: |
| aggregated[key].sample_values.extend(error.sample_values) |
| else: |
| aggregated[key] = ValidationError( |
| column=error.column, |
| check=error.check, |
| failure_count=1, |
| severity=error.severity, |
| sample_values=error.sample_values[:5], |
| recommendation=error.recommendation, |
| ) |
|
|
| return list(aggregated.values()) |
|
|
|
|
| |
| |
| |
|
|
|
|
| def get_expected_score_range(type_competition: str, echiquier: int) -> list[float]: |
| """Get valid score range based on competition type and board number.""" |
| if type_competition == "national_jeunes": |
| if ECHIQUIER_MIN <= echiquier <= ECHIQUIER_JEUNES_HIGH_BOARDS: |
| return VALID_GAME_SCORES_JEUNES_HIGH |
| return VALID_GAME_SCORES_JEUNES_LOW |
| elif type_competition == "scolaire": |
| return VALID_GAME_SCORES_JEUNES_LOW |
| return VALID_GAME_SCORES_ADULTES |
|
|
|
|
| def is_valid_niveau_for_elo(niveau: int, elo: int) -> bool: |
| """Check if Elo is valid for given competition level. |
| |
| A02 Art. 3.7.j: Elo > 2400 interdit en N4 et divisions inferieures. |
| """ |
| if niveau >= NIVEAU_N4 and niveau <= NIVEAU_HIERARCHY_MAX and elo > ELO_MAX_N4_PLUS: |
| return False |
| return True |
|
|
|
|
| def compute_quality_summary(df: pd.DataFrame) -> dict[str, Any]: |
| """Compute data quality summary for monitoring. |
| |
| Returns dict with key metrics for dashboards/logging. |
| """ |
| return { |
| "row_count": len(df), |
| "column_count": len(df.columns), |
| "null_percentage": df.isna().mean().mean() * 100, |
| "duplicate_rows": df.duplicated().sum(), |
| "saison_range": [int(df["saison"].min()), int(df["saison"].max())], |
| "elo_range": [ |
| int(min(df["blanc_elo"].min(), df["noir_elo"].min())), |
| int(max(df["blanc_elo"].max(), df["noir_elo"].max())), |
| ], |
| "competition_types": df["type_competition"].unique().tolist(), |
| } |
|
|
