Hugging Face's logo

Spaces:
anadoluuni
/
AIDidact
Sleeping

App Files Community
AIDidact
File size: 4,194 Bytes
054e65a
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
# Core Algorithms

## 1. Learner Profile Vector

```text
FUNCTION build_learner_profile_vector(registration, diagnostic, history):
  prior_learning_embedding = embed(registration.prior_learning)
  goal_embedding = embed(registration.goals)
  education_features = encode_categorical(registration.educational_level)
  readiness_features = normalize(diagnostic.scores)
  preference_features = encode_optional(registration.preferences)
  behavior_features = aggregate(history)

  profile_vector = concatenate(
    prior_learning_embedding,
    goal_embedding,
    education_features,
    readiness_features,
    preference_features,
    behavior_features
  )

  mastery_map = initialize_mastery(diagnostic)
  RETURN { profile_vector, mastery_map }
```

## 2. Module Vectorization

```text
FUNCTION build_module_vector(module):
  objective_embedding = embed(module.objectives)
  topic_embedding = embed(module.topics)
  bloom_features = encode_bloom_levels(module.objectives)
  workload_features = normalize(module.estimated_minutes, module.ects)
  activity_features = encode_multilabel(module.activity_types)
  prerequisite_features = encode_graph_position(module.prerequisites)

  RETURN concatenate(
    objective_embedding,
    topic_embedding,
    bloom_features,
    workload_features,
    activity_features,
    prerequisite_features
  )
```

## 3. Hybrid Recommendation

```text
FUNCTION recommend_modules(learner, candidates):
  FOR module IN candidates:
    content_score = cosine_similarity(learner.profile_vector, module.vector)
    collaborative_score = collaborative_model.predict(learner.id, module.id)
    readiness_score = readiness_alignment(learner.mastery_map, module.required_competencies)
    pacing_score = pace_alignment(learner, module)
    diversity_penalty = novelty_penalty(learner.recent_topics, module.topic_cluster)

    final_score =
      0.35 * content_score +
      0.30 * collaborative_score +
      0.20 * readiness_score +
      0.15 * pacing_score -
      diversity_penalty

    IF not prerequisites_satisfied(learner, module):
      final_score = -INF

  RETURN top_k_by_score(candidates)
```

## 4. Dynamic Assessment Generation

```text
FUNCTION generate_unique_assessment(blueprint, learner):
  selected_items = []

  FOR objective IN blueprint.objectives:
    pool = filter_question_pool(
      objective=objective,
      difficulty=target_difficulty(learner, objective)
    )

    item = choose_unique_variant(pool, learner.previous_items)

    IF item.parameterized:
      item = inject_unique_parameters(item, learner.id, now())

    IF item.ai_generatable:
      item = ai_generate_variant(item.template, blueprint.rubric)

    selected_items.append(item)

  RETURN shuffle(selected_items)
```

## 5. Open-Ended AI Evaluation

```text
FUNCTION evaluate_open_response(response, rubric):
  deterministic_checks = run_basic_checks(response, rubric)
  ai_result = ai_score_with_rubric(response.text, rubric)
  final_score = weighted_merge(deterministic_checks, ai_result.score)

  save_audit_trace(response.id, rubric, ai_result.rationale, ai_result.confidence)

  IF ai_result.confidence < 0.60:
    queue_human_review(response.id)

  RETURN final_score
```

## 6. Integrity Detection

```text
FUNCTION integrity_check(attempt):
  plagiarism = compare_to_corpus(attempt.responses)
  peer_similarity = compare_to_peer_attempts(attempt)
  timing_anomaly = detect_impossible_timing(attempt.event_stream)
  session_anomaly = detect_session_irregularity(attempt.session_metadata)

  risk = weighted_sum(plagiarism, peer_similarity, timing_anomaly, session_anomaly)

  IF risk >= 0.85:
    RETURN "block"
  IF risk >= 0.60:
    RETURN "review"
  RETURN "pass"
```

## 7. Dropout Risk Prediction

```text
FUNCTION predict_dropout_risk(learner_features):
  risk_probability = dropout_model.predict([
    learner_features.time_on_task_7d,
    learner_features.inactivity_days,
    learner_features.quiz_failure_rate,
    learner_features.pace_slippage,
    learner_features.unfinished_activity_ratio
  ])

  IF risk_probability > 0.75:
    trigger_high_priority_intervention()
  ELSE IF risk_probability > 0.45:
    trigger_nudge()

  RETURN risk_probability
```