Datasets:
File size: 9,087 Bytes
c427f62 | 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 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 | """NET area generator.
Loads configs/net/ + configs/shared/ and produces naturalistic teaching
program examples. Mand / Social / Spontaneous Vocal / some Intraverbal skills.
"""
import random
from pathlib import Path
from .base import (
load_area,
load_shared,
make_example_envelope,
)
AREA = "net"
TASK_TYPE = "teaching_program"
def pick_mo_category(skill_target: str, domain_id: str, compat: dict) -> str:
"""Match skill text against domain + keyword rules to pick an MO category.
Domain is checked first to avoid false matches from shared keywords
(e.g., 'preferred' in both mand skills and spontaneous-vocal skills).
"""
s = skill_target.lower()
if domain_id == "mand":
if "bathroom" in s or "potty" in s or "toilet" in s or "restroom" in s:
return "mand_bathroom"
if "break" in s:
return "mand_break"
if "all done" in s or "completion" in s or "finished" in s:
return "mand_completion"
if "missing" in s:
return "mand_missing"
if "help" in s:
return "mand_help"
if '"what"' in s or "what" in s.split():
return "mand_info_what"
if '"where"' in s or "where" in s.split():
return "mand_info_where"
if "attention" in s or "peers" in s:
return "mand_attention"
if "action" in s:
return "mand_action"
return "mand_item"
if domain_id == "social":
if "initiate" in s or "initiates" in s:
return "social_initiation"
if "turn" in s:
return "social_turn_taking"
if "reciprocal" in s or "conversation" in s:
return "intraverbal_multi_turn"
return "social_initiation"
if domain_id == "spontaneous_vocal":
if "greet" in s:
return "spontaneous_greeting"
return "spontaneous_comment"
if domain_id == "intraverbal":
if "multi-turn" in s or "conversation" in s:
return "intraverbal_multi_turn"
if "routine" in s:
return "intraverbal_routine"
return "intraverbal_multi_turn"
return compat["default_mo_category"]
def pick_mo_arrangement(mo_category: str, mo_arrangements: list, rng: random.Random) -> dict:
"""Find an MO arrangement matching the category, falling back to random."""
matches = [m for m in mo_arrangements if mo_category in m["applies_to"]]
if matches:
return rng.choice(matches)
return rng.choice(mo_arrangements)
def current_prompt_guidance(mastery_state_id: str) -> str:
"""Guidance for NET prompt level based on mastery state."""
if mastery_state_id in {"emerging", "developing"}:
return "begin with a model prompt delivered during the motivated moment; fade to expectant look across sessions."
if mastery_state_id == "approaching":
return "use time delay (0 s -> 2 s -> 4 s) before delivering any model prompt; reinforce independent responses differentially."
if mastery_state_id in {"near", "mastered", "generalization"}:
return "use expectant look only; avoid direct prompts. The MO itself should be sufficient to occasion the response."
return "prompt level calibrated to current performance."
class NETGenerator:
def __init__(self, config_dir: Path):
self.config_dir = Path(config_dir)
self.shared = load_shared(self.config_dir)
self.area = load_area(self.config_dir, AREA)
self.template = self.area["template"]
self.taxonomy = self.area["taxonomy"]
self.compat = self.area["compatibility"]
def sample_combination(self, rng: random.Random) -> dict:
# Level with weights
level_weights = self.compat["level_sampling_weights"]
levels = list(level_weights.keys())
weights = [level_weights[k] for k in levels]
level_id = rng.choices(levels, weights=weights)[0]
# Sample domain with a level match
all_domains = self.taxonomy["skill_domains"]["vbmapp"]["domains"]
domains_with_level = [d for d in all_domains if level_id in d]
if not domains_with_level:
domain = rng.choice(all_domains)
available_levels = [lv for lv in levels if lv in domain]
level_id = rng.choice(available_levels)
else:
domain = rng.choice(domains_with_level)
skill_target = rng.choice(domain[level_id])
# Learner profile
profiles = self.shared["learner_profiles"]["profiles"]
allowed = set(self.compat["level_to_learner_profiles"][level_id])
profile = rng.choice([p for p in profiles if p["id"] in allowed])
mastery_state = rng.choice(self.shared["mastery_states"]["states"])
mo_category = pick_mo_category(skill_target, domain["id"], self.compat)
mo_arrangement = pick_mo_arrangement(mo_category, self.taxonomy["mo_arrangements"], rng)
natural_context = rng.choice(
mo_arrangement.get("context_examples") or self.taxonomy["natural_contexts"]
)
prompt_strategy = rng.choice(self.taxonomy["prompt_strategies"])
mastery_criterion = rng.choice(self.taxonomy["mastery_criteria"])
return {
"skill_target": skill_target,
"domain_id": domain["id"],
"domain_name": domain["name"],
"level_id": level_id,
"learner_profile": profile,
"mastery_state": mastery_state,
"mo_category": mo_category,
"mo_arrangement": mo_arrangement,
"natural_context": natural_context,
"prompt_strategy": prompt_strategy,
"mastery_criterion": mastery_criterion,
}
def compute_slots(self, combo: dict, rng: random.Random) -> dict:
mastery_state = combo["mastery_state"]
reinforcer_map = self.taxonomy["natural_reinforcer_examples"]
natural_reinforcer = reinforcer_map.get(combo["mo_category"], reinforcer_map["default"])
# Build a natural-opportunity description from the MO arrangement + natural context
opportunity_text = (
f"Embed the teaching opportunity within the learner's {combo['natural_context']} routine. "
f"Deliver the opportunity when the MO is evident (learner oriented to the relevant stimulus, approaching the materials, or demonstrating interest)."
)
return {
"skill_target": combo["skill_target"],
"curriculum_ref": f"{combo['domain_name']} {combo['level_id']}",
"learner_profile_name": combo["learner_profile"]["name"],
"mastery_state_name": mastery_state["name"],
"mastery_state_short": mastery_state.get("short", mastery_state["name"].lower()),
"mo_arrangement_text": combo["mo_arrangement"]["text"],
"primary_natural_context": combo["natural_context"],
"natural_opportunity_text": opportunity_text,
"prompt_strategy_name": combo["prompt_strategy"]["name"],
"prompt_strategy_description": combo["prompt_strategy"]["description"],
"current_prompt_guidance": current_prompt_guidance(mastery_state["id"]),
"natural_reinforcer_text": f"Natural reinforcer: {natural_reinforcer}",
"n_exemplars": rng.choice([3, 4, 5]),
"n_settings": rng.choice([2, 3]),
"n_therapists": rng.choice([2, 3]),
"mastery_criterion_text": combo["mastery_criterion"]["text"],
"ioa_frequency": rng.choice([3, 4, 5]),
}
def render_example(self, rng: random.Random) -> dict:
combo = self.sample_combination(rng)
slots = self.compute_slots(combo, rng)
user_variant = rng.choice(self.template["user_variants"])
user_content = user_variant.format(**slots)
assistant_content = self.template["assistant_template"].format(**slots)
gold_labels = {
"method": AREA,
"domain": f"VB-MAPP.{combo['domain_id']}",
"level": combo["level_id"],
"learner_profile": combo["learner_profile"]["id"],
"mastery_state": combo["mastery_state"]["id"],
}
provenance = {
"layer": 1,
"area": AREA,
"template_id": self.template["template_id"],
"taxonomy_cells": {
"skill_target": combo["skill_target"],
"mo_category": combo["mo_category"],
"mo_arrangement": combo["mo_arrangement"]["id"],
"prompt_strategy": combo["prompt_strategy"]["id"],
"mastery_criterion": combo["mastery_criterion"]["id"],
},
"teacher_model": None,
"seed_tag": str(rng.getstate()[1][0] % 100000),
}
return make_example_envelope(
system_content=self.template["system_prompt"],
user_content=user_content,
assistant_content=assistant_content,
task_type=TASK_TYPE,
gold_labels=gold_labels,
provenance=provenance,
)
|