/// <summary> /// Scores the specified entry. /// </summary> /// <param name="entry">The entry.</param> /// <param name="context">The context.</param> /// <param name="log">The log.</param> /// <returns></returns> public override double Score(DocumentSelectResultEntry entry, DocumentSelectResult context, ILogBuilder log) { Double score = 0; WebSiteGraph webSiteGraph = context.domainNameToGraph[entry.DomainID]; // GraphRegistry[entry.DomainID]; freeGraphNodeAndLinks outLinks = webSiteGraph.GetLinks(entry.AssignedID, true, false); freeGraphNodeAndLinks inLinks = webSiteGraph.GetLinks(entry.AssignedID, false, true); if (functionFlags.HasFlag(GraphFactorFunctionEnum.count_outbound)) { score += outLinks.Count; } if (functionFlags.HasFlag(GraphFactorFunctionEnum.count_inbound)) { score += inLinks.Count; } if (score == 0) { return(score); } if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_graphlinks)) { score = score / webSiteGraph.CountLinks(); } if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_graphnodes)) { score = score / webSiteGraph.CountNodes(); } if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_inbound)) { score = score / inLinks.Count; } if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_outbound)) { score = score / outLinks.Count; } if (functionFlags.HasFlag(GraphFactorFunctionEnum.divide_by_linkCount)) { score = score / (inLinks.Count + outLinks.Count); } return(score); }
internal void AddOrUpdateNode(freeGraphNodeBase node, freeGraphLink link, freeGraphNodeAndLinks links, Boolean typeToMin, lemmaExpansionOptions options) { if (ContainsNode(node.name, true)) { var nd = GetNode(node.name, true); if (options.HasFlag(lemmaExpansionOptions.divideWeightByNumberOfSynonims)) { nd.weight = nd.weight + (node.weight.GetRatio(links.linkedNodeClones.Count)); } else if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceThatIsSumOfLinkWeights)) { nd.weight = nd.weight + node.weight.GetRatio(node.distance); if (nd.distance > 1) { nd.distance = Math.Min(nd.distance, node.distance + link.linkBase.weight); } else { nd.distance = node.distance + link.linkBase.weight; } } else { nd.weight = nd.weight + node.weight; } if (typeToMin) { nd.type = Math.Min(nd.type, node.type); } else { nd.type = Math.Max(nd.type, node.type); } } else { if (options.HasFlag(lemmaExpansionOptions.divideWeightByNumberOfSynonims)) { AddNode(node.name, node.weight.GetRatio(links.linkedNodeClones.Count), node.type); } else if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceThatIsSumOfLinkWeights)) { AddNode(node.name, node.weight.GetRatio(node.distance), node.type).distance = node.distance + link.linkBase.weight; } else { AddNode(node.name, node.weight, node.type); } } }
public freeGraphTypedResultSet <IObjectWithNameWeightAndType> GetLinked(TNode node) { freeGraphTypedResultSet <IObjectWithNameWeightAndType> output = new freeGraphTypedResultSet <IObjectWithNameWeightAndType>(); freeGraphNodeAndLinks res = graph.GetLinks(GetID(node), true); foreach (var r in res) { var n = new freeGraphTypedResultEntry <IObjectWithNameWeightAndType>(r.linkBase); n.TNodeA = source[t][r.nodeA.name]; n.TNodeB = source[t][r.nodeB.name]; output.Add(n); } return(output); }
public freeGraphTypedResultSet <TNodeB> GetLinkedNodesOfType <TNodeB>(TNode node) where TNodeB : IObjectWithNameWeightAndType { freeGraphTypedResultSet <TNodeB> output = new freeGraphTypedResultSet <TNodeB>(); Type t_B = typeof(TNodeB); Type t_A = typeof(TNode); freeGraphNodeAndLinks res = graph.GetLinks(GetID(node), true); foreach (freeGraphLink r in res) { var n = new freeGraphTypedResultEntry <TNodeB>(r.linkBase); n.TNodeA = (TNodeB)source[t_A][r.nodeA.name]; n.TNodeB = (TNodeB)source[t_B][r.nodeB.name]; output.Add(n); } return(output); }
/// <summary> /// Returns expanded cloud from given lemma list - only for matched lemmas /// </summary> /// <param name="lemmas">The lemmas.</param> /// <param name="expansionSteps">The expansion steps.</param> /// <param name="options">The options.</param> /// <param name="typeToMin">todo: describe typeToMin parameter on ExpandTermsToCloud</param> /// <returns></returns> public lemmaSemanticCloud ExpandTermsToCloud(IEnumerable <String> lemmas, Int32 expansionSteps, Boolean typeToMin = true, lemmaExpansionOptions options = lemmaExpansionOptions.initialWeightFromParent | lemmaExpansionOptions.weightAsSemanticDistanceFromParent) { lemmaSemanticCloud output = new lemmaSemanticCloud(); output.name = name + "_subset_exp" + expansionSteps; output.DisableCheck = true; StringBuilder sb = new StringBuilder(); sb.Append("Subset expanded from matched query lemmas ["); List <String> nextTerms = new List <string>(); List <String> allTerms = new List <string>(); foreach (String t in lemmas) { if (ContainsNode(t)) { sb.Append(t + " "); var l = GetNode(t); output.AddNode(l.name, l.weight, 0).distance = 1; nextTerms.Add(t); allTerms.Add(t); } } sb.Append("] using cloud [" + name + "]"); output.description = sb.ToString(); Int32 exp_i = 1; while (nextTerms.Any()) { List <String> newNextTerms = new List <string>(); foreach (String t in nextTerms) { freeGraphNodeAndLinks links = new freeGraphNodeAndLinks(); if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceFromParent)) { links = GetLinks(t, true, false, 1.GetRatio(exp_i), exp_i, true, options.HasFlag(lemmaExpansionOptions.initialWeightFromParent)); } else if (options.HasFlag(lemmaExpansionOptions.weightAsSemanticDistanceThatIsSumOfLinkWeights)) { var nd = output.GetNode(t, true); links = GetLinks(t, true, false, 1, exp_i, true, options.HasFlag(lemmaExpansionOptions.initialWeightFromParent)); } else { links = GetLinks(t, true, false, 1, exp_i, true, options.HasFlag(lemmaExpansionOptions.initialWeightFromParent)); } foreach (freeGraphLink link in links) { if (!allTerms.Contains(link.nodeA.name)) { newNextTerms.Add(link.nodeA.name); allTerms.Add(link.nodeA.name); } if (link.nodeA.name != t) { output.AddOrUpdateNode(link.nodeA, link, links, typeToMin, options); } if (!allTerms.Contains(link.nodeB.name)) { newNextTerms.Add(link.nodeB.name); allTerms.Add(link.nodeB.name); } if (link.nodeB.name != t) { output.AddOrUpdateNode(link.nodeB, link, links, typeToMin, options); } } foreach (freeGraphLink link in links) { if (!output.ContainsLink(link.linkBase.nodeNameA, link.linkBase.nodeNameB)) { output.AddLink(link.linkBase.nodeNameA, link.linkBase.nodeNameB, Math.Max(link.linkBase.weight, 1), link.linkBase.type); //var nd = output.GetNode(link.nodeB.name); //nd.weight = nd.weight + (link.nodeB.weight.GetRatio(links.linkedNodeClones.Count)); //nd.type = Math.Max(nd.type, link.nodeB.type); } else { var lnk = output.GetLink(link.linkBase.nodeNameA, link.linkBase.nodeNameB); lnk.weight += link.linkBase.weight; if (typeToMin) { lnk.type = Math.Min(link.linkBase.type, lnk.type); } else { lnk.type = Math.Max(link.linkBase.type, lnk.type); } } } } nextTerms = newNextTerms; exp_i++; if (exp_i > expansionSteps) { break; } } output.DisableCheck = false; output.RebuildIndex(); return(output); }