public void addTransition(string machine, string srcState, string dstState, double prob)
{
AltBot.writeDebugLine("MSM: addTransition({0},{1},{2},{3})", machine, srcState, dstState, prob);
string machineSrcState = machine + ":" + srcState;
string machineDstState = machine + ":" + dstState;
addMachineState(machine, srcState);
addMachineState(machine, dstState);
try
{
double newSum = prob;
if (transitionCounts.ContainsKey(machineSrcState))
{
newSum = newSum + (double)transitionCounts[machineSrcState];
}
transitionCounts[machineSrcState] = newSum;
string atomicKey = machineSrcState + " " + machineDstState;
atomicTransitionCount[atomicKey] = prob;
transSum += prob;
}
catch
{
AltBot.writeDebugLine("addTransition fail {0} {1} {2}", machineSrcState, machineDstState, prob);
}
}
public void addEvidenceState(string machine, string srcState, string evidence, double prob)
{
AltBot.writeDebugLine("MSM: addEvidenceState({0},{1},{2},{3})", machine, srcState, evidence, prob);
lastDefEvidence = evidence;
string machineSrcState = machine + ":" + srcState;
addMachineState(machine, srcState);
try
{
if (evidenceStateProbability.ContainsKey(evidence))
{
((Hashtable)evidenceStateProbability[evidence])[machineSrcState] = prob;
}
else
{
Hashtable emitter = new Hashtable();
emitter.Add(machineSrcState, prob);
evidenceStateProbability.Add(evidence, emitter);
}
}
catch
{
AltBot.writeDebugLine("addEvidenceState fail {0} {1} {2}", machineSrcState, evidence, prob);
}
}
public double getTransitionProb(string machine, string srcState, string dstState)
{
AltBot.writeDebugLine("MSM: getTransitionProb({0},{1},{2})", machine, srcState, dstState);
string machineSrcState = machine + ":" + srcState;
string machineDstState = machine + ":" + dstState;
try
{
string atomicKey = machineSrcState + " " + machineDstState;
double pSum = (double)transitionCounts[machineSrcState];
double pNom = (double)atomicTransitionCount[atomicKey];
double tp = (pNom / pSum);
if (pSum < 0.9)
{
tp = tp * 0.1;
}
if (tp > 0.9)
{
tp = 0.9;
}
if (tp < 0.0001)
{
tp = 0.0001;
}
return(tp);
}
catch
{
//AltBot.writeDebugLine(" missing Transition {0} -- {1} ", srcState, dstState);
return((double)0.0001);
}
}
protected override Unifiable ProcessChangeU()
{
if (CheckNode("evidencepattern"))
{
try
{
var varMSM = botActionMSM;
string payload = templateNodeInnerText.ToValue(query);
string evidence = GetAttribValue("evidence", varMSM.lastDefEvidence);
string prob_str = GetAttribValue("prob", "1.0");
double prob = double.Parse(prob_str);
//string quote = "" + '\u0022' + "";
string quote = "'";
string evidenceCode =
//@"<aiml graph=" + quote + "msm" + quote + ">" +
@"<topic name=" + quote + "CEP" + quote + " > <category><pattern>" + payload + "</pattern>" +
@"<template><think><setevidence evidence=" + quote + evidence + quote +
@" prob=" + quote + prob_str + quote +
@" /></think>ep " + evidence + "</template></category></topic>";
//@"</aiml>";
//Proc.AddAiml(evidenceCode);
GraphMaster myGraph = request.GetGraph("msm");
AddSideEffect("ADD AIML " + evidenceCode, () => Proc.AddAiml(myGraph, evidenceCode));
AltBot.writeDebugLine("MSM: evidence_pattern evidenceCode = {0}", evidenceCode);
}
catch (Exception e)
{
writeToLogWarn("MSMWARN: " + e);
}
}
return(Unifiable.Empty);
}
private void populateFromCyc()
{
TheBot.AddExcuteHandler("cycl", ExecCycQuery);
TheBot.AddExcuteHandler("subl", EvalSubLHandler);
int id = 1;
FileStream f = HostSystem.Open("nodes.txt", FileMode.Create);
TextWriter tw = new StreamWriter(f);
foreach (var item in cycAccess.converseList("(ask-template '?R '(#$and (#$genls ?R #$Communicating)(#$not (#$isa ?R #$NonVerbalCommunicating))) #$EverythingPSC)"))
{
string text = item.ToString();
string s =
"<Shape ID='" + id++ +
"' NameU='Decision' Type='Shape' Master='0'><XForm><PinX>0.984251968503937</PinX><PinY>11.02362204724409</PinY><Width Unit='MM' F='Inh'>0.984251968503937</Width><Height Unit='MM' F='Inh'>0.5905511811023623</Height><LocPinX Unit='MM' F='Inh'>0.4921259842519685</LocPinX><LocPinY Unit='MM' F='Inh'>0.2952755905511811</LocPinY><Angle F='Inh'>0</Angle><FlipX F='Inh'>0</FlipX><FlipY F='Inh'>0</FlipY><ResizeMode F='Inh'>0</ResizeMode></XForm><Event><TheData F='No Formula'>0</TheData><TheText F='No Formula'>0</TheText><EventDblClick F='Inh'>0</EventDblClick><EventXFMod F='No Formula'>0</EventXFMod><EventDrop F='No Formula'>0</EventDrop></Event><vx:Event xmlns:vx='http://schemas.microsoft.com/visio/2006/extension'><vx:EventMultiDrop F='No Formula'>0</vx:EventMultiDrop></vx:Event><LayerMem><LayerMember>0</LayerMember></LayerMem><Text>" +
text + "</Text></Shape>";
tw.WriteLine(s);
}
tw.Close();
try
{
f.Close();
}
catch (Exception)
{
}
AltBot.writeDebugLine("!NonVerbalCommunicating = " + id);
//cycAccess.setCyclist("CycAdministrator");
}
public override float CanUnify(Unifiable with)
{
if (templateNode.NodeType == XmlNodeType.Text)
{
return(Proc.TheCyc.IsaFilter(with, templateNode.InnerText) ? ISA_TRUE : ISA_FALSE);
}
if (templateNode.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in templateNode.ChildNodes)
{
try
{
Unifiable processChildNode = ProcessChildNode(childNode);
if (!Proc.TheCyc.IsaFilter(with, processChildNode))
{
return(ISA_FALSE);
}
SetWith(childNode, with);
}
catch (Exception e)
{
AltBot.writeDebugLine("" + e);
}
}
return(ISA_TRUE);
}
return(ISA_TRUE);
}
protected override Unifiable ProcessChangeU()
{
if (CheckNode("responsetopic"))
{
try
{
var varMSM = botActionMSM;
string payload = templateNodeInnerText.ToValue(query);
string payload2 = Recurse();
string payload3 = InnerXmlText(templateNode);
string machine = GetAttribValue("machine", varMSM.lastDefMachine);
string myState = GetAttribValue("state", varMSM.lastDefState);
string myTopic = GetAttribValue("topic", null);
string prob_str = GetAttribValue("prob", "0.1");
double prob = double.Parse(prob_str);
payload= payload.Replace("rcategory", "category");
payload= payload.Replace("rpattern", "pattern");
string responseCode = "<aiml graph=\"msm\"> <topic name=\"" + myTopic + "\"> " + payload + " </topic> </aiml>";
AltBot.writeDebugLine("MSM: response_topic ResponseCode = {0}", responseCode);
MachineSideEffect(() => varMSM.addResponse(machine, myState, myTopic, prob));
// TODO: define machine-state -> topic
AddSideEffect("Add AIML " + responseCode, () => TargetBot.AddAiml(responseCode));
}
catch (Exception e)
{
writeToLogWarn("MSMWARN: " + e);
}
}
return Unifiable.Empty;
}
public void setState(string machine, string state, double prob)
{
AltBot.writeDebugLine("MSM: setState({0},{1},{2})", machine, state, prob);
addMachineState(machine, state);
string machineState = machine + ":" + state;
cur_machineStateVal[machineState] = prob;
}
public static List <Unifiable> UnifyStars(string target, string source)
{
var matchVars = new List <object>();
string me = RegExFrom(target, matchVars);
MatchCollection mc = Regex.Matches(source, me, RegexOptions.IgnoreCase);
if (mc.Count == 0)
{
if (matchVars.Count == 0)
{
return(SUCCEED_NOVARS);
}
AltBot.writeDebugLine("DEBUG9: UnifyStars '" + me + "'!='" + source + "'");
return(null);
}
if (mc.Count != matchVars.Count)
{
if (mc.Count == 1)
{
Match mc1 = mc[0];
if (mc1.Success)
{
int mcLength = mc1.Length;
if (mcLength > 0)
{
if (mcLength == source.Length)
{
return(new List <Unifiable>()
{
source
});
}
}
}
AltBot.writeDebugLine("ERROR: UnifyStars '" + me + "'!='" + source + "'");
return(null);
}
}
int mi = 0;
var results = new List <Unifiable>(mc.Count);
foreach (Match match in mc)
{
string mv = match.Value;
object mp = matchVars[mi];
if (UnifyValues(mp, mv))
{
results.Add(mv);
}
else
{
return(null);
}
}
return(results);
}
private static T GetDictData0 <T>(IList <T> unifiables, string name, int startChars, out bool found) where T : IConvertible
{
string s = name.Substring(startChars);
if (s == "*" || s == "ALL" || s == "0")
{
StringAppendableUnifiableImpl result = Unifiable.CreateAppendable();
foreach (T u in unifiables)
{
result.Append(u.ToString());
}
found = true;
return(PASSTHRU <T>(result));
}
int uc = unifiables.Count;
bool fromend = false;
if (s.StartsWith("-"))
{
fromend = true;
s = s.Substring(1);
}
int i = Int32.Parse(s);
if (i == 0)
{
if (uc == 0)
{
found = true;
return(PASSTHRU <T>(""));
}
}
int ii = i - 1;
if (fromend)
{
ii = uc - i;
}
if (uc == 0)
{
AltBot.writeDebugLine(" !ERROR -star underflow! " + i + " in " + name);
found = false;
return(PASSTHRU <T>(String.Empty));
}
if (ii >= uc || ii < 0)
{
AltBot.writeDebugLine(" !ERROR -star badindexed 0 < " + i + " < " + uc + " in " + name);
found = false;
return(unifiables[ii]);
}
found = true;
return(unifiables[ii]);
}
public void defState(string machine, string state, double initProb, double selfProb)
{
AltBot.writeDebugLine("MSM: defState({0},{1},{2},{3})", machine, state, initProb, selfProb);
machines[machine] = 1;
lastDefState = state;
string machineState = machine + ":" + state;
addMachineState(machine, state);
setState(machine, state, initProb);
addTransition(machine, state, state, selfProb);
}
protected override Unifiable ProcessChangeU()
{
if (templateNode.Name.ToLower() == "Processmsm")
{
string machine = GetAttribValue("name", null);
string line = templateNodeInnerText.ToValue(query);
AltBot.writeDebugLine("\n\n >>>>>>>>>>>>>>>>>>>>>> PROCESSMSM : |{0}|<<<<<<<<<<<<<<<<<<<<", line);
Unifiable results = null;
MachineSideEffect(() => { results = ProcessChangeMSM(); });
return(results);
}
return(Unifiable.Empty);
}
public void addResponse(string machine, string myState, string myTopic, double prob)
{
addMachineState(machine, myState);
AltBot.writeDebugLine("MSM: addResponse({0},{1},{2},{3})", machine, myState, myTopic, prob);
string machineSrcState = machine + ":" + myState;
if (!machineStateResponses.ContainsKey(machineSrcState))
{
Hashtable h = new Hashtable();
h[myTopic] = prob;
machineStateResponses[machineSrcState] = h;
}
((Hashtable)machineStateResponses[machineSrcState])[myTopic] = prob;
}
internal void Invoke(string prefix)
{
try
{
if (prefix != null)
{
AltBot.writeDebugLine(prefix + "INVOKING: " + Name);
}
Value.Invoke();
}
catch (Exception e)
{
AltBot.writeDebugLine("ERROR " + prefix + " in " + this + "\n -reason: " + e);
}
}
private object EvalSubLHandler(string cmd, Request user)
{
try
{
return(EvalSubL(cmd, null));
}
catch (Exception e)
{
TheBot.writeToLog(e);
string s = "EvalSubLHandler: " + e;
AltBot.writeDebugLine(s);
writeToLog(s);
return(null);
}
}
public TemplateInfoImpl(Unifiable pattern, XmlNode cateNode, XmlNode templateNode,
LoaderOptions options, Unifiable responseInfo,
Unifiable guard, Unifiable topicInfo, Node patternNode, Unifiable thatInfo)
: base(pattern, cateNode, options)
{
if (templateNode == null || responseInfo.FullPath == Unifiable.Empty)
{
throw new NotImplementedException();
}
TemplateRating = 1.0;
Guard = guard;
if ((thatInfo != null && !thatInfo.IsCatchAll) || (guard != null && !guard.IsCatchAll) ||
(topicInfo != null && !topicInfo.IsCatchAll))
{
IsHighlyUsefull = true;
}
//CategoryXml = cateNode;
That = thatInfo;
Response = responseInfo;
Topic = topicInfo;
Pattern = pattern;
GraphmasterNode = patternNode;
srcNode = templateNode;
//ParentCategoryInfo = categoryInfo;
try
{
{
bool doCut;
if (StaticXMLUtils.TryParseBool(templateNode, "cut", out doCut) || StaticXMLUtils.TryParseBool(cateNode, "cut", out doCut))
{
NeckCut = doCut;
}
}
string scoreString = StaticXMLUtils.GetAttribValue(templateNode, "score", null);
scoreString = scoreString ?? StaticXMLUtils.GetAttribValue(cateNode, "score", null);
TemplateRating = scoreString != null?double.Parse(scoreString) : 1.0;
}
catch
{
}
if (TemplateRating != 1.0)
{
AltBot.writeDebugLine("!! SCORE =" + TemplateRating + " for " + this);
}
}
public override float CanUnify(Unifiable with)
{
if (templateNode.NodeType == XmlNodeType.Text)
{
string srch = ToUpper(" " + with.ToValue(query) + " ");
return((ToUpper(" " + templateNode.InnerText + " ").Equals(srch)) ? STAR_TRUE : STAR_FALSE);
}
if (templateNode.HasChildNodes)
{
{
Unifiable rest = with;
// recursively check
foreach (XmlNode childNode in templateNode.ChildNodes)
{
with = rest.First;
rest = rest.Rest;
try
{
if (childNode.NodeType == XmlNodeType.Text)
{
string srch = ToUpper(" " + with.ToValue(query) + " ");
return((ToUpper(" " + templateNode.InnerText + " ").Equals(srch))
? STAR_TRUE
: STAR_FALSE);
}
AIMLTagHandler part = GetChildTagHandler(childNode);
if (part.CallCanUnify(with) > 0)
{
return(STAR_FALSE);
}
}
catch (Exception e)
{
AltBot.writeDebugLine("" + e);
}
}
return(IsNullOrEmpty(rest) ? STAR_TRUE : STAR_FALSE);
}
}
return(IsNullOrEmpty(with) ? STAR_TRUE : STAR_FALSE);
}
public static void DoAll(Stack <NamedAction> todo)
{
lock (todo)
{
while (todo.Count > 0)
{
NamedAction undo = todo.Pop();
if (undo != null)
{
try
{
undo.Invoke("UNSTACK ");
}
catch (Exception exception)
{
AltBot.writeDebugLine("ERROR in DoAll " + exception);
}
}
}
}
}
public static R FromLoaderOper <R>(Func <R> action, GraphMaster gm, LoaderOptions loadOpts)
{
OutputDelegate prev = userTraceRedir;
try
{
userTraceRedir = gm.writeToLog;
try
{
if (!loadOpts.NeedsLoaderLock)
{
return(action());
}
lock (ErrorList)
{
lock (gm.LockerObject)
{
return(action());
}
}
}
catch (Exception e)
{
AltBot.writeDebugLine("ERROR: LoaderOper {0}", e);
if (!ChatOptions.AllowRuntimeErrors)
{
return(default(R));
}
throw;
//return default(R);
}
}
finally
{
userTraceRedir = prev;
}
}
private object ExecCycQuery(string cmd, Request user)
{
try
{
if (String.IsNullOrEmpty(cmd))
{
return("NIL");
}
Unifiable ss = EvalSubL("(cyc-query '" + cmd + " #$EverythingPSC)", null);
if (Unifiable.IsFalse(ss))
{
return(Unifiable.Empty);
}
return(ss);
}
catch (Exception e)
{
TheBot.writeToLog(e);
string s = "ExecCycQuery: " + e;
AltBot.writeDebugLine(s);
writeToLog(s);
return(null);
}
}
public void setEvidence(string evidence, double evidenceProb)
{
AltBot.writeDebugLine("MSM: setEvidence({0},{1})", evidence, evidenceProb);
currentEvidence.Add(evidence, evidenceProb);
}
public void WriteConfig()
{
AltBot.writeDebugLine("Cyc loaded");
}
public static Unifiable AltStar(string name, SubQuery query, ISettingsDictionary dict, out bool rfound)
{
try
{
if (name.Contains(","))
{
foreach (string subname in NamesStrings(name))
{
var val = AltStar(name, query, dict, out rfound);
if (rfound)
{
rfound = true;
return(val);
}
}
}
if (name.StartsWith("star_"))
{
return(GetDictData(query.InputStars, name, 5, out rfound));
}
else if (name.StartsWith("inputstar_"))
{
return(GetDictData(query.InputStars, name, 10, out rfound));
}
else if (name.StartsWith("input_"))
{
return(GetDictData(query.InputStars, name, 6, out rfound));
}
else if (name.StartsWith("thatstar_"))
{
return(GetDictData(query.ThatStars, name, 9, out rfound));
}
else if (name.StartsWith("that_"))
{
return(GetDictData(query.ThatStars, name, 5, out rfound));
}
else if (name.StartsWith("topicstar_"))
{
return(GetDictData(query.TopicStar, name, 10, out rfound));
}
else if (name.StartsWith("topic_"))
{
return(GetDictData(query.TopicStar, name, 6, out rfound));
}
else if (name.StartsWith("guardstar_"))
{
return(GetDictData(query.GuardStar, name, 10, out rfound));
}
else if (name.StartsWith("guard_"))
{
return(GetDictData(query.GuardStar, name, 6, out rfound));
}
else if (name.StartsWith("@"))
{
Unifiable value = query.Request.TargetBot.SystemExecute(name, null, query.Request);
rfound = true;
if (!IsNullOrEmpty(value))
{
return(value);
}
return(value);
}
else if (name.StartsWith("%dictvar_"))
{
Unifiable value = value = GetValue(query, dict, name.Substring(8), out rfound);
if (rfound)
{
return(value);
}
return(value);
}
else
{
if (name.StartsWith("%") || name.StartsWith("$"))
{
string str = name.Substring(1);
var vv = ResolveVariableValue(str, query, dict, out rfound);
if (rfound)
{
return(vv);
}
return(vv);
}
else if (name.Contains("."))
{
var vv = ResolveVariableValue(name, query, dict, out rfound);
if (rfound)
{
return(vv);
}
return(vv);
}
rfound = false;
return(name);
}
}
catch (Exception e)
{
AltBot.writeDebugLine("" + e);
rfound = false;
return(null);
}
}
internal static void writeToLog(string message, params object[] args)
{
AltBot.writeDebugLine("QUERYTRACE: " + message, args);
}
private void writeToLog(string s, params object[] args)
{
AltBot.writeDebugLine("" + this + " " + s, args);
}
public string advanceMachine(string machine)
{
if (!machineStates.ContainsKey(machine))
{
return("");
}
// Cycle through the machine staes
Hashtable statesHash = (Hashtable)machineStates[machine];
string guessPath = "";
int output = 0;
// ok, start guessing
string lastArgMax = "<idle>";
// The storage mechanism
double smoother = 0.00001; // 1 / transSum;
// ensure a transition count for each state
foreach (string stateKey in statesHash.Keys)
{
string mStateKey = machine + ":" + stateKey;
if (!transitionCounts.ContainsKey(mStateKey))
{
transitionCounts[mStateKey] = (double)0.01;
}
}
// what is the emission probability ?
// use a bayesian assumption and use the chain rule
// under Zubek
// Bt(s) = Sum_foreach Si in States{ p(S|Si) * q(Y|S) *Bt-1(Si) * Ns,t }
// and q(Y|S) = Et(Y) * g(S|Y) *N
// where E(Y) is evidence estimation
// and g(S|Y) is likelyhood of observing Y when in state S
// see zubek dissertation p.148 Naive implementation
// for each target state S, iterate over all possible source states Si
// summing up previous source state belief b(Si) at t-1 * transition prob p(S|Si)
// also sum up products of evidence g(Y|s) * evidence e(Y) over evidence types
// multiply the two gives raw belief estimate for state S
// normalize to get final belief value
double bestVal = 0;
string bestGuess = "";
double Nsum = 0;
ArrayList stateKeys = new ArrayList();
foreach (string astate in statesHash.Keys)
{
string machineState = machine + ":" + astate;
stateKeys.Add(machineState);
}
//foreach (string next_state in statesHash.Keys)
//{
// string nextSrcMachineState = machine + ":" + next_state;
foreach (string nextSrcMachineState in stateKeys)
{
double transitionChain = smoother;
//foreach (string cur_state in statesHash.Keys)
//{
// string curSrcMachineState = machine + ":" + cur_state;
foreach (string curSrcMachineState in stateKeys)
{
double bf_prob = smoother;
try
{
bf_prob = (double)cur_machineStateVal[curSrcMachineState];
}
catch
{
}
// Our faster transition lookup
double transP = smoother; // should be smarter
string atomicKey = curSrcMachineState + " " + nextSrcMachineState;
if (atomicTransitionCount.ContainsKey(atomicKey))
{
transP = (double)atomicTransitionCount[atomicKey] / (double)transitionCounts[curSrcMachineState];
}
else
{
// use default smoother
transP = smoother;
}
double p = transP * bf_prob;
//AltBot.writeDebugLine(" Transition: P({0}) = {1}", atomicKey, p);
transitionChain += p;
}// for cur_state
double evidenceChain = smoother;
foreach (string evidenceToken in currentEvidence.Keys)
{
double evidenceProb = (double)currentEvidence[evidenceToken];
double emitProb = smoother;
try
{
emitProb = (double)((Hashtable)emissionProbability[evidenceToken])[nextSrcMachineState];
}
catch
{
}
//AltBot.writeDebugLine(" Evidence: P({0}) = {1} ", evidenceToken,evidenceProb);
//AltBot.writeDebugLine(" EMP: P({0} | {1}) = {2} ", evidenceToken, nextSrcMachineState, emitProb);
//AltBot.writeDebugLine(" G: {0} ", (emitProb * evidenceProb));
evidenceChain = evidenceChain + (emitProb * evidenceProb);
}
double rawBeliefInNextState = evidenceChain * transitionChain;
next_machineStateVal[nextSrcMachineState] = rawBeliefInNextState;
Nsum += rawBeliefInNextState;
//AltBot.writeDebugLine(" Next Raw P({0}) = {1} from tcp={2} and ecp={3}", nextSrcMachineState, rawBeliefInNextState, transitionChain, evidenceChain);
if (rawBeliefInNextState > bestVal)
{
bestGuess = nextSrcMachineState;
bestVal = rawBeliefInNextState;
}
}//for next_state
// Normalize
//if (Nsum != 0)
//{
// foreach (string next_state in statesHash.Keys)
// {
// string nextSrcMachineState = machine + ":" + next_state;
// next_machineStateVal[nextSrcMachineState] = (double)next_machineStateVal[nextSrcMachineState]/Nsum;
// }
//}
normalizeMachineNextState(machine);
AltBot.writeDebugLine("MSM: The highest probability for machine {0} in state {1} [{2}]", machine, bestGuess, next_machineStateVal[bestGuess]);
AltBot.writeDebugLine("MSM: Guess = [{0}]", bestGuess);
return(bestGuess);
}
internal void writeToLog(string message, params object[] args)
{
AltBot.writeDebugLine(message, args);
}
protected Unifiable ProcessChangeMSM()
{
//if (this.templateNode.Name.ToLower() == "Processmsm")
{
string machine = GetAttribValue("name", null);
string line = templateNodeInnerText.ToValue(query);
AltBot.writeDebugLine("\n\n >>>>>>>>>>>>>>>>>>>>>> PROCESSMSM : |{0}|<<<<<<<<<<<<<<<<<<<<", line);
//varMSM.lastDefMachine = machine;
var varMSM = botActionMSM;
varMSM.addMachine(machine);
// set topic to "collectevidencepatterns"
//Proc.AddAiml("<set name='topic'>collectevidencepatters</set>");
//this.user.Predicates.updateSetting("topic", "collectevidencepatters");
user.TopicSetting = "CEP";
// Clear the evidence and next state
varMSM.clearEvidence();
varMSM.clearNextStateValues();
// estimate what evidence can be gleaned from the current state
varMSM.inspectEvidenceStates();
// Process the input text
//string evidenceReply = Proc.ChatString(line, this.user.UserID);
string evidenceReply = subChat(line, user.TopicSetting, request, true);
AltBot.writeDebugLine("MSM: WithEvidence {0} ", varMSM.ToString());
// TODO: we should also get evidence across machine boundries
// compute the "TRUE" topics from the state machines,advance all machines using evidence
Hashtable machinesTopState = new Hashtable();
foreach (string mac in varMSM.machines.Keys)
{
string top_State = varMSM.advanceMachine(mac);
machinesTopState[mac] = top_State;
}
// make the next_state values the new current state values
varMSM.advanceStateValues();
AltBot.writeDebugLine("MSM: AfterAdvance {0} ", varMSM.ToString());
// For each machine set the appropriate topic, and Process the input text
string totalReply = "";
double strongestVal = -9999;
foreach (string actingMachine in machinesTopState.Keys)
{
string actionState = (string)machinesTopState[actingMachine];
double actp = (double)varMSM.cur_machineStateVal[actionState];
Hashtable topicHt = (Hashtable)varMSM.machineStateResponses[actionState];
if ((topicHt != null) && (topicHt.Count > 0))
{
foreach (string responseTopic in topicHt.Keys)
{
//prob = topicHt[responseTopic] = prob;
string responseTopicUp = ToUpper(responseTopic);
//string topicSet = "<set name='topic'>"+responseTopic+"</set>";
//this.user.Predicates.updateSetting("topic", responseTopic);
user.TopicSetting = responseTopicUp;
//Proc.AddAiml(topicSet);
string actionReply = "";
//actionReply = Proc.ChatString(line, this.user.UserID);
actionReply = subChat(line, responseTopicUp, request, false);
// Append or use non-null response with the most certainty
//totalReply += " " + actionReply;
AltBot.writeDebugLine("MSM:[[ PossReply m:{0} s:{1} p:{2} RT: {3} REPLY:{4} ]] <<< * * * * * *", actingMachine, actionState, actp, responseTopicUp, actionReply.Trim());
if ((actp > strongestVal) && (actionReply.Trim().Length > 0))
{
strongestVal = actp;
totalReply = actionReply;
}
}
}
}
Unifiable result = totalReply.Trim();
AltBot.writeDebugLine("MSM: FinalReply :{0}", totalReply.Trim());
return(result);
}
return(Unifiable.Empty);
}
public void addMachine(string machine)
{
AltBot.writeDebugLine("MSM: addMachine({0})", machine);
machines[machine] = 1;
lastDefMachine = machine;
}
public void clearEvidence()
{
AltBot.writeDebugLine("MSM: clearEvidence()");
currentEvidence.Clear();
}
