規避 AI 詐欺偵測

# Adversarial transaction sequence design
class FraudEvasionTest:
    """
    Design transaction sequences that accomplish a
    fraudulent objective while minimizing fraud scores.
    """
 
    def design_low_and_slow(
        self, target_amount, customer_profile, fraud_model
    ):
        normal_amount_range = customer_profile.typical_amount_range
        normal_merchants = customer_profile.frequent_merchants
        normal_velocity = customer_profile.tx_per_day
        normal_times = customer_profile.typical_tx_times
 
        transactions = []
        remaining = target_amount
 
        while remaining > 0:
            amount = min(
                random.uniform(*normal_amount_range),
                remaining,
            )
            merchant = random.choice(normal_merchants)
            time = random.choice(normal_times)
 
            tx = {
                "amount": amount,
                "merchant": merchant,
                "time": time,
                "channel": customer_profile.preferred_channel,
            }
 
            score = fraud_model.score(tx, customer_profile)
            if score < 0.3:
                transactions.append(tx)
                remaining -= amount
            else:
                tx = self.adjust_for_lower_score(
                    tx, fraud_model, customer_profile
                )
                if fraud_model.score(tx, customer_profile) < 0.3:
                    transactions.append(tx)
                    remaining -= tx["amount"]
 
        return transactions

# Alert fatigue exploitation assessment
class AlertFatigueTest:
    """
    Assess whether a fraud detection system's alert volume
    can be manipulated to create analyst alert fatigue.
    """
 
    def measure_baseline_alert_rate(self, fraud_system, days=30):
        alerts = fraud_system.get_alert_history(days)
        return {
            "daily_alert_count": len(alerts) / days,
            "avg_review_time_seconds": np.mean(
                [a.review_time for a in alerts]
            ),
            "false_positive_rate": sum(
                1 for a in alerts if not a.confirmed_fraud
            ) / len(alerts),
        }
 
    def test_alert_inflation(
        self, fraud_system, inflation_transactions
    ):
        for tx in inflation_transactions:
            fraud_system.process_transaction(tx)
        return {
            "alert_volume_increase": self.measure_alert_change(),
            "review_time_decrease": self.measure_review_time_change(),
            "batch_approval_rate": self.detect_batch_approvals(),
        }