public IEnumerable <CaseRetrievalResult> Retrieve(ReasonerContext context) { var cases = new Dictionary <string, (double count, double measure)>(); foreach (var retriever in retrievers) { var retrievedCases = retriever.Retrieve(context).ToArray(); for (var i = 0; i < retrievedCases.Length; i++) { var retrievedCase = retrievedCases[i]; if (!cases.TryGetValue(retrievedCase.CaseId, out var targetCase)) { cases[retrievedCase.CaseId] = (i, retrievedCase.Measure); } else { cases[retrievedCase.CaseId] = (targetCase.count + i, targetCase.measure + retrievedCase.Measure); } } } return(cases.Select(c => new CaseRetrievalResult(c.Key, c.Value.count)) .OrderBy(c => c.Measure) .Take(threshold)); }
public IEnumerable <CaseRetrievalResult> Retrieve(ReasonerContext context) { var similaritySet = new SortedSet <CaseRetrievalResult>(new CaseRetrievalComparer()); using (var cursor = GetTargetFrame(context).GetCaseCursor()) { while (cursor.MoveNext()) { var similarity = measure.GetSimilarity(cursor, context.TargetCase, context); var result = new CaseRetrievalResult(cursor.GetId(), similarity); if (similaritySet.Count == threshold) { if (result.Measure >= similaritySet.Max.Measure) { continue; } similaritySet.Remove(similaritySet.Max); similaritySet.Add(result); } else { similaritySet.Add(result); } } } return(similaritySet); }
public double GetSimilarity(ICase caseA, ICase caseB, ReasonerContext context) { if (covarianceMatrix == null) { covarianceMatrix = GetCovarianceMatrix(context.Cases); } if (caseA == null) { throw new ArgumentNullException(nameof(caseA)); } if (caseB == null) { throw new ArgumentNullException(nameof(caseB)); } var differenceVector = new DenseMatrix(1, caseA.Schema.Count); for (var i = 0; i < caseA.Schema.Count; i++) { differenceVector[0, i] = caseA.GetAttribute <double>(caseA.Schema[i]) - caseB.GetAttribute <double>(caseA.Schema[i]); } var distance = differenceVector * covarianceMatrix.Transpose() * differenceVector.Transpose(); return(Math.Sqrt(distance[0, 0])); }
public TSolution Reuse <TSolution>(ReasonerContext context) { var nearestNeighbors = context.RetrievedCases .Take(k) .ToDictionary(c => c.CaseId, c => c.Measure); if (!nearestNeighbors.Any()) { return(default);
public IEnumerable <CaseRetrievalResult> Retrieve(ReasonerContext context) { if (lshSpace == null) { CreateLshSpace(context); } return(lshSpace .Get(context.TargetCase) .Select(id => new CaseRetrievalResult(id, 1))); }
private void CreateLshSpace(ReasonerContext context) { lshSpace = new LshSpace(size, context.Schema.Count, depth); using (var cursor = context.Cases.GetCaseCursor()) { while (cursor.MoveNext()) { lshSpace.Add(cursor); } } }
private static ICaseFrame GetTargetFrame(ReasonerContext context) { if (context.RetrievedCases == null || !context.RetrievedCases.Any()) { return(context.Cases); } var retrievedIds = context.RetrievedCases.Select(c => c.CaseId).ToArray(); return(context.Cases.FilterCases(retrievedIds)); }
public double GetSimilarity(ICase caseA, ICase caseB, ReasonerContext context) { if (caseA == null) { throw new ArgumentNullException(nameof(caseA)); } if (caseB == null) { throw new ArgumentNullException(nameof(caseB)); } var attributesA = caseA.Schema.Select(caseA.GetAttribute <double>).ToArray(); var attributesB = caseA.Schema.Select(caseB.GetAttribute <double>).ToArray(); return(Dot(attributesA, attributesB) / (Math.Pow(Dot(attributesA, attributesA), 2) * Math.Pow(Dot(attributesB, attributesB), 2))); }
public TSolution GetSolution <TSolution>(ICase targetCase) { if (data == null) { throw new InvalidOperationException("Case data for the reasoner is not set."); } var context = new ReasonerContext(data, targetCase); foreach (var retriever in cycle.Retrievers) { var retrievedCases = retriever.Retrieve(context); context.RetrievedCases = retrievedCases; } var result = cycle.Reuser != null?cycle.Reuser.Reuse <TSolution>(context) : default; return(result); }
public double GetSimilarity(ICase caseA, ICase caseB, ReasonerContext context) { if (caseA == null) { throw new ArgumentNullException(nameof(caseA)); } if (caseB == null) { throw new ArgumentNullException(nameof(caseB)); } double result = 0; foreach (var attribute in caseA.Schema) { if (targetAttributes.Length > 0 && !targetAttributes.Contains(attribute.Name)) { continue; } result += Math.Pow(Math.Abs(caseA.GetAttribute <double>(attribute) - caseB.GetAttribute <double>(attribute)), order); } return(Math.Pow(result, 1 / order)); }