def compositional_disjunction():
lexica = Lexica(baselexicon={
p: [w1, w2],
q: [w1, w3],
pandq: [w1]
},
costs={
p: 0.0,
q: 0.0,
pandq: 1.0
},
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=1.0)
lexica.display()
mod = Pragmod(lexica=lexica.lexica2matrices(),
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
prior=np.repeat(1.0 / len(lexica.states),
len(lexica.states)),
lexprior=np.repeat(1.0 / len(lexica), len(lexica)),
temperature=1.0,
alpha=1.0,
beta=1.0)
mod.run_expertise_model(n=2, display=True, digits=2)
def explore_listener_parameters(self):
"""Explore a large parameter space, classifying the parameter vectors
based on the max listener <world,lex> inference given self.msg"""
results = defaultdict(list)
for dcost, alpha, beta, depth in product(self.dcosts,
self.alphas,
self.betas,
self.depths):
params = {'alpha': alpha,
'beta': beta,
'depth': depth,
'disjunction_cost': dcost}
lexica = Lexica(
baselexicon=self.baselexicon,
costs=self.lexical_costs,
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=dcost,
unknown_word=self.unknown_word)
lexmats = lexica.lexica2matrices()
mod = Pragmod(
lexica=lexmats,
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
prior=np.repeat(1.0/len(lexica.states), len(lexica.states)),
lexprior=np.repeat(1.0/len(lexmats), len(lexmats)),
temperature=1.0,
alpha=alpha,
beta=beta)
# Run the model:
langs = mod.run_expertise_model(n=depth, display=False)
# Get the listener's joint probability table for this message:
msg_index = mod.messages.index(self.msg)
prob_table = langs[-1][msg_index]
sorted_probs = sorted(prob_table.flatten())
max_pair = None
max_prob = sorted_probs[-1]
# No ties allowed!
if max_prob != sorted_probs[-2]:
for i, j in product(list(range(prob_table.shape[0])),
list(range(prob_table.shape[1]))):
if prob_table[i, j] == max_prob:
max_pair = (i, mod.states[j])
# Add the target probability:
params['prob'] = max_prob
# Print to show progress:
print(max_pair, params)
# Store this dictionary of results -- parameters plus the predicted probability
# max_pair is a lexicon index and state name.
results[max_pair].append(params)
return results
def explore_listener_parameters(self):
"""Explore a large parameter space, classifying the parameter vectors
based on the max listener <world,lex> inference given self.msg"""
results = defaultdict(list)
for dcost, alpha, beta, depth in product(self.dcosts, self.alphas,
self.betas, self.depths):
params = {
'alpha': alpha,
'beta': beta,
'depth': depth,
'disjunction_cost': dcost
}
lexica = Lexica(baselexicon=self.baselexicon,
costs=self.lexical_costs,
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=dcost,
unknown_word=self.unknown_word)
lexmats = lexica.lexica2matrices()
mod = Pragmod(lexica=lexmats,
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
prior=np.repeat(1.0 / len(lexica.states),
len(lexica.states)),
lexprior=np.repeat(1.0 / len(lexmats), len(lexmats)),
temperature=1.0,
alpha=alpha,
beta=beta)
# Run the model:
langs = mod.run_expertise_model(n=depth, display=False)
# Get the listener's joint probability table for this message:
msg_index = mod.messages.index(self.msg)
prob_table = langs[-1][msg_index]
sorted_probs = sorted(prob_table.flatten())
max_pair = None
max_prob = sorted_probs[-1]
# No ties allowed!
if max_prob != sorted_probs[-2]:
for i, j in product(list(range(prob_table.shape[0])),
list(range(prob_table.shape[1]))):
if prob_table[i, j] == max_prob:
max_pair = (i, mod.states[j])
# Add the target probability:
params['prob'] = max_prob
# Print to show progress:
print(max_pair, params)
# Store this dictionary of results -- parameters plus the predicted probability
# max_pair is a lexicon index and state name.
results[max_pair].append(params)
return results
def simple_disjunction():
lexicon = np.array([[1.0, 1.0, 0.0], [1.0, 0.0, 1.0], [1.0, 0.0, 0.0],
[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
mod = Pragmod(lexica=None,
messages=[p, q, pandq, porq, NULL_MSG],
states=[w1, w2, w3],
costs=np.array([0.0, 0.0, 1.0, 1.0, 5.0]),
prior=np.repeat(1.0 / 4.0, 3),
lexprior=None,
temperature=1.0,
alpha=1.0,
beta=0.0)
mod.run_base_model(lexicon, n=2, display=True, digits=2)
def simple_scalar_inference_example():
def lexicon_iterator():
mats = [
np.array([[0., 1., 1.], [0., 0., 1.], [1., 1., 1.]]),
np.array([[0., 1., 0.], [0., 0., 1.], [1., 1., 1.]]),
np.array([[0., 0., 1.], [0., 0., 1.], [1., 1., 1.]])]
for mat in mats:
yield mat
mod = Pragmod(
lexica=lexicon_iterator,
messages=['A scored', 'A aced', 'NULL'],
states=['N', 'S', 'A'],
temperature=1.0,
nullmsg=True,
nullcost=5.0)
mod.stream_lexical_uncertainty(n=0)
for lex in lexicon_iterator():
print("=" * 70)
print("Messages")
display_matrix(lex, rnames=mod.messages, cnames=mod.states, digits=2)
print('l0')
display_matrix(mod.l0(lex), rnames=mod.messages, cnames=mod.states, digits=2)
print('s1')
display_matrix(mod.s1(lex), rnames=mod.states, cnames=mod.messages, digits=2)
print('l1')
display_matrix(mod.L(mod.S(lex)), rnames=mod.messages, cnames=mod.states, digits=2)
display_matrix(mod.final_listener, rnames=mod.messages, cnames=mod.states, digits=2)
def simple_disjunction():
lexicon = np.array([[1.0, 1.0, 0.0],
[1.0, 0.0, 1.0],
[1.0, 0.0, 0.0],
[1.0, 1.0, 1.0],
[1.0, 1.0, 1.0]])
mod = Pragmod(
lexica=None,
messages=[p, q, pandq, porq, NULL_MSG],
states=[w1, w2, w3],
costs=np.array([0.0, 0.0, 1.0, 1.0, 5.0]),
prior=np.repeat(1.0/4.0, 3),
lexprior=None,
temperature=1.0,
alpha=1.0,
beta=0.0)
mod.run_base_model(lexicon, n=2, display=True, digits=2)
def generic_disjunction_example(alpha=1.0,
beta=1.0,
disjunction_cost=1.0,
n=2,
fulldisplay=False,
unknown_word=None):
"""Common code for our two illustrative examples, which
differ only in the above keyword parameters. Increase n to see
greater depths of recursion. use fulldisplay=True to see more
details."""
# Use the lexicon generation convenience function to
# generate all the join-closure lexica and calculate
# the necessary message costs:
lexica = Lexica(baselexicon={
'A': ['1'],
'B': ['2'],
'X': ['1', '2']
},
costs={
'A': 0.0,
'B': 0.0,
'X': 0.0
},
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=disjunction_cost,
unknown_word=unknown_word)
# Lexical matrices:
lexmats = lexica.lexica2matrices()
# Pragmatic models for the above lexical space.
mod = Pragmod(lexica=lexmats,
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
prior=np.repeat(1.0 / len(lexica.states),
len(lexica.states)),
lexprior=np.repeat(1.0 / len(lexmats), len(lexmats)),
temperature=1.0,
alpha=alpha,
beta=beta)
if fulldisplay:
lexica.display()
# Run the base model on the individual lexica so we can show
# those lower steps:
for lex in lexmats:
print("=" * 70)
print(mod.lex2str(lex))
mod.run_base_model(lex, n=2, display=True, digits=2)
## Run the anxious experts model - fulldisplay=True for a fuller picture:
langs = mod.run_expertise_model(n=n, display=fulldisplay, digits=2)
# Look at the specific table we care about:
msg_index = mod.messages.index('A v X')
final_listener = langs[-1]
mod.display_joint_listener(final_listener[msg_index], digits=2)
return langs
def I_implicature_simulation_datapoint(common_ref_prob,
dcost=1.0,
alpha=2.0):
# Values to obtain:
is_max = False
listener_val = None
speaker_val = None
# Set-up:
lexica = Lexica(baselexicon=BASELEXICON,
costs=LEXICAL_COSTS,
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=dcost)
ref_probs = np.array([
common_ref_prob, (1.0 - common_ref_prob) / 2.0,
(1.0 - common_ref_prob) / 2.0
])
lexprior = np.repeat(1.0 / len(lexica.lexica2matrices()),
len(lexica.lexica2matrices()))
# Run the model:
mod = Pragmod(lexica=lexica.lexica2matrices(),
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
lexprior=lexprior,
prior=ref_probs,
alpha=alpha)
langs = mod.run_expertise_model(n=3, display=False, digits=2)
# Get the values we need:
speaker = mod.speaker_lexical_marginalization(langs[-2])
listener = mod.listener_lexical_marginalization(langs[-3])
superkind_term_index = mod.messages.index(SUPERKIND_MSG)
common_state_index = mod.states.index(COMMON_REF)
disj_term_index = mod.messages.index(DISJ_MSG)
disj_state_index = mod.states.index(DISJ_REF)
# Fill in listener_val and speaker_val:
listener_val = listener[superkind_term_index, common_state_index]
speaker_val = speaker[disj_state_index, disj_term_index]
# Determine whether max, with a bit of rounding to avoid
# spurious mismatch diagnosis:
maxspkval = np.max(speaker[disj_state_index])
is_max = np.round(speaker_val, 10) == np.round(maxspkval, 10)
# Return values:
return (listener_val, speaker_val, is_max)
def Q_implicature_simulation_datapoint(specific_cost,
dcost=1.0,
alpha=2.0):
# Values to obtain:
is_max = False
listener_val = None
speaker_val = None
# Set-up:
lexica = Lexica(baselexicon=BASELEXICON,
costs={
GENERAL_MSG: 0.0,
SPECIFIC_MSG: specific_cost
},
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=dcost)
ref_probs = np.repeat(1.0 / len(lexica.states), len(lexica.states))
lexprior = np.repeat(1.0 / len(lexica.lexica2matrices()),
len(lexica.lexica2matrices()))
# Run the model:
mod = Pragmod(lexica=lexica.lexica2matrices(),
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
lexprior=lexprior,
prior=ref_probs,
alpha=alpha)
langs = mod.run_expertise_model(n=3, display=False, digits=2)
# Get the values we need:
speaker = mod.speaker_lexical_marginalization(langs[-2])
listener = mod.listener_lexical_marginalization(langs[-3])
general_msg_index = lexica.messages.index(GENERAL_MSG)
general_only_state = lexica.states.index(GENERAL_ONLY_REF)
disj_state_index = lexica.states.index(DISJ_REF)
disj_msg_index = lexica.messages.index(DISJ_MSG)
speaker_val = speaker[disj_state_index, disj_msg_index]
listener_val = listener[general_msg_index, general_only_state]
# Determine whether max, with a bit of rounding to avoid spurious
# mismatch diagnosis:
maxspkval = np.max(speaker[disj_state_index])
is_max = np.round(speaker_val, 10) == np.round(maxspkval, 10)
# Return values:
return (listener_val, speaker_val, is_max)
def I_implicature_simulation_datapoint(
common_ref_prob, dcost=1.0, alpha=2.0):
# Values to obtain:
is_max = False
listener_val = None
speaker_val = None
# Set-up:
lexica = Lexica(
baselexicon=BASELEXICON,
costs=LEXICAL_COSTS,
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=dcost)
ref_probs = np.array([common_ref_prob, (1.0-common_ref_prob)/2.0,
(1.0-common_ref_prob)/2.0])
lexprior = np.repeat(1.0/len(lexica.lexica2matrices()),
len(lexica.lexica2matrices()))
# Run the model:
mod = Pragmod(
lexica=lexica.lexica2matrices(),
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
lexprior=lexprior,
prior=ref_probs,
alpha=alpha)
langs = mod.run_expertise_model(n=3, display=False, digits=2)
# Get the values we need:
speaker = mod.speaker_lexical_marginalization(langs[-2])
listener = mod.listener_lexical_marginalization(langs[-3])
superkind_term_index = mod.messages.index(SUPERKIND_MSG)
common_state_index = mod.states.index(COMMON_REF)
disj_term_index = mod.messages.index(DISJ_MSG)
disj_state_index = mod.states.index(DISJ_REF)
# Fill in listener_val and speaker_val:
listener_val = listener[superkind_term_index, common_state_index]
speaker_val = speaker[disj_state_index, disj_term_index]
# Determine whether max, with a bit of rounding to avoid
# spurious mismatch diagnosis:
maxspkval = np.max(speaker[disj_state_index])
is_max = np.round(speaker_val, 10) == np.round(maxspkval, 10)
# Return values:
return (listener_val, speaker_val, is_max)
def Q_implicature_simulation_datapoint(
specific_cost, dcost=1.0, alpha=2.0):
# Values to obtain:
is_max = False
listener_val = None
speaker_val = None
# Set-up:
lexica = Lexica(
baselexicon=BASELEXICON,
costs={GENERAL_MSG: 0.0, SPECIFIC_MSG: specific_cost},
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=dcost)
ref_probs = np.repeat(1.0/len(lexica.states), len(lexica.states))
lexprior = np.repeat(1.0/len(lexica.lexica2matrices()),
len(lexica.lexica2matrices()))
# Run the model:
mod = Pragmod(
lexica=lexica.lexica2matrices(),
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
lexprior=lexprior,
prior=ref_probs,
alpha=alpha)
langs = mod.run_expertise_model(n=3, display=False, digits=2)
# Get the values we need:
speaker = mod.speaker_lexical_marginalization(langs[-2])
listener = mod.listener_lexical_marginalization(langs[-3])
general_msg_index = lexica.messages.index(GENERAL_MSG)
general_only_state = lexica.states.index(GENERAL_ONLY_REF)
disj_state_index = lexica.states.index(DISJ_REF)
disj_msg_index = lexica.messages.index(DISJ_MSG)
speaker_val = speaker[disj_state_index, disj_msg_index]
listener_val = listener[general_msg_index, general_only_state]
# Determine whether max, with a bit of rounding to avoid spurious
# mismatch diagnosis:
maxspkval = np.max(speaker[disj_state_index])
is_max = np.round(speaker_val, 10) == np.round(maxspkval, 10)
# Return values:
return (listener_val, speaker_val, is_max)
def compositional_disjunction():
lexica = Lexica(
baselexicon={p: [w1, w2], q: [w1, w3], pandq:[w1]},
costs={p:0.0, q:0.0, pandq:1.0},
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=1.0)
lexica.display()
mod = Pragmod(
lexica=lexica.lexica2matrices(),
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
prior=np.repeat(1.0/len(lexica.states), len(lexica.states)),
lexprior=np.repeat(1.0/len(lexica), len(lexica)),
temperature=1.0,
alpha=1.0,
beta=1.0)
mod.run_expertise_model(n=2, display=True, digits=2)
def embedded_disjunction_example(refinable={}):
players = [a,b]
shots = [s1,s2]
worlds = get_worlds(basic_states=(0,1,2,3), length=2, increasing=False)
baselexicon = define_lexicon(player=players, shot=shots, worlds=worlds)
subjs = ('every_player', )
preds = ('hit_shot1', 'hit_shot2', 'hit_shot1_or_shot2', 'hit_shot1_and_shot2')
temperature = 1.0
nullmsg = True
nullcost = 5.0
# N: no shots; 1: made just shot1; 2: made just shot2; B: made both shot1 and shot2.
new_worldnames = (lambda w : "".join(["N12B"[i] for i in w]))
worldnames = [new_worldnames(w) for w in worlds]
messages = []
for subj, pred in product(subjs, preds):
msg = "%s %s" % (subj.replace("_", " "), pred)
formula = "iv(%s, %s)" % (subj, pred)
messages.append((msg, formula))
# Refinement model:
gram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=copy(worlds),
refinable=refinable,
nullmsg=nullcost)
mod = Pragmod(
lexica=gram.lexicon_iterator,
baselexicon=gram.baselexicon_mat,
messages=gram.messages,
states=worldnames,
temperature=temperature,
nullmsg=nullmsg,
nullcost=nullcost)
mod.stream_lexical_uncertainty(n=0)
display_matrix(
mod.final_listener,
rnames=mod.messages,
cnames=mod.states,
digits=2,
latex=True)
def generic_disjunction_example(
alpha=1.0,
beta=1.0,
disjunction_cost=1.0,
n=2,
fulldisplay=False,
unknown_word=None):
"""Common code for our two illustrative examples, which
differ only in the above keyword parameters. Increase n to see
greater depths of recursion. use fulldisplay=True to see more
details."""
# Use the lexicon generation convenience function to
# generate all the join-closure lexica and calculate
# the necessary message costs:
lexica = Lexica(
baselexicon={'A': ['1'], 'B': ['2'], 'X':['1', '2']},
costs={'A':0.0, 'B':0.0, 'X':0.0},
join_closure=True,
nullsem=True,
nullcost=5.0,
disjunction_cost=disjunction_cost,
unknown_word=unknown_word)
# Lexical matrices:
lexmats = lexica.lexica2matrices()
# Pragmatic models for the above lexical space.
mod = Pragmod(
lexica=lexmats,
messages=lexica.messages,
states=lexica.states,
costs=lexica.cost_vector(),
prior=np.repeat(1.0/len(lexica.states), len(lexica.states)),
lexprior=np.repeat(1.0/len(lexmats), len(lexmats)),
temperature=1.0,
alpha=alpha,
beta=beta)
if fulldisplay:
lexica.display()
# Run the base model on the individual lexica so we can show
# those lower steps:
for lex in lexmats:
print("=" * 70)
print(mod.lex2str(lex))
mod.run_base_model(lex, n=2, display=True, digits=2)
## Run the anxious experts model - fulldisplay=True for a fuller picture:
langs = mod.run_expertise_model(n=n, display=fulldisplay, digits=2)
# Look at the specific table we care about:
msg_index = mod.messages.index('A v X')
final_listener = langs[-1]
mod.display_joint_listener(final_listener[msg_index], digits=2)
return langs
def basic_scalar():
lexica = [
np.array([[1.0, 1.0], [1.0, 0.0], [1.0, 1.0]]),
np.array([[1.0, 0.0], [1.0, 0.0], [1.0, 1.0]]),
np.array([[0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
]
mod = Pragmod(lexica=lexica,
messages=['cheap', 'free', NULL_MSG],
states=[w1, w2],
costs=np.array([0.0, 0.0, 5.0]),
prior=np.repeat(1.0 / 2.0, 2),
lexprior=np.repeat(1.0 / 3.0, 3),
temperature=1.0,
alpha=1.0,
beta=2.0)
for lex in lexica:
print("=" * 70)
print(mod.lex2str(lex))
mod.run_base_model(lex, n=2, display=True, digits=2)
mod.run_expertise_model(n=3, display=True, digits=2)
def basic_scalar():
lexica = [np.array([[1.0,1.0], [1.0, 0.0], [1.0, 1.0]]),
np.array([[1.0,0.0], [1.0, 0.0], [1.0, 1.0]]),
np.array([[0.0,1.0], [1.0, 0.0], [1.0, 1.0]])]
mod = Pragmod(lexica=lexica,
messages=['cheap', 'free', NULL_MSG],
states=[w1, w2],
costs=np.array([0.0, 0.0, 5.0]),
prior=np.repeat(1.0/2.0, 2),
lexprior=np.repeat(1.0/3.0, 3),
temperature=1.0,
alpha=1.0,
beta=2.0)
for lex in lexica:
print("=" * 70)
print(mod.lex2str(lex))
mod.run_base_model(lex, n=2, display=True, digits=2)
mod.run_expertise_model(n=3, display=True, digits=2)
def scalar_disjunction_example(refinable={}):
players = [a]
shots = ['1', '2', 'f']
regular_shots = ['1', '2']
worlds = [("-",), ('f',), ('1',), ('2',), ('f1',), ('f2',), ('12',), ('f12',)]
lexicon = {
"player": players,
"PlayerA": [[a]],
"shot1": [['1']],
"shot2": [['2']],
"the_freethrow": [X for X in powerset(shots) if 'f' in X],
"hit": [[w, x, y] for w, x, y in product(worlds, players, shots)
if y in set(w[players.index(x)])],
"some_shot": [Y for Y in powerset(shots) if len(set(regular_shots) & set(Y)) > 0],
"only_some_shot": [Y for Y in powerset(shots) if len(set(regular_shots) & set(Y)) == 1],
"every_shot": [Y for Y in powerset(shots) if set(regular_shots) <= set(Y)],
"not_every_shot": [Y for Y in powerset(set(shots))
if not(set(regular_shots) <= set(Y))],
"AND": [[X, Y, [z for z in X if z in Y]]
for X, Y in product(list(powerset(powerset(shots))), repeat=2)],
"OR": [[X, Y, [z for z in X]+[z for z in Y if z not in X]]
for X, Y in product(list(powerset(powerset(shots))), repeat=2)],
"XOR": [[X, Y, [z for z in X if z not in Y]+[z for z in Y if z not in X]]
for X, Y in product(list(powerset(powerset(shots))), repeat=2)]}
# Import the new lexicon into the namespace:
for word, sem in list(lexicon.items()):
setattr(sys.modules[__name__], word, sem)
new_worldnames = (lambda x : "".join(map(str,x)))
worldnames = [new_worldnames(w) for w in worlds]
# Messages:
messages = [
("PlayerA hit the freethrow", "iv(PlayerA, tv(hit, the_freethrow, self.worlds, player))"),
("PlayerA hit every shot", "iv(PlayerA, tv(hit, every_shot, self.worlds, player))"),
("PlayerA hit some shot", "iv(PlayerA, tv(hit, some_shot, self.worlds, player))"),
("PlayerA hit some shot or the freethrow", "iv(PlayerA, tv(hit, coord(OR, some_shot, the_freethrow), self.worlds, player))"),
("PlayerA hit some shot and the freethrow", "iv(PlayerA, tv(hit, coord(AND, some_shot, the_freethrow), self.worlds, player))"),
("PlayerA hit every shot or the freethrow", "iv(PlayerA, tv(hit, coord(OR, every_shot, the_freethrow), self.worlds, player))"),
("PlayerA hit every shot and freethrow", "iv(PlayerA, tv(hit, coord(AND, every_shot, the_freethrow), self.worlds, player))")]
temperature = 1.0
nullmsg = True
nullcost = 5.0
# Refinement model:
gram = UncertaintyGrammars(
baselexicon=copy(lexicon),
messages=copy(messages),
worlds=copy(worlds),
refinable=refinable,
nullmsg=nullcost)
mod = Pragmod(
lexica=gram.lexicon_iterator,
baselexicon=gram.baselexicon_mat,
messages=gram.messages,
states=worldnames,
temperature=temperature,
nullmsg=nullmsg,
nullcost=nullcost)
# Model run:
mod.stream_lexical_uncertainty(n=0)
display_matrix(mod.final_listener, rnames=mod.messages, cnames=mod.states, digits=2, latex=True)
def parameter_exploration(
experiment_src=None,
rescaler=None,
output_filename=None,
response_transformation=None):
# Parameter space:
temps = np.concatenate((np.arange(0.1, 2.1, 0.1), np.arange(2.0, 6.0, 1)))
depths = [0, 1, 2, 3, 4, 5]
nullcosts = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
# General settings:
subjs= ('every_player', 'exactly_one_player', 'no_player')
objs = ('every_shot', 'no_shot', 'some_shot')
players = [a,b,c]
shots = [s1,s2]
basic_states = (0,1,2)
worlds = get_worlds(basic_states=(0,1,2), length=3, increasing=True)
baselexicon = define_lexicon(player=players, shot=shots, worlds=worlds)
nullmsg = True
worldnames = [worldname(w) for w in worlds]
messages = []
for d1, d2 in product(subjs, objs):
subj = d1.replace("_player", "(player)")
obj = d2.replace("_shot", "(shot)")
msg = "%s(hit(%s))" % (subj, obj)
formula = "iv(%s, tv(hit, %s, self.worlds, player))" % (d1, d2)
messages.append((msg, formula))
with open(output_filename, 'w') as output_file:
writer = csv.DictWriter(output_file,
fieldnames=['Experiment', 'Listener', 'lambda', 'depth', 'nullcost'] + \
['Pearson', 'Pearson p', 'Spearman', 'Spearman p', 'MSE'])
writer.writeheader()
# Runs:
for temperature, n, nullcost in product(temps, depths, nullcosts):
print(("{} {} {}".format(temperature, n, nullcost)))
neogram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=copy(worlds),
refinable={'some_player': ['exactly_one_player'],
'some_shot': ['exactly_one_shot']},
nullmsg=nullcost)
neomod = Pragmod(
name="NeoGricean",
lexica=neogram.lexicon_iterator,
baselexicon=neogram.baselexicon_mat,
messages=neogram.messages,
states=worldnames,
temperature=temperature,
nullmsg=nullmsg,
nullcost=nullcost)
ucgram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=copy(worlds),
refinable={'some_player': [], 'some_shot': []},
nullmsg=nullcost)
ucmod = Pragmod(
name="Unconstrained",
lexica=ucgram.lexicon_iterator,
baselexicon=ucgram.baselexicon_mat,
messages=ucgram.messages,
states=worldnames,
temperature=temperature,
nullmsg=nullmsg,
nullcost=nullcost)
ucmod.stream_lexical_uncertainty(n=n)
neomod.stream_lexical_uncertainty(n=n)
analysis = Analysis(
experiment=Experiment(
src_filename=experiment_src,
response_transformation=response_transformation),
models=[ucmod, neomod],
rescaler=rescaler)
results = analysis.numeric_analysis()
for key, vals in list(results.items()):
vals['Listener'] = key
vals['Experiment'] = experiment_src
vals['lambda'] = temperature
vals['depth'] = n
vals['nullcost'] = nullcost
writer.writerow(vals)
def experimental_assessment(
experiment_src=None,
plot_output_filename=None,
response_transformation=None,
rescaler=None,
uctemp=1.0,
ucnullcost=5.0,
ngtemp=1.0,
ngnullcost=5.0,
nrows=None):
# General settings:
subjs= ('every_player', 'exactly_one_player', 'no_player')
objs = ('every_shot', 'no_shot', 'some_shot')
players = [a,b,c]
shots = [s1,s2]
basic_states = (0,1,2)
worlds = get_worlds(basic_states=(0,1,2), length=3, increasing=True)
baselexicon = define_lexicon(player=players, shot=shots, worlds=worlds)
temperature = 1.0
nullmsg = True
nullcost = 5.0
worldnames = [worldname(w) for w in worlds]
messages = []
for d1, d2 in product(subjs, objs):
subj = d1.replace("_player", "(player)")
obj = d2.replace("_shot", "(shot)")
msg = "%s(hit(%s))" % (subj, obj)
formula = "iv(%s, tv(hit, %s, self.worlds, player))" % (d1, d2)
messages.append((msg, formula))
# Unconstrained refinement:
ucgram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=copy(worlds),
refinable={'some_player': [], 'some_shot': []},
nullmsg=nullmsg)
ucmod = Pragmod(
name="Unconstrained",
lexica=ucgram.lexicon_iterator,
baselexicon=ucgram.baselexicon_mat,
messages=ucgram.messages,
states=worldnames,
temperature=uctemp,
nullmsg=nullmsg,
nullcost=ucnullcost)
# Neo-Gricean refinement:
neogram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=copy(worlds),
refinable={'some_player': ['exactly_one_player'],
'some_shot': ['exactly_one_shot']},
nullmsg=nullmsg)
neomod = Pragmod(
name="Neo-Gricean",
lexica=neogram.lexicon_iterator,
baselexicon=neogram.baselexicon_mat,
messages=neogram.messages,
states=worldnames,
temperature=ngtemp,
nullmsg=nullmsg,
nullcost=ngnullcost)
# Run the models, going only to the first uncertainty listener (n=0):
ucmod.stream_lexical_uncertainty(n=0)
neomod.stream_lexical_uncertainty(n=0)
# The analysis:
analysis = Analysis(
experiment=Experiment(
src_filename=experiment_src,
response_transformation=response_transformation),
models=[ucmod, neomod],
rescaler=rescaler)
analysis.overall_analysis()
analysis.analysis_by_message()
analysis.comparison_plot(output_filename=plot_output_filename, nrows=nrows)
def complex_example():
# General settings:
players = [a,b]
shots = [s1,s2]
worlds = get_worlds(basic_states=(0,1,2), length=2, increasing=False)
baselexicon = define_lexicon(player=players, shot=shots, worlds=worlds)
subjs = ('PlayerA', 'PlayerB', 'some_player', 'every_player', 'no_player')
preds = ('scored', 'aced')
temperature = 1.0
nullmsg = True
nullcost = 5.0
worldnames = [worldname(w) for w in worlds]
messages = []
for subj, pred in product(subjs, preds):
msg = "%s %s" % (subj.replace("_", " "), pred)
formula = "iv(%s, %s)" % (subj, pred)
messages.append((msg, formula))
# Neo-Gricean refinement:
neogram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=worlds,
refinable={'some_player': ['exactly_one_player'],
'PlayerA': ['only_PlayerA'],
'PlayerB': ['only_PlayerB'],
'scored': ['scored_not_aced'],
'aced': []},
nullmsg=nullmsg)
neomod = Pragmod(
lexica=neogram.lexicon_iterator,
baselexicon=neogram.baselexicon_mat,
messages=neogram.messages,
states=worldnames,
temperature=temperature,
nullmsg=nullmsg,
nullcost=nullcost)
# Run and report:
neomod.stream_lexical_uncertainty(n=0)
neomod.listener_report(digits=2)
# Unconstrained refinement:
ucgram = UncertaintyGrammars(
baselexicon=copy(baselexicon),
messages=copy(messages),
worlds=worlds,
refinable={'some_player': [],
'PlayerA': [],
'PlayerB': [],
'scored': [],
'aced': []},
nullmsg=nullmsg)
ucmod = Pragmod(
lexica=ucgram.lexicon_iterator,
baselexicon=ucgram.baselexicon_mat,
messages=ucgram.messages,
states=worldnames,
temperature=temperature,
nullmsg=nullmsg,
nullcost=nullcost)
# Run and report:
ucmod.stream_lexical_uncertainty(n=0)
ucmod.listener_report(digits=2)