| """DTT area generator. |
| |
| Loads configs/dtt/ + configs/shared/ and produces JSONL examples with |
| clinically-consistent combinations sampled from the DTT taxonomy. |
| """ |
|
|
| import random |
| from pathlib import Path |
|
|
| from .base import ( |
| article, |
| load_area, |
| load_shared, |
| render_prompt_sequence, |
| sample_stimuli, |
| strip_trailing_period, |
| make_example_envelope, |
| ) |
|
|
| |
| AREA = "dtt" |
| TASK_TYPE = "teaching_program" |
|
|
|
|
| |
|
|
|
|
| def generate_sd(skill_target: str, domain_id: str, rng: random.Random) -> dict: |
| """Generate primary SD, variations, and presentation description. |
| |
| Sub-domain aware: Tact-of-colors gets "What color?", not "What is this?". |
| """ |
| skill = skill_target.lower() |
|
|
| if domain_id == "tact": |
| if "color" in skill: |
| return _sd("What color?", '"What color is this?"; "Tell me the color"', |
| "Present a single-color object and ask while pointing to it.") |
| if "shape" in skill: |
| return _sd("What shape?", '"What shape is this?"; "Tell me the shape"', |
| "Present a clearly-shaped object or shape card and ask while pointing to it.") |
| if "action" in skill: |
| return _sd("What is he doing?", '"What action?"; "What is she doing?"; "What is happening here?"', |
| "Present an action picture, video clip, or live demonstration.") |
| if "emotion" in skill or "feeling" in skill: |
| return _sd("How does he feel?", '"What emotion?"; "How is she feeling?"', |
| "Present a photograph or emoji card depicting the target emotion.") |
| if "body part" in skill: |
| return _sd("What is this?", '"Tell me"; "Name this body part"', |
| "Point to the target body part (on self, learner, or doll) and ask.") |
| if "animal" in skill: |
| return _sd("What animal is this?", '"What is this?"; "Name this animal"', |
| "Present an animal picture card and ask while pointing.") |
| if "preposition" in skill: |
| return _sd("Where is it?", '"Where is the {object}?"; "Tell me where"', |
| "Arrange two objects in a target spatial relation and ask about the position.") |
| if "adjective" in skill: |
| return _sd("What is it like?", '"Describe it"; "Is it big or little?"', |
| "Present two contrasting items and prompt a comparative description.") |
| if "past" in skill or "event" in skill: |
| return _sd("What happened?", '"What did she do?"; "Tell me what you did"', |
| "Reference a recently completed action or event familiar to the learner.") |
| if "categor" in skill: |
| return _sd("What category?", '"What group does this belong to?"; "What kind of thing?"', |
| "Present a clearly categorizable item and prompt the category label.") |
| return _sd("What is this?", '"Tell me what you see"; "What\'s that?"; "Name this"', |
| "Present the target stimulus within visual field and ask while pointing to it.") |
|
|
| if domain_id == "vp_mts": |
| return _sd("Match", '"Find the same"; "Put with same"', |
| "Present the sample stimulus and an array of comparison stimuli simultaneously.") |
|
|
| if domain_id in {"listener_responding", "lrffc"}: |
| return _sd("Touch [target item]", |
| '"Point to [target item]"; "Give me [target item]"; "Show me [target item]"', |
| "Present an array of items on the table and deliver a clear verbal SD.") |
|
|
| if domain_id == "reading": |
| if "sight word" in skill or "word" in skill: |
| return _sd("What word?", '"Read this word"; "What does it say?"', |
| "Present the sight-word card and deliver the SD.") |
| if "letter" in skill: |
| return _sd("What letter is this?", '"Read this letter"; "What does this say?"', |
| "Present the letter flashcard.") |
| if "sentence" in skill or "passage" in skill: |
| return _sd("Read this.", '"Read it aloud"; "What does this sentence say?"', |
| "Present the written sentence or passage at an appropriate reading level.") |
| return _sd("What letter is this?", '"Read this letter"; "What does this say?"', |
| "Present the letter or word on a flashcard.") |
|
|
| if domain_id == "writing": |
| return _sd("Write the target.", '"Trace this"; "Copy this"; "Write {word}"', |
| "Provide pencil and paper; deliver a clear verbal instruction naming the target letter or word.") |
|
|
| if domain_id == "math": |
| if "numeral" in skill or "identif" in skill: |
| return _sd("What number is this?", '"Which number?"; "Tell me the number"', |
| "Present the numeral card.") |
| if "count" in skill: |
| return _sd("How many?", '"Count these"; "How many are there?"', |
| "Present the set of objects to count.") |
| if "add" in skill or "subtract" in skill: |
| return _sd("Solve this.", '"What is the answer?"; "How much?"', |
| "Present a written or spoken arithmetic problem at target level.") |
| return _sd("How many?", '"Count these"; "What number is this?"', |
| "Present the numeral card or a set of objects to count.") |
|
|
| return _sd("Show me", '"Do this"; "Your turn"', |
| "Present relevant stimuli and deliver a clear verbal SD.") |
|
|
|
|
| def _sd(primary: str, variations: str, presentation: str) -> dict: |
| return {"primary_sd": primary, "sd_variations": variations, "sd_presentation": presentation} |
|
|
|
|
| def current_prompt_guidance(mastery_state_id: str) -> str: |
| """Translate mastery state into current-prompt-level guidance.""" |
| if mastery_state_id in {"emerging", "developing"}: |
| return "begin at higher prompt levels (full-physical or partial-physical) with systematic fading." |
| if mastery_state_id == "approaching": |
| return "deliver gestural or positional prompts; fade toward independence." |
| if mastery_state_id in {"near", "mastered", "generalization"}: |
| return "use minimal prompts (positional or verbal hint) only when needed; expect independent responding." |
| return "prompt level calibrated to current performance." |
|
|
|
|
| |
|
|
|
|
| class DTTGenerator: |
| """Generates teaching-program examples for the DTT area. |
| |
| Loads its self-contained taxonomy + template + compatibility rules from |
| configs/dtt/ and uses shared primitives from configs/shared/. |
| """ |
|
|
| 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"] |
| self.prompt_types = self.shared["prompt_types"]["prompt_types"] |
|
|
| |
|
|
| def sample_combination(self, rng: random.Random) -> dict: |
| """Sample a clinically-valid DTT combo.""" |
| |
| 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] |
|
|
| |
| |
| |
| 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]) |
|
|
| |
| profiles = self.shared["learner_profiles"]["profiles"] |
| allowed_profile_ids = set(self.compat["level_to_learner_profiles"][level_id]) |
| profile = rng.choice([p for p in profiles if p["id"] in allowed_profile_ids]) |
|
|
| mastery_state = rng.choice(self.shared["mastery_states"]["states"]) |
|
|
| |
| prompt_hierarchy = rng.choice(self.taxonomy["prompt_hierarchies"]) |
| all_ecs = self.taxonomy["error_corrections"] |
| required_hierarchy = self.compat.get("errorless_requires_hierarchy") |
| if prompt_hierarchy["id"] != required_hierarchy: |
| valid_ecs = [ec for ec in all_ecs if ec["id"] != "errorless"] |
| else: |
| valid_ecs = all_ecs |
| error_correction = rng.choice(valid_ecs) |
|
|
| |
| all_schedules = self.taxonomy["reinforcement_schedules"] |
| allowed_schedule_ids = set(self.compat["mastery_to_reinforcement"][mastery_state["id"]]) |
| valid_schedules = [s for s in all_schedules if s["id"] in allowed_schedule_ids] |
| if not valid_schedules: |
| valid_schedules = [s for s in all_schedules if s["id"] == "crf"] |
| reinforcement_schedule = rng.choice(valid_schedules) |
|
|
| 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, |
| "prompt_hierarchy": prompt_hierarchy, |
| "reinforcement_schedule": reinforcement_schedule, |
| "error_correction": error_correction, |
| "mastery_criterion": mastery_criterion, |
| } |
|
|
| |
|
|
| def compute_slots(self, combo: dict, rng: random.Random) -> dict: |
| array_size_info = self.compat["array_size_by_level"][combo["level_id"]] |
| array_size_n = array_size_info["n"] |
| array_size_text = array_size_info["text"] |
|
|
| sd = generate_sd(combo["skill_target"], combo["domain_id"], rng) |
| stim = sample_stimuli(combo["skill_target"], array_size_n, rng) |
|
|
| if stim["distractors"]: |
| distractor_block = f"Distractor stimuli: {', '.join(stim['distractors'])}" |
| else: |
| distractor_block = "Distractor stimuli: N/A (no-array SD format)" |
|
|
| mastery_state = combo["mastery_state"] |
|
|
| return { |
| "skill_target": combo["skill_target"], |
| "curriculum_ref": f"{combo['domain_name']} {combo['level_id']}", |
| "learner_profile_name": combo["learner_profile"]["name"], |
| "learner_profile_article": article(combo["learner_profile"]["name"]), |
| "mastery_state_name": mastery_state["name"], |
| "mastery_state_short": mastery_state.get("short", mastery_state["name"].lower()), |
| "primary_sd": sd["primary_sd"], |
| "sd_variations": sd["sd_variations"], |
| "sd_presentation": sd["sd_presentation"], |
| "prompt_hierarchy_name": combo["prompt_hierarchy"]["name"], |
| "prompt_sequence": render_prompt_sequence( |
| combo["prompt_hierarchy"]["sequence"], self.prompt_types |
| ), |
| "current_prompt_guidance": current_prompt_guidance(mastery_state["id"]), |
| "array_size": array_size_text, |
| "target_stimuli": ", ".join(stim["targets"]), |
| "distractor_block": distractor_block, |
| "error_correction_steps": combo["error_correction"]["steps"].strip(), |
| "reinforcement_schedule_name": combo["reinforcement_schedule"]["name"], |
| "reinforcement_description": strip_trailing_period(combo["reinforcement_schedule"]["description"]), |
| "mastery_criterion_text": combo["mastery_criterion"]["text"], |
| "ioa_frequency": rng.choice([3, 4, 5]), |
| "n_generalization_therapists": rng.choice([2, 3]), |
| "n_generalization_settings": rng.choice([2, 3]), |
| } |
|
|
| |
|
|
| 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"], |
| "prompt_hierarchy": combo["prompt_hierarchy"]["id"], |
| "reinforcement_schedule": combo["reinforcement_schedule"]["id"], |
| "error_correction": combo["error_correction"]["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, |
| ) |
|
|
