Hey there, education enthusiasts and data adventurers! 👋 Welcome to my project on making learning smarter, more adaptive, and personalized using Deep Knowledge Tracing (DKT). In this journey, I’m using the EdNet KT3 (2023) dataset to predict a learner's mastery over time and dynamically adjust their learning pathway based on their progress. Through this approach, the model aims to provide personalized learning experiences by dynamically adjusting the difficulty of future lessons and recommending review sessions when necessary. The DKT model continuously adapts to the learner's progress, making it a valuable tool for improving learning efficiency and retention in online education platforms.

The EdNet-KT3 dataset isn’t just about solving questions; it also logs various learning activities:

• Reading Explanations: After answering a question, students can view detailed explanations. These are tagged based on their source, such as after_sprint, after_review, or my_note for re-reads.
• Watching Lectures: The dataset tracks when students start or stop watching lecture videos, which can come from sources like archive, adaptive_offer, or todays_recommendation.
• Actions Tracked: Includes actions like enter, quit, respond, and submit for different activities, making it possible to analyze learning behaviors in depth.

With over 297,915 files, this dataset provides detailed insights into students' learning activities:

• Compressed Size: 0.8GB (762.8MB)
• Uncompressed Size: 4.3GB
• Learning Activities: From answering questions to watching lectures, it logs everything.

Here’s a quick look at the kind of data we’re working with:

The project is organized into various folders and scripts to keep things clean and modular:

• data_preprocessing.py: Functions to clean the dataset, convert timestamps, and calculate time spent on explanations/lectures.
• dkt_model.py: Code to build and train the LSTM-based DKT model.
• ab_testing.py: Methods for conducting A/B testing to compare different learning strategies.
• dynamic_adjustments.py: Functions to dynamically adjust learning paths based on the model's predictions.

Contains sample data for testing and development. The full dataset is not included for privacy reasons, but you can download it here.

Scripts to execute various parts of the project:

• run_data_preprocessing.py: Preprocesses the KT3 data.
• run_dkt_model.py: Trains the DKT model.
• run_ab_testing.py: Performs A/B testing.
• run_dynamic_adjustments.py: Applies the model's predictions to adjust learning paths dynamically.

1. Set Up the Environment: Create a Conda environment using environment.yml.

       conda env create -f environment.yml
       conda activate kt3-dkt
   

2. Download the Data: Get the EdNet KT3 dataset from here and place the unzipped files in the data/ folder.

3. Run Data Preprocessing: Clean and prepare the data.

   python scripts/run_data_preprocessing.py
   

4. Train the Model: Run the script to train the DKT model.

   python scripts/run_dkt_model.py

5. Evaluate with A/B Testing: Compare different recommendation strategies.

   python scripts/run_ab_testing.py
   

6. Apply Dynamic Adjustments: Use predictions to adjust the learning paths.

   python scripts/run_dynamic_adjustments.py
   

I compared two groups:

• Group A: Static learning recommendations.
• Group B: Dynamic recommendations based on DKT predictions.

Tracking students' mastery over time helps understand their learning journey better:

• Accuracy Plot: Tracks model accuracy during training.

• Mastery Prediction Plot: Shows how predicted mastery changes based on interactions.

  import matplotlib.pyplot as plt
  
  # Plot mastery progress for a student
  plt.plot(predicted_mastery)
  plt.title('Student Mastery Progress Over Time 🎢')
  plt.xlabel('Interaction Number')
  plt.ylabel('P(Mastery)')
  plt.show()

A working knowledge tracing system that dynamically suggests review materials or new challenges for students based on their predicted mastery state. Include a report showing how this system adapts based on user interactions and performance.

There’s still plenty of room to grow:

• Tuning Hyperparameters: Experiment with different model configurations.
• Feature Engineering: Incorporate more behavioral data, like frequency of explanation views.
• Real-time Adaptations: Integrate the model into an actual platform to provide real-time feedback.

Using the EdNet KT3 Dataset (2023) provides a more recent and rich data source for experimenting with Deep Knowledge Tracing and adaptive learning techniques. This project gives a hands-on experience in implementing DKT models and building a dynamic, personalized learning system that can suggest reviews or new challenges based on user readiness.