| """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_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 = 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"]) |
|
|
| |
| 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, |
| ) |
|
|
