C# ICollection.ToLookup方法代码示例

        /// <summary>
        /// Entropy of a set of examples
        /// </summary>
        private static double Entropy(ICollection<Example> examples)
        {
            var exampleValues = examples.ToLookup(x => x.ClassLabel);

            var probabilities = exampleValues.Select(x => (double)x.Count() / examples.Count);

            return -probabilities.Sum(x => x * Math.Log(x, 2));
        }

        /// <summary>
        /// Recursively construct decision tree from examples and attributes
        /// </summary>
        private static TreeNode LearnInternal(ICollection<Example> examples, ICollection<DataAttribute> attributes, IEnumerable<Example> parentExamples)
        {
            // if no examples, use parent plurality
            if (examples.Count == 0)
            {
                return PluralityValue(parentExamples);
            }

            // if all examples have same classification, use it
            if (examples.Select(x => x.ClassLabel).Distinct().Count() == 1)
            {
                return new TreeNode
                    {
                        ClassLabel = examples.First().ClassLabel,
                    };
            }

            // if no attributes, use plurality
            if (attributes.Count == 0)
            {
                return PluralityValue(examples);
            }

            // pick most important attribute
            var attr = attributes.OrderByDescending(x => Importance(examples, x)).First();

            // get other attributes
            var remainingAttrs = attributes.Where(x => x != attr).ToList();

            // group the examples by their value for selected attribute
            var examplesByAttrValue = examples.ToLookup(x => x.Attributes[attr.ColNum]);

            // construct a decision tree for this attribute
            var tree = new TreeNode
                {
                    ColNum = attr.ColNum,
                };

            // for each value, recursively construct a sub-tree
            foreach (var attrValue in attr.Values)
            {
                var childExamples = examplesByAttrValue[attrValue].ToList();

                var subTree = LearnInternal(childExamples, remainingAttrs, examples);

                tree.Children.Add(attrValue, subTree);
            }

            return tree;
        }

        /// <summary>
        /// Instantiate dependencies, resolve method metadata tokens and from that build
        /// caller-callee method pairs
        /// </summary>
        /// <param name="assembly">the assembly that is being probed</param>
        internal InspectionHelper(Assembly assembly)
        {
            _logger = LogManager.GetLogger(GetType().Name);

            _assembly = assembly;
            _methodILBytes = assembly.GetTypes()
                .SelectMany(t => t.GetMethods(BindingFlags.Instance
                                              | BindingFlags.NonPublic
                                              | BindingFlags.Public
                                              | BindingFlags.Static
                                              | BindingFlags.DeclaredOnly))
                .Where(mi => mi.GetMethodBody() != null)
                .ToDictionary(mi => mi,
                              mi => mi.GetMethodBody().GetILAsByteArray());

            _calls = new List<Tuple<MethodInfo, MethodInfo>>(_methodILBytes.Count);
            FindCalls();

            _callsLookup = _calls.ToLookup(x => x.Item1, x => x.Item2);
        }

        /// <summary>
        /// Remaining entropy after attribute divides example set
        /// </summary>
        private static double Remainder(ICollection<Example> examples, DataAttribute attr)
        {
            var subsets = examples.ToLookup(x => x.Attributes[attr.ColNum]);

            return subsets.Select(x => x.ToList())
                          .Select(subset => new
                              {
                                  prob = (double)subset.Count / examples.Count,
                                  entropy = Entropy(subset),
                              })
                          .Sum(x => x.prob * x.entropy);
        }