Tasks for the exercise session on June 23, 2005:

1/ as homework, you were to implement a _simulation_ of speech
recognition confidence -- here is a check-list:

-- in the text-based enviroment we've built so far, add
a text-based query to prompt the user to simulate (==type in)
the value of recognition-confidence after user-input nodes

-- btw, you need a variable for the value of the confidence
score... let's say the variable-name is conf_score
(since the value is to be read from a text console,
the variable type will be String)

-- the node for confidence score simulation is going
to read in the value of the confidence score --> in the Input
tab of the node, type the name of the variable you are reading;
in my case: conf_score

-- then, based on the simulated confidence score decide how
the system should proceed with the dialog:

for example, depending on a confidence threshold
you set, the system might accept the input, ask for
confirmation or reject the input

to model this you need a Condition node ("Conditional"
in the nodes popup menu) to branch the graph depending
on the confidence score value -- specify the appropriate
test in the Condition tab of this node -- for example,
if you want to accept inputs recognized with confidence
higher than e.g. 0.75 (75% confidence), type
parseReal(conf_score) > 0.75
(the built-in function 'real parseReal(string s)'
casts a String into a Real)

2/ btw (-; why we are doing this:  clarification strategies

now that you can simulate confidence scores you may
experiment a bit with different clarification strategies!

for example, you may extend the dialogs built in the class
by adding different reactions to unrecognized input, e.g.

(1) the simplest reaction might consist of informing
the user that the input was not recognized (_rejected_)
if recognition confidence score is below some value you set

(2) if confidence score falls within a certain range
you consider "safe enough", the strategy might be to
ask for _confirmation_;  e.g. "Did you mean What-Was-Recognized ?"

(3) if confidence score is above a certain threshold,
the system might _accept_ the input without confirmation

(4a) if the system rejects input more than some number
of times (provided you count the number of rejected
inputs, of course...), a strategy might be to offer a list
of inputs that the system can recognize as a form of
"multiple-choice" question -- the user would respond,
for instance, by providing the key associated
with the appropriate answer

(4b) alternatively (or following 4a if 4a doesn't
work) the system might offer the known inputs one
at a time asking yes/no questions after each;
e.g. "Did you mean Answer-1? Please answer Yes or No",
"Did you mean Answer-2? Please answer Yes or No", etc.

-------

at the class on Thursday, we will link the speech
recognizer and the synthesiser and start with
modularization

please send the xml files of the dialogs you'll have
built since last Thursday by around noon tomorrow
-- this is for us to have an idea how far you've
gone with the homework till then