AI Ethics and Bias: The Hard Problems

AI Ethics and Bias: The Hard Problems

In 2016, Microsoft released Tay, an AI chatbot on Twitter. Within hours, internet users taught it to produce racist and sexist tweets. In 2018, Amazon scrapped an AI hiring tool after discovering it discriminated against women. In India, facial recognition systems have been found to have significantly lower accuracy on darker skin tones. These aren't edge cases—they're fundamental challenges in deploying AI systems that affect billions of people.

What is Bias in AI?

Bias is systematic error in AI system behavior. A biased system makes different quality predictions for different groups. For example, a loan approval AI might approve 80% of applications from one community but only 40% from another, even when credit scores are similar.

Sources of Bias:

• Data Bias: Training data doesn't represent real population. Historical data reflects past discrimination.
• Algorithmic Bias: The algorithm itself, even on unbiased data, can introduce unfairness.
• Representation Bias: Underrepresented groups in training data get worse predictions.
• Measurement Bias: How we measure outcomes can be biased. In criminal justice, "crime" is arrests, not actual crimes.

Historical Discrimination in Data

Historical training data encodes past discrimination. If a college's admission AI is trained on decades of historical decisions made by biased humans, the AI learns to discriminate in the same ways.

Case Study: Criminal Justice (ProPublica, 2016) COMPAS is a risk assessment algorithm used by US courts to estimate recidivism (likelihood of reoffending). ProPublica's analysis found: - Black defendants: 45% falsely flagged as high-risk - White defendants: 25% falsely flagged as high-risk The algorithm used proxy variables correlated with race, like zip code and arrest history. Even though race wasn't explicitly in the model, the system discriminated.

This is called redlining through proxies: using variables that correlate with protected attributes to discriminate indirectly.

Measuring Fairness: The Mathematical Perspective

Defining fairness mathematically is surprisingly hard. Different definitions can contradict each other. Let's examine key metrics.

Demographic Parity: Prediction rate is equal across groups. P(Ŷ = 1 | Group A) = P(Ŷ = 1 | Group B) Example: Loan approval rate should be 60% for all demographic groups. Problem: Even if groups have different credit profiles, this forces equal approval rates, which might be unfair (denying creditworthy people).

Equalized Odds: True positive and false positive rates are equal across groups. TPR_A = TPR_B AND FPR_A = FPR_B Example: If the AI catches 80% of fraud cases, it should do this for all groups. Problem: Can be impossible to achieve if groups have different base rates.

Calibration: For predictions of probability p, the model should be right p% of the time, for each group separately. When model says "70% chance of repayment," actual repayment should be 70% for all groups. Problem: Doesn't guarantee equal treatment; groups with lower base rates of positive outcomes still get fewer positive predictions.

Impossibility Result (Corbett-Davies et al., 2017): If base rates differ between groups, we cannot simultaneously achieve demographic parity, equalized odds, and predictive parity for all groups. We must choose which fairness metric matters most.

Real-World Case Study: Facial Recognition Bias

Major facial recognition systems (Microsoft, Google, Amazon) have shown significantly higher error rates on darker skin tones, especially for women. Why?

Root Causes: 1. Training data skew: ImageNet and other datasets are disproportionately light-skinned individuals 2. Annotation bias: When humans label data, they might label diverse faces incorrectly 3. Undersampling: Reduced performance is acceptable for underrepresented groups

The implications are severe: - Wrongful arrests (Robert Williams in Michigan, 2020) - Immigration detention errors - Reduced access to security systems for minorities

Indian Context: Studies have documented similar biases in facial recognition systems used by Indian law enforcement. The NITI Aayog has raised concerns about AI systems trained primarily on lighter skin tones having reduced accuracy on Indian populations.

Fairness in Machine Learning: Practical Approaches

1. Balanced Data Collection: Oversample underrepresented groups. For facial recognition, collect equal images across skin tones, ages, expressions.

2. Fairness Constraints During Training: Add fairness as an objective alongside accuracy: L_total = L_accuracy + λ × L_fairness Example: Penalize large differences in TPR across groups.

import numpy as np
from sklearn.metrics import confusion_matrix

def fairness_loss(y_true, y_pred, groups, fairness_metric='tpr_diff'):
    """
    Calculate fairness loss (difference in TPR across groups)
    """
    losses = []
    group_names = np.unique(groups)

    tprs = []
    for group in group_names:
        mask = groups == group
        tn, fp, fn, tp = confusion_matrix(y_true[mask], y_pred[mask]).ravel()
        tpr = tp / (tp + fn) if (tp + fn) > 0 else 0
        tprs.append(tpr)

    # Loss = variance in TPRs (lower is fairer)
    fairness_loss = np.var(tprs)
    return fairness_loss

# Training with fairness constraint
def train_fair_model(X, y, groups, fairness_weight=0.1):
    """
    Train model balancing accuracy and fairness
    """
    model = LogisticRegression()

    # Standard training
    model.fit(X, y)
    y_pred = model.predict(X)

    # Calculate fairness loss
    f_loss = fairness_loss(y, y_pred, groups)

    # In practice, we'd use methods like adversarial debiasing
    # that explicitly optimize for both accuracy and fairness
    return model, f_loss

3. Post-Processing: Adjust predictions after training to satisfy fairness constraints. Example: lower approval threshold for underrepresented groups to achieve demographic parity.

4. Interpretability & Auditing: Use SHAP values and LIME to understand why models make decisions. Audit models regularly for disparate impact.

The Accountability Problem

Even if we solve technical bias problems, accountability remains. When an AI system discriminates: - Who is responsible? The data scientist? Manager? Company? Government? - How do individuals appeal decisions? - What's the recourse process? In India's context, with limited AI regulation compared to EU's GDPR or emerging AI Act, accountability gaps are significant. A person denied a bank loan by an AI has little recourse.

Transparency & Explainability: Systems should explain decisions in human-understandable terms. Regulators increasingly require this (right to explanation under GDPR Article 22).

Algorithmic Transparency: Can We Explain Deep Learning?

Deep neural networks are often "black boxes"—we can't easily explain why they made a decision. SHAP (SHapley Additive exPlanations) provides one approach:

import shap
import xgboost as xgb

# Train a model
model = xgb.XGBClassifier()
model.fit(X_train, y_train)

# Create SHAP explainer
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# Visualize feature importance
shap.summary_plot(shap_values, X_test, feature_names=feature_names)

# Explain individual prediction
shap.force_plot(explainer.expected_value, shap_values[0], X_test[0])

SHAP values tell us how much each feature contributed to pushing the prediction away from the base value. This provides interpretability even for complex models.

The Broader Ethical Landscape

Privacy: Data collection for training raises privacy concerns. Can we train fair models without exposing sensitive personal information? Answer: Yes, through federated learning and differential privacy.

Consent: Do people consent to their data being used for AI training? Many don't even know it is.

Autonomy: Should AI make high-stakes decisions (hiring, criminal justice, medical) alone? Or only support human decisions?

Environmental Cost: Training GPT-3 cost ~$4.6M in compute. That energy consumption produces significant carbon emissions.

Indian Regulatory Landscape

Unlike Europe's GDPR or proposed AI Act, India has no comprehensive AI regulation yet. However: - RBI issued guidelines on AI/ML for banking - NITI Aayog released Responsible AI toolkit - Delhi High Court cases beginning to address algorithmic accountability There's an opportunity for India to learn from other countries' mistakes and design fair AI governance.

Key Takeaways

• Bias in AI is systematic error that harms specific groups
• Sources: biased historical data, algorithmic issues, measurement problems
• Fairness definitions can contradict (impossibility theorem)
• Demographic parity, equalized odds, and calibration are different fairness metrics
• Facial recognition shows how training data skew causes real harm
• Technical fixes: balanced data, fairness-aware training, post-processing
• Accountability requires transparency, explainability, and recourse mechanisms
• SHAP values provide interpretability for complex models
• India needs comprehensive AI governance for responsible deployment
• Building ethical AI is a continuous process, not a one-time solution

Engineering Perspective: AI Ethics and Bias: The Hard Problems

When you sit for a technical interview at any top company — whether it is Google, Microsoft, Amazon, or an Indian unicorn like Zerodha, Razorpay, or Meesho — they are not just testing whether you know the definition of ai ethics and bias: the hard problems. They are testing whether you can APPLY these concepts to solve novel problems, whether you understand the TRADEOFFS involved, and whether you can reason about system behaviour at scale.

This chapter approaches ai ethics and bias: the hard problems with that depth. We will examine not just what it is, but why it works the way it does, what alternatives exist and when to choose each one, and how real systems use these ideas in production. ISRO's mission control systems, India's UPI payment network handling 10 billion transactions per month, Aadhaar's biometric authentication serving 1.4 billion identities — all rely on the principles we discuss here.

Transformer Architecture: The Engine Behind GPT and Modern AI

The Transformer architecture, introduced in the landmark 2017 paper "Attention Is All You Need," revolutionised NLP and eventually all of deep learning. Here is the core mechanism:

# Self-Attention Mechanism (simplified)
import numpy as np

def self_attention(Q, K, V, d_k):
    """
    Q (Query): What am I looking for?
    K (Key):   What do I contain?
    V (Value): What do I actually provide?
    d_k:       Dimension of keys (for scaling)
    """
    # Step 1: Compute attention scores
    scores = np.matmul(Q, K.T) / np.sqrt(d_k)

    # Step 2: Softmax to get probabilities
    attention_weights = softmax(scores)

    # Step 3: Weighted sum of values
    output = np.matmul(attention_weights, V)
    return output

# Multi-Head Attention: Run multiple attention heads in parallel
# Each head learns different relationships:
# Head 1: syntactic relationships (subject-verb agreement)
# Head 2: semantic relationships (word meanings)
# Head 3: positional relationships (word order)
# Head 4: coreference (pronoun → noun it refers to)

The key insight of self-attention is that every token can attend to every other token simultaneously (unlike RNNs which process sequentially). This parallelism enables efficient GPU training. The computational complexity is O(n²·d) where n is sequence length and d is dimension, which is why context windows are a major engineering challenge.

State-of-the-art developments include: sparse attention (reducing O(n²) to O(n·√n)), mixture of experts (MoE — activating only a subset of parameters per input), retrieval-augmented generation (RAG — grounding responses in external documents), and constitutional AI (alignment through principles rather than RLHF alone). Indian researchers at institutions like IIT Bombay, IISc Bangalore, and Microsoft Research India are actively contributing to these frontiers.

India's Scale Challenges: Engineering for 1.4 Billion

Building technology for India presents unique engineering challenges that make it one of the most interesting markets in the world. UPI handles 10 billion transactions per month — more than all credit card transactions in the US combined. Aadhaar authenticates 100 million identities daily. Jio's network serves 400 million subscribers across 22 telecom circles. Hotstar streamed IPL to 50 million concurrent viewers — a world record. Each of these systems must handle India's diversity: 22 official languages, 28 states with different regulations, massive urban-rural connectivity gaps, and price-sensitive users expecting everything to work on ₹7,000 smartphones over patchy 4G connections. This is why Indian engineers are globally respected — if you can build systems that work in India, they will work anywhere.

Advanced Algorithms: Dynamic Programming and Graph Theory

Dynamic Programming (DP) solves complex problems by breaking them into overlapping subproblems. This is a favourite in competitive programming and interviews:

# Longest Common Subsequence — classic DP problem
# Used in: diff tools, DNA sequence alignment, version control

def lcs(s1, s2):
    m, n = len(s1), len(s2)
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i-1] == s2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])

    return dp[m][n]

# Dijkstra's Shortest Path — used by Google Maps!
import heapq

def dijkstra(graph, start):
    dist = {node: float('inf') for node in graph}
    dist[start] = 0
    pq = [(0, start)]  # (distance, node)

    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:
            continue
        for v, weight in graph[u]:
            if dist[u] + weight < dist[v]:
                dist[v] = dist[u] + weight
                heapq.heappush(pq, (dist[v], v))

    return dist

# Real use: Google Maps finding shortest route from
# Connaught Place to India Gate, considering traffic weights

Dijkstra's algorithm is how mapping applications find optimal routes. When you ask Google Maps to navigate from Mumbai to Pune, it models the road network as a weighted graph (intersections are nodes, roads are edges, travel time is weight) and runs a variant of Dijkstra's algorithm. Indian highways, city roads, and even railway networks can all be modelled this way. IRCTC's route optimisation for trains across 13,000+ stations uses graph algorithms at its core.

Research Frontiers and Open Problems in AI Ethics and Bias: The Hard Problems

Beyond production engineering, ai ethics and bias: the hard problems connects to active research frontiers where fundamental questions remain open. These are problems where your generation of computer scientists will make breakthroughs.

Quantum computing threatens to upend many of our assumptions. Shor's algorithm can factor large numbers efficiently on a quantum computer, which would break RSA encryption — the foundation of internet security. Post-quantum cryptography is an active research area, with NIST standardising new algorithms (CRYSTALS-Kyber, CRYSTALS-Dilithium) that resist quantum attacks. Indian researchers at IISER, IISc, and TIFR are contributing to both quantum computing hardware and post-quantum cryptographic algorithms.

AI safety and alignment is another frontier with direct connections to ai ethics and bias: the hard problems. As AI systems become more capable, ensuring they behave as intended becomes critical. This involves formal verification (mathematically proving system properties), interpretability (understanding WHY a model makes certain decisions), and robustness (ensuring models do not fail catastrophically on edge cases). The Alignment Research Center and organisations like Anthropic are working on these problems, and Indian researchers are increasingly contributing.

Edge computing and the Internet of Things present new challenges: billions of devices with limited compute and connectivity. India's smart city initiatives and agricultural IoT deployments (soil sensors, weather stations, drone imaging) require algorithms that work with intermittent connectivity, limited battery, and constrained memory. This is fundamentally different from cloud computing and requires rethinking many assumptions.

Finally, the ethical dimensions: facial recognition in public spaces (deployed in several Indian cities), algorithmic bias in loan approvals and hiring, deepfakes in political campaigns, and data sovereignty questions about where Indian citizens' data should be stored. These are not just technical problems — they require CS expertise combined with ethics, law, and social science. The best engineers of the future will be those who understand both the technical implementation AND the societal implications. Your study of ai ethics and bias: the hard problems is one step on that path.

Key Vocabulary

Here are important terms from this chapter that you should know:

🏗️ Architecture Challenge

Design the backend for India's election results system. Requirements: 10 lakh (1 million) polling booths reporting simultaneously, results must be accurate (no double-counting), real-time aggregation at constituency and state levels, public dashboard handling 100 million concurrent users, and complete audit trail. Consider: How do you ensure exactly-once delivery of results? (idempotency keys) How do you aggregate in real-time? (stream processing with Apache Flink) How do you serve 100M users? (CDN + read replicas + edge computing) How do you prevent tampering? (digital signatures + blockchain audit log) This is the kind of system design problem that separates senior engineers from staff engineers.

The Frontier

You now have a deep understanding of ai ethics and bias: the hard problems — deep enough to apply it in production systems, discuss tradeoffs in system design interviews, and build upon it for research or entrepreneurship. But technology never stands still. The concepts in this chapter will evolve: quantum computing may change our assumptions about complexity, new architectures may replace current paradigms, and AI may automate parts of what engineers do today.

What will NOT change is the ability to think clearly about complex systems, to reason about tradeoffs, to learn quickly and adapt. These meta-skills are what truly matter. India's position in global technology is only growing stronger — from the India Stack to ISRO to the startup ecosystem to open-source contributions. You are part of this story. What you build next is up to you.

Crafted for Class 10–12 • AI Applications & Ethics • Aligned with NEP 2020 & CBSE Curriculum