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"));
129​

1var prices = [50, 500, 1000, 5000, 10000];
2var pricePrior = Categorical({vs: prices, ps: [0.8070, 0.1070, 0.0434, 0.0223, 0.0203]});
3​
4var valenceProbTable = {50: 0.3173, 500: 0.7920, 1000: 0.8933, 5000: 0.9524, 10000: 0.9864};
5var valencePrior = function(state) {
6  return flip(valenceProbTable[state]);
7};
8​
9var utterances = ["expensive", "notExpensive"];
10var utterancePrior = function() { return uniformDraw(utterances); };
11​
12var thetaPrior = function() { return uniformDraw(prices); };
13​
14var meaning = function(utterance, price, theta) {
15  return utterance === "expensive" ? price >= theta :
16         utterance === "notExpensive" ? price <= theta :
17         true;
18};
19​
20var cost = function(utterance) {
21  return utterance === "notExpensive" ? 1 : 0;
22};
23​
24var qudFns = {
25  price: function(state) { return {price: state.price}; },
26  valence: function(state) { return {valence: state.valence}; },
27  priceValence: function(state) { return {price: state.price, valence: state.valence}; }
28};
29​
30var qudPrior = function() {
31  return uniformDraw(["price", "valence", "priceValence"]);
32};
33​
34var alpha = 1;
35​
36var literalListener = mem(function(utterance, qud, theta) {
37  return Infer({method: 'enumerate'}, function() {
38    var price = sample(pricePrior);
39    var valence = valencePrior(price);
40    var fullState = {price: price, valence: valence};
41    var qudAnswer = qudFns[qud](fullState);
42    condition(meaning(utterance, price, theta));
43    return qudAnswer;
44  });
45});
46​
47var speaker = mem(function(fullState, qud, theta) {
48  return Infer({method: 'enumerate'}, function() {
49    var utterance = utterancePrior();
50    var L0 = literalListener(utterance, qud, theta);
51    var qudAnswer = qudFns[qud](fullState);
52    factor(alpha * (L0.score(qudAnswer) - cost(utterance)));
53    return utterance;
54  });
55});
56​
57var pragmaticListener = function(utterance) {
58  return Infer({method: 'enumerate'}, function() {
59    var price = sample(pricePrior);
60    var valence = valencePrior(price);
61    var qud = qudPrior();
62    var theta = thetaPrior();
63    var fullState = {price: price, valence: valence};
64    var S1 = speaker(fullState, qud, theta);
65    observe(S1, utterance);
66    return {price: price, valence: valence};
67  });
68};
69​
70var ANSWER = pragmaticListener("expensive");

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 = (pragmaticListener("dumb as rocks"));
118​

1var states = [1, 2, 3, 4];
2var utterances = ["", "dumb as rocks", "dumb", "f*cking idiot"];
3​
4var literalSemantics = {
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};
10​
11var meaning = function(utterance, state) {
12  return flip(literalSemantics[utterance][state - 1]);
13};
14​
15var valencePrior = function(state) {
16  return state === 1 ? (flip(0.01) ? "good" : "bad") :
17         state === 2 ? (flip(0.33) ? "good" : "bad") :
18         state === 3 ? (flip(0.66) ? "good" : "bad") :
19         (flip(0.99) ? "good" : "bad");
20};
21​
22var arousals = ["low", "high"];
23var arousalPrior = function(state) {
24  return state === 1 ? categorical({vs: arousals, ps: [0.1, 0.9]}) :
25         state === 2 ? categorical({vs: arousals, ps: [0.7, 0.3]}) :
26         state === 3 ? categorical({vs: arousals, ps: [0.7, 0.3]}) :
27         categorical({vs: arousals, ps: [0.1, 0.9]});
28};
29​
30var goals = ["goalState", "goalValence", "goalArousal"];
31var goalPrior = function() {
32  return categorical({vs: goals, ps: [1, 1, 1]});
33};
34​
35var goalState = function(goal, state, valence, arousal) {
36  return goal === "goalState" ? state :
37         goal === "goalValence" ? valence :
38         arousal;
39};
40​
41var literalListener = mem(function(utterance, goal) {
42  return Infer({method: 'enumerate'}, function() {
43    var state = uniformDraw(states);
44    var valence = valencePrior(state);
45    var arousal = arousalPrior(state);
46    condition(meaning(utterance, state));
47    var qudAnswer = goalState(goal, state, valence, arousal);
48    return {QUDanswer: qudAnswer, state: state};
49  });
50});
51​
52var lambda = -1.25;
53var valueFunction = function(s) { return lambda * s; };
54var alpha = 10;
55​
56var speaker1 = mem(function(state, phi, goal, valence, arousal) {
57  return Infer({method: 'enumerate'}, function() {
58    var utterance = uniformDraw(utterances);
59    var L0 = literalListener(utterance, goal);
60    var qudAnswer = goalState(goal, state, valence, arousal);
61    
62    // Epistemic utility: score of the QUD answer under L0
63    var epistemicUtility = L0.score({QUDanswer: qudAnswer, state: state});
64    
65    // Antisocial utility: expectation of valueFunction over L0 state marginal
66    var L0stateMarginal = Infer({method: 'enumerate'}, function() {
67      var sample = sample(L0);
68      return sample.state;
69    });
70    
71    var antisocialUtility = expectation(L0stateMarginal, valueFunction);
72    
73    var speakerUtility = phi * epistemicUtility + (1 - phi) * antisocialUtility;
74    factor(alpha * speakerUtility);
75    return utterance;
76  });
77});
78​
79var pragmaticListener = function(utterance) {
80  return Infer({method: 'enumerate'}, function() {
81    var state = uniformDraw(states);
82    var valence = valencePrior(state);
83    var arousal = arousalPrior(state);
84    var goal = goalPrior();
85    var phiVals = _.range(0.05, 0.95, 0.05);
86    var phi = uniformDraw(phiVals);
87    
88    var S1 = speaker1(state, phi, goal, valence, arousal);
89    observe(S1, utterance);
90    
91    return {state: state, phi: phi, goal: goal, valence: valence, arousal: arousal};
92  });
93};
94​
95var ANSWER = pragmaticListener("dumb as rocks");

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​

1var icecream = {
2  prices: [1, 4, 6, 10, 14, 18, 22, 30, 34, 38],
3  probabilities: [0.01, 0.50, 0.85, 0.63, 0.35, 0.10, 0.04, 0.02, 0.02, 0.01]
4};
5​
6var marginalize = function(dist, key) {
7  return Infer({method: 'enumerate'}, function() {
8    return sample(dist)[key];
9  });
10};
11​
12var statePrior = function() {
13  return categorical(icecream.probabilities, icecream.prices);
14};
15​
16var thetaPrior = function() {
17  return uniformDraw(icecream.prices);
18};
19​
20var alpha = 1;
21​
22var utterances = ["expensive", "null", "cheap"];
23var cost = {"expensive": 1, "cheap": 2, "null": 0};
24​
25var utterancePrior = function() {
26  return categorical(map(function(u) { return Math.exp(-cost[u]); }, utterances), utterances);
27};
28​
29var meaning = function(utterance, price, theta) {
30  return utterance === "expensive" ? price >= theta :
31         utterance === "cheap" ? price <= theta :
32         true;
33};
34​
35var QUDs = ["expensive?", "less than 15?", "what is the price?"];
36​
37var QUDPrior = function() {
38  return categorical([0, 0, 1], QUDs);
39};
40​
41var QUDFun = function(QUD, state) {
42  return QUD === "expensive?" ? state >= 15 :
43         QUD === "less than 15?" ? state <= 15 :
44         state;
45};
46​
47var literalListener = mem(function(utterance, theta, QUD) {
48  return Infer({method: 'enumerate'}, function() {
49    var price = statePrior();
50    condition(meaning(utterance, price, theta));
51    return QUDFun(QUD, price);
52  });
53});
54​
55var speaker = mem(function(price, theta, QUD) {
56  return Infer({method: 'enumerate'}, function() {
57    var utt = utterancePrior();
58    factor(alpha * literalListener(utt, theta, QUD).score(QUDFun(QUD, price)));
59    return utt;
60  });
61});
62​
63var pragmaticListener = function(utterance) {
64  return Infer({method: 'enumerate'}, function() {
65    var price = statePrior();
66    var theta = thetaPrior();
67    var QUD = QUDPrior();
68    factor(speaker(price, theta, QUD).score(utterance));
69    return {price: price, theta: theta, qud: QUD};
70  });
71};
72​
73var ANSWER = expectation(marginalize(pragmaticListener('expensive'), 'price'));