Russel-Morant commited on
Commit
72154cc
Β·
verified Β·
1 Parent(s): 76c7b82

Upload app.py

Browse files
Files changed (1) hide show
  1. app.py +470 -0
app.py ADDED
@@ -0,0 +1,470 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ """
2
+ hf_gradio_flan_sde_app.py
3
+
4
+ Single-file Gradio app (Hugging Face Spaces compatible) that:
5
+ - Runs a conversational profiler (13D) with question-driven probing.
6
+ - Uses a real Hugging Face Flan-T5 model (configurable) to output SDE parameters (mu, k, A_lowrank, sigma).
7
+ - Runs an Euler–Maruyama SDE simulator to produce trajectories and a final predicted state.
8
+ - Displays results and plots in the Gradio UI and logs each run to a local JSONL file for later export.
9
+
10
+ Notes for deployment:
11
+ - Put this file into a Spaces repo and set up `requirements.txt` with `transformers`, `torch`, `gradio`, `scikit-learn`, `numpy`, `matplotlib`.
12
+ - Spaces will run the file and serve the Gradio interface. The file is careful to avoid argparse conflicts in Colab/Spaces.
13
+ - If you want to persist logs to the Hugging Face Hub, set the env var `HF_TOKEN` and the app will try to push `runs/logs.jsonl` to a dataset (optional; requires `datasets` and proper permissions).
14
+
15
+ """
16
+
17
+ import os
18
+ import json
19
+ import math
20
+ import time
21
+ import random
22
+ import traceback
23
+ from typing import Dict, Any, List, Optional, Tuple
24
+ from collections import defaultdict
25
+ from dataclasses import dataclass
26
+
27
+ import numpy as np
28
+ import matplotlib.pyplot as plt
29
+ import gradio as gr
30
+ import torch
31
+ from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
32
+ from sklearn.cluster import KMeans
33
+
34
+ # ---------------------------
35
+ # Config
36
+ # ---------------------------
37
+ MODEL_ID_DEFAULT = os.environ.get('FLAN_MODEL', 'google/flan-t5-small')
38
+ DEVICE = 'cuda' if torch.cuda.is_available() else 'cpu'
39
+ SEED = int(os.environ.get('APP_SEED', 42))
40
+ np.random.seed(SEED); random.seed(SEED)
41
+
42
+ LABELS = [
43
+ "Attention", "Empathy", "Control", "Masking", "Interest", "Relevance", "Strategy",
44
+ "Fear", "Trust", "Validation", "DominanceThreshold", "Unpredictability", "RiskAppetite"
45
+ ]
46
+
47
+ INITIAL_QUESTIONS = [
48
+ "What situations make you feel most alert or withdrawn?",
49
+ "How do you handle high-pressure challenges?",
50
+ "What drives you to take charge in group settings?",
51
+ "How do you respond to unexpected changes?"
52
+ ]
53
+
54
+ FALLBACK_QUESTIONS = {
55
+ "Attention": "How does your focus shift in demanding situations?",
56
+ "Empathy": "What role does understanding others play in your decisions?",
57
+ "Control": "How do you maintain influence over a situation?",
58
+ "Masking": "When do you hide your true intentions?",
59
+ "Interest": "What keeps you engaged in a task?",
60
+ "Relevance": "How do you decide what matters most in a scenario?",
61
+ "Strategy": "How do you plan your approach to challenges?",
62
+ "Fear": "What makes you feel cautious or hesitant?",
63
+ "Trust": "When do you feel comfortable relying on others?",
64
+ "Validation": "What makes you feel recognized or valued?",
65
+ "DominanceThreshold": "How much control do you need to feel secure?",
66
+ "Unpredictability": "How do you handle unexpected twists?",
67
+ "RiskAppetite": "What drives you to take bold risks?"
68
+ }
69
+
70
+ # Simple regex patterns for scoring (cleaned with  boundaries)
71
+ import re
72
+ _PATTERNS = {
73
+ "control": (re.compile(r"(manipulat|control|dominat|exploit|test|punish|revenge|hurt)", re.IGNORECASE),
74
+ {"Control": 0.12, "Strategy": 0.08, "Masking": 0.05}),
75
+ "empathy": (re.compile(r"(trust|like|care|feel|empath|compass)", re.IGNORECASE),
76
+ {"Empathy": 0.12, "Trust": 0.08}),
77
+ "bored": (re.compile(r"(bore|boring|meh|dont care|who cares|whatever)", re.IGNORECASE),
78
+ {"Interest": -0.15, "Relevance": 0.10}),
79
+ "happy": (re.compile(r"(happy|fun|enjoy|excite|pleasur|thrill)", re.IGNORECASE),
80
+ {"Validation": 0.08, "Interest": 0.08}),
81
+ "mask": (re.compile(r"(fake|act|mask|perform|play a role)", re.IGNORECASE),
82
+ {"Masking": 0.12}),
83
+ "fear": (re.compile(r"(fear|scared|nervous|anxious|afraid)", re.IGNORECASE),
84
+ {"Fear": 0.12, "Unpredictability": 0.05}),
85
+ "think": (re.compile(r"(think|analyse|analyz|calculate|model|simulate|reason)", re.IGNORECASE),
86
+ {"Strategy": 0.12, "Attention": 0.05}),
87
+ "risk_up": (re.compile(r"(risk|gamble|bet|danger|reckless|thrill|adventur|dare)", re.IGNORECASE),
88
+ {"RiskAppetite": 0.12}),
89
+ "risk_down": (re.compile(r"(cautious|safe|avoid|conservativ|hesitant|secure|careful)", re.IGNORECASE),
90
+ {"RiskAppetite": -0.12}),
91
+ }
92
+
93
+ # ---------------------------
94
+ # Session state
95
+ # ---------------------------
96
+ @dataclass
97
+ class SessionState:
98
+ values: Dict[str, float]
99
+ round: int = 0
100
+ last_target: Optional[str] = None
101
+ last_q: Optional[str] = None
102
+ used_targets: set = None
103
+ used_questions: set = None
104
+ history: List = None
105
+
106
+ def __post_init__(self):
107
+ if self.used_targets is None:
108
+ self.used_targets = set()
109
+ if self.used_questions is None:
110
+ self.used_questions = set()
111
+ if self.history is None:
112
+ self.history = []
113
+
114
+
115
+ def init_state() -> SessionState:
116
+ base = {
117
+ "Attention": 0.5, "Empathy": 0.2, "Control": 0.8, "Masking": 0.6, "Interest": 0.5,
118
+ "Relevance": 0.5, "Strategy": 0.7, "Fear": 0.5, "Trust": 0.3, "Validation": 0.5,
119
+ "DominanceThreshold": 0.4, "Unpredictability": 0.3, "RiskAppetite": 0.5
120
+ }
121
+ return SessionState(values=defaultdict(lambda:0.5, base))
122
+
123
+ # Simple in-memory session registry (for Spaces this works; for multi-instance you need external store)
124
+ SESSIONS: Dict[str, SessionState] = {}
125
+
126
+ # ---------------------------
127
+ # HF Flan wrapper (lazy load)
128
+ # ---------------------------
129
+ _HF_TOKENIZER = None
130
+ _HF_MODEL = None
131
+
132
+ def load_flan(model_id: str = MODEL_ID_DEFAULT, device: str = DEVICE):
133
+ global _HF_TOKENIZER, _HF_MODEL
134
+ if _HF_MODEL is None:
135
+ print(f"[info] Loading Flan model {model_id} on {device}...")
136
+ _HF_TOKENIZER = AutoTokenizer.from_pretrained(model_id)
137
+ _HF_MODEL = AutoModelForSeq2SeqLM.from_pretrained(model_id)
138
+ _HF_MODEL.to(torch.device(device))
139
+ return _HF_TOKENIZER, _HF_MODEL
140
+
141
+ PROMPT_TEMPLATE = """INSTRUCTION: Given the profiles and situation, output compact JSON with keys: mu, k, A_lowrank, sigma.
142
+ Return arrays as lists only. Example: {{ "mu":[...], "k":[...], "A_lowrank":{{"U":[[...]], "V":[[...]]}}, "sigma":[...] }}
143
+
144
+ PROFILES:
145
+ {profiles_text}
146
+
147
+ SITUATION:
148
+ {scenario_text}
149
+
150
+ OUTPUT JSON:"""
151
+
152
+
153
+ def build_prompt_from_profile(session: SessionState, extra_situation: Optional[Dict[str,Any]]=None) -> str:
154
+ profiles_text = "- candidate: role=candidate, trust={:.3f}, dominance={:.3f}, vec=[{}]".format(
155
+ session.values['Trust'], session.values['DominanceThreshold'],
156
+ ','.join(f"{session.values.get(k,0.5):.3f}" for k in ["Strategy","Empathy","Control","Masking","RiskAppetite"])
157
+ )
158
+ situation = {'scenario':'random_scene','stakes':0.5,'duration_mins':10,'unpredictability':session.values.get('Unpredictability',0.3)}
159
+ if extra_situation:
160
+ situation.update(extra_situation)
161
+ scenario_text = ', '.join([f"{k}={v}" for k,v in situation.items()])
162
+ return PROMPT_TEMPLATE.format(profiles_text=profiles_text, scenario_text=scenario_text)
163
+
164
+
165
+ def flan_generate_params(prompt: str, model_id: str = MODEL_ID_DEFAULT, device: str = DEVICE, max_length: int = 256) -> Dict[str,Any]:
166
+ try:
167
+ tokenizer, model = load_flan(model_id, device)
168
+ inputs = tokenizer(prompt, truncation=True, padding=True, return_tensors='pt', max_length=1024).to(model.device)
169
+ outs = model.generate(**inputs, max_length=max_length, do_sample=False)
170
+ text = tokenizer.decode(outs[0], skip_special_tokens=True)
171
+ parsed = _parse_json_loose(text)
172
+ return parsed
173
+ except Exception as e:
174
+ print('[warn] Flan generation failed:', e)
175
+ return _fallback_theta()
176
+
177
+
178
+ def _parse_json_loose(text: str) -> Dict[str,Any]:
179
+ try:
180
+ return json.loads(text)
181
+ except Exception:
182
+ s = text.find('{')
183
+ e = text.rfind('}')
184
+ if s != -1 and e != -1 and e > s:
185
+ try:
186
+ return json.loads(text[s:e+1])
187
+ except Exception:
188
+ pass
189
+ raise ValueError('Could not parse model output as JSON')
190
+
191
+
192
+ def _fallback_theta() -> Dict[str,Any]:
193
+ mu = [1.0, 0.9, 0.85, 0.7, 0.35]
194
+ k = [0.8, 0.9, 0.6, 0.5, 0.5]
195
+ sigma = [0.02, 0.015, 0.03, 0.04, 0.03]
196
+ U = [[0.0, 0.0],[0.0,0.0],[0.0,-0.2],[0.0,0.05],[0.0,0.0]]
197
+ V = [[0.0,0.0],[0.0,0.0],[0.0,0.0],[0.0,0.0],[0.0,-0.1]]
198
+ return {'mu':mu,'k':k,'A_lowrank':{'U':U,'V':V},'sigma':sigma}
199
+
200
+ # ---------------------------
201
+ # SDE simulator (Euler–Maruyama)
202
+ # ---------------------------
203
+
204
+ def _reconstruct_A(U: List[List[float]], V: List[List[float]]):
205
+ Ua = np.array(U); Va = np.array(V)
206
+ return Ua.dot(Va.T)
207
+
208
+
209
+ def simulate_sde(mu, k, A, sigma, X0, T=1.0, dt=0.002, n_samps=512, seed: int = SEED):
210
+ rng = np.random.default_rng(seed)
211
+ mu = np.array(mu); k = np.array(k); sigma = np.array(sigma); A = np.array(A)
212
+ d = len(X0); steps = int(T/dt)
213
+ X = np.tile(X0, (n_samps,1)).astype(float)
214
+ paths = np.zeros((n_samps,d,steps+1), dtype=float)
215
+ paths[:,:,0] = X
216
+ for i in range(steps):
217
+ drift_revert = - (X - mu) * k
218
+ drift_direct = X.dot(A.T)
219
+ drift = drift_revert + drift_direct
220
+ dW = rng.normal(scale=np.sqrt(dt), size=(n_samps,d))
221
+ diffusion = dW * sigma
222
+ X = X + drift * dt + diffusion
223
+ X = np.clip(X, 0.0, 1.5)
224
+ paths[:,:,i+1] = X
225
+ return paths
226
+
227
+ # ---------------------------
228
+ # Postprocess + decode
229
+ # ---------------------------
230
+ TEMPLATE_UTTERANCES = [
231
+ '(calm, structured) I appreciate the question. My approach is... [concise, no personal detail].',
232
+ '(guarded) I prefer to focus on the professional aspects.',
233
+ '(bold) I\'m willing to take that responsibility and here\'s why...',
234
+ '(hesitant) That\'s an interesting point β€” could you clarify?',
235
+ '(neutral) I tend to be methodical: step 1..., step 2...'
236
+ ]
237
+
238
+ def extract_modes_from_paths(paths: np.ndarray, n_modes: int = 3):
239
+ n_samps, d, steps = paths.shape
240
+ feats = np.concatenate([paths.mean(axis=2), paths[:,:, -1]], axis=1)
241
+ kmeans = KMeans(n_clusters=min(n_modes, n_samps), random_state=0).fit(feats)
242
+ modes = []
243
+ labels = kmeans.labels_
244
+ for mode in range(kmeans.n_clusters):
245
+ idx = np.where(labels == mode)[0]
246
+ weight = len(idx)/n_samps
247
+ mean_path = paths[idx].mean(axis=0) if len(idx)>0 else np.zeros((d, steps))
248
+ last_state = mean_path[:, -1]
249
+ modes.append({'mode': mode, 'weight': float(weight), 'last_state': last_state.tolist()})
250
+ modes = sorted(modes, key=lambda m: -m['weight'])
251
+ return modes
252
+
253
+
254
+ def decode_state(state_arr):
255
+ S, Emp, C, M, R = state_arr[:5]
256
+ if M > 0.8 and C > 0.8:
257
+ return TEMPLATE_UTTERANCES[0]
258
+ if M > 0.7 and Emp < 0.4:
259
+ return TEMPLATE_UTTERANCES[1]
260
+ if R > 0.6 and S > 0.8:
261
+ return TEMPLATE_UTTERANCES[2]
262
+ if Emp < 0.3 and R < 0.2:
263
+ return TEMPLATE_UTTERANCES[3]
264
+ return TEMPLATE_UTTERANCES[4]
265
+
266
+ # ---------------------------
267
+ # Simple profiler: scoring & question selection
268
+ # ---------------------------
269
+
270
+ def score_updates(answer: str):
271
+ updates = defaultdict(float)
272
+ ans = answer.lower()
273
+ for name, (pat, upd) in _PATTERNS.items():
274
+ if pat.search(ans):
275
+ for k,v in upd.items():
276
+ updates[k] += v
277
+ return updates
278
+
279
+
280
+ def apply_updates(session: SessionState, updates: Dict[str,float]):
281
+ for k,v in updates.items():
282
+ session.values[k] = min(1.0, max(0.0, session.values.get(k,0.5) + v))
283
+
284
+
285
+ def most_uncertain_dims(session: SessionState, k: int = 5):
286
+ uncertainties = [(label, abs(session.values[label]-0.5)) for label in LABELS]
287
+ return [label for label,_ in sorted(uncertainties, key=lambda x: x[1])[:k]]
288
+
289
+
290
+ def next_target(session: SessionState):
291
+ dims = most_uncertain_dims(session)
292
+ used = session.used_targets
293
+ available = [d for d in dims if d not in used]
294
+ if not available or len(used) >= len(LABELS)-1:
295
+ used.clear(); available = dims
296
+ last = session.last_target
297
+ if last and last in available and len(available)>1:
298
+ available.remove(last)
299
+ target = random.choice(available) if available else dims[0]
300
+ session.used_targets.add(target)
301
+ return target
302
+
303
+
304
+ def build_followup_prompt(prev_q: Optional[str], prev_a: Optional[str], target: str, session: SessionState):
305
+ top3 = most_uncertain_dims(session, k=3)
306
+ state_str = " | ".join(f"{d}:{session.values[d]:.2f}" for d in top3)
307
+ return (
308
+ f"Generate a short, unique question to probe {target.lower()}. Context: Previous question was '{prev_q or 'None'}'"
309
+ f" with answer '{prev_a or 'None'}'. Current state: {state_str}. Avoid repeating prior questions."
310
+ )
311
+
312
+
313
+ def get_initial_question(session: SessionState):
314
+ available = [q for q in INITIAL_QUESTIONS if q not in session.used_questions]
315
+ if not available:
316
+ session.used_questions.clear(); available = INITIAL_QUESTIONS
317
+ q = random.choice(available); session.used_questions.add(q)
318
+ return q
319
+
320
+ # ---------------------------
321
+ # Logging (local JSONL)
322
+ # ---------------------------
323
+ LOG_DIR = 'runs'
324
+ os.makedirs(LOG_DIR, exist_ok=True)
325
+ LOG_PATH = os.path.join(LOG_DIR, 'logs.jsonl')
326
+
327
+
328
+ def log_run(entry: Dict[str,Any]):
329
+ try:
330
+ with open(LOG_PATH, 'a', encoding='utf-8') as f:
331
+ f.write(json.dumps(entry, ensure_ascii=False) + '
332
+ ')
333
+ except Exception:
334
+ print('Warning: failed to write log')
335
+
336
+ # ---------------------------
337
+ # Gradio UI callbacks
338
+ # ---------------------------
339
+
340
+ def start_session() -> Tuple[str, Dict[str,float], str]:
341
+ sid = str(int(time.time()*1000))
342
+ SESSIONS[sid] = init_state()
343
+ q = get_initial_question(SESSIONS[sid])
344
+ # return session id, initial profile snapshot, first question
345
+ return sid, dict(SESSIONS[sid].values), q
346
+
347
+
348
+ def user_reply(session_id: str, user_input: str, use_flan: bool = True, model_id: str = MODEL_ID_DEFAULT, n_samps: int = 256):
349
+ # handle user reply, update profile, and produce next question
350
+ if session_id not in SESSIONS:
351
+ return 'ERROR: unknown session', {}, ''
352
+ session = SESSIONS[session_id]
353
+ cmd = user_input.strip().upper()
354
+ if cmd == 'RESET':
355
+ SESSIONS[session_id] = init_state(); q = get_initial_question(SESSIONS[session_id]);
356
+ return session_id, dict(SESSIONS[session_id].values), q
357
+ if cmd == 'STOP':
358
+ # finalize and run predict
359
+ out = predict_from_session(session, use_flan=use_flan, model_id=model_id, n_samps=n_samps)
360
+ entry = {'timestamp': time.time(), 'session_id': session_id, 'profile_start': dict(session.values), 'situation': out['prompt'], 'theta': out['theta'], 'modes': out['modes']}
361
+ log_run(entry)
362
+ return session_id, dict(session.values), 'FINAL:' + json.dumps({'modes': out['modes']}, default=str)
363
+
364
+ # normal flow: score, update, generate next question
365
+ updates = score_updates(user_input)
366
+ apply_updates(session, updates)
367
+ target = next_target(session)
368
+ session.last_target = target
369
+ prompt = build_followup_prompt(session.last_q, user_input, target, session)
370
+ # generate a question (lightweight) via Flan or fallback text
371
+ question = FALLBACK_QUESTIONS.get(target)
372
+ if use_flan:
373
+ try:
374
+ tokenizer, model = load_flan(model_id, DEVICE)
375
+ inputs = tokenizer(prompt, return_tensors='pt', truncation=True, max_length=512).to(model.device)
376
+ outs = model.generate(**inputs, max_new_tokens=40, do_sample=False)
377
+ q_text = tokenizer.decode(outs[0], skip_special_tokens=True).strip()
378
+ if q_text.endswith('?') and q_text not in session.used_questions and 'probe' not in q_text.lower():
379
+ question = q_text
380
+ except Exception as e:
381
+ print('Warn: question-gen failed:', e)
382
+ session.used_questions.add(question)
383
+ session.last_q = question
384
+ session.round += 1
385
+ session.history.append({'user': user_input, 'bot': question})
386
+ return session_id, dict(session.values), question
387
+
388
+
389
+ def predict_from_session(session: SessionState, use_flan: bool = True, model_id: str = MODEL_ID_DEFAULT, n_samps: int = 512):
390
+ prompt = build_prompt_from_profile(session)
391
+ if use_flan:
392
+ theta = flan_generate_params(prompt, model_id=model_id, device=DEVICE)
393
+ else:
394
+ theta = _fallback_theta()
395
+ mu = theta['mu']; k = theta['k']; sigma = theta['sigma']; U = theta['A_lowrank']['U']; V = theta['A_lowrank']['V']
396
+ A = _reconstruct_A(U, V)
397
+ X0 = np.array([session.values.get('Strategy',0.5), session.values.get('Empathy',0.5), session.values.get('Control',0.5), session.values.get('Masking',0.5), session.values.get('RiskAppetite',0.5)])
398
+ paths = simulate_sde(mu, k, A, sigma, X0, n_samps=n_samps)
399
+ modes = extract_modes_from_paths(paths, n_modes=3)
400
+ for m in modes:
401
+ m['utterance'] = decode_state(np.array(m['last_state']))
402
+ return {'modes': modes, 'prompt': prompt, 'theta': theta, 'paths': paths}
403
+
404
+
405
+ def plot_paths(paths: np.ndarray, labels: List[str] = None):
406
+ n_samps, d, steps = paths.shape
407
+ t = np.linspace(0,1,steps)
408
+ fig, ax = plt.subplots(figsize=(8,4))
409
+ mean = paths.mean(axis=0)
410
+ for i in range(d):
411
+ ax.plot(t, mean[i], label=(labels[i] if labels else f'dim{i}'))
412
+ ax.set_ylim(0,1.2)
413
+ ax.legend(loc='upper right')
414
+ ax.set_xlabel('Normalized time'), ax.set_ylabel('State')
415
+ plt.tight_layout()
416
+ return fig
417
+
418
+ # ---------------------------
419
+ # Gradio app layout
420
+ # ---------------------------
421
+ with gr.Blocks(title='Flan-SDE Behavioral Profiler') as demo:
422
+ gr.Markdown("# Flan-SDE Behavioral Profiler
423
+ Ask questions, build a profile, and simulate behavior using a Flan-T5 generated SDE.")
424
+ with gr.Row():
425
+ with gr.Column(scale=1):
426
+ start_btn = gr.Button('Start Session')
427
+ sid_out = gr.Textbox(label='Session ID')
428
+ profile_view = gr.JSON(label='Current Profile', interactive=False)
429
+ qbox = gr.Textbox(label='Bot question', interactive=False)
430
+ user_in = gr.Textbox(placeholder='Type your answer. Type STOP to finish, RESET to restart.')
431
+ send_btn = gr.Button('Send')
432
+ use_flan_chk = gr.Checkbox(value=True, label='Use real Flan-T5 (may be slow on CPU)')
433
+ model_in = gr.Textbox(value=MODEL_ID_DEFAULT, label='Flan model id')
434
+ n_samps_slider = gr.Slider(minimum=64, maximum=1024, value=256, step=64, label='Monte Carlo paths')
435
+ with gr.Column(scale=1):
436
+ out_console = gr.Textbox(label='Console', interactive=False)
437
+ modes_json = gr.JSON(label='Predicted Modes', interactive=False)
438
+ plot_out = gr.Plot(label='Trajectory (mean)')
439
+
440
+ def on_start():
441
+ sid, prof, q = start_session()
442
+ return sid, prof, q, ''
443
+
444
+ def on_send(sid, user_text, prof, q, use_flan, model_id, n_samps):
445
+ if not sid:
446
+ return gr.update(), {}, '', 'ERROR: start a session first', None, None
447
+ sid2, profdict, next_q = user_reply(sid, user_text, use_flan=use_flan, model_id=model_id, n_samps=int(n_samps))
448
+ # if STOP, user_reply returns FINAL:... as question; detect and run predict
449
+ if next_q.startswith('FINAL:'):
450
+ # extract modes from logged predict
451
+ try:
452
+ # get last log entry by reading file
453
+ with open(LOG_PATH, 'r', encoding='utf-8') as f:
454
+ lines = f.read().strip().split('
455
+ ')
456
+ last = json.loads(lines[-1]) if lines else None
457
+ modes = last.get('modes') if last else []
458
+ fig = plot_paths(np.array(modes[0]['paths']) if 'paths' in modes[0] else np.zeros((1,5,2)))
459
+ except Exception:
460
+ modes = []
461
+ fig = None
462
+ return sid2, profdict, '', json.dumps(modes), fig
463
+ else:
464
+ return sid2, profdict, next_q, '', None, None
465
+
466
+ start_btn.click(on_start, outputs=[sid_out, profile_view, qbox, out_console])
467
+ send_btn.click(on_send, inputs=[sid_out, user_in, profile_view, qbox, use_flan_chk, model_in, n_samps_slider], outputs=[sid_out, profile_view, qbox, out_console, modes_json, plot_out])
468
+
469
+ if __name__ == '__main__':
470
+ demo.launch()