AI: AI 伦理与未来

# Simulate how gender-associated keywords bias AI scoring
def score_resume(resume_text, model_bias=0.0):
    """Simulate an AI resume scorer with configurable bias."""
    base_score = 70

    # Male-associated keywords get a boost, female-associated get a penalty
    male_keywords = ["football", "military", "competitive", "dominant"]
    female_keywords = ["cheerleading", "nursing", "collaborative", "supportive"]

    for kw in male_keywords:
        if kw in resume_text.lower():
            base_score += 5 + model_bias  # bias amplifies the gap

    for kw in female_keywords:
        if kw in resume_text.lower():
            base_score -= 5 + model_bias

    return min(max(base_score, 0), 100)

# Two identical qualifications, different extracurriculars
resume_a = "BS in CS, 5 years experience, football team captain"
resume_b = "BS in CS, 5 years experience, cheerleading captain"

print(f"Resume A (male-coded): {score_resume(resume_a, model_bias=3)}")
print(f"Resume B (female-coded): {score_resume(resume_b, model_bias=3)}")
print(f"Gap: {score_resume(resume_a, model_bias=3) - score_resume(resume_b, model_bias=3)} points")

Resume A (male-coded): 88
Resume B (female-coded): 52
Gap: 36 points

# Demonstrate differential privacy concept with a simple example
import random

def count_with_dp(data, threshold, epsilon=1.0):
    """Count items above threshold with differential privacy noise."""
    true_count = sum(1 for x in data if x >= threshold)

    # Laplace mechanism: add noise calibrated to sensitivity and epsilon
    # Sensitivity = 1 (adding/removing one person changes count by at most 1)
    sensitivity = 1
    scale = sensitivity / epsilon
    noise = random.gauss(0, scale)  # Gaussian mechanism variant

    noisy_count = true_count + noise
    return true_count, round(noisy_count, 2)

# Salaries of 10 employees (in $1000s)
salaries = [45, 52, 48, 78, 55, 61, 49, 92, 53, 67]

true_val, dp_val = count_with_dp(salaries, threshold=60, epsilon=1.0)
print(f"True count (salary >= $60k): {true_val}")
print(f"DP count (epsilon=1.0):      {dp_val}")
print(f"Privacy guarantee: any single person's presence changes output by at most ~1/{1.0}")

# Smaller epsilon = more privacy, more noise
true_val2, dp_val2 = count_with_dp(salaries, threshold=60, epsilon=0.1)
print(f"\nWith stronger privacy (epsilon=0.1):")
print(f"True count: {true_val2}, DP count: {dp_val2}")
print(f"More noise added, but stronger privacy protection")

True count (salary >= $60k): 4
DP count (epsilon=1.0):      3.72
Privacy guarantee: any single person's presence changes output by at most ~1/1.0

With stronger privacy (epsilon=0.1):
True count: 4, DP count: 6.15
More noise added, but stronger privacy protection

Case Study: AI-Generated Image Copyright Disputes

Case 1: Getty Images vs. Stability AI (2023)
- Getty sued Stability AI for using millions of copyrighted images
  to train Stable Diffusion without license or compensation.
- Key issue: Does training on copyrighted images constitute fair use?
- Status: Ongoing litigation, potential industry-shaping precedent.

Case 2: Thaler v. Perlmutter (US Copyright Office, 2023)
- Stephen Thaler sought copyright for an image generated entirely by
  his AI system DABUS with no human input.
- Ruling: Copyright denied — human authorship is required.
- Implication: Pure AI output has no copyright protection.

Case 3: Naruto v. Slater (Monkey Selfie Case, 2018)
- A macaque took a selfie; court ruled non-humans cannot hold copyright.
- Precedent extended to AI: non-human creators lack copyright standing.

Key Takeaways for Developers:
1. Do NOT assume AI output is copyright-free — laws vary by jurisdiction
2. Using copyrighted data to train may expose you to legal risk
3. Adding significant human creative input to AI output strengthens
   your copyright claim
4. Always check the license/terms of the AI tool you use

# Simulate a simple Deepfake detection score analysis
def analyze_deepfake_indicators(video_metadata):
    """Analyze video metadata for deepfake indicators."""
    indicators = {
        "face_consistency": video_metadata.get("face_consistency", 0),  # 0-100
        "audio_visual_sync": video_metadata.get("audio_visual_sync", 0),  # 0-100
        "edge_artifacts": video_metadata.get("edge_artifacts", 0),  # 0-100, higher = more artifacts
        "blink_frequency": video_metadata.get("blink_frequency", 0),  # blinks per minute
        "skin_tone_consistency": video_metadata.get("skin_tone_consistency", 0),  # 0-100
    }

    # Weighted scoring (higher = more likely real)
    weights = {
        "face_consistency": 0.25,
        "audio_visual_sync": 0.25,
        "edge_artifacts": 0.15,  # inverse: high artifacts = suspicious
        "blink_frequency": 0.15,
        "skin_tone_consistency": 0.20,
    }

    # Edge artifacts: higher value = more suspicious (invert for score)
    artifact_score = 100 - indicators["edge_artifacts"]

    # Blink frequency: normal is 15-20 per minute
    blink_score = 100 - abs(indicators["blink_frequency"] - 17) * 5

    overall = (
        indicators["face_consistency"] * weights["face_consistency"]
        + indicators["audio_visual_sync"] * weights["audio_visual_sync"]
        + artifact_score * weights["edge_artifacts"]
        + blink_score * weights["blink_frequency"]
        + indicators["skin_tone_consistency"] * weights["skin_tone_consistency"]
    )

    if overall >= 75:
        verdict = "LIKELY AUTHENTIC"
    elif overall >= 50:
        verdict = "UNCERTAIN - Needs manual review"
    else:
        verdict = "LIKELY DEEPFAKE"

    return round(overall, 1), verdict

# Test with a suspicious video
suspicious = {
    "face_consistency": 55,
    "audio_visual_sync": 40,
    "edge_artifacts": 70,
    "blink_frequency": 3,
    "skin_tone_consistency": 50,
}

# Test with a genuine video
genuine = {
    "face_consistency": 92,
    "audio_visual_sync": 88,
    "edge_artifacts": 5,
    "blink_frequency": 16,
    "skin_tone_consistency": 95,
}

score1, v1 = analyze_deepfake_indicators(suspicious)
score2, v2 = analyze_deepfake_indicators(genuine)
print(f"Suspicious video: score={score1}, verdict={v1}")
print(f"Genuine video:    score={score2}, verdict={v2}")

Suspicious video: score=48.4, verdict=LIKELY DEEPFAKE
Genuine video:    score=90.3, verdict=LIKELY AUTHENTIC

Developer AI Skills Roadmap — Connecting This Course to Next Steps

Level 1: AI Foundations (This Course, Lessons 1-15)
├── Lesson 01-05: Python basics, data structures, NumPy
├── Lesson 06-10: ML fundamentals, supervised learning
├── Lesson 11-14: Deep learning, NLP, LLM applications
└── Lesson 15: Ethics, safety, responsible AI  <-- YOU ARE HERE

Level 2: AI Engineering (Recommended Next Course)
├── MLOps: model deployment, monitoring, CI/CD for ML
├── Prompt Engineering: advanced techniques, evaluation
├── RAG Systems: building retrieval-augmented applications
└── Fine-tuning: LoRA, QLoRA for domain adaptation

Level 3: AI Specialization (Choose Your Path)
├── Path A: AI Safety Research
│   ├── Alignment techniques (RLHF, Constitutional AI)
│   ├── Interpretability and mechanistic understanding
│   └── Red-teaming and adversarial evaluation
├── Path B: AI Product Development
│   ├── Multi-agent systems and orchestration
│   ├── Edge AI and on-device deployment
│   └── Human-AI interaction design
└── Path C: AI Infrastructure
    ├── Distributed training systems
    ├── Inference optimization (quantization, distillation)
    └── AI platform architecture

Level 4: AI Leadership (Long-term Growth)
├── Responsible AI governance frameworks
├── AI strategy and business integration
└── Cross-disciplinary collaboration skills

# AI Recruitment System — Ethics Audit Report Generator
# Step 1: Identify bias in training data
# Step 2: Propose mitigation strategies
# Step 3: Design fairness tests
# Step 4: Define privacy protection policies
# Step 5: Output a structured ethics audit report

import json
from datetime import datetime


def audit_training_data(data_stats):
    """Step 1: Identify bias in training data."""
    findings = []

    total = data_stats["total_samples"]
    for group, count in data_stats["group_distribution"].items():
        ratio = count / total
        if ratio < 0.2 or ratio > 0.6:
            findings.append({
                "group": group,
                "issue": "Under/over-represented",
                "ratio": round(ratio, 3),
                "severity": "HIGH" if ratio < 0.1 or ratio > 0.8 else "MEDIUM"
            })

    # Check label distribution across groups
    for group, label_dist in data_stats["label_by_group"].items():
        positive_rate = label_dist.get("positive", 0) / sum(label_dist.values())
        findings.append({
            "group": group,
            "issue": "Positive label rate",
            "positive_rate": round(positive_rate, 3),
            "severity": "INFO"
        })

    return findings


def propose_mitigations(findings):
    """Step 2: Propose mitigation strategies based on findings."""
    mitigations = []
    for f in findings:
        if "Under/over" in f.get("issue", ""):
            mitigations.append({
                "target": f["group"],
                "strategy": "Resampling + data augmentation",
                "rationale": f"Group {f['group']} has ratio {f['ratio']}, need balance"
            })
        elif "Positive label" in f.get("issue", ""):
            mitigations.append({
                "target": f["group"],
                "strategy": "Equalized odds constraint during training",
                "rationale": f"Group {f['group']} positive rate: {f['positive_rate']}"
            })
    return mitigations


def design_fairness_tests():
    """Step 3: Design fairness evaluation tests."""
    tests = [
        {
            "name": "Demographic Parity Test",
            "metric": "selection_rate_difference",
            "threshold": 0.05,
            "description": "Difference in positive prediction rates across groups should be < 5%"
        },
        {
            "name": "Equalized Odds Test",
            "metric": "true_positive_rate_difference",
            "threshold": 0.05,
            "description": "TPR difference across groups should be < 5%"
        },
        {
            "name": "Individual Fairness Test",
            "metric": "similar_individual_similarity",
            "threshold": 0.9,
            "description": "Similar candidates should receive similar scores (correlation > 0.9)"
        },
        {
            "name": "Intersectional Bias Test",
            "metric": "selection_rate_by_intersection",
            "threshold": 0.1,
            "description": "Check bias at intersection of protected attributes (e.g., race + gender)"
        }
    ]
    return tests


def define_privacy_policies(data_types):
    """Step 4: Define privacy protection policies."""
    policies = []
    for dtype in data_types:
        if dtype in ["name", "email", "phone", "address"]:
            policies.append({
                "data_type": dtype,
                "action": "REMOVE before training",
                "method": "Direct deletion from dataset"
            })
        elif dtype in ["age", "location", "education"]:
            policies.append({
                "data_type": dtype,
                "action": "GENERALIZE / k-anonymize",
                "method": "Bucket into ranges (age: 20-30, 30-40, etc.)"
            })
        elif dtype in ["work_history", "skills"]:
            policies.append({
                "data_type": dtype,
                "action": "DIFFERENTIAL PRIVACY on model",
                "method": "Apply DP-SGD with epsilon <= 3.0 during training"
            })
    return policies


def generate_report(data_stats, data_types):
    """Step 5: Generate the complete ethics audit report."""
    findings = audit_training_data(data_stats)
    mitigations = propose_mitigations(findings)
    tests = design_fairness_tests()
    privacy = define_privacy_policies(data_types)

    report = {
        "title": "AI Recruitment System Ethics Audit Report",
        "date": datetime.now().strftime("%Y-%m-%d"),
        "summary": {
            "total_findings": len(findings),
            "high_severity": len([f for f in findings if f.get("severity") == "HIGH"]),
            "mitigations_proposed": len(mitigations),
            "fairness_tests_designed": len(tests),
            "privacy_policies_defined": len(privacy)
        },
        "step1_data_bias_findings": findings,
        "step2_mitigation_strategies": mitigations,
        "step3_fairness_tests": tests,
        "step4_privacy_policies": privacy,
        "recommendations": [
            "1. Do NOT deploy until all HIGH severity findings are resolved",
            "2. Run fairness tests on every model update (automated CI/CD gate)",
            "3. Establish a human review committee for borderline decisions",
            "4. Conduct quarterly external ethics audits",
            "5. Publish a transparency report annually"
        ]
    }
    return report


# Run the audit
data_stats = {
    "total_samples": 50000,
    "group_distribution": {
        "male": 35000,
        "female": 12000,
        "non-binary": 3000
    },
    "label_by_group": {
        "male": {"positive": 14000, "negative": 21000},
        "female": {"positive": 2400, "negative": 9600},
        "non-binary": {"positive": 300, "negative": 2700}
    }
}

data_types = ["name", "email", "age", "location", "education", "work_history", "skills"]

report = generate_report(data_stats, data_types)
print(json.dumps(report, indent=2, ensure_ascii=False))

{
  "title": "AI Recruitment System Ethics Audit Report",
  "date": "2026-07-07",
  "summary": {
    "total_findings": 6,
    "high_severity": 0,
    "mitigations_proposed": 6,
    "fairness_tests_designed": 4,
    "privacy_policies_defined": 7
  },
  "step1_data_bias_findings": [
    {
      "group": "male",
      "issue": "Under/over-represented",
      "ratio": 0.7,
      "severity": "MEDIUM"
    },
    ...
  ],
  "recommendations": [
    "1. Do NOT deploy until all HIGH severity findings are resolved",
    "2. Run fairness tests on every model update (automated CI/CD gate)",
    "3. Establish a human review committee for borderline decisions",
    "4. Conduct quarterly external ethics audits",
    "5. Publish a transparency report annually"
  ]
}