Practice Questions — AI Ethics, Responsible AI, and Career Roadmap

bias_types = ["Historical", "Representation", "Measurement", "Labeling"]
for i, bias in enumerate(bias_types, 1):
    print(f"{i}. {bias} bias")

roles = {
    "Data Analyst": "4-8 LPA",
    "Data Scientist": "8-20 LPA",
    "ML Engineer": "12-30 LPA",
    "AI Researcher": "20-50+ LPA"
}
for role, salary in roles.items():
    print(f"{role:20s}: {salary}")

principles = ["Transparency", "Accountability", "Privacy", "Safety", "Fairness"]
print(f"Responsible AI has {len(principles)} key principles:")
for p in principles:
    print(f"  - {p}")

def disparate_impact_ratio(group_a_rate, group_b_rate):
    ratio = min(group_a_rate, group_b_rate) / max(group_a_rate, group_b_rate)
    return round(ratio, 3)

male_rate = 0.75
female_rate = 0.55

ratio = disparate_impact_ratio(male_rate, female_rate)
print(f"Male approval rate: {male_rate}")
print(f"Female approval rate: {female_rate}")
print(f"Disparate impact ratio: {ratio}")
print(f"Passes 80% rule: {ratio >= 0.8}")

eu_ai_risk_levels = [
    ("Unacceptable", "Banned", "Social scoring"),
    ("High", "Regulated", "Credit scoring, hiring"),
    ("Limited", "Disclosure", "Chatbots, deepfakes"),
    ("Minimal", "No regulation", "Games, spam filters")
]

print("EU AI Act Risk Classification:")
for level, requirement, examples in eu_ai_risk_levels:
    print(f"  {level:15s} | {requirement:15s} | {examples}")

interview_rounds = {
    "ML Theory": ["Bias-variance", "Regularization", "Gradient descent"],
    "Coding": ["Python", "Data structures", "ML from scratch"],
    "System Design": ["Recommendation", "Fraud detection", "Search ranking"],
    "Behavioral": ["Past projects", "Teamwork", "Ethics"]
}

for round_name, topics in interview_rounds.items():
    print(f"{round_name}: {', '.join(topics)}")
print(f"\nTotal rounds: {len(interview_rounds)}")

import numpy as np

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def logistic_loss(y_true, y_pred):
    epsilon = 1e-8
    return -np.mean(
        y_true * np.log(y_pred + epsilon) +
        (1 - y_true) * np.log(1 - y_pred + epsilon)
    )

# Interview question: compute loss for perfect and imperfect predictions
y_true = np.array([1, 0, 1, 0])

# Perfect predictions
y_perfect = np.array([0.99, 0.01, 0.99, 0.01])
loss_perfect = logistic_loss(y_true, y_perfect)

# Imperfect predictions
y_imperfect = np.array([0.6, 0.4, 0.7, 0.3])
loss_imperfect = logistic_loss(y_true, y_imperfect)

# Worst predictions (opposite)
y_worst = np.array([0.01, 0.99, 0.01, 0.99])
loss_worst = logistic_loss(y_true, y_worst)

print(f"Perfect:   loss = {loss_perfect:.4f}")
print(f"Imperfect: loss = {loss_imperfect:.4f}")
print(f"Worst:     loss = {loss_worst:.4f}")
print(f"\nPerfect < Imperfect < Worst: {loss_perfect < loss_imperfect < loss_worst}")

fairness_metrics = ["Demographic Parity", "Equal Opportunity", "Equalized Odds", "Individual Fairness"]
for metric in fairness_metrics:
    print(f"  - {metric}")
print(f"Total: {len(fairness_metrics)} (cannot all be satisfied simultaneously)")

def salary_range(role, experience_years):
    base = {"Data Analyst": 6, "Data Scientist": 12, "ML Engineer": 18, "AI Researcher": 30}
    b = base[role]
    low = b + experience_years * 1.5
    high = b + experience_years * 3
    return f"{low:.0f}-{high:.0f} LPA"

for role in ["Data Analyst", "Data Scientist", "ML Engineer"]:
    print(f"{role:20s}: {salary_range(role, 3)}")

ml_interview = {
    "ML Theory": 30,
    "Coding": 25,
    "System Design": 25,
    "Behavioral": 20
}
print("Interview Weight Distribution:")
for round_name, weight in ml_interview.items():
    bar = "#" * (weight // 5)
    print(f"  {round_name:15s}: {weight}% {bar}")
print(f"Total: {sum(ml_interview.values())}%")

top_companies = ["Google", "Microsoft", "Amazon", "Flipkart", "PhonePe"]
print(f"Top AI hiring companies in India ({len(top_companies)}):")
for c in top_companies:
    print(f"  - {c}")

portfolio_items = [
    "Kaggle competitions",
    "GitHub projects",
    "Blog posts",
    "Open source contributions"
]
for item in portfolio_items:
    print(f"  Portfolio: {item}")
print(f"Total: {len(portfolio_items)} types")

skills_by_role = {
    "Data Analyst": ["SQL", "Excel", "Tableau"],
    "ML Engineer": ["Python", "Docker", "MLOps"]
}
for role, skills in skills_by_role.items():
    print(f"{role}: {' + '.join(skills)}")

def check_fairness(group_a_tpr, group_b_tpr, threshold=0.1):
    diff = abs(group_a_tpr - group_b_tpr)
    return {
        "difference": round(diff, 3),
        "fair": diff < threshold,
        "metric": "Equal Opportunity"
    }

result = check_fairness(0.85, 0.72)
print(f"Metric: {result['metric']}")
print(f"TPR difference: {result['difference']}")
print(f"Fair: {result['fair']}")

def salary_comparison(india_lpa, us_usd_k):
    # Approximate conversion: 1 LPA = ~$1,200 USD
    india_usd = india_lpa * 1200
    us_usd = us_usd_k * 1000
    ppp_factor = 4.5  # PPP adjustment for India
    india_adjusted = india_usd * ppp_factor
    return {
        "india_nominal": india_usd,
        "us_nominal": us_usd,
        "india_ppp": india_adjusted,
        "ppp_ratio": round(india_adjusted / us_usd, 2)
    }

# ML Engineer salary comparison
result = salary_comparison(20, 150)  # 20 LPA India, $150K US
print(f"India (nominal): ${result['india_nominal']:,}")
print(f"US (nominal): ${result['us_nominal']:,}")
print(f"India (PPP-adjusted): ${result['india_ppp']:,}")
print(f"PPP ratio: {result['ppp_ratio']}")

def bias_variance_tradeoff(model_complexity):
    """ML interview classic: explain bias-variance."""
    if model_complexity < 3:
        return {"bias": "High", "variance": "Low", "error": "Underfitting"}
    elif model_complexity > 7:
        return {"bias": "Low", "variance": "High", "error": "Overfitting"}
    else:
        return {"bias": "Medium", "variance": "Medium", "error": "Good fit"}

for complexity in [1, 5, 9]:
    result = bias_variance_tradeoff(complexity)
    print(f"Complexity={complexity}: {result['error']:12s} | "
          f"Bias={result['bias']:6s} | Variance={result['variance']}")

explain_tools = {"LIME": "Local linear approximation", "SHAP": "Shapley value attribution"}
for tool, method in explain_tools.items():
    print(f"{tool}: {method}")

def career_skills_overlap(role1_skills, role2_skills):
    common = set(role1_skills) & set(role2_skills)
    return sorted(common)

ds_skills = ["Python", "Statistics", "ML", "SQL", "Communication"]
mle_skills = ["Python", "Docker", "MLOps", "ML", "Cloud", "APIs"]

overlap = career_skills_overlap(ds_skills, mle_skills)
print(f"Data Scientist skills: {len(ds_skills)}")
print(f"ML Engineer skills: {len(mle_skills)}")
print(f"Overlap: {overlap}")
print(f"Overlap count: {len(overlap)}")