1// ADJECTIVES + QUD MODEL
2// frankie + shane RSA project 
3​
4// code adapted from the Kao et al. hyperbole model + 
5// gradable adjectives & vagueness resolution model 
6​
7​
8var utterances = ["expensive", "notExpensive"]
9​
10var utterancePrior = function() {
11  return  uniformDraw(utterances)
12}
13​
14var thetaPrior = function() {
15  return uniformDraw(prices)
16}
17​
18// theta moderates interpretation of utterances
19var meaning = function(utterance, price, theta) {
20return utterance == "expensive" ? price >= theta : 
21  utterance == "notExpensive" ? price <= theta :
22  true
23}
24​
25// more words = higher cost 
26var cost = function(utterance) {
27  return utterance== 'notExpensive'? 1 :
28  0
29};
30​
31var prices = [
32  50, 
33  500,
34  1000,
35  5000,
36  10000
37]
38​
39var pricePrior = function() {
40  return categorical({
41    vs: prices,
42    ps: [
43      0.8070,
44      0.1070,
45      0.0434,
46      0.0223,
47      0.0203
48    ]
49  })
50}
51​
52var valencePrior = function(state) {
53  var probs = {
54    50 : 0.3173,
55    500 : 0.7920,
56    1000 : 0.8933,
57    5000 : 0.9524,
58    10000 : 0.9864
59  }
60  var tf = flip(probs[state])
61  return tf
62}
63​
64var qudFns = {
65  price : function(state) {return { price: state.price } },
66  valence : function(state) {return { valence: state.valence } },
67  priceValence : function(state) {
68    return { price: state.price, valence: state.valence }
69  }
70  }
71​
72var qudPrior = function() {
73  categorical({
74    vs: ["price", "valence", "priceValence"],
75    ps: [1, 1, 1]
76  })
77}
78​
79var literalListener = cache(function(utterance, qud, theta) {
80  return Infer({model: function(){
81    var price = uniformDraw(prices)
82    var valence = valencePrior(price)
83    var fullState = {price, valence}
84    var qudFn = qudFns[qud]
85    var qudAnswer = qudFn(fullState)
86    condition( meaning(utterance, price, theta) )
87    return qudAnswer
88  }
89               })})
90​
91// speaker optimality
92var alpha = 1
93​
94var speaker = cache(function(fullState, qud, theta) {
95  return Infer({model: function(){
96    var utterance = utterancePrior()
97    var qudFn = qudFns[qud]
98    var qudAnswer = qudFn(fullState)
99    factor(alpha*(literalListener(utterance,qud,theta).score(qudAnswer) 
100                  - cost(utterance)))
101    return utterance
102  }})
103})
104​
105var pragmaticListener = cache(function(utterance) {
106  return Infer({model: function(){
107    //////// priors ////////
108    var price = pricePrior()
109    var valence = valencePrior(price)
110    var qud = qudPrior()
111    var theta = thetaPrior()
112    ////////////////////////
113    var fullState = {price, valence}
114    observe(speaker(fullState, qud, theta), utterance)
115    return {price, valence}
116​
117  }})
118})
119​
120var listenerPosterior1 = pragmaticListener("expensive")
121var listenerPosterior2 = pragmaticListener('notExpensive')
122​
123print('Pragmatic listener hears "expensive":')
124viz(listenerPosterior1)
125print('Pragmatic listener hears "not expensive":')
126viz(listenerPosterior2)
127​
128var ANSWER = (pragmaticListener("expensive"));

1# RSA adjectives + QUD model (frankie + shane). Pragmatic listener hears "expensive";
2# query is the joint posterior over {price, valence}.
3# Every RSA level is a genuine Pyro enumerated model (config_enumerate +
4# TraceEnum_ELBO.compute_marginals); each level's normalized posterior comes from Pyro's
5# engine, and lower-level log-scores feed the next level only through pyro.factor.
6#
7# State = (price, valence) with valence|price ~ Bernoulli(valence_p[price]).
8# meaning depends only on price, so under L0 valence is conditionally independent of the
9# evidence given price: the L0 joint factors as L0(price)*prior(valence|price), where the
10# L0 price posterior is produced by Pyro inference (compute_marginals) and valence|price is
11# its (un-inferred) prior. The speaker scores L0's score of the QUD projection of its
12# fullState; the pragmatic listener enumerates (price, valence, qud, theta) and factors in
13# the speaker's log-score of "expensive".
14​
15utterances = ["expensive", "notExpensive"]
16prices = [50, 500, 1000, 5000, 10000]
17price_t = torch.tensor([float(p) for p in prices])
18price_prior = torch.tensor([0.8070, 0.1070, 0.0434, 0.0223, 0.0203])
19valence_p = torch.tensor([0.3173, 0.7920, 0.8933, 0.9524, 0.9864])  # P(valence=True | price)
20quds = ["price", "valence", "priceValence"]
21alpha = 1.0
22cost = {"expensive": 0.0, "notExpensive": 1.0}
23NEG = torch.tensor(float("-inf"))
24ZERO = torch.tensor(0.0)
25​
26def meaning_mask(utterance, theta):
27    if utterance == "expensive":
28        return price_t >= theta
29    return price_t <= theta  # notExpensive
30​
31# Literal listener L0: a Pyro enumerated model over price (uniformDraw over prices) with the
32# meaning factor. compute_marginals returns the normalized price posterior (log-probs).
33def literal_price_logprobs(utterance, theta):
34    mask = meaning_mask(utterance, theta)
35    @pyro.infer.config_enumerate
36    def m():
37        pi = pyro.sample("price", dist.Categorical(torch.ones(len(prices)) / len(prices)))
38        pyro.factor("meaning", torch.where(mask[pi], ZERO, NEG))
39        return None
40    marg = pyro.infer.TraceEnum_ELBO(max_plate_nesting=0).compute_marginals(m, lambda: None)
41    pm = marg["price"]
42    sup = pm.enumerate_support()
43    lp = pm.log_prob(sup)
44    out = torch.full((len(prices),), float("-inf"))
45    for j in range(len(sup)):
46        out[int(sup[j].item())] = lp[j]
47    return out
48​
49lit_cache = {}
50def literal_price_logprobs_cached(utterance, theta):
51    key = (utterance, round(float(theta), 6))
52    if key not in lit_cache:
53        lit_cache[key] = literal_price_logprobs(utterance, theta)
54    return lit_cache[key]
55​
56# L0 log-score of a QUD answer for the speaker's known fullState (price index pidx, valence v).
57# qud == price      : score = log L0price[pidx]
58# qud == valence    : score = log sum_p L0price[p] * P(v | p)
59# qud == priceValence: score = log( L0price[pidx] * P(v | pidx) )
60def l0_qud_logscore(utterance, theta, qud, pidx, v):
61    lpr = literal_price_logprobs_cached(utterance, theta)  # log P(price) under L0
62    pr = lpr.exp()
63    vp = valence_p if v else (1.0 - valence_p)
64    if qud == "price":
65        s = float(pr[pidx].item())
66    elif qud == "valence":
67        s = float((pr * vp).sum().item())
68    else:  # priceValence
69        s = float((pr[pidx] * vp[pidx]).item())
70    return math.log(s) if s > 0.0 else float("-inf")
71​
72# Speaker S1(utterance | fullState, qud, theta): Pyro enumerated model over utterances with
73# factor alpha*(logL0(qudAnswer|utt) - cost(utt)). compute_marginals normalizes.
74def speaker_logprobs(theta, qud, pidx, v):
75    score = torch.tensor([
76        alpha * (l0_qud_logscore(u, theta, qud, pidx, v) - cost[u]) for u in utterances
77    ])
78    @pyro.infer.config_enumerate
79    def m():
80        ui = pyro.sample("utt", dist.Categorical(torch.ones(len(utterances)) / len(utterances)))
81        pyro.factor("score", score[ui])
82        return None
83    marg = pyro.infer.TraceEnum_ELBO(max_plate_nesting=0).compute_marginals(m, lambda: None)
84    um = marg["utt"]
85    sup = um.enumerate_support()
86    lp = um.log_prob(sup)
87    out = torch.full((len(utterances),), float("-inf"))
88    for j in range(len(sup)):
89        out[int(sup[j].item())] = lp[j]
90    return out
91​
92target_idx = utterances.index("expensive")
93thetas = list(prices)  # thetaPrior = uniformDraw(prices)
94​
95# Speaker log-score of "expensive" indexed by (price index, valence in {0,1}, qud, theta).
96# Used as the pragmatic listener's factor.
97spk = {}
98for pidx in range(len(prices)):
99    for v in (True, False):
100        for qi, qud in enumerate(quds):
101            for ti, theta in enumerate(thetas):
102                spk[(pidx, int(v), qi, ti)] = speaker_logprobs(theta, qud, pidx, v)[target_idx]
103​
104spk_table = torch.zeros(len(prices), 2, len(quds), len(thetas))
105for (pidx, vi, qi, ti), val in spk.items():
106    spk_table[pidx, vi, qi, ti] = val
107​
108# Pragmatic listener L1: Pyro enumerated model over price, valence, qud, theta; factor in the
109# speaker's log-score of "expensive". infer_discrete draws joint (price, valence) posterior
110# samples (the query is a joint over two latents); aggregate the tuples into the distribution.
111@pyro.infer.config_enumerate
112def pragmatic_model():
113    pi = pyro.sample("price", dist.Categorical(price_prior))
114    vi = pyro.sample("valence", dist.Bernoulli(valence_p[pi]))
115    qi = pyro.sample("qud", dist.Categorical(torch.ones(len(quds)) / len(quds)))
116    ti = pyro.sample("theta", dist.Categorical(torch.ones(len(thetas)) / len(thetas)))
117    pyro.factor("speaker", spk_table[pi, vi.long(), qi, ti])
118    return pi, vi
119​
120serving = pyro.infer.infer_discrete(
121    pyro.infer.config_enumerate(pragmatic_model), first_available_dim=-1
122)
123​
124counts = Counter()
125N = 8000
126for _ in range(N):
127    pi, vi = serving()
128    p = prices[int(pi.item())]
129    v = bool(vi.item() > 0.5)
130    counts[(p, v)] += 1
131​
132_json = __import__("json")
133ANSWER = {
134    _json.dumps({"price": p, "valence": v}, sort_keys=True): c / N
135    for (p, v), c in counts.items()
136}
137​

1// Level of intelligence
2var states = [1,2,3,4]
3​
4// What can be said
5var utterances = ["", "dumb as rocks", "dumb", "f*cking idiot"]
6​
7// Correspondence of utterances to states
8var literalSemantics = {
9  "" : [.25,.25,.25,.25],
10  "dumb as rocks" : [0.45,0.85,0.20,.02],
11  "dumb" : [.85,.95,.02,.02],
12  "f*cking idiot" : [.95,.55,.02,.02]
13}
14​
15// Determine whether the utterance describes the state
16// Flip a coin with the literalSemantics weight
17// *state - 1 because of 0-indexing*
18var meaning = function(utterance, state){
19  return flip(literalSemantics[utterance][state - 1]);
20}
21​
22// Whether the speaker feels good or bad about the listener's action.
23// Speakers' attitudes toward the true state of the world (e.g., the valence of their affect), which is modeled simply as a binary positive/negative variable (representing whether or not the speaker is repulsed by the listener's behavior).
24var valencePrior = function(state) {
25  state === 1 ? flip(0.01) ? "good" : "bad" :
26  state === 2 ? flip(0.33) ? "good" : "bad" :
27  state === 3 ? flip(0.66) ? "good" : "bad" :
28  state === 4 ? flip(0.99) ? "good" : "bad" :
29  true}
30​
31// How amplified the speaker feels about the listener being dumb to different degrees.
32var arousals = ["low", "high"]
33​
34//How passionate/aroused the listener feels about how intelligent the person is
35var arousalPrior = function(state) {
36  state === 1 ? categorical([0.1, 0.9], arousals) :
37  state === 2 ? categorical([0.7, 0.3], arousals) :
38  state === 3 ? categorical([0.7, 0.3], arousals) :
39  state === 4 ? categorical([0.1, 0.9], arousals) :
40  true
41}
42​
43// A list of strings of QUD choices
44var goals = ["goalState", "goalValence", "goalArousal"]
45​
46// There are 3 possible goals with a flat prior
47var goalPrior = function() {
48  categorical([1, 1, 1], goals)
49}
50​
51// A speaker's goal is satisfied if the listener infers the correct
52// and relevant information.
53var goalState = function(goal, state, valence, arousal) {
54  goal === "goalState" ? state :
55  goal === "goalValence" ? valence :
56  goal === "goalArousal" ? arousal :
57  true
58}
59​
60// literal listener
61var literalListener = function(utterance, goal) {
62  Infer({model: function(){
63    var state = uniformDraw(states)
64    var valence = valencePrior(state)
65    var arousal = arousalPrior(state) 
66    var m = meaning(utterance, state);
67    condition(m);
68    return {QUDanswer: goalState(goal,state,valence,arousal), state: state}
69  }})
70}
71​
72// value function scales social utility by a parameter lambda
73var lambda = -1.25
74var valueFunction = function(s){
75  return lambda * s
76};
77​
78var alpha = 10
79var speaker1 = function(state, phi, goal, valence, arousal) {
80  Infer({model: function(){
81    var utterance = uniformDraw(utterances)
82    var QUDanswer = goalState(goal,state,valence,arousal)
83    var L0_posterior = literalListener(utterance,goal)
84    var L0_stateMarginal = marginalize(L0_posterior,"state")
85    var L0_qudAnswerMarginal = marginalize(L0_posterior,"QUDanswer")
86    var utility = {
87      epistemic: L0_qudAnswerMarginal.score(QUDanswer),
88      antisocial: expectation(L0_stateMarginal, valueFunction)
89    }
90    var speakerUtility = phi * utility.epistemic +
91                        (1 - phi) * utility.antisocial
92    factor(alpha * speakerUtility)
93    return utterance
94  }})
95}
96​
97//pragmatic listener 
98var pragmaticListener = function(utterance) {
99  Infer({model: function(){
100    var state = uniformDraw(states)
101    var valence = valencePrior(state)
102    var arousal = arousalPrior(state) 
103    var goal = goalPrior()
104//0.05 corresponds to the starting point of phi while 0.95 is the endpoint. 
105//The last 0.05 corresponds to the interval length
106    var phi = uniformDraw(_.range(0.05, 0.95, 0.05))
107    var S1 = speaker1(state, phi, goal, valence, arousal)
108    observe(S1, utterance)
109   return { state, phi, goal, valence, arousal }
110  }})
111}
112viz.marginals(pragmaticListener(""))
113viz.marginals(pragmaticListener("dumb as rocks"))
114viz.marginals(pragmaticListener("dumb"))
115viz.marginals(pragmaticListener("f*cking idiot"))
116​
117var ANSWER = marginalize(pragmaticListener("dumb as rocks"), "state");

1​
2states = [1, 2, 3, 4]
3utterances = ["", "dumb as rocks", "dumb", "f*cking idiot"]
4literalSemantics = {
5    "": [0.25, 0.25, 0.25, 0.25],
6    "dumb as rocks": [0.45, 0.85, 0.20, 0.02],
7    "dumb": [0.85, 0.95, 0.02, 0.02],
8    "f*cking idiot": [0.95, 0.55, 0.02, 0.02],
9}
10valence_good = {1: 0.01, 2: 0.33, 3: 0.66, 4: 0.99}
11arousal_low = {1: 0.1, 2: 0.7, 3: 0.7, 4: 0.1}
12goals = ["goalState", "goalValence", "goalArousal"]
13phis = [round(0.05 + 0.05 * i, 10) for i in range(18)]  # 0.05..0.90 step 0.05
14alpha = 10.0
15lam = -1.25
16valence_labels = ["good", "bad"]
17arousal_labels = ["low", "high"]
18​
19def _elbo():
20    return pyro.infer.TraceEnum_ELBO(max_plate_nesting=0)
21​
22_LL_CACHE = {}
23def literal_listener_marginals(utterance, goal):
24    key = (utterance, goal)
25    if key in _LL_CACHE:
26        return _LL_CACHE[key]
27    sem = torch.tensor(literalSemantics[utterance])
28​
29    @pyro.infer.config_enumerate
30    def model():
31        si = pyro.sample("state", dist.Categorical(torch.ones(4) / 4))
32        pg = torch.tensor([valence_good[s] for s in states])[si]
33        pyro.sample("valence", dist.Categorical(torch.stack([pg, 1 - pg], -1)))
34        pl = torch.tensor([arousal_low[s] for s in states])[si]
35        pyro.sample("arousal", dist.Categorical(torch.stack([pl, 1 - pl], -1)))
36        pyro.factor("meaning", torch.log(sem[si]))  # condition on literal meaning
37        return si
38​
39    marg = _elbo().compute_marginals(model, lambda: None)
40    _LL_CACHE[key] = marg
41    return marg
42​
43def qud_answer(goal, state, valence, arousal):
44    if goal == "goalState":
45        return ("state", state)
46    if goal == "goalValence":
47        return ("valence", valence)
48    return ("arousal", arousal)
49​
50def ll_logp_qud(utterance, goal, ans):
51    marg = literal_listener_marginals(utterance, goal)
52    kind, val = ans
53    if kind == "state":
54        d = marg["state"]; idx = states.index(val)
55    elif kind == "valence":
56        d = marg["valence"]; idx = valence_labels.index(val)
57    else:
58        d = marg["arousal"]; idx = arousal_labels.index(val)
59    return float(d.log_prob(torch.tensor(idx)))
60​
61def ll_state_expectation(utterance, goal):
62    d = literal_listener_marginals(utterance, goal)["state"]
63    sup = d.enumerate_support()
64    p = torch.exp(d.log_prob(sup))
65    return float(sum(lam * states[int(i)] * float(pp) for i, pp in zip(sup, p)))
66​
67_S1_CACHE = {}
68def speaker1(state, phi, goal, valence, arousal):
69    key = (state, phi, goal, valence, arousal)
70    if key in _S1_CACHE:
71        return _S1_CACHE[key]
72    ans = qud_answer(goal, state, valence, arousal)
73    utils = torch.tensor([
74        phi * ll_logp_qud(u, goal, ans) + (1 - phi) * ll_state_expectation(u, goal)
75        for u in utterances
76    ])
77​
78    @pyro.infer.config_enumerate
79    def model():
80        ui = pyro.sample("utt", dist.Categorical(torch.ones(len(utterances)) / len(utterances)))
81        pyro.factor("util", alpha * utils[ui])
82        return ui
83​
84    marg = _elbo().compute_marginals(model, lambda: None)["utt"]
85    _S1_CACHE[key] = marg
86    return marg
87​
88target = "dumb as rocks"
89target_idx = utterances.index(target)
90​
91# enumerated joint config space for the pragmatic listener
92cfgs = []
93for st in states:
94    for val in valence_labels:
95        for ar in arousal_labels:
96            for goal in goals:
97                for phi in phis:
98                    cfgs.append((st, val, ar, goal, phi))
99​
100# prior over each config (valence/arousal priors depend on state)
101prior = torch.tensor([
102    (1.0 / len(states))
103    * (valence_good[c[0]] if c[1] == "good" else 1 - valence_good[c[0]])
104    * (arousal_low[c[0]] if c[2] == "low" else 1 - arousal_low[c[0]])
105    * (1.0 / len(goals))
106    * (1.0 / len(phis))
107    for c in cfgs
108])
109​
110# speaker likelihood of the target utterance for each config (from S1 inference)
111lik = torch.tensor([
112    float(torch.exp(speaker1(c[0], c[4], c[3], c[1], c[2]).log_prob(torch.tensor(target_idx))))
113    for c in cfgs
114])
115​
116@pyro.infer.config_enumerate
117def pragmatic_model():
118    ci = pyro.sample("cfg", dist.Categorical(prior / prior.sum()))
119    pyro.factor("speaker", torch.log(lik[ci] + 1e-300))  # observe(S1, utterance)
120    return ci
121​
122cfg_marg = _elbo().compute_marginals(pragmatic_model, lambda: None)["cfg"]
123sup = cfg_marg.enumerate_support()
124p = torch.exp(cfg_marg.log_prob(sup))
125state_post = {s: 0.0 for s in states}
126for i, pp in zip(sup, p):
127    state_post[cfgs[int(i)][0]] += float(pp)
128​
129ANSWER = state_post
130​

1var marginalize = function(dist, key){
2  return Infer( {model: function(){
3  return sample(dist)[key];
4  }})
5};
6///
7 
8var icecream = {
9  "prices":  [1, 4, 6, 10, 14, 18, 22, 30, 34, 38],
10"probabilities": [0.01, 0.50, 0.85, 0.63, 0.35, 0.10, 0.04, 0.02, 0.02, 0.01]
11};
12 
13var statePrior = function() {
14  return categorical(icecream.probabilities, icecream.prices);
15};
16 
17var thetaPrior = function() {
18  return uniformDraw(icecream.prices);
19};
20 
21var alpha = 1; // optimality parameter
22 
23var utterances = ["expensive", "null", "cheap"];
24var cost = {
25  "expensive": 1,
26  "cheap": 2,
27  "null": 0
28};
29var utterancePrior = function() {
30  var uttProbs = map(function(u) {return Math.exp(-cost[u]) }, utterances);
31  return categorical(uttProbs, utterances);
32};
33 
34var meaning = function(utterance, price, theta) {
35  utterance == "expensive" ? price >= theta :
36  utterance == "cheap" ? price <= theta :
37  true
38};
39// QUDs
40var QUDs = ["expensive?","less than 15?","what is the price?"]
41var QUDPrior = function() {
42  //uniformDraw(QUDs)
43// categorical([1,10,1],QUDs)// this is equivalent to uniformDraw
44categorical([0,0,1],QUDs)// this is your baseline version
45}
46var QUDFun = function(QUD,state) {
47  QUD == "expensive?" ? state >= 15 :
48  QUD == "less than 15?" ? state <= 15 :
49  state;
50};
51 
52var literalListener = cache(function(utterance, theta, QUD) {
53  return Infer({model:function() {
54  var price = statePrior()
55  var qPrice = QUDFun(QUD,price)
56    condition(meaning(utterance, price, theta))
57  return qPrice;
58}})
59});
60 
61var speaker = cache(function(price, theta,QUD) {
62  return Infer( {model: function() {
63  var utterance = utterancePrior()
64  var qPrice= QUDFun(QUD, price)
65  factor( alpha * literalListener(utterance, theta, QUD).score(qPrice) );
66  return utterance;
67  }});
68});
69 
70var pragmaticListener = function(utterance) {
71  return Infer({model: function() {
72  var price = statePrior()
73  var theta = thetaPrior()
74  var QUD =QUDPrior()
75    factor(speaker(price, theta, QUD).score(utterance));
76  return { price: price, theta: theta, qud: QUD};
77  }})
78}
79 
80 
81 
82print ('cheap icecream')
83var expensiveIcecream = pragmaticListener('expensive');
84print(expectation(marginalize(expensiveIcecream, "price")))
85viz.hist(marginalize(expensiveIcecream, "price"));
86viz.hist(marginalize(expensiveIcecream, "theta"));
87viz.hist(marginalize(expensiveIcecream, "qud"));
88​
89var ANSWER = (expectation(marginalize(pragmaticListener('expensive'), 'price')));
90​