Learning Caller Urgency
As part of the Aida project we want to handle incoming phone calls
and take appropriate action. A rough draft of our ideas in this direction is
outlined here.
The Idea
The idea is to allow some input from the caller. Ask them to specify the urgency of their call.So that we have two pieces of information about each
caller, caller ID and the urgency. We then want to determine the
urgency of the call as perceived by the client.
We also want to use some context,so the idea here is to allow the client to specify their current status.eg
- Working
- Working hard
- Do not disturb
- Lunch
- Break
- Out of Town
- Bathroom
- On Phone
- Meeting
Encoding the input
We could build a vector with one boolean component for each of the
possible status variables. These will be refered to as the client
weights.
In addition we could have two weights per caller,
- Caller importance
- Caller scaling factor
Encoding the Problem
So we have some feeling for what the input will be. It seems that the
simplest type of function for us to learn would be a -1,+1
classification of each call into either urgent or not urgent.
So for each call we have inputs as described above and we want to
classify the call as either urgent or not urgent.
We will have two weights for each caller as described above and we will
have several client weights which will be shared across callers. There
will be one client weight per possible state.
- Need a default caller, so that if a caller has not called before we can
do something.
- Need to move from default to specific as we learn more about a caller.
(Use a prior ??)
- Need to have different learning rates for the different parts of the
weight vector. Anneal the weights (maybe also look at tracking)
- Need a test set.
- The client attributes will be learnt on all calls - we can anneal the
learning rate.
- The caller attributes will be learnt only on calls from that caller.
- The learning of the client attributes is shared across callers.
How to predict ?
Clearly, we want to predict using the weights for this caller and the
client weights.
A first choice would be to predict with the dot product.
How to learn ?
Clearly, we only want to update the weights used for the prediction.
But there are many issues.
- Normalization ?
- Anneal the learning rate ?
- Update ?
nigeduff@cse.ucsc.edu,