Exemple #1
0
 public int CountNodes(Node node)
 {
     int result = 1;
     if (node.GetLeft() != null)
         result += CountNodes(node.GetLeft());
     if (node.GetRight() != null)
         result += CountNodes(node.GetRight());
     return result;
 }
Exemple #2
0
 public int CountLeafLastNodes(Node node)
 {
     int result = 0;
     if (node.GetLeft() != null)
         result += CountLeafLastNodes(node.GetLeft());
     if (node.GetRight() != null)
         result += CountLeafLastNodes(node.GetRight());
     if (node.GetLeft() == null && node.GetRight() == null)
         return node.leaf;
     return result;
 }
Exemple #3
0
        public void Algorithm(double[][] dataInput, Node node)
        {
            /*
            * Choose class for node if is the case.
            */
            node.classType = sameClass(dataInput);
            if (node.classType != -1)
            {
                node.leaf = dataInput.Length;
                return;
            }

            node.classType = sameAtributtes(dataInput);
            if (node.classType != -1)
            {
                node.leaf = dataInput.Length;
                return;
            }

            /*
             * Choose best axis-parallel split node for dataInput.
             */
            bestAxisParallel(dataInput, node);

            /*
             * Apply OC1
             */
            Node auxNode = (Node)node.Clone();
            for (int i = 0; i < R; i++)
            {
                if (i > 0)
                    auxNode.Random();

            step1:
                double initialGain = gain(dataInput, node); // Gain for better node.
                for (int d = 0; d < dataInput[0].Length; d++)
                {
                    pertube(d, auxNode, dataInput);
                    if (gain(dataInput, auxNode) > initialGain)
                    {
                        node.SetNode(auxNode);
                        break;
                    }
                }

                // step 2
                initialGain = gain(dataInput, node);
                for (int j = 0; j < J; j++)
                {
                    Random rand = new Random();
                    int direction = rand.Next(dataInput[0].Length - 1);
                    pertube(direction, auxNode, dataInput);
                    if (gain(dataInput, auxNode) > initialGain)
                    {
                        node.SetNode(auxNode);
                        goto step1;
                    }
                }
                if (gain(dataInput, auxNode) > gain(dataInput, node))
                    node.SetNode(auxNode);
            }

            /*
             * Recursive Algorithm for each branch for node.
             */
            Node left = new Node(new double[dataInput[0].Length], 0);
            Node right = new Node(new double[dataInput[0].Length], 0);

            node.SetLeft(left);
            node.SetRight(right);
            List<double[]>[] data = divideData(dataInput, node);
            Algorithm(data[0].ToArray(), node.GetLeft());
            Algorithm(data[1].ToArray(), node.GetRight());
        }
Exemple #4
0
        private void pertube(int m, Node node, double[][] dataInput)
        {
            if (!node.ActiveAtributtes[m])
                return;

            Node auxNode = (Node)node.Clone();
            double[] U = new double[dataInput.Length];
            for (int i = 0; i < dataInput.Length; i++)
                U[i] = Math.Min((node.weights[m] * dataInput[i][m] - node.Evaluate(dataInput[i])) / dataInput[i][m], 0);
            Array.Sort(U);

            int bestA = 0;
            int dif = Int16.MaxValue;
            for (int i = 0; i < U.Length; i++)
            {
                int positive = 0;
                int negative = 0;
                for (int j = 0; j < U.Length; j++)
                {
                    if (j <= i && U[j] <= 0)
                        negative++;
                    else if (j > i && U[j] > 0)
                        positive++;
                }
                if (Math.Abs(positive - negative) < dif)
                {
                    dif = Math.Abs(positive - negative);
                    bestA = i;
                }

            }

            auxNode.weights[m] = U[bestA];
            if (gain(dataInput, auxNode) > gain(dataInput, node))
            {
                node.weights[m] = U.Max();
                node.ResetPmove();
            }
            else if (gain(dataInput, auxNode) == gain(dataInput, node))
            {
                if(node.EvaluatePmove())
                    node.weights[m] = U.Max();
                node.DecreasePmove();
            }
        }
Exemple #5
0
 private void bestAxisParallel(double[][] dataInput, Node n)
 {
     bool[] dimensionUsed = new bool[dataInput[0].Length];
     dimensionUsed[dataInput[0].Length - 1] = true;
     for (int k = 0; k < _k; k++)
     {
         int bestDimension = 0;
         double bestGain = gain(dataInput, n);
         for (int d = 0; d < dataInput[0].Length; d++)
         {
             if (!dimensionUsed[d])
             {
                 n.weights[d] = 1;
                 for (int i = 0; i < dataInput.Length; i++)
                 {
                     double baias = n.baias;
                     n.SetBaias(dataInput[i]);
                     if (gain(dataInput, n) > bestGain)
                     {
                         bestDimension = d;
                         bestGain = gain(dataInput, n);
                     }
                     else
                         n.baias = baias;
                 }
                 n.weights[d] = 0;
             }
         }
         dimensionUsed[bestDimension] = true;
         n.weights[bestDimension] = 1;
         n.Activate(bestDimension);
     }
 }
Exemple #6
0
 private static double gain(double[][] input, Node node)
 {
     double gain = entropy(input);
     List<double[]>[] dataGroups = divideData(input, node);
     for (int i = 0; i < 2; i++)
     {
         if(dataGroups[i].Count > 0)
             gain -= (dataGroups[i].Count * entropy(dataGroups[i].ToArray())) / input.Length;
     }
     return gain;
 }
Exemple #7
0
        /*
         * data[0]: left
         * data[1]: right
         */
        private static List<double[]>[] divideData(double[][] input, Node node)
        {
            List<double[]>[] data = new List<double[]>[2];
            data[0] = new List<double[]>();
            data[1] = new List<double[]>();

            for (int i = 0; i < input.Length; i++)
            {
                if (node.Evaluate(input[i]) < 0) //Curioso caso.
                    data[0].Add(input[i]);
                else
                    data[1].Add(input[i]);
            }
            return data;
        }
Exemple #8
0
 private void setParent(Node parent)
 {
     _parent = parent;
 }
Exemple #9
0
 public void SetRight(Node right)
 {
     _right = right;
     _right.setParent(this);
 }
Exemple #10
0
 public void SetNode(Node input)
 {
     for (int i = 0; i < weights.Length; i++)
     {
         weights[i] = input.weights[i];
     }
     baias = input.baias;
 }
Exemple #11
0
 public void SetLeft(Node left)
 {
     _left = left;
     _left.setParent(this);
 }
Exemple #12
0
 public DesicionTree(Node root)
 {
     _root = root;
 }
Exemple #13
0
        private void Prunning(int n, Node node)
        {
            if (node.GetLeft() != null)
                Prunning(n, node.GetLeft());
            if (node.GetRight() != null)
                Prunning(n, node.GetRight());

            if (node.GetRight() == null && node.GetLeft() == null)
                return;

            if (node.GetRight() == null && node.GetLeft().leaf < n)
            {
                node.leaf += node.GetLeft().leaf;
                node.classType = node.GetLeft().classType;
                node.RemoveLeft();
            }
            else if (node.GetLeft() == null && node.GetRight().leaf < n)
            {
                node.leaf += node.GetRight().leaf;
                node.classType = node.GetRight().classType;
                node.RemoveRight();
            }

            else if (node.GetRight().leaf < n && node.GetLeft().leaf >= n)
            {
                node.classType = node.GetRight().classType;
                node.leaf += node.GetRight().leaf;
                node.RemoveRight();
            }
            else if (node.GetRight().leaf >= n && node.GetLeft().leaf < n)
            {
                node.classType = node.GetLeft().classType;
                node.leaf += node.GetLeft().leaf;
                node.RemoveLeft();
            }
            else if (node.GetRight().leaf < n && node.GetLeft().leaf < n)
            {
                if (node.GetRight().leaf > node.GetLeft().leaf)
                    node.classType = node.GetRight().classType;
                else
                    node.classType = node.GetLeft().classType;

                node.leaf += node.GetLeft().leaf + node.GetRight().leaf;
                node.RemoveLeft();
                node.RemoveRight();
            }
        }