《专家系统破解篇九、Simple Rule Engine规则推理引擎二(基本程序分析)》

最新推荐文章于 2021-07-19 14:36:13 发布

weixin_34189116

最新推荐文章于 2021-07-19 14:36:13 发布

阅读量201

点赞数

原文链接：https://my.oschina.net/mahaisong/blog/143432

版权

2019独角兽企业重金招聘Python工程师标准>>>

基本程序分析：

1.加载事实信息和规则信息
XmlDocument rules = new XmlDocument();
string directory = AppDomain.CurrentDomain.BaseDirectory + @"\..\..\..\RuleExample.xml";//规则链条
rules.Load(directory);

ROM rom = Compiler.Compile(rules);//加载，并确认事实与规则之间的关系

每个链表规则的对应的Fact，都存入DependentEvidence List中。

2. 加载需要的参数，也可以说是激活的一种方式。
     //模型
    XmlDocument model = new XmlDocument();
    model.LoadXml("<a><number1>10</number1><number2>1</number2><result2/></a>");
    rom.AddModel("bob", model);

这种激活方式，是不需要匹配的，而是把所有的链表规则统统执行一遍，测试例子上是因为在此数据时事实的参数，而链表规则的条件是此事实的参数的计算而得到的真假。

3.引起全部规则计算

rom.Evaluate();

调用Decisions类的.Evaluate()方法。

通过上面11个图。可以看出具体的加载之后的数据的存储，数据类型与数据之间的关系了。

4.核心的推理函数

public void Evaluate(Dictionary<string, IEvidence> evidenceCollection, Dictionary<string, List<string>> factRelationships)
        {
            #region register all evidences in this rom with this instance of decision
            foreach (IEvidence evidence in evidenceCollection.Values)
            {
                evidence.CallbackLookup += RaiseCallback;
                evidence.EvidenceLookup += RaiseEvidenceLookup;
                evidence.ModelLookup += RaiseModelLookup;
                evidence.Changed += delegate(object sender, ChangedArgs args)
                {
                    IEvidence evidence1 = (IEvidence)sender;
                    if (!(evidence1 is IFact))
                        return;

                    //找出这ifact模型
                    IFact fact = (IFact)evidence1;
                    IEvidenceValue value = (IEvidenceValue)fact.ValueObject;
                    string modelId = value.ModelId;

                    //遍历所有ifacts并添加这些到相同的模型来执行列表
                    foreach(IEvidence evidence2 in evidenceCollection.Values)
                    {
                        //排除所有不IFact证据类型
                        if (!(evidence2 is IFact))
                            continue;
                        //排除自己
                        if (evidence2.ID == evidence1.ID)
                            continue;
                        //排除所有那些不同的ifacts模型
                        if (evidence2.ValueObject.ModelId != modelId)
                            continue;
                        //加入list
                        executionList.Add(evidence2);
                    }
                };
            }
            #endregion

            #region load up the execution list with facts
            //加载执行列表与事实
            foreach (IEvidence fact in evidenceCollection.Values)
            {
                if (!(fact is IFact))
                    continue;

                executionList.Add(fact);
                Debug.WriteLine("Added fact to execution list: " + fact.ID);
            }
            #endregion

            #region load up the execution list with chainable rules
            //加载执行列表链式规则
            foreach (IEvidence rule in evidenceCollection.Values)
            {
                if (rule is IRule && ((IRule)rule).isChainable)
                {
                    executionList.Add(rule);
                    Debug.WriteLine("Added rule to execution list: " + rule.ID);
                }
            }
            #endregion

            #region execute list
            //执行列
            //Debug.WriteLine("Iteration");
            //Debug.IndentLevel++;
            while (executionList.HasNext)
            {
                Trace.WriteLine("Execution List: " + executionList.ToString());
                Trace.WriteLine("Processing");
                //Debug.IndentLevel++;
                //最低优先级作为计算List第一项。
                string evidenceId = executionList.Read();
                IEvidence evidence = evidenceCollection[evidenceId];
                Trace.WriteLine("EvidenceId: " + evidence.ID);

                //计算证明
                evidence.Evaluate();

                //如果证明有子句的，增加它的行为
                if (evidence.ClauseEvidence!=null)
                {
                    foreach (string clauseEvidenceId in evidence.ClauseEvidence)
                    {
                        Evidence.IEvidence clauseEvidence = (Evidence.IEvidence)evidenceCollection[clauseEvidenceId];
                        executionList.Add(clauseEvidence);
                        Trace.WriteLine("增加证据执行列表: " + clauseEvidence.ID);
                    }
                }

                //执行列表的链式的相关的事实
                if (factRelationships.ContainsKey(evidence.ID))
                {
                    List<string> dependentFacts = factRelationships[evidence.ID];
                    foreach (string dependentFact in dependentFacts)
                    {
                        Evidence.IEvidence dependentEvidence = (Evidence.IEvidence)evidenceCollection[dependentFact];
                        executionList.Add(dependentEvidence);
                        Trace.WriteLine("加入链式的相关事实到执行列表: " + dependentEvidence.ID);
                    }
                }

                //Debug.IndentLevel--;
                Trace.WriteLine("End Processing");
                Trace.WriteLine("");
            }
            //Debug.IndentLevel--;
            Trace.WriteLine("End Iteration");

            #endregion

        }

//加载执行列表与事实

//加载执行列表链式规则

while (executionList.HasNext)//这里是核心的推理。

大家也看到了发布的推理中间结果输出有点混乱。我会专门搞一篇，把中间结果的推理过程写出来的。

从 rule1的 execute 推到 rule2

利用嵌套方式来得到的。但是推理过程并不是那么明晰。

F1。删除F1

不是fact 继续，是fact 下一步。

ID一样，继续，不一样下一步，

是fact了。然后ID不同了。 model是一个组。加入。

true

false