AI: Ética da IA e o Futuro

# 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

Roteiro de Habilidades de IA para Desenvolvedores — Conectando Este Curso aos Próximos Passos

Nível 1: Fundamentos de IA (Este Curso, Lições 1-15)
├── Lição 01-05: Básico de Python, estruturas de dados, NumPy
├── Lição 06-10: Fundamentos de ML, aprendizado supervisionado
├── Lição 11-14: Deep learning, NLP, aplicações de LLM
└── Lição 15: Ética, segurança, IA responsável  <-- VOCÊ ESTÁ AQUI

Nível 2: Engenharia de IA (Próximo Curso Recomendado)
├── MLOps: implantação de modelos, monitoramento, CI/CD para ML
├── Engenharia de Prompt: técnicas avançadas, avaliação
├── Sistemas RAG: construindo aplicações com recuperação aumentada
└── Ajuste Fino: LoRA, QLoRA para adaptação a domínios

Nível 3: Especialização em IA (Escolha Seu Caminho)
├── Caminho A: Pesquisa em Segurança de IA
│   ├── Técnicas de alinhamento (RLHF, IA Constitucional)
│   ├── Interpretabilidade e entendimento mecanicista
│   └── Red-teaming e avaliação adversarial
├── Caminho B: Desenvolvimento de Produto com IA
│   ├── Sistemas multiagentes e orquestração
│   ├── IA na borda e implantação no dispositivo
│   └── Design de interação humano-IA
└── Caminho C: Infraestrutura de IA
    ├── Sistemas de treinamento distribuído
    ├── Otimização de inferência (quantização, destilação)
    └── Arquitetura de plataforma de IA

Nível 4: Liderança em IA (Crescimento a Longo Prazo)
├── Frameworks de governança de IA responsável
├── Estratégia de IA e integração nos negócios
└── Habilidades de colaboração interdisciplinar

# 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": "Relatório de Auditoria Ética do Sistema de Recrutamento por IA",
  "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": "Sub/sobre-representado",
      "ratio": 0.7,
      "severity": "MEDIUM"
    },
    ...
  ],
  "recommendations": [
    "1. NÃO implementar até que todos os achados de gravidade ALTA sejam resolvidos",
    "2. Executar testes de justiça em cada atualização do modelo (gate de CI/CD automatizado)",
    "3. Estabelecer um comitê de revisão humana para decisões limítrofes",
    "4. Realizar auditorias éticas externas trimestrais",
    "5. Publicar um relatório de transparência anual"
  ]
}