信用評分 AI 攻擊

# Credit scoring adversarial feature optimization
class CreditFeatureAttack:
    """
    Find minimum feature changes to flip a credit decision
    from 'deny' to 'approve' using gradient-based optimization.
    """
 
    def __init__(self, surrogate_model, feature_constraints):
        self.model = surrogate_model
        self.constraints = feature_constraints
 
    def optimize_features(self, original_features, target="approve"):
        perturbed = original_features.copy()
        for iteration in range(1000):
            gradient = self.compute_gradient(perturbed, target)
            for feature, grad in zip(
                self.constraints.manipulable_features, gradient
            ):
                step = grad * self.constraints.step_size[feature]
                new_value = perturbed[feature] + step
                new_value = max(
                    self.constraints.min_value[feature],
                    min(self.constraints.max_value[feature], new_value),
                )
                perturbed[feature] = new_value
            decision = self.model.predict(perturbed)
            if decision == target:
                return {
                    "success": True,
                    "iterations": iteration,
                    "original": original_features,
                    "optimized": perturbed,
                    "changes": self.compute_diff(
                        original_features, perturbed
                    ),
                }
        return {"success": False, "iterations": 1000}

# Disparate impact testing framework
def test_disparate_impact(credit_model, test_applications):
    """
    Test a credit model for disparate impact across
    protected characteristic groups.
    """
    results_by_group = {}
    for app in test_applications:
        score = credit_model.score(app["features"])
        decision = credit_model.decide(app["features"])
        group = app["demographic_group"]
        if group not in results_by_group:
            results_by_group[group] = {
                "total": 0, "approved": 0, "scores": []
            }
        results_by_group[group]["total"] += 1
        if decision == "approved":
            results_by_group[group]["approved"] += 1
        results_by_group[group]["scores"].append(score)
    approval_rates = {
        group: data["approved"] / data["total"]
        for group, data in results_by_group.items()
    }
    max_rate = max(approval_rates.values())
    disparate_impact = {}
    for group, rate in approval_rates.items():
        ratio = rate / max_rate if max_rate > 0 else 0
        disparate_impact[group] = {
            "approval_rate": rate,
            "ratio_to_max": ratio,
            "four_fifths_violation": ratio < 0.8,
        }
    return disparate_impact

# Attribute inference attack on credit scoring API
class AttributeInferenceAttack:
    """
    Infer a specific attribute of a known individual
    from credit model API responses.
    """
 
    def infer_income(self, model_api, known_features, target_name):
        query = known_features.copy()
        confidence_by_income = []
        for income in range(20000, 500000, 5000):
            query["annual_income"] = income
            response = model_api.score(query)
            confidence_by_income.append({
                "income": income,
                "score": response.score,
                "confidence": response.confidence,
            })
        best_match = max(
            confidence_by_income,
            key=lambda x: x["confidence"],
        )
        return {
            "inferred_income": best_match["income"],
            "confidence": best_match["confidence"],
            "method": "maximum_confidence_inference",
        }