/// <summary>
/// Import script results
/// </summary>
/// <param name="result">RScriptResults object</param>
/// <returns>Script results</returns>
public override object ImportResults(RScriptResult result)
{
// index = id - 1
string[] ids = Generics.ImportStrings(_mapFile);
TextReader resultsMatrix = new StreamReader(_outputFile);
TLSimilarityMatrix matrix = new TLSimilarityMatrix();
string[] sources = resultsMatrix.ReadLine().Split();
string line;
while ((line = resultsMatrix.ReadLine()) != null)
{
if (String.IsNullOrWhiteSpace(line))
{
continue;
}
// [0] target id, [x+] source sims index = x - 1
string[] entries = line.Split();
string entry = ids[Convert.ToInt32(entries[0]) - 1];
for (int i = 0; i < sources.Length; i++)
{
matrix.AddLink(ids[Convert.ToInt32(sources[i]) - 1], entry, Convert.ToDouble(entries[i + 1]));
}
}
resultsMatrix.Close();
return(matrix);
}
/// <summary>
/// Imports script results
/// </summary>
/// <param name="result">RScriptResults object</param>
/// <returns>Script results</returns>
public override object ImportResults(RScriptResult result)
{
TextReader rfile = new StreamReader(_outputFile);
string rawdata = rfile.ReadToEnd();
rfile.Close();
TLSimilarityMatrix matrix = new TLSimilarityMatrix();
string[] sims = rawdata.Remove(0, 2).Replace(")", String.Empty).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
int src = 0;
int tgt = _source.DocMap.Count;
if (sims.Length != _source.DocMap.Count * _target.DocMap.Count)
{
throw new RDataException("Results are incorrect size: " + sims.Length + " vs " + (_source.DocMap.Count * _target.DocMap.Count));
}
foreach (string sim in sims)
{
matrix.AddLink(_source.DocMap[src], _target.DocMap[tgt - _source.DocMap.Count], Convert.ToDouble(sim.Trim()));
tgt++;
if (tgt == _source.DocMap.Count + _target.DocMap.Count)
{
tgt = _source.DocMap.Count;
src++;
}
}
return(matrix);
}
private static void CreateCSVReport(TLSimilarityMatrix similarityMatrix, string outputPath)
{
if (similarityMatrix == null)
{
throw new ComponentException("Received similarity matrix is null!");
}
if (outputPath == null)
{
throw new ComponentException("Output path cannot be null.");
}
if (!System.IO.Path.IsPathRooted(outputPath))
{
throw new ComponentException(String.Format("Absolute output path is required. Given path is '{0}'", outputPath));
}
if (outputPath.EndsWith(".csv", StringComparison.CurrentCultureIgnoreCase) == false)
{
outputPath = outputPath + ".csv";
}
using (System.IO.TextWriter writeFile = new StreamWriter(outputPath))
{
ReadSimilarityMatrixToFile(similarityMatrix, writeFile);
writeFile.Flush();
writeFile.Close();
}
}
/// <summary>
/// Computes the cosine similarity between the given document pairs in the matrix
/// </summary>
/// <param name="matrix">Term-by-document matrix</param>
/// <param name="sourceIDs">Collection of source artifacts ids</param>
/// /// <param name="targetIDs">Collection of target artifacts ids</param>
/// <returns>Similarity matrix</returns>
public static TLSimilarityMatrix ComputeCosine(TermDocumentMatrix matrix, IEnumerable <string> sourceIDs, IEnumerable <string> targetIDs)
{
TLSimilarityMatrix sims = new TLSimilarityMatrix();
foreach (string sourceID in sourceIDs)
{
double[] sourceDoc = matrix.GetDocument(sourceID);
foreach (string targetID in targetIDs)
{
// compute cosine similarity between source and target
double[] targetDoc = matrix.GetDocument(targetID);
double lengthProduct = ComputeLength(sourceDoc) * ComputeLength(targetDoc);
if (lengthProduct == 0.0)
{
sims.AddLink(sourceID, targetID, 0.0);
}
else
{
double score = ComputeDotProduct(sourceDoc, targetDoc) / lengthProduct;
sims.AddLink(sourceID, targetID, score);
}
}
}
return(sims);
}
private static TLSimilarityMatrix ConvertRocco(ref Info info, string input, string output)
{
TLSimilarityMatrix matrix = RanklistImporter.Import(input);
Similarities.Export(matrix, output);
return(matrix);
}
/// <summary>
/// Exports an answer matrix to a file.
/// </summary>
/// <param name="answerMatrix">Answer matrix</param>
/// <param name="filename">Output file path</param>
public static void Export(TLSimilarityMatrix answerMatrix, string filename)
{
TextWriter tw = null;
try
{
tw = new StreamWriter(filename);
foreach (string sourceID in answerMatrix.SourceArtifactsIds)
{
tw.Write(sourceID);
foreach (string targetID in answerMatrix.GetSetOfTargetArtifactIdsAboveThresholdForSourceArtifact(sourceID))
{
tw.Write(" " + targetID);
}
tw.WriteLine();
}
tw.Flush();
tw.Close();
}
catch (Exception e)
{
if (tw != null)
{
tw.Close();
}
throw new DevelopmentKitException("There was an exception writing to file (" + filename + ")", e);
}
}
public static void Export(TLSimilarityMatrix answerSet, string sourceId, string targetId, string outputPath)
{
if (answerSet == null)
{
throw new TraceLabSDK.ComponentException("Received null answer similarity matrix");
}
System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
settings.Indent = true;
settings.CloseOutput = true;
settings.CheckCharacters = true;
//create file
using (System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(outputPath, settings))
{
writer.WriteStartDocument();
writer.WriteStartElement("answer_set");
WriteAnswerSetInfo(writer, sourceId, targetId);
WriteLinks(answerSet, writer);
writer.WriteEndElement(); //answer_set
writer.WriteEndDocument();
writer.Close();
}
System.Diagnostics.Trace.WriteLine("File created , you can find the file " + outputPath);
}
public static void ComputeMetrics(TLSimilarityMatrix sims, TLSimilarityMatrix oracle, RecallLevel level,
out TLKeyValuePairsList precision, out TLKeyValuePairsList recall, out TLKeyValuePairsList avgPrecision, out TLKeyValuePairsList meanAvgPrecision)
{
TLLinksList links = MetricsUtil.GetLinksAtRecall(sims, oracle, level);
int numCorrect = 0;
int totalRead = 0;
double totalAvgPrecision = 0.0;
foreach (TLSingleLink link in links)
{
totalRead++;
if (oracle.IsLinkAboveThreshold(link.SourceArtifactId, link.TargetArtifactId))
{
numCorrect++;
totalAvgPrecision += numCorrect / (double)totalRead;
}
}
// temporary
precision = new TLKeyValuePairsList();
precision.Add(new KeyValuePair <string, double>("#TOTAL", numCorrect / Convert.ToDouble(links.Count)));
recall = new TLKeyValuePairsList();
recall.Add(new KeyValuePair <string, double>("#TOTAL", Math.Ceiling(oracle.Count * RecallLevelUtil.RecallValue(level)) / oracle.Count));
avgPrecision = new TLKeyValuePairsList();
avgPrecision.Add(new KeyValuePair <string, double>("#TOTAL", totalAvgPrecision / oracle.Count));
meanAvgPrecision = new TLKeyValuePairsList();
meanAvgPrecision.Add(new KeyValuePair <string, double>("#TOTAL", MeanAveragePrecision.Compute(Similarities.CreateMatrix(links), oracle)));
}
public override void Compute()
{
TLSimilarityMatrix matrix = (TLSimilarityMatrix)Workspace.Load("Matrix");
TLSimilarityMatrix pruned = TLSimilarityMatrixUtil.CreateMatrix(TLSimilarityMatrixUtil.RemoveBottomPercentage(matrix, _config.Percentage));
Workspace.Store("PrunedMatrix", pruned);
}
public override void Compute()
{
TLSimilarityMatricesCollection listOfMatrices = (TLSimilarityMatricesCollection)Workspace.Load("listOfMatrices");
if (listOfMatrices == null)
{
throw new ComponentException("The 'listOfMatrices' is null or has not been found in the Workspace.");
}
TLSimilarityMatrix matrix = (TLSimilarityMatrix)Workspace.Load("matrix");
if (matrix == null)
{
throw new ComponentException("The 'matrix' input is null or has not been found in the Workspace.");
}
string name = (string)Workspace.Load("name");
if (name == null)
{
throw new ComponentException("The 'name' for matrix is null or has not been found in the Workspace. Please, provide the name for the matrix.");
}
matrix.Name = name;
listOfMatrices.Add(matrix);
Workspace.Store("listOfMatrices", listOfMatrices);
}
public void EmptyDictionaryIndexTest()
{
TLArtifactsCollection sourceArtifacts = new TLArtifactsCollection();
sourceArtifacts.Add(new TLArtifact("id", "text"));
TLArtifactsCollection targetArtifacts = new TLArtifactsCollection();
targetArtifacts.Add(new TLArtifact("id", "text"));
TLDictionaryIndex dictionary = new TLDictionaryIndex();
Workspace.Store("sourceArtifacts", sourceArtifacts);
Workspace.Store("targetArtifacts", targetArtifacts);
Workspace.Store("dictionaryIndex", dictionary);
((TracerConfig)TestComponent.Configuration).SimilarityMetric = SimilarityMetricMethod.SimpleMatching;
TestComponent.Compute();
TLSimilarityMatrix simMat = (TLSimilarityMatrix)Workspace.Load("similarityMatrix");
if (simMat == null || simMat.Count != 0)
{
Assert.Fail("Similarity Matrix should still be created but have nothing in it");
}
}
public void TestTracingOfComponent()
{
TLArtifactsCollection sourceArtifacts = new TLArtifactsCollection();
TLArtifactsCollection targetArtifacts = new TLArtifactsCollection();
TLDictionaryIndex dictionary = new TLDictionaryIndex();
// TODO: add inputs that matter
sourceArtifacts.Add(new TLArtifact("id1", "first text"));
sourceArtifacts.Add(new TLArtifact("id2", "words to do stuff with"));
sourceArtifacts.Add(new TLArtifact("id3", "some more text"));
targetArtifacts.Add(new TLArtifact("id1", "hello world"));
targetArtifacts.Add(new TLArtifact("id2", "very very random yes indeed"));
targetArtifacts.Add(new TLArtifact("id3", "yep"));
targetArtifacts.Add(new TLArtifact("id4", "chickens in the coop"));
dictionary.AddTermEntry("term", 3, 3, 0.2);
Workspace.Store("sourceArtifacts", sourceArtifacts);
Workspace.Store("targetArtifacts", targetArtifacts);
Workspace.Store("dictionaryIndex", dictionary);
((TracerConfig)TestComponent.Configuration).SimilarityMetric = SimilarityMetricMethod.SimpleMatching;
TestComponent.Compute();
TLSimilarityMatrix simMat = (TLSimilarityMatrix)Workspace.Load("similarityMatrix");
// TODO: add tests to make sure the output is correctly formatted
Assert.Fail();
}
public static DataSetPairs Compute(TLSimilarityMatrix sims, TLSimilarityMatrix oracle, RecallLevel recall)
{
TLSimilarityMatrix matrix = Similarities.CreateMatrix(MetricsUtil.GetLinksAtRecall(sims, oracle, recall));
matrix.Threshold = double.MinValue;
DataSetPairs pairs = new DataSetPairs();
foreach (string sourceArtifact in oracle.SourceArtifactsIds)
{
TLLinksList links = matrix.GetLinksAboveThresholdForSourceArtifact(sourceArtifact);
links.Sort();
int totalCorrect = oracle.GetLinksAboveThresholdForSourceArtifact(sourceArtifact).Count;
int numCorrect = 0;
int totalRead = 0;
double totalAvgPrecision = 0.0;
foreach (TLSingleLink link in links)
{
totalRead++;
if (oracle.IsLinkAboveThreshold(link.SourceArtifactId, link.TargetArtifactId))
{
numCorrect++;
totalAvgPrecision += numCorrect / (double)totalRead;
}
}
pairs.PrecisionData.Add(new KeyValuePair <string, double>(sourceArtifact, numCorrect / Convert.ToDouble(links.Count)));
pairs.RecallData.Add(new KeyValuePair <string, double>(sourceArtifact, Convert.ToDouble(numCorrect) / totalCorrect));
pairs.AveragePrecisionData.Add(new KeyValuePair <string, double>(sourceArtifact, totalAvgPrecision / totalCorrect));
}
pairs.MeanAveragePrecisionData.Add(new KeyValuePair <string, double>("#TOTAL", DataSetPairsCollection.CalculateAverage(pairs.AveragePrecisionData)));
return(pairs);
}
public override void Compute()
{
List <string> map = (List <string>)Workspace.Load("DocumentMap");
TLSimilarityMatrix sims = Similarities.Import(_config.Directory.Absolute, map);
Workspace.Store("Similarities", sims);
}
/// <summary>
/// Computes the score for the given current results.
/// </summary>
/// <param name="baselineMatrices">The baseline matrices.</param>
/// <param name="currentResults">The current results.</param>
/// <returns></returns>
public static double ComputeScore(TLSimilarityMatricesCollection baselineMatrices, TLSimilarityMatricesCollection currentResultsMatrices,
TLDatasetsList datasets, MetricComputationComponentConfig config)
{
double score = 0.0;
double sum = 0;
double counts = 0;
IMetricComputation metricComputation = GetMetricComputation(config);
foreach (TLDataset dataset in datasets)
{
TLSimilarityMatrix baseline = baselineMatrices[dataset.Name];
TLSimilarityMatrix current = currentResultsMatrices[dataset.Name];
//score is computed based on delta between two techniques from metric computation
SortedDictionary <string, double> baselineValues = metricComputation.Calculate(baseline, dataset);
SortedDictionary <string, double> currentValues = metricComputation.Calculate(current, dataset);
var deltas = ScoreComputationHelper.Delta(baselineValues, currentValues);
//now compute average of computed deltas, and that's the score
foreach (double delta in deltas.Values)
{
sum += delta;
}
counts += deltas.Count;
}
score = sum / counts;
return(score);
}
/// <summary>
/// Imports a file in the form (each line):
/// SOURCE TARGET SCORE
/// </summary>
/// <param name="filename">Similarities file</param>
/// <returns>Similarity matrix</returns>
public static TLSimilarityMatrix Import(String filename)
{
StreamReader file = new StreamReader(filename);
TLSimilarityMatrix answer = new TLSimilarityMatrix();
String line;
int num = 0;
while ((line = file.ReadLine()) != null)
{
num++;
if (String.IsNullOrWhiteSpace(line))
{
continue;
}
try
{
String[] artifacts = line.Split();
String source = artifacts[0];
String target = artifacts[1];
double score = Convert.ToDouble(artifacts[2]);
answer.AddLink(source, target, score);
}
catch (IndexOutOfRangeException e)
{
file.Close();
throw new InvalidDataException("Invalid data format on line " + num + " of file:" + filename, e);
}
}
file.Close();
return(answer);
}
public override void Compute()
{
TLSimilarityMatrix similarityMatrix = (TLSimilarityMatrix)Workspace.Load("SimilarityMatrix");
DevelopmentKit.IO.Similarities.ExportCSV(similarityMatrix, Config.Path.Absolute);
Logger.Info(String.Format("Matrix has been saved into csv file '{0}'", Config.Path.Absolute));
}
public override void Compute()
{
TLSimilarityMatrix sims = (TLSimilarityMatrix)Workspace.Load("Similarities");
TLSimilarityMatrix oracle = (TLSimilarityMatrix)Workspace.Load("Oracle");
Workspace.Store("DataSetPairs", OverallMetricsComputation.ComputeAll(sims, oracle));
}
public void RunBeforeEachTest()
{
oracle = new TLSimilarityMatrix();
oracle.AddLink("A", "B*", 1);
oracle.AddLink("A", "C*", 1);
oracle.AddLink("A", "D*", 1);
sims = new TLSimilarityMatrix();
/* Sorted order:
* sims.AddLink("A", "B*", 10);
* sims.AddLink("A", "E", 9);
* sims.AddLink("A", "F", 8);
* sims.AddLink("A", "C*", 7);
* sims.AddLink("A", "G", 6);
* sims.AddLink("A", "H", 5);
* sims.AddLink("A", "I", 4);
* sims.AddLink("A", "J", 3);
* sims.AddLink("A", "D*", 2);
* sims.AddLink("A", "K", 1);
*/
sims.AddLink("A", "G", 6);
sims.AddLink("A", "K", 1);
sims.AddLink("A", "B*", 10);
sims.AddLink("A", "E", 9);
sims.AddLink("A", "J", 3);
sims.AddLink("A", "F", 8);
sims.AddLink("A", "C*", 7);
sims.AddLink("A", "H", 5);
sims.AddLink("A", "D*", 2);
sims.AddLink("A", "I", 4);
}
private static TLSimilarityMatrix Process(TLArtifactsCollection sourceArtifacts, TLDictionaryIndex dict, TracerConfig config)
{
if (sourceArtifacts == null)
{
throw new ComponentException("Received null sourceArtifacts");
}
if (dict == null)
{
throw new ComponentException("Received null dictionaryIndex");
}
TLSimilarityMatrix similarityMatrix = new TLSimilarityMatrix();
Searcher searcher = new Searcher(SimilarityMetricFactory.GetSimiliarityMetric(config.SimilarityMetric));
// Iterates over all the source artifacts to determine the probabilities to target artifacts - by executing a search
foreach (TLArtifact sourceArtifact in sourceArtifacts.Values)
{
String query = sourceArtifact.Text;
// Executes the query
List <Result> results;
results = searcher.search(query, dict);
// Iterates over the results and stores them in the matrix
foreach (Result r in results)
{
string targetArtifactId = r.ArtifactId;
similarityMatrix.AddLink(sourceArtifact.Id, targetArtifactId, r.Ranking);
}
}
return(similarityMatrix);
}
public override void Compute()
{
Logger.Trace("Starting metrics computation: " + _config.TechniqueName);
TLSimilarityMatrix matrix = (TLSimilarityMatrix)Workspace.Load("CandidateMatrix");
TLSimilarityMatrix oracle = (TLSimilarityMatrix)Workspace.Load("AnswerMatrix");
TLExperimentResults exResults = new TLExperimentResults(_config.TechniqueName);
#region Effectiveness Best Measure
if (_config.EffectivenessBestMeasure)
{
Logger.Trace("Computing effectiveness best measure...");
IMetricComputation computation = new EffectivenessBestMeasureComputation(matrix, oracle);
computation.Compute();
ResultsController.Instance.AddResult(_config.TechniqueName, _config.DatasetName, computation);
}
else
{
Logger.Trace("Skipped effectiveness best measure computation.");
}
#endregion
#region Effectiveness All Measure
if (_config.EffectivenessAllMeasure)
{
Logger.Trace("Computing effectiveness all measure...");
IMetricComputation computation = new EffectivenessAllMeasureComputation(matrix, oracle);
computation.Compute();
ResultsController.Instance.AddResult(_config.TechniqueName, _config.DatasetName, computation);
}
else
{
Logger.Trace("Skipped effectiveness all measure computation.");
}
#endregion
}
public override void Compute()
{
List <CSMR13DataSet> ListOfDatasets = (List <CSMR13DataSet>)Workspace.Load("ListOfDatasets");
int CurrentDataset = (int)Workspace.Load("CurrentDataset");
ListOfDatasets[CurrentDataset].Metrics = new DataSetPairsCollection();
ListOfDatasets[CurrentDataset].Similarities = new List <TLSimilarityMatrix>();
string[] IRmodels = new string[] { "VSM", "JS" };
string[] StructuralModels = new string[] { "OCSTI", "UDCSTI" };
foreach (string IRmodel in IRmodels)
{
TLSimilarityMatrix baseSims = (TLSimilarityMatrix)Workspace.Load(IRmodel + "_Similarities");
baseSims.Name = IRmodel;
ListOfDatasets[CurrentDataset].Similarities.Add(baseSims);
foreach (DataSetPairs basePairs in (DataSetPairsCollection)Workspace.Load(IRmodel + "_Metrics"))
{
basePairs.Name = IRmodel + " @" + basePairs.Name;
ListOfDatasets[CurrentDataset].Metrics.Add(basePairs);
}
foreach (string StructuralModel in StructuralModels)
{
TLSimilarityMatrix structuralSims = (TLSimilarityMatrix)Workspace.Load(IRmodel + "_" + StructuralModel);
structuralSims.Name = IRmodel + "_" + StructuralModel;
ListOfDatasets[CurrentDataset].Similarities.Add(structuralSims);
foreach (DataSetPairs structuralPairs in (DataSetPairsCollection)Workspace.Load(IRmodel + "_" + StructuralModel + "_Metrics"))
{
structuralPairs.Name = IRmodel + " " + StructuralModel + " @" + structuralPairs.Name;
ListOfDatasets[CurrentDataset].Metrics.Add(structuralPairs);
}
}
}
Workspace.Store("ListOfDatasets", ListOfDatasets);
}
/// <summary>
/// Returns links for the desired recall level.
/// </summary>
/// <param name="matrix">Candidate matrix</param>
/// <param name="answerMatrix">Answer matrix</param>
/// <param name="level">Desired recall level</param>
/// <returns>List of links at desired recall</returns>
public static TLLinksList GetLinksAtRecall(TLSimilarityMatrix matrix, TLSimilarityMatrix answerMatrix, double level)
{
if (level <= 0.0 || level > 1.0)
{
throw new DevelopmentKitException("Recall level must be between 0 and 1.");
}
double totalCorrect = answerMatrix.Count * level;
int numCorrect = 0;
TLLinksList links = matrix.AllLinks;
links.Sort();
TLLinksList newLinks = new TLLinksList();
while (links.Count > 0 && numCorrect < totalCorrect)
{
TLSingleLink link = links[0];
if (answerMatrix.IsLinkAboveThreshold(link.SourceArtifactId, link.TargetArtifactId))
{
numCorrect++;
}
newLinks.Add(link);
links.RemoveAt(0);
}
return(newLinks);
}
public void SimilarityMatrixRawSerializationTest()
{
string[] sources = new string[] { "source1", "source2", "source3", "source4", "source5", "source6", "source7", "source8", "source9", "source10" };
string[] targets = new string[] { "target1", "target2", "target3", "target4", "target5", "target6", "target7", "target8", "target9", "target10" };
TLSimilarityMatrix matrixIn = new TLSimilarityMatrix();
for (int i = 0; i < sources.Length; i++)
{
matrixIn.AddLink(sources[i], targets[i], (double)i);
}
BinaryWriter binWriter = new BinaryWriter(new MemoryStream());
BinaryReader binReader = new BinaryReader(binWriter.BaseStream);
matrixIn.WriteData(binWriter);
binReader.BaseStream.Position = 0;
TLSimilarityMatrix matrixOut = new TLSimilarityMatrix();
matrixOut.ReadData(binReader);
Assert.AreEqual(matrixIn.Count, matrixOut.Count);
StringHashSet setIn = matrixIn.SourceArtifactsIds;
StringHashSet setOut = matrixOut.SourceArtifactsIds;
foreach (string artifact in setIn)
{
Assert.IsTrue(setOut.Contains(artifact));
}
}
public override void Compute()
{
TLSimilarityMatrix sims = (TLSimilarityMatrix)Workspace.Load("Similarities");
TLSimilarityMatrix oracle = (TLSimilarityMatrix)Workspace.Load("Oracle");
Workspace.Store("DataSetPairs", MetricsPerSourceArtifact.Compute(sims, oracle, _config.Recall));
}
/// <summary>
/// Computes cosine similarities between two TermDocumentMatrices.
/// Cosine similarity is defined as (dot product) / (length * length)
/// </summary>
/// <param name="m1">Binary document matrix</param>
/// <param name="m2">tf-idf weighted document matrix</param>
/// <returns>Similarity matrix</returns>
public static TLSimilarityMatrix ComputeCosine(TermDocumentMatrix m1, TermDocumentMatrix m2)
{
TLSimilarityMatrix sims = new TLSimilarityMatrix();
List <TermDocumentMatrix> matrices = TermDocumentMatrix.Equalize(m1, m2);
for (int i = 0; i < m1.NumDocs; i++)
{
TLLinksList links = new TLLinksList();
for (int j = 0; j < m2.NumDocs; j++)
{
double lengthProduct = ComputeLength(matrices[0].GetDocument(i)) * ComputeLength(matrices[1].GetDocument(j));
if (lengthProduct == 0.0)
{
links.Add(new TLSingleLink(m1.GetDocumentName(i), m2.GetDocumentName(j), 0.0));
}
else
{
links.Add(new TLSingleLink(m1.GetDocumentName(i), m2.GetDocumentName(j), ComputeDotProduct(matrices[0].GetDocument(i), matrices[1].GetDocument(j)) / lengthProduct));
}
}
links.Sort();
foreach (TLSingleLink link in links)
{
sims.AddLink(link.SourceArtifactId, link.TargetArtifactId, link.Score);
}
}
return(sims);
}
public override void Compute()
{
TLSimilarityMatrix matrix = (TLSimilarityMatrix)Workspace.Load("Matrix");
TLSimilarityMatrix pruned = TLSimilarityMatrixUtil.CreateMatrix(TLSimilarityMatrixUtil.GetTopNLinks(matrix, _config.N));
Workspace.Store("PrunedMatrix", pruned);
}
/// <summary>
/// Computes the delta value for an individual artifact
/// </summary>
/// <param name="matrix">Similarities</param>
/// <param name="source">Source artifact id</param>
/// <returns>delta</returns>
public static double ComputeForSourceArtifact(TLSimilarityMatrix matrix, string source)
{
matrix.Threshold = double.MinValue;
double min = Double.MaxValue;
double max = Double.MinValue;
foreach (TLSingleLink link in matrix.GetLinksAboveThresholdForSourceArtifact(source))
{
if (link.Score < min)
{
min = link.Score;
}
if (link.Score > max)
{
max = link.Score;
}
}
double delta = (max - min) / 2.0;
// according to R scripts
if (delta < 0.05)
{
delta = Math.Pow(delta, 4) / 4;
}
return(delta);
}
/// <summary>
/// Exports a TLSimilarityMatrix to CSV with an additional column for correct links
/// 0 - incorrect link
/// 1 - correct link
/// </summary>
/// <param name="similarityMatrix">Candidate Matrix</param>
/// <param name="answerMatrix">Answer Matrix</param>
/// <param name="outputPath">Output file path</param>
public static void ExportCSVWithCorrectness(TLSimilarityMatrix similarityMatrix, TLSimilarityMatrix answerMatrix, string outputPath)
{
if (similarityMatrix == null)
{
throw new DevelopmentKitException("Received similarity matrix is null!");
}
if (answerMatrix == null)
{
throw new DevelopmentKitException("Received answer similarity matrix is null!");
}
if (outputPath == null)
{
throw new DevelopmentKitException("Output path cannot be null.");
}
if (!System.IO.Path.IsPathRooted(outputPath))
{
throw new DevelopmentKitException(String.Format("Absolute output path is required. Given path is '{0}'", outputPath));
}
if (outputPath.EndsWith(".csv", StringComparison.CurrentCultureIgnoreCase) == false)
{
outputPath = outputPath + ".csv";
}
using (System.IO.TextWriter writeFile = new StreamWriter(outputPath))
{
WriteMatrixCSVWithCorrectness(similarityMatrix, answerMatrix, writeFile);
writeFile.Flush();
writeFile.Close();
}
}
public override void Compute()
{
TLSimilarityMatrix sims = (TLSimilarityMatrix)Workspace.Load("Similarities");
TLSimilarityMatrix relationships = (TLSimilarityMatrix)Workspace.Load("StructuralRelationships");
Workspace.Store("O-CSTI_Similarities", OCSTI.Compute(sims, relationships));
}
/// <summary>
/// Reads the data. (allows faster custom serialization for better performance in TraceLab)
/// </summary>
/// <param name="reader">The reader.</param>
public void ReadData(System.IO.BinaryReader reader)
{
int dataversion = reader.ReadInt32();
if (dataversion != TLDataset.version)
{
throw new InvalidOperationException("Binary reader did not read correct data version. Data corrupted. Potentially IRawSerializable not implemented correctly");
}
else
{
this.m_name = reader.ReadString();
bool isMemberPresent = reader.ReadBoolean();
if (isMemberPresent)
{
TLArtifactsCollection artifacts = new TLArtifactsCollection();
artifacts.ReadData(reader);
this.SourceArtifacts = artifacts;
}
isMemberPresent = reader.ReadBoolean();
if (isMemberPresent)
{
TLArtifactsCollection artifacts = new TLArtifactsCollection();
artifacts.ReadData(reader);
this.TargetArtifacts = artifacts;
}
isMemberPresent = reader.ReadBoolean();
if (isMemberPresent)
{
TLSimilarityMatrix matrix = new TLSimilarityMatrix();
matrix.ReadData(reader);
this.AnswerSet = matrix;
}
}
}
