getc.cs

基于BP算法的贝叶斯网络参数学习

/*****************************************************************************************
 这个类主要用于在已知输入样本值和权值以及节点集合的情况下
 得到相应的输出，这个输出不单纯是输出节点的输出，只有后面的sumofC个
 才是输出
*****************************************************************************************/
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using System.Windows.Forms;

namespace bs
{
    class GetC
    {
        public NodeArray myNodeArray = null;
        public LineArray Lines = null;
        public int sumofR = 0;//输入节点数量
        public int sumofC = 0;//输出节点数量
        public ArrayList arryA;//要返回的结果，包括输入和输出
        public ArrayList ShuRu;//输入的样本值

        public GetC(NodeArray na, LineArray li, ArrayList arrR)
        {
            this.myNodeArray = na;//节点集合
            this.Lines = li;//边的集合
            this.ShuRu = arrR;//实际输入样本的样本值
            this.GetNumRC();
        }

        public void GetNumRC()
        {
            #region 得到输入和输出节点数量
            for (int i = 0; i < myNodeArray.Count; i++)
            {
                if (myNodeArray[i].indegree == 0)
                {
                    sumofR++;
                }
                if (myNodeArray[i].outdegree == 0)
                {
                    sumofC++;
                }
            }
            #endregion
        }

        public ArrayList GetShuChu()
        {
            #region 得到相应输入的输出
            if (ShuRu.Count != this.sumofR)
            {
                MessageBox.Show("输入值数量和网络输入节点数量不等！");
                return null;
            }
            else
            {
                ArrayList arrNode = new ArrayList();
                int i = 0;
                foreach (BNode1 node in myNodeArray)
                {
                    if (node.indegree == 0)
                    {
                        BNode_InOut bnode = new BNode_InOut();
                        bnode.DOut = (double)ShuRu[i];
                        bnode.node = node;
                        arrNode.Add(bnode);
                    }
                    i++;
                }
                for (int curtem = 0; curtem < myNodeArray.Count; curtem++)
                {
                    if (myNodeArray[curtem].indegree != 0)
                    {
                        ArrayList arr = this.NParent(myNodeArray[curtem].name);
                        BNode_InOut bio = new BNode_InOut();
                        double sumMul = 1.0d;
                        if (myNodeArray[curtem].m_style == "Noisy_And")
                        {
                            for (int w = 0; w < arr.Count; w++)
                            {
                                double Dout = 0.0d;
                                for (int curri = 0; curri < arrNode.Count; curri++)
                                {
                                    if (((BNode_InOut)arrNode[curri]).node.name == (string)arr[w])
                                    {
                                        Dout = ((BNode_InOut)arrNode[curri]).DOut;
                                    }
                                }
                                sumMul *= (1 - this.GetWij((string)arr[w], myNodeArray[curtem].name) * (1 - Dout));
                            }
                        }
                        else if (myNodeArray[curtem].m_style == "Noisy_Or")
                        {
                            for (int w = 0; w < arr.Count; w++)
                            {
                                double Dout = 0.0d;
                                for (int curri = 0; curri < arrNode.Count; curri++)
                                {
                                    if (((BNode_InOut)arrNode[curri]).node.name == (string)arr[w])
                                    {
                                        Dout = ((BNode_InOut)arrNode[curri]).DOut;
                                    }
                                }
                                sumMul *= (1 - (this.GetWij((string)arr[w], myNodeArray[curtem].name) * Dout));
                            }
                            sumMul = 1 - sumMul;
                        }
                        bio.node = myNodeArray[curtem];
                        bio.DOut = sumMul;
                        arrNode.Add(bio);
                    }
                }
                return arrNode;
            }
            #endregion
        }

        public ArrayList NParent(string assessNode)
        {
            #region 得到节点父节点的集合
            ArrayList parent = new ArrayList();
            foreach (Line l in Lines)
            {
                if (l.dNode == assessNode)
                {
                    parent.Add(l.sNode);
                }
            }
            return parent;
            #endregion
        }

        private double GetWij(string NodeNames, string NodeNameD)
        {
            #region 得到权值在lines数组
            string wijtem = "";
            foreach (Line l in this.Lines)
            {
                if ((l.sNode == NodeNames) && (l.dNode == NodeNameD))
                {
                    wijtem = l.wij;
                }
            }
            return Convert.ToDouble(wijtem);
            #endregion
        }
    }
}