| """Pure-Python request contract and probability conversion.""" |
| import json, math |
|
|
| def text(value): |
| return value if isinstance(value,str) else json.dumps(value,ensure_ascii=False,sort_keys=True,separators=(',',':')) |
|
|
| def normalize_question(q): |
| if not isinstance(q,dict): raise ValueError('Each question must be an object.') |
| kind=q.get('type'); instruction=q.get('instructions') |
| if kind not in ('choice','score','noul'): raise ValueError('type must be choice, score, or noul') |
| if instruction is None or not text(instruction).strip(): raise ValueError('instructions must be nonempty') |
| instruction=text(instruction) |
| criteria=q.get('criteria') |
| if kind=='noul': |
| if criteria is not None: |
| if not isinstance(criteria,dict) or set(criteria)!={'true','false'}: raise ValueError('Noul criteria must contain true and false.') |
| instruction+='\nTrue means: '+text(criteria['true'])+'\nFalse means: '+text(criteria['false']) |
| return kind,instruction,[''],['true'] |
| if kind=='choice': |
| if not isinstance(criteria,dict) or not 2<=len(criteria)<=255: raise ValueError('Choice needs 2–255 named criteria.') |
| if any(not isinstance(k,str) or not k.strip() for k in criteria): raise ValueError('Choice keys must be nonempty strings.') |
| keys=list(criteria) |
| candidates=[k if v is None else text(v) for k,v in criteria.items()] |
| else: |
| if not isinstance(criteria,list) or not 2<=len(criteria)<=10: raise ValueError('Score needs 2–10 ordered criteria.') |
| candidates=[text(c) for c in criteria];keys=[str(i) for i in range(len(criteria))] |
| if kind=='score' and len(set(candidates))!=len(candidates): raise ValueError('Score criteria descriptions must be distinct.') |
| return kind,instruction,candidates,keys |
|
|
| def hypothesis(kind,instruction,candidate): |
| return instruction if kind=='noul' else instruction+'\nCandidate answer: '+candidate |
|
|
| def softmax(values): |
| m=max(values);ex=[math.exp(x-m) for x in values];s=sum(ex) |
| return [v/s for v in ex] |
|
|
| def probabilities(logits,kind,temperature=1.,bias=0.): |
| if not math.isfinite(temperature) or temperature<=0: raise ValueError('temperature must be positive and finite') |
| if not logits or any(not math.isfinite(x) for x in logits): raise ValueError('Nonfinite or empty logits') |
| if kind=='noul': |
| x=logits[0]/temperature+bias |
| p=1/(1+math.exp(-x)) if x>=0 else math.exp(x)/(1+math.exp(x)) |
| return [1-p,p] |
| return softmax([x/temperature for x in logits]) |
|
|
| def answer(kind,keys,candidates,probs): |
| if kind=='noul':return {'type':'noul','noul':probs[1],'stats':{}} |
| entropy=-sum(p*math.log(p) for p in probs if p>0) |
| confidence=max(0.,min(1.,(len(probs)*max(probs)-1)/(len(probs)-1) if kind=='choice' else 1-entropy/math.log(len(probs)))) |
| result={'type':kind,'probabilities':dict(zip(keys,probs)),'confidence':round(confidence,2),'stats':{}} |
| if kind=='choice':result['choice']=keys[max(range(len(probs)),key=probs.__getitem__)] |
| else: |
| result['score']=round(sum(i*p for i,p in enumerate(probs)),2) |
| result['legend']=dict(zip(keys,candidates)) |
| return result |
|
|
| def record_hypothesis(record,index): |
| candidate=record["candidates"][index] |
| if record["kind"]=="choice": |
| key=record["keys"][index] |
| if key!=candidate:candidate=key+": "+candidate |
| return hypothesis(record["kind"],record["instructions"],candidate) |
|
|
