private void EncodeSeedNodes(
IEnumerable <CstNode> seedNodes, EncodingResult result,
IDictionary <BigInteger, string> idealVector2Path,
IDictionary <BigInteger, string> seedVector2Path, LearningExperiment oracle)
{
foreach (var node in seedNodes)
{
var vector = node.GetFeatureVector(_featureString2Bit, _extractor);
if (oracle.IsAcceptedUsingOracle(node))
{
// TODO: for debug
if (result.IdealRejectedVector2GroupPath.ContainsKey(vector))
{
PrintNotDistinguishedElement(node, vector, result, oracle);
}
}
else
{
// TODO: for debug
if (result.IdealAcceptedVector2GroupPath.ContainsKey(vector))
{
PrintNotDistinguishedElement(node, vector, result, oracle);
}
}
UpdateVector2GroupPath(idealVector2Path, vector, node);
seedVector2Path[vector] = idealVector2Path[vector];
UpdateVectorDict(result, vector, node);
}
}
private void EncodeTargetNodes(
IEnumerable <CstNode> allUppermostNodes, EncodingResult result,
LearningExperiment oracle)
{
foreach (var uppermostNode in allUppermostNodes)
{
var vector = uppermostNode.GetFeatureVector(_featureString2Bit, _extractor);
if (oracle.IsAcceptedUsingOracle(uppermostNode))
{
// TODO: for debug
if (result.IdealRejectedVector2GroupPath.ContainsKey(vector))
{
PrintNotDistinguishedElement(uppermostNode, vector, result, oracle);
}
UpdateVector2GroupPath(result.IdealAcceptedVector2GroupPath, vector,
uppermostNode);
}
else
{
// TODO: for debug
if (result.IdealAcceptedVector2GroupPath.ContainsKey(vector))
{
PrintNotDistinguishedElement(uppermostNode, vector, result, oracle);
}
UpdateVector2GroupPath(result.IdealRejectedVector2GroupPath, vector,
uppermostNode);
}
UpdateVectorDict(result, vector, uppermostNode);
}
}
private void PrintNotDistinguishedElement(
CstNode e, BigInteger vector, EncodingResult result, LearningExperiment oracle)
{
if (--_printCount >= 0)
{
Console.WriteLine("==========================================");
Console.WriteLine(e.Parent.Name + ", " + e.Name + ", " + e.Code);
Console.WriteLine(Experiment.GetGoodAncestorNode(e).Code);
Console.WriteLine(
result.Vector2Node[vector].Parent.Name + ", "
+ result.Vector2Node[vector].Name + ", "
+ result.Vector2Node[vector].Code);
Console.WriteLine(Experiment.GetGoodAncestorNode(result.Vector2Node[vector]).Code);
Console.WriteLine("------------------------------------------");
if (Experiment.GetGoodAncestorNode(e).Code.Contains("Contract.Requires") &&
Experiment.GetGoodAncestorNode(result.Vector2Node[vector])
.Code.Contains("Contract.Requires"))
{
oracle.IsAcceptedUsingOracle(e);
oracle.IsAcceptedUsingOracle(result.Vector2Node[vector]);
}
foreach (var featureString in GetFeatureStringsByVector(vector))
{
Console.WriteLine(Experiment.Beautify(featureString));
}
}
}
public IDictionary <BigInteger, string> RevealSuspiciousElements(
ICollection <BigInteger> actuallyAcceptedVectors,
IList <SuspiciousNode> suspiciousNodes,
EncodingResult encodingResult, RevealedVectorSet trainingSet)
{
var additionalAcceptedVector2GroupPath = new Dictionary <BigInteger, string>();
foreach (var t in suspiciousNodes)
{
if (actuallyAcceptedVectors.Contains(t.Vector))
{
additionalAcceptedVector2GroupPath.Add(t.Vector, t.GroupKey);
trainingSet.Accepted.Add(t.Vector, t.GroupKey);
}
else
{
trainingSet.Rejected.Add(t.Vector, t.GroupKey);
}
}
Console.WriteLine(
"Accepted: " + trainingSet.AcceptedCount + " + "
+ additionalAcceptedVector2GroupPath.Count
+ " / " + encodingResult.IdealVectorSet.AcceptedCount);
Console.WriteLine(
"Rejected: " + trainingSet.RejectedCount + " + "
+ (suspiciousNodes.Count - additionalAcceptedVector2GroupPath.Count)
+ " / " + encodingResult.IdealVectorSet.RejectedCount);
return(additionalAcceptedVector2GroupPath);
}
public ClassificationResult(
IEnumerable<SuspiciousNode> suspiciousNodes, IEnumerable<BigInteger> wronglyAcceptedFeatures,
IEnumerable<BigInteger> wronglyRejectedFeatures, int wrongVectorCount, int wrongElementCount,
EncodingResult encodingResult) {
SuspiciousNodes = suspiciousNodes != null ? suspiciousNodes.ToImmutableList() : null;
WronglyAcceptedVectors = wronglyAcceptedFeatures.ToImmutableList();
WronglyRejectedVectors = wronglyRejectedFeatures.ToImmutableList();
WrongVectorCount = wrongVectorCount;
WrongElementCount = wrongElementCount;
_vector2Node = encodingResult.Vector2Node;
}
public EncodingResult Encode(
ICollection <string> codePaths, IEnumerable <CstNode> allCsts,
LearningExperiment oracle, SeedNodeSet seedNodeSet = null)
{
var fileName = codePaths.Count > 0
? string.Join(",", codePaths).GetHashCode() + "_" +
(codePaths.First() + "," + codePaths.Last() + ",").GetHashCode() + "_"
+ codePaths.Count + ".encoded"
: null;
var formatter = new BinaryFormatter();
if (fileName != null && File.Exists(fileName))
{
using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
try {
var ret = ((EncodingResult)formatter.Deserialize(fs)).MakeImmutable();
Console.WriteLine("############### Warning ###############");
Console.WriteLine("Cache file of encoded result is used.");
Console.WriteLine("#######################################");
return(ret);
} catch (Exception e) {
Console.Error.WriteLine(e);
}
}
}
var allUppermostNodes = allCsts.SelectMany(
cst => LearningExperimentUtil.GetUppermostNodesByNames(cst, _selectedNodeNames));
var result = new EncodingResult();
if (seedNodeSet != null)
{
result.SeedAcceptedNodeCount = seedNodeSet.AcceptedNodes.Count;
result.SeedNodeCount = result.SeedAcceptedNodeCount
+ seedNodeSet.RejectedNodes.Count;
EncodeSeedNodes(
seedNodeSet.AcceptedNodes, result, result.IdealAcceptedVector2GroupPath,
result.SeedAcceptedVector2GroupPath, oracle);
EncodeSeedNodes(
seedNodeSet.RejectedNodes, result, result.IdealRejectedVector2GroupPath,
result.SeedRejectedVector2GroupPath, oracle);
}
EncodeTargetNodes(allUppermostNodes, result, oracle);
if (fileName != null)
{
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
formatter.Serialize(fs, result);
}
}
return(result.MakeImmutable());
}
private static void UpdateVectorDict(EncodingResult result, BigInteger vector, CstNode node)
{
result.Vector2Node[vector] = node;
if (result.Vector2Count.ContainsKey(vector))
{
result.Vector2Count[vector]++;
}
else
{
result.Vector2Count[vector] = 1;
}
}
public ClassificationResult(
IEnumerable <SuspiciousNode> suspiciousNodes, IEnumerable <BigInteger> wronglyAcceptedFeatures,
IEnumerable <BigInteger> wronglyRejectedFeatures, int wrongVectorCount, int wrongElementCount,
EncodingResult encodingResult)
{
SuspiciousNodes = suspiciousNodes != null?suspiciousNodes.ToImmutableList() : null;
WronglyAcceptedVectors = wronglyAcceptedFeatures.ToImmutableList();
WronglyRejectedVectors = wronglyRejectedFeatures.ToImmutableList();
WrongVectorCount = wrongVectorCount;
WrongElementCount = wrongElementCount;
_vector2Node = encodingResult.Vector2Node;
}
private void EncodeSeedNodes(
IEnumerable<CstNode> seedNodes, EncodingResult result,
IDictionary<BigInteger, string> idealVector2Path,
IDictionary<BigInteger, string> seedVector2Path, LearningExperiment oracle) {
foreach (var node in seedNodes) {
var vector = node.GetFeatureVector(_featureString2Bit, _extractor);
if (oracle.IsAcceptedUsingOracle(node)) {
// TODO: for debug
if (result.IdealRejectedVector2GroupPath.ContainsKey(vector)) {
PrintNotDistinguishedElement(node, vector, result, oracle);
}
} else {
// TODO: for debug
if (result.IdealAcceptedVector2GroupPath.ContainsKey(vector)) {
PrintNotDistinguishedElement(node, vector, result, oracle);
}
}
UpdateVector2GroupPath(idealVector2Path, vector, node);
seedVector2Path[vector] = idealVector2Path[vector];
UpdateVectorDict(result, vector, node);
}
}
public ClassificationResult Classify(
int count, Classifier classifier, GroupCache groupCache,
EncodingResult encodingResult,
RevealedVectorSet trainingSet = null)
{
trainingSet = trainingSet ?? new RevealedVectorSet();
var correctlyAccepted = 0;
var correctlyRejected = 0;
var wronglyAccepted = 0;
var wronglyRejected = 0;
var correctlyRejectedInRejecting = 0;
var wronglyRejectedInRejecting = 0;
var rejectAccept = new List <List <SuspiciousNode> >();
var rejectReject = new List <List <SuspiciousNode> >();
var acceptAccept = new List <List <SuspiciousNode> >();
var acceptReject = new List <List <SuspiciousNode> >();
for (int i = 0; i < classifier.GroupCount; i++)
{
rejectAccept.Add(new List <SuspiciousNode>());
rejectReject.Add(new List <SuspiciousNode>());
acceptAccept.Add(new List <SuspiciousNode>());
acceptReject.Add(new List <SuspiciousNode>());
}
var wrongNodeCount = 0;
var wronglyRejectedFeatures = new List <BigInteger>();
var wronglyAcceptedFeatures = new List <BigInteger>();
foreach (var vectorAndGroupPath in encodingResult.IdealVectorSet.Accepted)
{
var vector = vectorAndGroupPath.Key;
var groupPath = vectorAndGroupPath.Value;
var groupIndex = groupCache.GetGroupIndex(vector);
var rejected = classifier.IsRejected(vector, groupIndex);
var accepted = classifier.IsAccepted(vector, groupIndex);
if (!trainingSet.Accepted.ContainsKey(vector) &&
!trainingSet.Rejected.ContainsKey(vector))
{
var target = new SuspiciousNode {
Vector = vector,
GroupKey = groupPath,
Used = false,
};
if (accepted)
{
if (!rejected)
{
acceptAccept[groupIndex].Add(target);
}
else
{
acceptReject[groupIndex].Add(target);
}
}
else
{
if (!rejected)
{
rejectAccept[groupIndex].Add(target);
}
else
{
rejectReject[groupIndex].Add(target);
}
}
}
if (!accepted)
{
wronglyRejected++;
wrongNodeCount += encodingResult.Vector2Count[vector];
wronglyRejectedFeatures.Add(vector);
}
else if (!rejected)
{
correctlyAccepted++;
}
else
{
wronglyRejectedInRejecting++;
wrongNodeCount += encodingResult.Vector2Count[vector];
wronglyRejectedFeatures.Add(vector);
}
}
foreach (var vectorAndGroupPath in encodingResult.IdealVectorSet.Rejected)
{
var vector = vectorAndGroupPath.Key;
var groupPath = vectorAndGroupPath.Value;
var groupIndex = groupCache.GetGroupIndex(vector);
var rejected = classifier.IsRejected(vector, groupIndex);
var accepted = classifier.IsAccepted(vector, groupIndex);
if (!trainingSet.Accepted.ContainsKey(vector) &&
!trainingSet.Rejected.ContainsKey(vector))
{
var target = new SuspiciousNode {
Vector = vector,
GroupKey = groupPath,
Used = false,
};
if (accepted)
{
if (!rejected)
{
acceptAccept[groupIndex].Add(target);
}
else
{
acceptReject[groupIndex].Add(target);
}
}
else
{
if (!rejected)
{
rejectAccept[groupIndex].Add(target);
}
else
{
rejectReject[groupIndex].Add(target);
}
}
}
if (!accepted)
{
correctlyRejected++;
}
else if (!rejected)
{
wronglyAccepted++;
wrongNodeCount += encodingResult.Vector2Count[vector];
wronglyAcceptedFeatures.Add(vector);
}
else
{
correctlyRejectedInRejecting++;
}
}
Console.WriteLine("done");
Console.WriteLine(
"WA: " + wronglyAccepted + ", WR: " + wronglyRejected + "/"
+ wronglyRejectedInRejecting + ", CA: "
+ correctlyAccepted + ", CR: " + correctlyRejected + "/"
+ correctlyRejectedInRejecting);
Console.WriteLine(
"TR: "
+ trainingSet.Count + ", AF: "
+ String.Join(", ", classifier.CountAcceptingFeatures())
+ ", RF: "
+ String.Join(", ", classifier.CountRejectingFeatures()));
var wrongFeatureCount = wronglyAccepted + wronglyRejected
+ wronglyRejectedInRejecting;
var selector = new SuspiciousNodeSelector(classifier.AcceptingFeatureBitMask,
classifier.RejectingFeatureBitMask);
var suspiciousNodes = selector.SelectSuspiciousNodes(count, classifier, acceptAccept,
acceptReject, rejectAccept, rejectReject);
return(new ClassificationResult(suspiciousNodes, wronglyAcceptedFeatures,
wronglyRejectedFeatures,
wrongFeatureCount, wrongNodeCount, encodingResult));
}
public IList <int> CountRejectedVectorsOfEachGroup(EncodingResult encodingResult)
{
return(CountVectorsOfEachGroup(encodingResult.IdealRejectedVector2GroupPath.Values));
}
public EncodingResult Encode(
ICollection<string> codePaths, IEnumerable<CstNode> allCsts,
LearningExperiment oracle, SeedNodeSet seedNodeSet = null) {
var fileName = codePaths.Count > 0
? string.Join(",", codePaths).GetHashCode() + "_" +
(codePaths.First() + "," + codePaths.Last() + ",").GetHashCode() + "_"
+ codePaths.Count + ".encoded"
: null;
var formatter = new BinaryFormatter();
if (fileName != null && File.Exists(fileName)) {
using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read)) {
try {
var ret = ((EncodingResult)formatter.Deserialize(fs)).MakeImmutable();
Console.WriteLine("############### Warning ###############");
Console.WriteLine("Cache file of encoded result is used.");
Console.WriteLine("#######################################");
return ret;
} catch (Exception e) {
Console.Error.WriteLine(e);
}
}
}
var allUppermostNodes = allCsts.SelectMany(
cst => LearningExperimentUtil.GetUppermostNodesByNames(cst, _selectedNodeNames));
var result = new EncodingResult();
if (seedNodeSet != null) {
result.SeedAcceptedNodeCount = seedNodeSet.AcceptedNodes.Count;
result.SeedNodeCount = result.SeedAcceptedNodeCount
+ seedNodeSet.RejectedNodes.Count;
EncodeSeedNodes(
seedNodeSet.AcceptedNodes, result, result.IdealAcceptedVector2GroupPath,
result.SeedAcceptedVector2GroupPath, oracle);
EncodeSeedNodes(
seedNodeSet.RejectedNodes, result, result.IdealRejectedVector2GroupPath,
result.SeedRejectedVector2GroupPath, oracle);
}
EncodeTargetNodes(allUppermostNodes, result, oracle);
if (fileName != null) {
using (var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write)) {
formatter.Serialize(fs, result);
}
}
return result.MakeImmutable();
}
private void PrintNotDistinguishedElement(
CstNode e, BigInteger vector, EncodingResult result, LearningExperiment oracle) {
if (--_printCount >= 0) {
Console.WriteLine("==========================================");
Console.WriteLine(e.Parent.Name + ", " + e.Name + ", " + e.Code);
Console.WriteLine(Experiment.GetGoodAncestorNode(e).Code);
Console.WriteLine(
result.Vector2Node[vector].Parent.Name + ", "
+ result.Vector2Node[vector].Name + ", "
+ result.Vector2Node[vector].Code);
Console.WriteLine(Experiment.GetGoodAncestorNode(result.Vector2Node[vector]).Code);
Console.WriteLine("------------------------------------------");
if (Experiment.GetGoodAncestorNode(e).Code.Contains("Contract.Requires") &&
Experiment.GetGoodAncestorNode(result.Vector2Node[vector])
.Code.Contains("Contract.Requires")) {
oracle.IsAcceptedUsingOracle(e);
oracle.IsAcceptedUsingOracle(result.Vector2Node[vector]);
}
foreach (var featureString in GetFeatureStringsByVector(vector)) {
Console.WriteLine(Experiment.Beautify(featureString));
}
}
}
private static void UpdateVectorDict(EncodingResult result, BigInteger vector, CstNode node) {
result.Vector2Node[vector] = node;
if (result.Vector2Count.ContainsKey(vector)) {
result.Vector2Count[vector]++;
} else {
result.Vector2Count[vector] = 1;
}
}
public ClassificationResult Classify(
int count, Classifier classifier, GroupCache groupCache,
EncodingResult encodingResult,
RevealedVectorSet trainingSet = null) {
trainingSet = trainingSet ?? new RevealedVectorSet();
var correctlyAccepted = 0;
var correctlyRejected = 0;
var wronglyAccepted = 0;
var wronglyRejected = 0;
var correctlyRejectedInRejecting = 0;
var wronglyRejectedInRejecting = 0;
var rejectAccept = new List<List<SuspiciousNode>>();
var rejectReject = new List<List<SuspiciousNode>>();
var acceptAccept = new List<List<SuspiciousNode>>();
var acceptReject = new List<List<SuspiciousNode>>();
for (int i = 0; i < classifier.GroupCount; i++) {
rejectAccept.Add(new List<SuspiciousNode>());
rejectReject.Add(new List<SuspiciousNode>());
acceptAccept.Add(new List<SuspiciousNode>());
acceptReject.Add(new List<SuspiciousNode>());
}
var wrongNodeCount = 0;
var wronglyRejectedFeatures = new List<BigInteger>();
var wronglyAcceptedFeatures = new List<BigInteger>();
foreach (var vectorAndGroupPath in encodingResult.IdealVectorSet.Accepted) {
var vector = vectorAndGroupPath.Key;
var groupPath = vectorAndGroupPath.Value;
var groupIndex = groupCache.GetGroupIndex(vector);
var rejected = classifier.IsRejected(vector, groupIndex);
var accepted = classifier.IsAccepted(vector, groupIndex);
if (!trainingSet.Accepted.ContainsKey(vector)
&& !trainingSet.Rejected.ContainsKey(vector)) {
var target = new SuspiciousNode {
Vector = vector,
GroupKey = groupPath,
Used = false,
};
if (accepted) {
if (!rejected) {
acceptAccept[groupIndex].Add(target);
} else {
acceptReject[groupIndex].Add(target);
}
} else {
if (!rejected) {
rejectAccept[groupIndex].Add(target);
} else {
rejectReject[groupIndex].Add(target);
}
}
}
if (!accepted) {
wronglyRejected++;
wrongNodeCount += encodingResult.Vector2Count[vector];
wronglyRejectedFeatures.Add(vector);
} else if (!rejected) {
correctlyAccepted++;
} else {
wronglyRejectedInRejecting++;
wrongNodeCount += encodingResult.Vector2Count[vector];
wronglyRejectedFeatures.Add(vector);
}
}
foreach (var vectorAndGroupPath in encodingResult.IdealVectorSet.Rejected) {
var vector = vectorAndGroupPath.Key;
var groupPath = vectorAndGroupPath.Value;
var groupIndex = groupCache.GetGroupIndex(vector);
var rejected = classifier.IsRejected(vector, groupIndex);
var accepted = classifier.IsAccepted(vector, groupIndex);
if (!trainingSet.Accepted.ContainsKey(vector)
&& !trainingSet.Rejected.ContainsKey(vector)) {
var target = new SuspiciousNode {
Vector = vector,
GroupKey = groupPath,
Used = false,
};
if (accepted) {
if (!rejected) {
acceptAccept[groupIndex].Add(target);
} else {
acceptReject[groupIndex].Add(target);
}
} else {
if (!rejected) {
rejectAccept[groupIndex].Add(target);
} else {
rejectReject[groupIndex].Add(target);
}
}
}
if (!accepted) {
correctlyRejected++;
} else if (!rejected) {
wronglyAccepted++;
wrongNodeCount += encodingResult.Vector2Count[vector];
wronglyAcceptedFeatures.Add(vector);
} else {
correctlyRejectedInRejecting++;
}
}
Console.WriteLine("done");
Console.WriteLine(
"WA: " + wronglyAccepted + ", WR: " + wronglyRejected + "/"
+ wronglyRejectedInRejecting + ", CA: "
+ correctlyAccepted + ", CR: " + correctlyRejected + "/"
+ correctlyRejectedInRejecting);
Console.WriteLine(
"TR: "
+ trainingSet.Count + ", AF: "
+ String.Join(", ", classifier.CountAcceptingFeatures())
+ ", RF: "
+ String.Join(", ", classifier.CountRejectingFeatures()));
var wrongFeatureCount = wronglyAccepted + wronglyRejected
+ wronglyRejectedInRejecting;
var selector = new SuspiciousNodeSelector(classifier.AcceptingFeatureBitMask,
classifier.RejectingFeatureBitMask);
var suspiciousNodes = selector.SelectSuspiciousNodes(count, classifier, acceptAccept,
acceptReject, rejectAccept, rejectReject);
return new ClassificationResult(suspiciousNodes, wronglyAcceptedFeatures,
wronglyRejectedFeatures,
wrongFeatureCount, wrongNodeCount, encodingResult);
}
public GroupCache(EncodingResult encodingResult, Classifier classifier)
{
_encodingResult = encodingResult;
UpdateGroupCache(classifier);
}
public GroupCache(EncodingResult encodingResult, Classifier classifier) {
_encodingResult = encodingResult;
UpdateGroupCache(classifier);
}
public IDictionary<BigInteger, string> RevealSuspiciousElements(
ICollection<BigInteger> actuallyAcceptedVectors,
IList<SuspiciousNode> suspiciousNodes,
EncodingResult encodingResult, RevealedVectorSet trainingSet) {
var additionalAcceptedVector2GroupPath = new Dictionary<BigInteger, string>();
foreach (var t in suspiciousNodes) {
if (actuallyAcceptedVectors.Contains(t.Vector)) {
additionalAcceptedVector2GroupPath.Add(t.Vector, t.GroupKey);
trainingSet.Accepted.Add(t.Vector, t.GroupKey);
} else {
trainingSet.Rejected.Add(t.Vector, t.GroupKey);
}
}
Console.WriteLine(
"Accepted: " + trainingSet.AcceptedCount + " + "
+ additionalAcceptedVector2GroupPath.Count
+ " / " + encodingResult.IdealVectorSet.AcceptedCount);
Console.WriteLine(
"Rejected: " + trainingSet.RejectedCount + " + "
+ (suspiciousNodes.Count - additionalAcceptedVector2GroupPath.Count)
+ " / " + encodingResult.IdealVectorSet.RejectedCount);
return additionalAcceptedVector2GroupPath;
}
public IList<int> CountRejectedVectorsOfEachGroup(EncodingResult encodingResult) {
return CountVectorsOfEachGroup(encodingResult.IdealRejectedVector2GroupPath.Values);
}
private void EncodeTargetNodes(
IEnumerable<CstNode> allUppermostNodes, EncodingResult result,
LearningExperiment oracle) {
foreach (var uppermostNode in allUppermostNodes) {
var vector = uppermostNode.GetFeatureVector(_featureString2Bit, _extractor);
if (oracle.IsAcceptedUsingOracle(uppermostNode)) {
// TODO: for debug
if (result.IdealRejectedVector2GroupPath.ContainsKey(vector)) {
PrintNotDistinguishedElement(uppermostNode, vector, result, oracle);
}
UpdateVector2GroupPath(result.IdealAcceptedVector2GroupPath, vector,
uppermostNode);
} else {
// TODO: for debug
if (result.IdealAcceptedVector2GroupPath.ContainsKey(vector)) {
PrintNotDistinguishedElement(uppermostNode, vector, result, oracle);
}
UpdateVector2GroupPath(result.IdealRejectedVector2GroupPath, vector,
uppermostNode);
}
UpdateVectorDict(result, vector, uppermostNode);
}
}
