Add semantic text-to-gloss option

index.js

@@ -95,6 +95,30 @@ function ensureStyles() {
             font-size: 16px;
             color: #0f172a;
         }
+        .stable-playground-actions {
+            display: flex;
+            align-items: center;
+            justify-content: flex-end;
+            gap: 10px;
+            flex-wrap: wrap;
+        }
+        .stable-playground-actions label {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            margin: 0;
+            font-size: 13px;
+            font-weight: 600;
+            color: #334155;
+        }
+        .stable-playground-actions input {
+            width: auto;
+            margin: 0;
+        }
+        .stable-playground-actions button {
+            padding: 6px 10px;
+            white-space: nowrap;
+        }
         .stable-video-frame {
             position: relative;
             width: 100%;
@@ -190,6 +214,30 @@ function ensureStyles() {
         .stable-control-actions button {
             flex: 1;
         }
+        .stable-translation-options {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 10px;
+            margin-top: 8px;
+            font-size: 13px;
+            color: #334155;
+        }
+        .stable-translation-options label {
+            display: inline-flex;
+            align-items: center;
+            gap: 6px;
+            margin: 0;
+            font-weight: 600;
+        }
+        .stable-translation-options input {
+            width: auto;
+            margin: 0;
+        }
+        .stable-translation-options button {
+            white-space: nowrap;
+            padding: 6px 10px;
+        }
         .stable-status-chip {
             font-size: 13px;
             padding: 6px 12px;
@@ -628,6 +676,7 @@ export default class StableSignerPlugin extends ControlWavePlugin {
                         <div class="stable-control-actions">
                             <button id="stable-prewarm" class="btn secondary">Prewarm</button>
                             <button id="stable-translate" class="btn secondary">Text → Available Gloss</button>
+                            <button id="stable-semantic-demo" class="btn secondary">Semantic Demo</button>
                         </div>
                         <span class="stable-status-chip" id="stable-status">Idle</span>
                     </div>
@@ -635,6 +684,10 @@ export default class StableSignerPlugin extends ControlWavePlugin {
                         <label>Prompt / Text</label>
                         <textarea id="stable-prompt-text" placeholder="Describe the action or context; the system will translate it to gloss."></textarea>
                         <div class="stable-hint">Input text auto-translates and fills the uppercase gloss field below (still editable).</div>
+                        <div class="stable-translation-options">
+                            <label><input type="checkbox" id="stable-semantic-gloss"> Semantic constrained gloss</label>
+                            <span>Uses conservative synonym fallback; output remains limited to available poses.</span>
+                        </div>
                         <div class="form-group" style="margin-top:8px;font-size:13px;color:#475569;">
                             <div>Prompt samples (picked from the latest prompt2gloss eval logs with strongest gloss matches):</div>
                             <div>1. Can you provide instruction on the sign language for &ldquo;You&rsquo;re going to hit it just a little more behind.&rdquo;?</div>
@@ -752,7 +805,11 @@ export default class StableSignerPlugin extends ControlWavePlugin {
                 <div class="stable-text-playground stable-signer-panel">
                     <div class="stable-text-playground-title">
                         <h3>Selection Translation Playground</h3>
-                        <span class="stable-status-chip">Select text to translate</span>
+                        <div class="stable-playground-actions">
+                            <label><input type="checkbox" id="stable-selection-semantic-gloss" checked> Semantic gloss</label>
+                            <button id="stable-selection-semantic-demo" type="button" class="btn secondary">Semantic Demo</button>
+                            <span class="stable-status-chip">Select text to translate</span>
+                        </div>
                     </div>
                     <div id="stable-selection-template" class="stable-reading-area stable-dialogue-area" tabindex="0" contenteditable="true">
                         <div class="stable-dialogue-turn question">
@@ -820,6 +877,10 @@ export default class StableSignerPlugin extends ControlWavePlugin {
         this.refineLogsPre = container.querySelector('#stable-refine-logs');
         this.prewarmBtn = container.querySelector('#stable-prewarm');
         this.translateBtn = container.querySelector('#stable-translate');
+        this.semanticDemoBtn = container.querySelector('#stable-semantic-demo');
+        this.semanticGlossCheckbox = container.querySelector('#stable-semantic-gloss');
+        this.selectionSemanticCheckbox = container.querySelector('#stable-selection-semantic-gloss');
+        this.selectionSemanticDemoBtn = container.querySelector('#stable-selection-semantic-demo');
         this.selectionTemplate = container.querySelector('#stable-selection-template');
         this.selectionPopover = container.querySelector('#stable-selection-popover');
         this.selectionTranslateBtn = container.querySelector('#stable-selection-translate');
@@ -873,6 +934,9 @@ export default class StableSignerPlugin extends ControlWavePlugin {
     attachEvents() {
         this.prewarmBtn.addEventListener('click', () => this.handlePrewarm());
         this.translateBtn.addEventListener('click', () => this.handleTranslate());
+        if (this.semanticDemoBtn) {
+            this.semanticDemoBtn.addEventListener('click', () => this.handleSemanticDemo());
+        }
         this.generateBtn.addEventListener('click', () => this.handleGenerate());
         this.videoRefreshBtn.addEventListener('click', () => this.refreshRecentVideos());
         this.videoSelect.addEventListener('change', () => this.handleRecentSelection());
@@ -885,6 +949,9 @@ export default class StableSignerPlugin extends ControlWavePlugin {
             this.selectionTemplate.addEventListener('mouseup', () => this.handleTemplateSelection());
             this.selectionTemplate.addEventListener('keyup', () => this.handleTemplateSelection());
         }
+        if (this.selectionSemanticDemoBtn) {
+            this.selectionSemanticDemoBtn.addEventListener('click', () => this.handleSelectionSemanticDemo());
+        }
         if (this.selectionTranslateBtn) {
             this.selectionTranslateBtn.addEventListener('click', () => this.handleSelectedTextGenerate(true));
         }
@@ -929,7 +996,8 @@ export default class StableSignerPlugin extends ControlWavePlugin {
             refImagePath: this.refImageInput.value,
             normalizePose: this.normalizeCheckbox.checked,
             hideTorsoLines: this.hideTorsoCheckbox.checked,
-            translationMode: 'text2gloss'
+            translationMode: this.semanticGlossCheckbox && this.semanticGlossCheckbox.checked ? 'semantic' : 'text2gloss',
+            useSemantic: !!(this.semanticGlossCheckbox && this.semanticGlossCheckbox.checked)
         };
     }
 
@@ -1040,11 +1108,18 @@ export default class StableSignerPlugin extends ControlWavePlugin {
             this.setTranslateLoading(true);
         }
         try {
-            const gloss = await this.translatePromptToGloss(normalizedPrompt, maxTokens, promptTextRaw);
+            const result = await this.translatePromptToGloss(normalizedPrompt, maxTokens, promptTextRaw);
+            const gloss = typeof result === 'string' ? result : result.gloss;
             this.glossInput.value = gloss;
             if (!isAuto) {
                 this.updateStatus('Gloss translation completed');
-                this.logsPre.textContent = `Translation result: ${gloss}`;
+                const semantic = result.semantic && result.semantic.length > 0
+                    ? `\nSemantic fallback: ${result.semantic.map(([src, dst]) => `${src}→${dst}`).join(', ')}`
+                    : '';
+                const dropped = result.dropped && result.dropped.length > 0
+                    ? `\nDropped: ${result.dropped.join(', ')}`
+                    : '';
+                this.logsPre.textContent = `Translation result: ${gloss}\nMode: ${result.mode || 'rule'}${semantic}${dropped}`;
             }
             return gloss;
         } finally {
@@ -1059,12 +1134,15 @@ export default class StableSignerPlugin extends ControlWavePlugin {
             throw new Error('Prompt/Text is empty');
         }
         const payloadPrompt = originalPrompt || promptText;
+        const useSemantic = !!(this.semanticGlossCheckbox && this.semanticGlossCheckbox.checked);
         const response = await window.controlWaveWebSocket.sendRequest(this.id, {
             action: 'text_to_gloss',
             data: {
                 text: promptText,
                 prompt: payloadPrompt,
-                maxNewTokens
+                maxNewTokens,
+                mode: useSemantic ? 'semantic' : 'rule',
+                useSemantic
             }
         });
         if (!response || response.status !== 'success' || !response.gloss) {
@@ -1073,7 +1151,37 @@ export default class StableSignerPlugin extends ControlWavePlugin {
         if (response.dropped && response.dropped.length > 0) {
             console.info('[StableSigner] dropped non-renderable text tokens', response.dropped);
         }
-        return response.gloss;
+        return response;
+    }
+
+    handleSemanticDemo() {
+        if (this.semanticGlossCheckbox) {
+            this.semanticGlossCheckbox.checked = true;
+        }
+        this.promptTextInput.value = 'Could you aid me? I bought a mobile and go home later.';
+        this.handleTranslate(false).catch((error) => {
+            this.updateStatus('Semantic demo failed');
+            this.logsPre.textContent = (error && error.message) ? error.message : 'Semantic demo failed';
+        });
+    }
+
+    handleSelectionSemanticDemo() {
+        if (this.selectionSemanticCheckbox) {
+            this.selectionSemanticCheckbox.checked = true;
+        }
+        const demoText = 'Could you aid me? I bought a mobile and go home later.';
+        if (this.selectionTemplate) {
+            this.selectionTemplate.innerHTML = `<div class="stable-dialogue-turn question"><span class="stable-dialogue-speaker">User</span><p>${demoText}</p></div>`;
+        }
+        this.selectedTemplateText = demoText;
+        this.lastGeneratedSelection = '';
+        if (this.selectionTextEl) {
+            this.selectionTextEl.textContent = demoText;
+        }
+        if (this.selectionPopover) {
+            this.selectionPopover.style.display = 'block';
+        }
+        this.handleSelectedTextGenerate(true);
     }
 
     handleTemplateSelection() {
@@ -1154,6 +1262,9 @@ export default class StableSignerPlugin extends ControlWavePlugin {
             throw new Error('WebSocket not ready');
         }
         const payload = this.collectPayload();
+        const selectionUseSemantic = !!(this.selectionSemanticCheckbox && this.selectionSemanticCheckbox.checked);
+        payload.translationMode = selectionUseSemantic ? 'semantic' : 'text2gloss';
+        payload.useSemantic = selectionUseSemantic;
         payload.maxNewTokens = Math.min(toInt(this.maxNewTokensInput.value, 64), 18);
         payload.maxCandidates = Math.min(toInt(this.maxCandidatesInput.value, 10), 3);
         const response = await window.controlWaveWebSocket.sendRequest(this.id, {

pipeline01_text2gloss.py

@@ -108,12 +108,100 @@ PHRASE_MAP = {
 }
 
 
+SEMANTIC_PHRASE_MAP = {
+    "HELP ME": ["HELP", "I"],
+    "NEED HELP": ["NEED", "HELP"],
+    "I NEED HELP": ["I", "NEED", "HELP"],
+    "PLEASE HELP": ["PLEASE", "HELP"],
+    "GO TO SCHOOL": ["GO", "SCHOOL"],
+    "GO HOME": ["GO", "HOME"],
+    "COME HERE": ["COME", "HERE"],
+    "SEE YOU": ["SEE", "YOU"],
+    "NICE TO MEET YOU": ["NICE", "MEET", "YOU"],
+    "HOW ARE YOU": ["HOW", "YOU"],
+}
+
+
+SEMANTIC_TOKEN_MAP = {
+    "ASSIST": "HELP",
+    "AID": "HELP",
+    "SUPPORT": "HELP",
+    "SUPPORTING": "HELP",
+    "REQUIRE": "NEED",
+    "REQUIRES": "NEED",
+    "REQUIRED": "NEED",
+    "MUST": "NEED",
+    "SHOULD": "NEED",
+    "PURCHASE": "BUY",
+    "PURCHASED": "BUY",
+    "PURCHASING": "BUY",
+    "GET": "BUY",
+    "BOUGHT": "BUY",
+    "OBTAIN": "BUY",
+    "SPEAK": "TALK",
+    "SPEAKING": "TALK",
+    "TELL": "SAY",
+    "TOLD": "SAY",
+    "VIEW": "SEE",
+    "WATCH": "SEE",
+    "OBSERVE": "SEE",
+    "UNDERSTOOD": "UNDERSTAND",
+    "UNDERSTANDING": "UNDERSTAND",
+    "CHILDREN": "CHILD",
+    "KIDS": "CHILD",
+    "KID": "CHILD",
+    "ADULTS": "ADULT",
+    "PEOPLE": "PERSON",
+    "HUMAN": "PERSON",
+    "PERSONS": "PERSON",
+    "PHYSICIAN": "DOCTOR",
+    "MEDICAL": "DOCTOR",
+    "HOSPITAL": "DOCTOR",
+    "INSTRUCTOR": "TEACHER",
+    "EDUCATOR": "TEACHER",
+    "PUPIL": "STUDENT",
+    "LEARNER": "STUDENT",
+    "AUTOMOBILE": "CAR",
+    "VEHICLE": "CAR",
+    "CELL": "PHONE",
+    "MOBILE": "PHONE",
+    "TELEPHONE": "PHONE",
+    "RESIDENCE": "HOME",
+    "HOUSE": "HOME",
+    "WEATHER": "WEATHER",
+    "RAINING": "RAIN",
+    "SUNNY": "SUN",
+    "COLD": "COLD",
+    "HOT": "HOT",
+    "BEAUTIFUL": "NICE",
+    "GREAT": "GOOD",
+    "EXCELLENT": "GOOD",
+    "FINE": "GOOD",
+    "HAPPY": "HAPPY",
+    "SAD": "SAD",
+    "AFRAID": "FEAR",
+    "SCARED": "FEAR",
+    "SOON": "LATER",
+    "AFTER": "LATER",
+    "CURRENTLY": "NOW",
+    "IMMEDIATELY": "NOW",
+    "YESTERDAY": "YESTERDAY",
+    "TOMORROW": "TOMORROW",
+}
+
+
+AMBIGUOUS_SEMANTIC_BLOCKLIST = {
+    "CAN", "MAY", "MIGHT", "LEFT", "RIGHT", "LIGHT", "WELL", "KIND", "MEAN", "PART", "SECOND"
+}
+
+
 @dataclass
 class TextToGlossResult:
     gloss: str
     tokens: List[str]
     matched: List[Tuple[str, str]]
     dropped: List[str]
+    semantic: List[Tuple[str, str]]
 
 
 def load_available_glosses(path: Path | str = DEFAULT_POSE_DICT) -> Set[str]:
@@ -168,6 +256,41 @@ def _best_vocab_match(token: str, vocab: Set[str]) -> Optional[str]:
     return None
 
 
+def _best_semantic_match(token: str, vocab: Set[str]) -> Optional[str]:
+    if token in AMBIGUOUS_SEMANTIC_BLOCKLIST:
+        return None
+    candidates = _simple_lemma(token)
+    for candidate in candidates:
+        mapped = SEMANTIC_TOKEN_MAP.get(candidate)
+        if mapped and mapped in vocab:
+            return mapped
+    return None
+
+
+def _apply_semantic_phrase_map(tokens: Sequence[str], vocab: Set[str]) -> Tuple[List[str], List[Tuple[str, str]]]:
+    output: List[str] = []
+    matched: List[Tuple[str, str]] = []
+    i = 0
+    phrases = sorted(SEMANTIC_PHRASE_MAP.items(), key=lambda item: len(item[0].split()), reverse=True)
+    while i < len(tokens):
+        consumed = False
+        for phrase, gloss_tokens in phrases:
+            phrase_tokens = phrase.split()
+            if list(tokens[i : i + len(phrase_tokens)]) != phrase_tokens:
+                continue
+            available = [gloss for gloss in gloss_tokens if gloss in vocab]
+            if available:
+                output.extend(available)
+                matched.append((phrase, " ".join(available)))
+                i += len(phrase_tokens)
+                consumed = True
+                break
+        if not consumed:
+            output.append(tokens[i])
+            i += 1
+    return output, matched
+
+
 def _apply_phrase_map(tokens: Sequence[str], vocab: Set[str]) -> Tuple[List[str], List[Tuple[str, str]]]:
     output: List[str] = []
     matched: List[Tuple[str, str]] = []
@@ -195,11 +318,16 @@ def translate_text_to_gloss(
     text: str,
     vocab: Optional[Iterable[str]] = None,
     max_tokens: int = 64,
+    use_semantic: bool = False,
 ) -> TextToGlossResult:
     """Translate English text into a renderable uppercase gloss sequence."""
     vocab_set = {item.upper() for item in vocab} if vocab is not None else load_available_glosses()
     raw_tokens = tokenize_english(text)
     phrase_tokens, phrase_matches = _apply_phrase_map(raw_tokens, vocab_set)
+    semantic_matches: List[Tuple[str, str]] = []
+    if use_semantic:
+        phrase_tokens, semantic_phrase_matches = _apply_semantic_phrase_map(phrase_tokens, vocab_set)
+        semantic_matches.extend(semantic_phrase_matches)
 
     gloss_tokens: List[str] = []
     matched: List[Tuple[str, str]] = list(phrase_matches)
@@ -212,6 +340,10 @@ def translate_text_to_gloss(
             dropped.append(token)
             continue
         gloss = _best_vocab_match(token, vocab_set)
+        if not gloss and use_semantic:
+            gloss = _best_semantic_match(token, vocab_set)
+            if gloss:
+                semantic_matches.append((token, gloss))
         if gloss:
             gloss_tokens.append(gloss)
             if token != gloss:
@@ -224,6 +356,7 @@ def translate_text_to_gloss(
         tokens=gloss_tokens,
         matched=matched,
         dropped=dropped,
+        semantic=semantic_matches,
     )
 
 
@@ -232,11 +365,12 @@ def main() -> None:
     parser.add_argument("text", help="English text to translate.")
     parser.add_argument("--pose-dict", default=str(DEFAULT_POSE_DICT), help="WLASL-style pose dictionary JSON.")
     parser.add_argument("--max-tokens", type=int, default=64)
+    parser.add_argument("--semantic", action="store_true", help="Enable conservative semantic synonym fallback.")
     parser.add_argument("--json", action="store_true", help="Print structured JSON instead of only gloss.")
     args = parser.parse_args()
 
     vocab = load_available_glosses(args.pose_dict)
-    result = translate_text_to_gloss(args.text, vocab=vocab, max_tokens=args.max_tokens)
+    result = translate_text_to_gloss(args.text, vocab=vocab, max_tokens=args.max_tokens, use_semantic=args.semantic)
     if args.json:
         print(
             json.dumps(
@@ -245,6 +379,7 @@ def main() -> None:
                     "tokens": result.tokens,
                     "matched": result.matched,
                     "dropped": result.dropped,
+                    "semantic": result.semantic,
                 },
                 ensure_ascii=True,
                 indent=2,

viser_backend.py

@@ -213,17 +213,20 @@ class StableSignerBackend(PluginBackendBase):
         decoded = tokenizer.batch_decode(outputs, skip_special_tokens=True)[0].strip().upper()
         return decoded
 
-    def _generate_constrained_text_gloss(self, text: str, max_tokens: int) -> Dict[str, Any]:
+    def _generate_constrained_text_gloss(self, text: str, max_tokens: int, use_semantic: bool = False) -> Dict[str, Any]:
         result = translate_text_to_gloss(
             text,
             vocab=self._get_available_glosses(),
             max_tokens=max_tokens,
+            use_semantic=use_semantic,
         )
         return {
             "gloss": result.gloss,
             "tokens": result.tokens,
             "matched": result.matched,
             "dropped": result.dropped,
+            "semantic": result.semantic,
+            "mode": "semantic" if use_semantic else "rule",
         }
 
     def _build_output_path(self, gloss_tokens: List[str], draw_style: str) -> Path:
@@ -345,8 +348,10 @@ class StableSignerBackend(PluginBackendBase):
         if not text:
             return {"status": "error", "message": "Text is empty."}
         max_tokens = _safe_int(data.get("maxNewTokens"), 64)
+        mode = str(data.get("mode") or data.get("translationMode") or "rule").lower()
+        use_semantic = bool(data.get("useSemantic")) or mode in {"semantic", "semantic_text2gloss", "semantic-text2gloss"}
         try:
-            result = self._generate_constrained_text_gloss(text, max_tokens)
+            result = self._generate_constrained_text_gloss(text, max_tokens, use_semantic=use_semantic)
             if not result["gloss"]:
                 return {
                     "status": "error",
@@ -508,10 +513,11 @@ class StableSignerBackend(PluginBackendBase):
                     self._generation_lock.release()
                     return {"status": "error", "message": "Please enter Prompt/Text or a gloss sequence."}
                 translation_mode = (data.get("translationMode") or "text2gloss").strip().lower()
+                use_semantic = bool(data.get("useSemantic")) or translation_mode in {"semantic", "semantic_text2gloss", "semantic-text2gloss"}
                 if translation_mode == "prompt2gloss":
                     gloss_input = self._generate_gloss(text_input, prompt_input, max_new_tokens)
                 else:
-                    gloss_input = self._generate_constrained_text_gloss(text_input, max_new_tokens)["gloss"]
+                    gloss_input = self._generate_constrained_text_gloss(text_input, max_new_tokens, use_semantic=use_semantic)["gloss"]
 
             gloss_tokens = [token for token in gloss_input.upper().split() if token]
             if not gloss_tokens:
@@ -603,10 +609,11 @@ class StableSignerBackend(PluginBackendBase):
                 if not text_input:
                     return {"status": "error", "message": "Please enter Prompt/Text or a gloss sequence."}
                 translation_mode = (data.get("translationMode") or "text2gloss").strip().lower()
+                use_semantic = bool(data.get("useSemantic")) or translation_mode in {"semantic", "semantic_text2gloss", "semantic-text2gloss"}
                 if translation_mode == "prompt2gloss":
                     gloss_input = self._generate_gloss(text_input, prompt_input, max_new_tokens)
                 else:
-                    gloss_result = self._generate_constrained_text_gloss(text_input, max_new_tokens)
+                    gloss_result = self._generate_constrained_text_gloss(text_input, max_new_tokens, use_semantic=use_semantic)
                     gloss_input = gloss_result["gloss"]
 
             gloss_tokens = [token for token in gloss_input.upper().split() if token]