Adaptive Algorithms | Ed Tech Docs

Adaptive Learning Algorithms: The Engine of Personalised Education

Adaptive learning systems adjust to each learner in real-time, but how? These are the algorithms and approaches that power personalised education—from simple rule-based systems to sophisticated machine learning models.

What Makes Learning "Adaptive"

Definition

Adaptive Learning: Educational systems that modify content, pace, or presentation based on individual learner performance and behavior.

Key Characteristics:

Real-time adjustment
Data-driven decisions
Individualized experiences
Continuous optimization
Feedback loops

Levels of Adaptation

Level 1: Static Branching

code

If score < 70% → Review content
If score ≥ 70% → Advance to next topic

Level 2: Rule-Based Adaptation

code

If struggle with concept A → Provide additional examples
If fast completion → Increase difficulty
If multiple errors → Offer hints

Level 3: Statistical Models

code

Predict performance based on historical patterns
Recommend optimal learning path
Estimate time to mastery

Level 4: Machine Learning

code

Learn from millions of learner interactions
Discover hidden patterns
Adapt strategies dynamically
Improve over time

Core Adaptive Algorithms

1. Knowledge Tracing

Purpose: Track what a learner knows over time

Bayesian Knowledge Tracing (BKT):

Model Parameters:

code

P(L₀) = Prior probability of knowing skill
P(T) = Probability of learning (transition)
P(S) = Probability of slip (know but get wrong)
P(G) = Probability of guess (don't know but get right)

How It Works:

code

1. Start with prior knowledge estimate
2. Student answers question
3. Update probability based on:
   - Correctness
   - Question difficulty
   - Slip/guess probabilities
4. Decide next action:
   - Mastered (P > 0.95) → Move on
   - Not mastered → More practice

Example:

code

Topic: Variables in Python
Initial P(knows) = 0.3

Question 1 (easy): Correct
Updated P(knows) = 0.6

Question 2 (medium): Correct
Updated P(knows) = 0.85

Question 3 (hard): Incorrect
Updated P(knows) = 0.78 (might be slip)

Question 4 (medium): Correct
Updated P(knows) = 0.92

Continue practicing...

Deep Knowledge Tracing (DKT):

Modern Approach: Uses recurrent neural networks (RNNs/LSTMs)

Advantages Over BKT:

Captures long-term dependencies
Handles complex skill relationships
Learns from large datasets
More accurate predictions

Input Sequence:

code

[skill₁, correct], [skill₂, incorrect], [skill₁, correct]...

Output:

code

Predicted performance on next question for each skill

2. Item Response Theory (IRT)

Purpose: Model relationship between learner ability and question difficulty

Basic IRT Model:

code

P(correct) = 1 / (1 + e^(-a(θ - b)))

Where:
θ (theta) = Learner ability
b = Item difficulty
a = Item discrimination (how well it separates abilities)

Interpretation:

code

If θ > b: High probability of correct answer
If θ = b: 50% probability
If θ < b: Low probability

Adaptive Testing with IRT:

code

1. Start with medium difficulty (b = 0)
2. If correct → Present harder question (increase b)
3. If incorrect → Present easier question (decrease b)
4. Continue until ability estimate stabilizes
5. Result: Accurate assessment in fewer questions

Example Application:

code

GRE adaptive test:
- First question: Medium difficulty
- Answer correctly → Harder questions
- Answer incorrectly → Easier questions
- Final score based on question difficulty + correctness

3. Collaborative Filtering

Purpose: Recommend content based on similar learners

User-Based Collaborative Filtering:

code

1. Find learners similar to you
2. See what they learned/liked
3. Recommend their successful paths

Algorithm:

code

Similarity = cosine_similarity(user_vector, other_user_vectors)

Recommendation score = weighted_average(similar_users' ratings)

Example:

code

You: [Python: 90%, JavaScript: 85%, ML: ?, Data: ?]
Similar User A: [Python: 88%, JavaScript: 87%, ML: 92%, Data: 78%]
Similar User B: [Python: 91%, JavaScript: 84%, ML: 88%, Data: 95%]

Recommendation:
- ML highly recommended (both similar users scored high)
- Data recommended (User B scored very high)

Item-Based Collaborative Filtering:

code

1. Find content similar to what you've completed
2. Recommend related content

Example:

code

You completed: "Intro to Python"
Students who took that also took:
- "Python Data Structures" (85% correlation)
- "Python for Data Analysis" (78% correlation)
- "Web Scraping with Python" (72% correlation)

4. Spaced Repetition Algorithms

Purpose: Optimize review timing for long-term retention

SuperMemo Algorithm (SM-2):

code

After each review:

EF = EF + (0.1 - (5 - quality) × (0.08 + (5 - quality) × 0.02))

If quality < 3: interval = 1 day
If repetition = 1: interval = 1 day
If repetition = 2: interval = 6 days
If repetition > 2: interval = previous_interval × EF

Where:
EF = Easiness Factor (starts at 2.5)
quality = Self-rating (0-5)

Example Schedule:

code

Learn "Binary Search":
Review 1: Tomorrow (quality: 4, EF: 2.5)
Review 2: 6 days (quality: 5, EF: 2.6)
Review 3: 16 days (quality: 4, EF: 2.6)
Review 4: 42 days (quality: 5, EF: 2.7)
Review 5: 113 days

Modern Variation (Anki):

code

interval = previous_interval × ease_factor × interval_modifier

Adjusts based on:
- Performance history
- Card difficulty
- Personal retention goals

5. Reinforcement Learning

Purpose: Learn optimal teaching strategies through trial and error

Q-Learning for Tutoring:

code

State: Learner's knowledge state
Action: What to teach next (content, difficulty, format)
Reward: Learning gain

Q(state, action) = expected future reward

Example Application:

code

State: Student struggling with loops
Possible actions:
A1: Provide video explanation
A2: Give worked example
A3: Offer interactive exercise
A4: Suggest simpler concept first

System learns over time:
If struggling → Worked example (A2) has highest Q-value
If confident → Interactive exercise (A3) best

Multi-Armed Bandit:

code

Balance exploration vs exploitation:
- Try different teaching strategies (explore)
- Use what works best (exploit)
- Optimize for each learner type

6. Content Recommendation Engines

Purpose: Suggest next best learning material

Hybrid Approach:

code

Score = w₁(content_similarity) + 
        w₂(collaborative_filtering) +
        w₃(knowledge_gap) +
        w₄(goal_alignment) +
        w₅(difficulty_match)

Components:

Content-Based:

code

You studied: "React Hooks"
Similar content:
- Same topic: "Advanced Hooks Patterns"
- Related: "React Context API"
- Prerequisite check: "JavaScript Closures"

Knowledge Graph:

code

Nodes: Concepts/skills
Edges: Prerequisites, relationships

Navigate graph based on:
- What you know (completed nodes)
- Your goals (target nodes)
- Optimal path (shortest, considering difficulty)

Example:

code

Goal: Learn Machine Learning
Current: Know Python, Basic Math

Graph suggests path:
Python → NumPy → Pandas → Statistics → 
Linear Algebra → ML Algorithms → Deep Learning

7. Difficulty Adaptation

Purpose: Adjust challenge level in real-time

Zone of Proximal Development (ZPD) Targeting:

code

Current ability: θ
Target difficulty: θ + ε (slightly above current level)

If struggling (multiple errors): Reduce difficulty
If breezing through: Increase difficulty

Dynamic Difficulty Adjustment (DDA):

code

difficulty_adjustment = f(
    recent_performance,
    error_rate,
    time_per_question,
    hint_requests,
    frustration_signals
)

Example:

code

Coding challenge progression:

Challenge 1: "Print 'Hello World'" (difficulty: 1)
→ Complete in 30 seconds

Challenge 2: "Print numbers 1-10" (difficulty: 2)
→ Complete in 1 minute

Challenge 3: "Sum of array" (difficulty: 5) ← Jump
→ Struggle, request hint

Challenge 4: "Find max in array" (difficulty: 3) ← Reduced
→ Complete successfully

Challenge 5: "Sort array" (difficulty: 4) ← Gradual increase

Real-World Implementations

Khan Academy

Approach: Mastery-based learning with knowledge maps

Algorithm:

code

1. Build knowledge graph (prerequisite structure)
2. Track mastery per concept (0-100%)
3. Recommend:
   - Review if mastery < 80%
   - Next concept if current mastered
   - Fill gaps before advancing
4. Use spaced repetition for retention

Mastery Calculation:

code

Recent performance weighted heavily
Decay over time if not practiced
Multiple correct in a row → Mastery

Duolingo

Approach: Spaced repetition + difficulty adaptation

Algorithm:

code

1. Half-Life Regression (HLR):
   Predict probability you remember a word

2. Schedule review when P(remember) ≈ 0.75

3. Adjust based on:
   - Previous performance
   - Time since last review
   - Word difficulty
   - Interference from similar words

Adaptive Lessons:

code

If error rate > 30%: Introduce easier content
If error rate < 10%: Skip redundant exercises
Dynamic exercise generation based on weak areas

Carnegie Learning

Approach: Cognitive Tutors with Knowledge Tracing

Algorithm:

code

1. Cognitive model of problem-solving
2. Track student steps (not just answers)
3. Provide contextual hints
4. Adapt difficulty based on detailed understanding

Step-Level Adaptation:

code

Problem: Solve 2x + 3 = 7

Student steps:
Step 1: Subtract 3 → ✓
Step 2: Divide by 2 → ✓

Next problem: More complex equation
(System knows specific operations mastered)

Coursera Degree Programs

Approach: Learning path recommendation

Algorithm:

code

1. Career goal analysis
2. Skill gap identification
3. Course prerequisite mapping
4. Optimal sequence generation
5. Pace suggestion based on available time

Personalisation:

code

Input:
- Goal: "Become Data Scientist"
- Current: "Python programmer"
- Time: "10 hours/week"

Output:
Week 1-4: Statistics fundamentals
Week 5-8: Pandas and data wrangling
Week 9-12: Machine learning basics
Week 13-16: Specialised ML topics
Week 17-20: Capstone project

Building Adaptive Systems

Architecture Components

1. Student Model:

code

{
  learner_id: "user123",
  knowledge_state: {
    "python_variables": 0.92,
    "python_loops": 0.78,
    "python_functions": 0.65
  },
  learning_rate: 0.8,
  preferred_format: "video",
  available_time: "30min/day",
  goals: ["web_development"]
}

2. Domain Model:

code

{
  skills: [
    {
      id: "python_functions",
      prerequisites: ["python_variables", "python_syntax"],
      difficulty: 5,
      importance: 9,
      avg_time: "2 hours"
    }
  ],
  dependencies: directed_acyclic_graph
}

3. Pedagogical Model:

code

rules: [
  {
    condition: "mastery < 0.7 AND attempts > 3",
    action: "provide_worked_example"
  },
  {
    condition: "mastery > 0.9 AND time_since_review > 7_days",
    action: "schedule_review"
  }
]

4. Adaptation Engine:

python

def select_next_activity(student, domain):
    # Get current knowledge state
    mastery_levels = student.knowledge_state
    
    # Find learnable skills (prerequisites met)
    available_skills = find_learnable_skills(mastery_levels, domain)
    
    # Score each potential activity
    scores = []
    for skill in available_skills:
        score = calculate_value(
            knowledge_gap=1 - mastery_levels.get(skill, 0),
            goal_relevance=get_relevance(skill, student.goals),
            difficulty_match=match_zpd(skill, student.ability),
            time_fit=skill.time_needed <= student.available_time
        )
        scores.append((skill, score))
    
    # Select highest value activity
    return max(scores, key=lambda x: x[1])[0]

Data Collection

Essential Data:

code

Interaction logs:
- Timestamp
- Activity attempted
- Response/answer
- Time taken
- Hints requested
- Final correctness

Performance metrics:
- Pre/post assessments
- Skill mastery estimates
- Learning velocity
- Retention measurements

Privacy Considerations:

code

Collect:
✓ Performance data
✓ Interaction patterns
✓ Anonymised usage

Don't collect unnecessarily:
✗ Personal identifiers (beyond necessary)
✗ Off-platform behavior
✗ Sensitive demographics (unless essential)

Evaluation Metrics

Algorithm Performance:

code

Prediction accuracy: How well does it predict performance?
Adaptation effectiveness: Does personalisation help?
Efficiency: Time to mastery vs baseline
Engagement: Completion rates, return visits

A/B Testing:

code

Control: Traditional linear content
Treatment: Adaptive algorithm

Metrics:
- Learning gains (pre/post test)
- Time to competency
- Engagement (time on platform)
- Satisfaction ratings

Challenges and Limitations

Cold Start Problem

Issue: New users have no history

Solutions:

code

1. Initial assessment/placement test
2. Self-reported goals and background
3. Default to average until data collected
4. Borrow from similar users (collaborative filtering)

Algorithmic Bias

Risks:

Reinforcing existing gaps
Limiting exposure to challenging material
Stereotyping based on demographics
Overfitting to training data

Mitigation:

code

- Regular bias audits
- Diverse training data
- Transparency in recommendations
- Override options for learners
- Human oversight

Over-Adaptation

Problem: System becomes too responsive

Example:

code

Student struggles → Difficulty reduced
Student succeeds → Confidence up
Never challenged → Limited growth

Balance:

code

- Maintain productive struggle
- Periodic stretch challenges
- Gradual difficulty increase
- Don't remove all frustration

Data Requirements

Reality:

Effective algorithms need data
Takes time to personalise accurately
Cold start is inevitable
Privacy-utility tradeoff

Pragmatic Approach:

Start with simple rules
Add sophistication as data grows
Hybrid human-algorithm decisions
Progressive enhancement

Future Directions

Advanced AI Techniques

Natural Language Processing:

code

- Understand free-text responses
- Provide conversational feedback
- Detect confusion from questions
- Generate personalised explanations

Computer Vision:

code

- Analyse facial expressions (engagement, confusion)
- Detect attention patterns
- Optimise content presentation
- Accessibility adaptations

Multi-Modal Learning:

code

Combine:
- Performance data
- Engagement signals
- Biometric data (ethical considerations!)
- Context information (time, location)

Explainable AI

Current Problem: Black box recommendations

Future:

code

"Why this content?"
→ "Based on your goal of X, and having mastered Y, 
   this fills the gap in Z and prepares you for your 
   target role."

"Why this difficulty?"
→ "You're scoring 85% on medium problems. This slightly 
   harder challenge matches your current ability."

Continuous Learning

Beyond Courses:

code

Adaptive systems that:
- Work across platforms
- Track lifelong learning
- Integrate formal + informal learning
- Connect learning to performance

Best Practices

For Developers:

Start simple (rule-based) before ML
Collect quality data from day one
A/B test everything
Provide override options
Make recommendations transparent
Monitor for bias
Fail gracefully (default to quality content)

For Educators:

Understand algorithm limitations
Combine human + algorithm intelligence
Review recommendations critically
Provide feedback to improve systems
Ensure equity in access and outcomes

For Learners:

Give systems time to adapt (provide data)
Be honest in self-assessments
Explore beyond recommendations
Provide feedback on effectiveness
Maintain agency over learning path

Next Steps

Explore more about personalised learning:

Adaptive learning algorithms are powerful tools for personalisation, but they're most effective when combined with quality content, pedagogical expertise, and learner agency. The goal is augmented intelligence—technology enhancing human teaching, not replacing it.