databubble-scoring 0.1.0__py3-none-any.whl

databubble_scoring/__init__.py

@@ -0,0 +1,9 @@
+"""
+databubble-scoring — pure, offline scoring/replay logic for DataBubble
+model cards, scorecards, and segment scorers. numpy/pandas/scipy/pydantic
+only; mlflow_pyfunc.py (mlflow support) is not imported here since it is an
+optional extra — import it explicitly if you have `databubble-scoring[mlflow]`
+installed.
+"""
+
+__version__ = "0.1.0"

databubble_scoring/classifier.py

@@ -0,0 +1,196 @@
+"""
+Pure scoring core shared by classification and segmentation. This is a
+SUBSET of the platform's skills/models/classifier.py — only the score-time
+path lives here (zero sklearn dependency, confirmed by direct read of
+score_observations, which reconstructs the linear function from stored
+coef_/intercept_/scaler_mean/scaler_scale lists using nothing but numpy).
+
+fit_classifier / fit_classifier_for_graph / check_segment_labels (sklearn-
+heavy, fit-time only) stay in the platform's own classifier.py, which
+re-imports FittedPipeline/score_observations/_sigmoid/_softmax from here so
+exactly one definition of FittedPipeline exists repo-wide.
+"""
+from __future__ import annotations
+
+from collections import Counter
+from typing import Optional
+
+import numpy as np
+import pandas as pd
+from pydantic import BaseModel
+
+
+class FittedPipeline(BaseModel):
+    """
+    Serialisable representation of a fitted classifier.
+    No sklearn objects — only lists and primitives.
+    score_observations reconstructs the linear function from these fields.
+    """
+    model_type: str                        # "binary" | "multinomial"
+    feature_names: list[str]               # column order expected at score time
+    scaler_mean: list[float]
+    scaler_scale: list[float]
+    classes_: list                         # class labels in order (as strings)
+    coef_: list[list[float]]               # shape (n_classes_or_1, n_features)
+    intercept_: list[float]               # shape (n_classes_or_1,)
+    threshold: float                       # decision threshold (binary: cost-adjusted; multinomial: argmax)
+    dummy_mapping: Optional[dict] = None   # for plain-English labels at score time
+    imputer_medians: Optional[list[float]] = None  # median per feature for NaN imputation at score time
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class ScoringOutput(BaseModel):
+    """
+    Structurally identical to the platform's skills.formatter.SkillOutput
+    (skill_name/summary/findings/warnings/recommendations/chapter_ref) —
+    this package has no platform dependency, so score_observations returns
+    this local model instead. .findings["labels"] etc. access is unchanged
+    for every caller.
+    """
+    skill_name: str
+    summary: str
+    findings: dict = {}
+    warnings: list[str] = []
+    recommendations: list[str] = []
+    chapter_ref: Optional[str] = None
+
+
+def _sigmoid(z: np.ndarray) -> np.ndarray:
+    return 1.0 / (1.0 + np.exp(-np.clip(z, -500, 500)))
+
+
+def _softmax(z: np.ndarray) -> np.ndarray:
+    # z shape: (n_obs, n_classes)
+    z_shifted = z - z.max(axis=1, keepdims=True)
+    exp_z = np.exp(z_shifted)
+    return exp_z / exp_z.sum(axis=1, keepdims=True)
+
+
+def score_observations(
+    new_X: pd.DataFrame,
+    pipeline: FittedPipeline,
+    low_confidence_threshold: float = 0.60,
+) -> ScoringOutput:
+    """
+    Score new observations using a FittedPipeline.
+    Reconstructs the linear function from stored coefficients — no sklearn needed.
+
+    Returns findings:
+      labels              : list of predicted class labels
+      probabilities       : list of dicts {class: prob} per observation
+      low_confidence      : list of bool
+      low_confidence_count: int
+      class_distribution  : dict {label: count}
+    """
+    missing = [f for f in pipeline.feature_names if f not in new_X.columns]
+    if missing:
+        return ScoringOutput(
+            skill_name="score_observations",
+            summary="Scoring failed — input columns do not match training features.",
+            findings={
+                "error": f"Missing columns: {missing}",
+                "expected": pipeline.feature_names,
+                "received": list(new_X.columns),
+            },
+            warnings=[f"Input is missing {len(missing)} column(s) from the training feature set."],
+            recommendations=["Ensure new data passes through the same feature preparation step as training data."],
+            chapter_ref="Chapter 19",
+        )
+
+    X_mat = new_X[pipeline.feature_names].values.astype(float)
+
+    if pipeline.imputer_medians is not None and np.isnan(X_mat).any():
+        _medians = np.array(pipeline.imputer_medians)
+        _nan_mask = np.isnan(X_mat)
+        X_mat[_nan_mask] = np.take(_medians, np.where(_nan_mask)[1])
+
+    mean_ = np.array(pipeline.scaler_mean)
+    scale_ = np.array(pipeline.scaler_scale)
+    X_scaled = (X_mat - mean_) / scale_
+
+    coef_ = np.array(pipeline.coef_)      # (1, n_feat) binary | (n_cls, n_feat) multinomial
+    intercept_ = np.array(pipeline.intercept_)
+
+    if pipeline.model_type == "binary":
+        logits = X_scaled @ coef_[0] + intercept_[0]   # (n_obs,)
+        probs_pos = _sigmoid(logits)                     # (n_obs,)
+        prob_matrix = np.column_stack([1 - probs_pos, probs_pos])  # (n_obs, 2)
+    else:
+        logits = X_scaled @ coef_.T + intercept_        # (n_obs, n_classes)
+        prob_matrix = _softmax(logits)                   # (n_obs, n_classes)
+
+    classes = pipeline.classes_
+    max_probs = prob_matrix.max(axis=1)
+    predicted_indices = prob_matrix.argmax(axis=1)
+    labels = [classes[i] for i in predicted_indices]
+
+    if pipeline.model_type == "binary" and pipeline.threshold != 0.50:
+        labels = [
+            classes[1] if prob_matrix[i, 1] >= pipeline.threshold else classes[0]
+            for i in range(len(labels))
+        ]
+
+    low_confidence = [bool(p < low_confidence_threshold) for p in max_probs]
+    low_confidence_count = sum(low_confidence)
+
+    probabilities = [
+        {cls: round(float(prob_matrix[i, j]), 4) for j, cls in enumerate(classes)}
+        for i in range(len(labels))
+    ]
+
+    class_dist = {str(k): v for k, v in Counter(labels).items()}
+    for _k in (str(c) for c in pipeline.classes_):
+        if _k not in class_dist:
+            class_dist[_k] = 0
+
+    n_obs = len(labels)
+    lc_pct = low_confidence_count / n_obs if n_obs > 0 else 0
+
+    warnings_out = []
+    if lc_pct > 0.20:
+        warnings_out.append(
+            f"{low_confidence_count} of {n_obs} observations ({lc_pct:.1%}) scored below "
+            f"the {low_confidence_threshold:.0%} confidence threshold. "
+            "These assignments should be treated as uncertain."
+        )
+
+    confidence_implausibly_low = False
+    if n_obs >= 100 and lc_pct < 0.005:
+        confidence_implausibly_low = True
+        warnings_out.append(
+            f"Only {lc_pct:.1%} of observations fell below the 0.60 confidence threshold. "
+            f"With real-world data this is statistically implausible and may indicate overfitting or "
+            f"data leakage — validate on genuinely unseen data."
+        )
+
+    summary = (
+        f"{n_obs} observations scored. "
+        f"Class distribution: {class_dist}. "
+        f"{low_confidence_count} flagged as low confidence (<{low_confidence_threshold:.0%})."
+    )
+
+    return ScoringOutput(
+        skill_name="score_observations",
+        summary=summary,
+        findings={
+            "labels": labels,
+            "probabilities": probabilities,
+            "low_confidence": low_confidence,
+            "low_confidence_count": low_confidence_count,
+            "low_confidence_pct": round(lc_pct, 4),
+            "confidence_implausibly_low": confidence_implausibly_low,
+            "class_distribution": class_dist,
+            "n_observations": n_obs,
+            "threshold_used": pipeline.threshold,
+            "low_confidence_threshold": low_confidence_threshold,
+        },
+        warnings=warnings_out,
+        recommendations=(
+            ["Review low-confidence observations manually before acting on segment assignments."]
+            if lc_pct > 0.20 else
+            ["Segment assignments are ready to use."]
+        ),
+        chapter_ref="Chapter 19",
+    )

databubble_scoring/drift_monitoring.py

@@ -0,0 +1,231 @@
+"""
+DataBubble — Drift Monitoring for Exported ModelCards
+
+Compares a new batch of rows against a ModelCard's fit-time
+feature_snapshot (per-column mean/std/skewness or proportion, added by the
+platform's linear_regression.py::run_regression at fit time — see
+model_card.py::ColumnSnapshot). Point-summary only, never raw reference
+rows — a one-sample t-test (mean) and two-sample z-tests (skewness,
+proportion) are the right tests here, not a full two-sample PSI/KS, since
+no second full distribution exists to compare against.
+
+apply_recipe (model_card.py) rebuilds new rows into the exact fit-time
+model-matrix shape — reused here for column alignment and for its existing
+missing-column/unseen-level validation, rather than duplicating either.
+
+The proportion two-sample z-test is hand-rolled with scipy.stats.norm
+(standard pooled-variance two-proportion z-test) rather than taking
+statsmodels as a runtime dependency, keeping this package to
+numpy/pandas/scipy/pydantic only. Cross-checked against
+statsmodels.stats.proportion.proportions_ztest in this package's own test
+suite (a dev-only dependency, never a runtime one).
+"""
+from __future__ import annotations
+
+import math
+import warnings
+from typing import Any, Literal, Optional
+
+import numpy as np
+import pandas as pd
+from scipy import stats
+from pydantic import BaseModel
+
+try:
+    from .model_card import ModelCard, apply_recipe
+except ImportError:
+    from model_card import ModelCard, apply_recipe
+
+DRIFT_ALPHA = 0.05      # two-tailed significance threshold
+SKEW_DRIFT_Z = 1.96     # ~95% two-tailed z-critical
+
+
+class ColumnDriftResult(BaseModel):
+    column: str
+    kind: Literal["continuous", "proportion"]
+    n_observed: int
+    reference: dict[str, Any]
+    observed: dict[str, Any]
+    drifted: bool
+    detail: str
+
+
+class DriftResult(BaseModel):
+    applicable: bool
+    reason: Optional[str] = None
+    n_features_checked: int = 0
+    n_features_drifted: int = 0
+    drift_detected: bool = False
+    per_feature: list[ColumnDriftResult] = []
+    interpretation: str = ""
+
+
+def _skewness_se(n: int) -> float:
+    """
+    Fisher's standard error of the sample skewness coefficient. Undefined
+    for n < 3 — callers must guard that themselves.
+    """
+    return math.sqrt((6 * n * (n - 1)) / ((n - 2) * (n + 1) * (n + 3)))
+
+
+def _two_proportion_ztest(count: list[int], nobs: list[int]) -> tuple[float, float]:
+    """
+    Standard pooled-variance two-proportion z-test, two-sided. Hand-rolled
+    replacement for statsmodels.stats.proportion.proportions_ztest(count,
+    nobs) with its default prop_var (pooled) behavior — cross-checked
+    against the real thing in test_drift_monitoring.py.
+    Returns (z_statistic, p_value). p_value is nan when the pooled variance
+    is exactly 0 (both samples identical, e.g. all-0 or all-1) — caller
+    already has its own "std=0" fallback for a nan p-value.
+    """
+    count1, count2 = count
+    n1, n2 = nobs
+    p1, p2 = count1 / n1, count2 / n2
+    p_pool = (count1 + count2) / (n1 + n2)
+    var = p_pool * (1 - p_pool) * (1.0 / n1 + 1.0 / n2)
+    if var <= 0:
+        return float("nan"), float("nan")
+    z = (p1 - p2) / math.sqrt(var)
+    p_value = 2 * float(stats.norm.sf(abs(z)))
+    return float(z), p_value
+
+
+def _check_continuous_drift(column: str, snapshot: dict, observed: pd.Series, alpha: float) -> ColumnDriftResult:
+    values = observed.dropna()
+    n_obs = len(values)
+    notes: list[str] = []
+    drifted = False
+
+    ref_mean = snapshot.get("mean")
+    if ref_mean is not None and n_obs >= 2:
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                _, p_value = stats.ttest_1samp(values, popmean=ref_mean)
+            if math.isnan(p_value):
+                shifted = float(values.mean()) != ref_mean
+                p_note = "std=0"
+            else:
+                shifted = p_value < alpha
+                p_note = f"p={p_value:.4g}"
+        except Exception:
+            shifted, p_note = False, ""
+        if shifted:
+            drifted = True
+            new_mean = float(values.mean())
+            direction = "up" if new_mean > ref_mean else "down"
+            notes.append(f"mean shifted {direction} from {ref_mean:.4g} to {new_mean:.4g} ({p_note})")
+
+    ref_skew = snapshot.get("skewness")
+    ref_n = snapshot.get("n")
+    if ref_skew is not None and ref_n is not None and n_obs >= 3 and ref_n >= 3:
+        try:
+            new_skew = float(values.skew())
+            se_diff = math.sqrt(_skewness_se(n_obs) ** 2 + _skewness_se(ref_n) ** 2)
+            z = (new_skew - ref_skew) / se_diff if se_diff > 0 else 0.0
+            if abs(z) >= SKEW_DRIFT_Z:
+                drifted = True
+                notes.append(f"skewness shifted from {ref_skew:.4g} to {new_skew:.4g} (z={z:.2f})")
+        except Exception:
+            pass
+
+    return ColumnDriftResult(
+        column=column, kind="continuous", n_observed=n_obs,
+        reference=snapshot,
+        observed={"mean": float(values.mean()) if n_obs else None,
+                  "std": float(values.std(ddof=1)) if n_obs >= 2 else None,
+                  "skewness": float(values.skew()) if n_obs >= 3 else None},
+        drifted=drifted,
+        detail="; ".join(notes) if notes else "No significant shift detected.",
+    )
+
+
+def _check_proportion_drift(column: str, snapshot: dict, observed: pd.Series, alpha: float) -> ColumnDriftResult:
+    values = observed.dropna()
+    n_obs = len(values)
+    ref_proportion = snapshot.get("proportion")
+    ref_n = snapshot.get("n")
+    new_proportion = float(values.mean()) if n_obs else None
+    drifted = False
+    detail = "No significant shift detected."
+
+    if ref_proportion is not None and ref_n and n_obs >= 1:
+        new_count = int(values.sum())
+        ref_count = round(ref_proportion * ref_n)
+        try:
+            _stat, p_value = _two_proportion_ztest(
+                count=[new_count, ref_count], nobs=[n_obs, ref_n],
+            )
+            if math.isnan(p_value):
+                drifted = new_proportion != ref_proportion
+                detail = "std=0"
+            elif p_value < alpha:
+                drifted = True
+                direction = "up" if new_proportion > ref_proportion else "down"
+                detail = (
+                    f"proportion shifted {direction} from {ref_proportion:.4g} to "
+                    f"{new_proportion:.4g} (p={p_value:.4g})"
+                )
+        except Exception:
+            pass
+
+    return ColumnDriftResult(
+        column=column, kind="proportion", n_observed=n_obs,
+        reference=snapshot, observed={"proportion": new_proportion},
+        drifted=drifted, detail=detail,
+    )
+
+
+def diagnose_feature_drift(card: ModelCard, new_rows: pd.DataFrame, alpha: float = DRIFT_ALPHA) -> DriftResult:
+    """
+    Compares new_rows against card.feature_snapshot (the training-time
+    per-column reference captured at fit time). Raises RecipeError (same
+    as predict_from_card) when new_rows can't be rebuilt into the card's
+    model matrix — missing columns or unseen categorical levels.
+    """
+    if not card.feature_snapshot:
+        return DriftResult(
+            applicable=False,
+            reason=(
+                "This card predates drift monitoring (schema < 1.2) — "
+                "re-export the model to enable it."
+            ),
+        )
+
+    matrix = apply_recipe(new_rows, card.recipe)
+
+    per_feature: list[ColumnDriftResult] = []
+    for column, snap in card.feature_snapshot.items():
+        snapshot = snap if isinstance(snap, dict) else snap.model_dump()
+        if column not in matrix.columns:
+            continue
+        if snapshot.get("kind") == "proportion":
+            per_feature.append(_check_proportion_drift(column, snapshot, matrix[column], alpha))
+        else:
+            per_feature.append(_check_continuous_drift(column, snapshot, matrix[column], alpha))
+
+    n_drifted = sum(1 for pf in per_feature if pf.drifted)
+    drift_detected = n_drifted > 0
+
+    if drift_detected:
+        drifted_cols = [pf.column for pf in per_feature if pf.drifted]
+        interpretation = (
+            f"{n_drifted} of {len(per_feature)} feature(s) shifted significantly "
+            f"from their training-time distribution: {', '.join(drifted_cols)}. "
+            f"Predictions from this model may no longer be reliable for this "
+            f"population — review before continuing to use it."
+        )
+    else:
+        interpretation = (
+            f"No significant shift detected across {len(per_feature)} feature(s) "
+            f"checked against their training-time distribution."
+        )
+
+    return DriftResult(
+        applicable=True,
+        n_features_checked=len(per_feature),
+        n_features_drifted=n_drifted,
+        drift_detected=drift_detected,
+        per_feature=per_feature,
+        interpretation=interpretation,
+    )

databubble_scoring/mlflow_pyfunc.py

@@ -0,0 +1,198 @@
+"""
+DataBubble — MLflow pyfunc artifact for offline scoring.
+
+Wraps a ModelCard / Scorecard / SegmentScorer as a standard MLflow pyfunc
+model: `predict()` runs the exact same predict_from_card / score_from_scorecard
+/ score_from_segment_scorer path the DataBubble platform itself uses at
+export time, so a locally-loaded artifact and the hosted API can never
+silently diverge. No network call at inference.
+
+Optional module: only import this if you have `databubble-scoring[mlflow]`
+installed. databubble_scoring/__init__.py never imports it.
+
+ModelCardBundle (multi-group cards) is not supported in this version —
+export a single group's ModelCard instead.
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from typing import Optional, Union
+
+import pandas as pd
+from pydantic import BaseModel
+
+try:
+    import mlflow.pyfunc
+except ImportError as e:
+    raise ImportError(
+        "mlflow is required to use databubble_scoring.mlflow_pyfunc — install "
+        "with `pip install databubble-scoring[mlflow]`."
+    ) from e
+
+try:
+    from . import __version__
+    from .model_card import ModelCard, RecipeError
+    from .predict import predict_from_card, PredictionResult
+    from .scorecard import Scorecard, score_from_scorecard
+    from .segment_scorer import SegmentScorer, score_from_segment_scorer
+except ImportError:
+    from databubble_scoring import __version__
+    from model_card import ModelCard, RecipeError
+    from predict import predict_from_card, PredictionResult
+    from scorecard import Scorecard, score_from_scorecard
+    from segment_scorer import SegmentScorer, score_from_segment_scorer
+
+Artifact = Union[ModelCard, Scorecard, SegmentScorer, dict]
+
+
+def _detect_kind(d: dict) -> str:
+    kind = d.get("kind")
+    if kind == "classification_scorecard":
+        return "classification_scorecard"
+    if kind == "segment_scorer":
+        return "segment_scorer"
+    if kind == "bundle":
+        raise ValueError(
+            "ModelCardBundle (multi-group cards) is not supported by the MLflow "
+            "pyfunc wrapper — export and save a single group's ModelCard instead."
+        )
+    if kind is not None:
+        raise ValueError(f"Unrecognised card 'kind': {kind!r}")
+    # ModelCard carries no `kind` field at all — its required fields are what
+    # distinguish it from a malformed payload.
+    if {"outcome", "intercept", "terms", "recipe", "provenance"} <= d.keys():
+        return "model_card"
+    raise ValueError(
+        "Could not determine artifact kind from card.json — expected a ModelCard "
+        "(no 'kind' field), a Scorecard ('kind': 'classification_scorecard'), or "
+        "a SegmentScorer ('kind': 'segment_scorer')."
+    )
+
+
+def _artifact_dict(artifact: Artifact) -> dict:
+    if isinstance(artifact, BaseModel):
+        return artifact.model_dump()
+    if isinstance(artifact, dict):
+        return artifact
+    raise TypeError(f"artifact must be a ModelCard/Scorecard/SegmentScorer or dict, got {type(artifact)}")
+
+
+def _prediction_result_to_frame(result: PredictionResult) -> pd.DataFrame:
+    data = {"prediction": result.predictions}
+    for col in ("ci_lower", "ci_upper", "pi_lower", "pi_upper"):
+        val = getattr(result, col)
+        if val is not None:
+            data[col] = val
+    return pd.DataFrame(data)
+
+
+def _scoring_output_to_frame(findings: dict, kind: str) -> pd.DataFrame:
+    if findings.get("labels") is None:
+        raise ValueError(
+            f"Scoring failed: {findings.get('error', 'input columns did not match the fitted pipeline')} "
+            f"(expected columns: {findings.get('expected')}, received: {findings.get('received')})"
+        )
+    data = {"label": findings["labels"]}
+    df = pd.DataFrame(data)
+    probs = findings.get("probabilities") or []
+    if probs:
+        df = pd.concat([df, pd.DataFrame(probs).add_prefix("probability_")], axis=1)
+    if "low_confidence" in findings:
+        df["low_confidence"] = findings["low_confidence"]
+    if kind == "segment_scorer":
+        assignments = findings.get("assignments") or []
+        if assignments:
+            df["segment"] = [a["segment"] for a in assignments]
+    return df
+
+
+class DataBubbleScoringModel(mlflow.pyfunc.PythonModel):
+    """
+    Generic pyfunc wrapper for any DataBubble scoring artifact. The concrete
+    kind (ModelCard / Scorecard / SegmentScorer) is auto-detected from
+    card.json at load time — one model class covers all three, since the
+    scoring call each dispatches to is already the single source of truth
+    (predict_from_card / score_from_scorecard / score_from_segment_scorer).
+    """
+
+    def load_context(self, context):
+        with open(context.artifacts["card_json"]) as f:
+            d = json.load(f)
+        self._kind = _detect_kind(d)
+        if self._kind == "model_card":
+            self._artifact = ModelCard(**d)
+        elif self._kind == "classification_scorecard":
+            self._artifact = Scorecard(**d)
+        else:
+            self._artifact = SegmentScorer(**d)
+
+    def predict(self, context, model_input, params=None):
+        if not isinstance(model_input, pd.DataFrame):
+            model_input = pd.DataFrame(model_input)
+
+        if self._kind == "model_card":
+            result = predict_from_card(self._artifact, model_input)
+            return _prediction_result_to_frame(result)
+
+        try:
+            if self._kind == "classification_scorecard":
+                scoring_result = score_from_scorecard(self._artifact, model_input)
+            else:
+                scoring_result = score_from_segment_scorer(self._artifact, model_input)
+        except RecipeError as e:
+            raise ValueError(f"Recipe replay failed: {e}") from e
+        return _scoring_output_to_frame(scoring_result.findings, self._kind)
+
+
+def _write_card_json(artifact: Artifact) -> str:
+    d = _artifact_dict(artifact)
+    _detect_kind(d)  # validate (raises early on a bundle/malformed payload) before any file/mlflow I/O
+    fd, path = tempfile.mkstemp(suffix=".json", prefix="databubble_card_")
+    with os.fdopen(fd, "w") as f:
+        json.dump(d, f)
+    return path
+
+
+def save_databubble_model(artifact: Artifact, path: str, **save_model_kwargs) -> None:
+    """
+    Save a ModelCard/Scorecard/SegmentScorer as a local MLflow pyfunc model
+    directory. `artifact` may be the pydantic instance or its .model_dump()
+    dict. Reload with `mlflow.pyfunc.load_model(path)`.
+    """
+    card_path = _write_card_json(artifact)
+    try:
+        mlflow.pyfunc.save_model(
+            path=path,
+            python_model=DataBubbleScoringModel(),
+            artifacts={"card_json": card_path},
+            pip_requirements=[f"databubble-scoring=={__version__}"],
+            **save_model_kwargs,
+        )
+    finally:
+        os.remove(card_path)
+
+
+def log_databubble_model(
+    artifact: Artifact,
+    artifact_path: str,
+    registered_model_name: Optional[str] = None,
+    **log_model_kwargs,
+):
+    """
+    Log a ModelCard/Scorecard/SegmentScorer as an MLflow pyfunc model to the
+    active run. Returns the mlflow.models.model.ModelInfo from log_model.
+    """
+    card_path = _write_card_json(artifact)
+    try:
+        return mlflow.pyfunc.log_model(
+            artifact_path=artifact_path,
+            python_model=DataBubbleScoringModel(),
+            artifacts={"card_json": card_path},
+            pip_requirements=[f"databubble-scoring=={__version__}"],
+            registered_model_name=registered_model_name,
+            **log_model_kwargs,
+        )
+    finally:
+        os.remove(card_path)