public GWNeuralNetwork(List <NeuralNetworkInputNode <InputData> > inputNodes, int[] innerLayers)
{
Graph = new GWGraph <NeuralNetworkNodeData, NeuralNetworkEdgeData, GWNeuralNetwork <InputData> >();
Graph.GraphStyle = GraphStyle.Directed;
InputNodes = inputNodes.ToList();
// init layers
Layers = new List <GWNode <NeuralNetworkNodeData, NeuralNetworkEdgeData, GWNeuralNetwork <InputData> > > [innerLayers.Length + 2];
for (int layer = 0; layer < Layers.Length; layer++)
{
Layers[layer] = new List <GWNode <NeuralNetworkNodeData, NeuralNetworkEdgeData, GWNeuralNetwork <InputData> > >();
}
//inputLayer:
for (int i = 0; i < InputNodes.Count; i++)
{
var node = Graph.CreateNode();
node.Data = InputNodes[i];
Layers[0].Add(node);
}
//create inner layers
var random = new Random();
int defConnects = 4;
for (int layer = 1; layer <= innerLayers.Length; layer++)
{
Layers[layer] = new List <GWNode <NeuralNetworkNodeData, NeuralNetworkEdgeData, GWNeuralNetwork <InputData> > >();
for (int i = 0; i < innerLayers[layer - 1]; i++)
{
var node = Graph.CreateNode();
node.Data = new NeuralNetworkNodeData();
//connect with former layer
for (int k = 0; k < defConnects; k++)
{
var otherNode = Layers[layer - 1].RandomElement(random);
var edge = Graph.CreateEdge(otherNode, node);
edge.Data = new NeuralNetworkEdgeData();
edge.Data.Weight = random.NextDouble();
}
Layers[layer].Add(node);
}
}
//create endingPoint
var endnode = Graph.CreateNode();
endnode.Data = new NeuralNetworkNodeData();
for (int i = 0; i < Layers[Layers.Length - 2].Count; i++)
{
var edge = Graph.CreateEdge(Layers[Layers.Length - 2][i], endnode);
edge.Data = new NeuralNetworkEdgeData();
edge.Data.Weight = random.NextDouble();
}
Layers[Layers.Length - 1].Add(endnode);
}
private static void SetEdgeMaxDiffValues(GWGraph <CRFNodeData, CRFEdgeData, CRFGraphData> crfGraph)
{
foreach (var edge in crfGraph.Edges)
{
edge.Data.MaxZellnerScore = edge.Head.Data.Characteristics[0] >= edge.Foot.Data.Characteristics[0] ? edge.Head.Data.Characteristics[0] : edge.Foot.Data.Characteristics[0];
edge.Data.DiffZellnerScore = Math.Abs((edge.Head.Data.Characteristics[0] - edge.Foot.Data.Characteristics[0]));
}
}
public static void assignedLabeling(GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> cloneGraph)
{
// Aufruf der Inferenz-Heuristik
int numberOfLabels = 2;
int bufferSize = 200;
var request = new SolveInference(cloneGraph, numberOfLabels, bufferSize);
request.RequestInDefaultContext();
cloneGraph.Data.AssginedLabeling = request.Solution.Labeling;
}
public OLMEvaluationGraphResult(GWGraph <CRFNodeData, CRFEdgeData, CRFGraphData> graph, int[] prediction, int tp, int tn, int fp, int fn, double sensitivity, double specificity, double mcc, double accuracy)
{
Graph = graph;
Prediction = prediction;
TP = tp;
TN = tn;
FP = fp;
FN = fn;
Sensitivity = sensitivity;
Specificity = specificity;
MCC = mcc;
Accuracy = accuracy;
}
public static GWGraph <SGLNodeData, SGLEdgeData, SGLGraphData> ParseFile_CRF_Class(string file)
{
var graph = new GWGraph <SGLNodeData, SGLEdgeData, SGLGraphData>();
graph.Data = new SGLGraphData();
using (var reader = new StreamReader(file))
{
//if (reader.ReadLine() != "reflabels:")
// throw new IOException("unbekanntes FileFormat - File sollte mit 'numlabels:' beginnen");
//int refLabels = int.Parse(reader.ReadLine());
//if (reader.ReadLine() != "observations:")
// throw new IOException("unbekanntes FileFormat - File sollte mit 'numlabels:' beginnen");
//int observations = int.Parse(reader.ReadLine());
if (reader.ReadLine() != "nodes:")
{
throw new IOException("unbekanntes FileFormat - File sollte 'nodes:' in Zeile 3 enthalten");
}
string line = string.Empty;
while ((line = reader.ReadLine()) != "edges:" && line.NotNullOrEmpty())
{
string[] words = Regex.Split(line, "\\s");
var node = graph.CreateNode();
var scores = new List <double>();
node.Data = new SGLNodeData();
node.Data.ReferenceLabel = int.Parse(words[1]);
node.Data.Observation = int.Parse(words[2]);
if (words.Length > 3)
{
node.Data.AssignedLabel = int.Parse(words[3]);
}
node.Data.Id = words[0];
}
while ((line = reader.ReadLine()).NotNullOrEmpty())
{
string[] words = Regex.Split(line, "\\s");
string name = words[0] + "_" + words[1];
string check = words[1] + "_" + words[0];
var edge = graph.CreateEdge(graph.Nodes.First((n) => n.Data.Id.Equals(words[0])), graph.Nodes.First((n) => n.Data.Id.Equals(words[1])));
edge.Data = new SGLEdgeData();
}
}
return(graph);
}
//Davids files
public static GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> ParseFileFormatThree(string file)
{
var graph = new GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData>();
var edgeMode = false;
int CountAdd = 0;
using (var reader = new StreamReader(file))
{
string line = string.Empty;
while ((line = reader.ReadLine()) != null)
{
if (line.Equals("NODES"))
{
reader.ReadLine();
edgeMode = false;
}
else if (line.Equals("EDGES"))
{
reader.ReadLine();
edgeMode = true;
}
else if (!edgeMode)
{
string[] words = Regex.Split(line, ";");
var node = graph.CreateNode();
var scoreI = int.Parse(words[1]);
var scoreN = int.Parse(words[2]);
var scores = new List <double>();
scores.AddRange(scoreN + CountAdd, scoreI + CountAdd);
graph.Nodes.Add(node);
node.Data.Scores = scores.ToArray();
node.Data.Id = words[0];
node.Data.ReferenceLabel = (words[3].Equals("N")) ? 0 : 1;
}
else
{
string[] words = Regex.Split(line, ";");
var headId = words[0];
var footId = words[1];
var head = graph.Nodes.First(n => n.Data.Id.Equals(headId));
var foot = graph.Nodes.First(n => n.Data.Id.Equals(footId));
var edge = new GWEdge <ICRFNodeData, ICRFEdgeData, ICRFGraphData>(head, foot);
graph.Edges.Add(edge);
}
}
}
return(graph);
}
// delete graph
public static void randomLabeling(GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> cloneGraph)
{
int count = cloneGraph.Data.ReferenceLabeling.Count();
int[] label = new int[count];
for (int j = 0; j < count; j++)
{
int l = rdm.Next(0, 2);
label[j] = l;
//Console.Write(label[i]);
}
cloneGraph.Data.ReferenceLabeling = label;
}
public TrainingEvaluationCycleInputParameters(GWGraph <CRFNodeData, CRFEdgeData, CRFGraphData> graph,
int numberOfGraphInstances, int numberOfSeedsForPatchCreation, int maximumTotalPatchSize,
List <OLMVariant> trainingVariantsToTest, double isingConformityParameter, double isingCorrelationParameter,
double[,] transitionProbabilities, int numberOfLabels, int bufferSizeViterbi)
{
Graph = graph;
NumberOfGraphInstances = numberOfGraphInstances;
NumberOfSeedsForPatchCreation = numberOfSeedsForPatchCreation;
MaximumTotalPatchSize = maximumTotalPatchSize;
TrainingVariantsToTest = trainingVariantsToTest;
IsingConformityParameter = isingConformityParameter;
IsingCorrelationParameter = isingCorrelationParameter;
TransitionProbabilities = transitionProbabilities;
NumberOfLabels = numberOfLabels;
BufferSizeViterbi = bufferSizeViterbi;
}
public OLMEvaluationGraphResult computeEvalutionGraphResult(GWGraph <CRFNodeData, CRFEdgeData, CRFGraphData> graph,
int[] predicitionLabeling)
{
double sensitivity = 0.0, specificity = 0.0, mcc = 0.0, accuracy = 0.0;
int[] referenceLabel = graph.Data.ReferenceLabeling;
// für jeden graphen: true positives / false positives / true negatives / fn || 0: negative 1: positive
int[] tps = computeClassification(referenceLabel, predicitionLabeling);
int tp = tps[0], tn = tps[1], fp = tps[2], fn = tps[3];
// Sensitivität / Spezifität / MCC Matthew Correlation Coefficient
sensitivity = computeTPR(tp, fn);
specificity = computeSPC(tn, fp);
mcc = computeMCC(tp, tn, fp, fn);
accuracy = computeAcc(tp, tn, fp, fn);
OLMEvaluationGraphResult result = new OLMEvaluationGraphResult(graph, predicitionLabeling, tp, tn, fp, fn, sensitivity, specificity, mcc, accuracy);
return(result);
}
private static void startTestCycle()
{
// erzeugt die RequestListener
Build.Do();
// einfache Graphen erzeugen (12 clone)
//var graph = CreateGraphs.createGraph_Grid2D();
var pdbFile = PDBExt.Parse(RandomlySelectedPDBFile);
var proteinGraph = CreateProteinGraph.Do(pdbFile, 6.0, ResidueNodeCenterDefinition.CAlpha).Values.First();
IGWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> crfGraph = proteinGraph.Convert(nd => new CRFNodeData(nd.Data.Residue.Id), ed => new CRFEdgeData(), gd => new CRFGraphData());
// seeding
// 12 clone erzeugen
var clone = new GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> [clones];
for (int i = 0; i < clones; i++)
{
var cloneGraph = crfGraph.Clone(ConvertData.convertNodeData, ConvertData.convertEdgeData, ConvertData.convertGraphData);
// für jeden graphen (clone): Erzeugung eines Labelings (rdm) => als int[]
Labeling.randomLabeling(cloneGraph);
Labeling.assignedLabeling(cloneGraph);
clone[i] = cloneGraph;
}
// calculation of tp, fp, tn, fn, sensitivity, specificity, mcc
double[][] keysForAllClones = new double[clones][];
for (int i = 0; i < clones; i++)
{
double[] keys = Compute.computeKeys(crfGraph, clone, i);
keysForAllClones[i] = keys;
}
// test
//outputKeys(keysForAllClones);
outputLabelingsScores(clone);
}
public static GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> CreateGraph(this ProteinGraph graph, IDictionary <ResidueNodeData, double[]> nodescores, IDictionary <SimpleEdgeData, double[, ]> edgescores)
{
var clonegraph = new GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData>();
foreach (var node in graph.Nodes)
{
var clone = clonegraph.CreateNode();
clone.Data = new CRFNodeData()
{
Id = node.Data.Residue.Id, Scores = nodescores[node.Data]
};
clonegraph.Nodes.Add(clone);
}
foreach (var edge in graph.Edges)
{
var newEdge = new GWEdge <ICRFNodeData, ICRFEdgeData, ICRFGraphData>(clonegraph.Nodes.First(n => n.Data.Id.Equals(edge.Head.Data.Residue.Id)),
clonegraph.Nodes.First(n => n.Data.Id.Equals(edge.Foot.Data.Residue.Id)));
newEdge.Data = new CRFEdgeData();
newEdge.Data.Scores = edgescores[edge.Data];
clonegraph.Edges.Add(newEdge);
}
return(clonegraph);
}
public void DoMCMCStyle(GWGraph <CRFNode3DInfo, CRFEdge3DInfo, Graph3DInfo> graph, int steps, double ChangePenalty)
{
var rdm = new Random();
int[] stateMap = new int[graph.Nodes.Count()];
int[] stateCounts = new int[stateMap.Length];
int numberStates = stateMap.Length;
foreach (var node in graph.Nodes)
{
node.Data.ClusterId = node.GraphId;
node.Data.CurrentState = node.GraphId;
node.Data.LastUpdate = 0;
node.Data.InStateCounts = new int[numberStates];
node.Data.StateScores = new double[numberStates];
for (int st = 0; st < numberStates; st++)
{
node.Data.StateScores[st] = 1.0 / numberStates;
}
}
foreach (var edge in graph.Edges)
{
edge.Data.StateScores = new double[numberStates, numberStates];
for (int st1 = 0; st1 < numberStates; st1++)
{
for (int st2 = 0; st2 < numberStates; st2++)
{
if (st1 == st2)
{
edge.Data.StateScores[st1, st2] = 1.0;
}
else
{
edge.Data.StateScores[st1, st2] = ChangePenalty;
}
}
}
}
for (int i = 0; i < stateMap.Length; i++)
{
stateMap[i] = i;
stateCounts[i] = 1;
}
var nodes = graph.Nodes.ToList().RemoveWhere(n => !n.Neighbours.Any()).ToList();
for (int step = 1; step <= steps; step++)
{
var selectedNode = nodes[rdm.Next(nodes.Count)];
var possibleNewState = rdm.Next(numberStates);
var oldState = selectedNode.Data.CurrentState;
if (possibleNewState == oldState)
{
continue;
}
var oldScore = 1.0;
oldScore *= selectedNode.Data.StateScores[selectedNode.Data.CurrentState];
foreach (var edge in selectedNode.Edges)
{
oldScore *= edge.Data.StateScores[edge.Head.Data.CurrentState, edge.Foot.Data.CurrentState];
}
selectedNode.Data.CurrentState = possibleNewState;
var newScore = 1.0;
oldScore *= selectedNode.Data.StateScores[selectedNode.Data.CurrentState];
foreach (var edge in selectedNode.Edges)
{
newScore *= edge.Data.StateScores[edge.Head.Data.CurrentState, edge.Foot.Data.CurrentState];
}
if (rdm.NextDouble() < oldScore / (newScore + oldScore))
{
selectedNode.Data.CurrentState = oldState;
}
selectedNode.Data.InStateCounts[selectedNode.Data.CurrentState] += step - selectedNode.Data.LastUpdate;
selectedNode.Data.LastUpdate = step;
if (step % 250 == 0)
{
foreach (var node in nodes)
{
node.Data.ClusterId = node.Data.InStateCounts.MaxEntry(st => st);
}
Thread.Sleep(100);
}
}
foreach (var node in nodes)
{
node.Data.ClusterId = node.Data.InStateCounts.MaxEntry(st => st);
}
}
//public void Do(GWGraph<Node3DWrap<NodeData>, EdgeData, GraphData> graph)
//{
// var rdm = new Random();
// int[] clusterMap = new int[graph.Nodes.Count()];
// int[] clusterCounts = new int[clusterMap.Length];
// foreach (var node in graph.Nodes)
// {
// node.Data.ClusterId = node.GraphId;
// }
// for (int i = 0; i < clusterMap.Length; i++)
// {
// clusterMap[i] = i;
// clusterCounts[i] = 1;
// }
// var totalPossibleEdges = (clusterMap.Length * (clusterMap.Length - 1)) / 2;
// var ClusterEdges = 0.0;
// var clusterEdgesPossible = 0.0;
// var otherEdges = 0.0;
// var totalOtherEdges = 0.0;
// foreach (var edge in graph.Edges)
// {
// if (clusterMap[edge.Foot.GraphId] == clusterMap[edge.Head.GraphId])
// {
// ClusterEdges++;
// }
// else
// otherEdges++;
// }
// for (int i = 0; i < clusterCounts.Length; i++)
// {
// clusterEdgesPossible += (clusterCounts[i] * (clusterCounts[i] - 1)) / 2;
// }
// totalOtherEdges = totalPossibleEdges - clusterEdgesPossible;
// var clusterEdgeProb = clusterEdgesPossible == 0 ? 0 : ClusterEdges / clusterEdgesPossible;
// var interClusterEdgesProb = otherEdges / totalOtherEdges;
// var score = clusterEdgeProb / interClusterEdgesProb;
// var nodes = graph.Nodes.ToList().RemoveWhere(n => !n.Neighbours.Any()).ToList();
// for (int step = 0; step < 100000; step++)
// {
// var selectedNode = nodes[rdm.Next(nodes.Count)];
// var possibleClusters = selectedNode.Neighbours.Select(nb => clusterMap[nb.GraphId]).ToList();
// if (possibleClusters.Count() == 1 && clusterMap[selectedNode.GraphId] == possibleClusters.First())
// {
// step--;
// continue;
// }
// var selectedCluster = 0;// possibleClusters[rdm.Next(possibleClusters.Count)];
// var clusterMappingScore = new Dictionary<int, double>();
// var tempScore = 0.0;
// foreach (var cluster in possibleClusters)
// {
// selectedCluster = cluster;
// //Preview Scores
// if (clusterMap[selectedNode.GraphId] == selectedCluster)
// {
// clusterMappingScore.Add(selectedCluster, score);
// continue;
// }
// var scoreLocal = 1.0;
// var changeClusterEdges = 0;
// foreach (var nb in selectedNode.Neighbours)
// {
// if (clusterMap[nb.GraphId] == clusterMap[selectedNode.GraphId])
// {
// changeClusterEdges--;
// scoreLocal *= 0.3;
// }
// else if (clusterMap[nb.GraphId] == selectedCluster)
// {
// changeClusterEdges++;
// scoreLocal *= 3.0;
// }
// }
// var changePossibleClusterEdges = 0;
// changePossibleClusterEdges -= clusterCounts[selectedNode.GraphId] > 1 ?
// (clusterCounts[selectedNode.GraphId] * (clusterCounts[selectedNode.GraphId] - 1)) / 2 - ((clusterCounts[selectedNode.GraphId] - 1) * (clusterCounts[selectedNode.GraphId] - 2)) / 2 : 0;
// changePossibleClusterEdges -= clusterCounts[selectedCluster] > 0 ?
// (clusterCounts[selectedCluster] * (clusterCounts[selectedCluster] - 1)) / 2 - ((clusterCounts[selectedCluster] + 1) * (clusterCounts[selectedCluster])) / 2 : 0;
// var clusterEdgeProbLocal = clusterEdgesPossible + changePossibleClusterEdges == 0 ? 0 : (ClusterEdges + changeClusterEdges) / (clusterEdgesPossible + changePossibleClusterEdges);
// var interClusterEdgesProbLocal = (otherEdges - changeClusterEdges) / totalOtherEdges;
// //var scoreLocal = Math.Max(0, changeClusterEdges); //(clusterEdgeProbLocal / interClusterEdgesProbLocal, 2);
// clusterMappingScore.Add(selectedCluster, scoreLocal);
// tempScore += scoreLocal;
// }
// //execute best score
// selectedCluster = clusterMappingScore.ChooseByDistributionNormalize(); // clusterMappingScore.First(kvp => kvp.Value == clusterMappingScore.Values.Max()).Key;
// if (clusterMap[selectedNode.GraphId] == selectedCluster)
// {
// continue;
// }
// var temp = step;
// var changeClusterEdges2 = 0;
// foreach (var nb in selectedNode.Neighbours)
// {
// if (clusterMap[nb.GraphId] == clusterMap[selectedNode.GraphId])
// changeClusterEdges2--;
// else if (clusterMap[nb.GraphId] == selectedCluster)
// changeClusterEdges2++;
// }
// var changePossibleClusterEdges2 = 0;
// changePossibleClusterEdges2 -= clusterCounts[selectedNode.GraphId] > 1 ?
// (clusterCounts[selectedNode.GraphId] * (clusterCounts[selectedNode.GraphId] - 1)) / 2 - ((clusterCounts[selectedNode.GraphId] - 1) * (clusterCounts[selectedNode.GraphId] - 2)) / 2 : 0;
// changePossibleClusterEdges2 -= clusterCounts[selectedCluster] > 0 ?
// (clusterCounts[selectedCluster] * (clusterCounts[selectedCluster] - 1)) / 2 - ((clusterCounts[selectedCluster] + 1) * (clusterCounts[selectedCluster])) / 2 : 0;
// var clusterEdgeProbLocal2 = clusterEdgesPossible + changePossibleClusterEdges2 == 0 ? 0 : (ClusterEdges + changeClusterEdges2) / (clusterEdgesPossible + changePossibleClusterEdges2);
// var interClusterEdgesProbLocal2 = (otherEdges - changeClusterEdges2) / totalOtherEdges;
// var scoreLocal2 = clusterEdgeProbLocal2 / interClusterEdgesProbLocal2;
// score = scoreLocal2;
// ClusterEdges += changeClusterEdges2;
// clusterEdgesPossible += changePossibleClusterEdges2;
// otherEdges -= changeClusterEdges2;
// selectedNode.Data.ClusterId = selectedCluster;
// clusterCounts[clusterMap[selectedNode.GraphId]]--;
// clusterCounts[selectedCluster]++;
// clusterMap[selectedNode.GraphId] = selectedCluster;
// Thread.Sleep(10);
// }
//}
public void Do(GWGraph <Node3DWrap <NodeData>, Edge3DWrap <EdgeData>, GraphData> graph)
{
var rdm = new Random();
int[] clusterMap = new int[graph.Nodes.Count()];
int[] clusterCounts = new int[clusterMap.Length];
foreach (var node in graph.Nodes)
{
node.Data.ClusterId = node.GraphId;
}
for (int i = 0; i < clusterMap.Length; i++)
{
clusterMap[i] = i;
clusterCounts[i] = 1;
}
var totalPossibleEdges = (clusterMap.Length * (clusterMap.Length - 1)) / 2;
var ClusterEdges = 0.0;
var clusterEdgesPossible = 0.0;
var otherEdges = 0.0;
var totalOtherEdges = 0.0;
foreach (var edge in graph.Edges)
{
if (clusterMap[edge.Foot.GraphId] == clusterMap[edge.Head.GraphId])
{
ClusterEdges++;
}
else
{
otherEdges++;
}
}
for (int i = 0; i < clusterCounts.Length; i++)
{
clusterEdgesPossible += (clusterCounts[i] * (clusterCounts[i] - 1)) / 2;
}
totalOtherEdges = totalPossibleEdges - clusterEdgesPossible;
var clusterEdgeProb = clusterEdgesPossible == 0 ? 0 : ClusterEdges / clusterEdgesPossible;
var interClusterEdgesProb = otherEdges / totalOtherEdges;
var score = clusterEdgeProb / interClusterEdgesProb;
var nodes = graph.Nodes.ToList().RemoveWhere(n => !n.Neighbours.Any()).ToList();
for (int step = 0; step < 100000; step++)
{
var selectedNode = nodes[rdm.Next(nodes.Count)];
var possibleClusters = selectedNode.Neighbours.Select(nb => clusterMap[nb.GraphId]).Distinct().ToList();
if (possibleClusters.Count() == 1 && clusterMap[selectedNode.GraphId] == possibleClusters.First())
{
step--;
continue;
}
var selectedCluster = 0;// possibleClusters[rdm.Next(possibleClusters.Count)];
var clusterMappingScore = new Dictionary <int, double>();
var tempScore = 0.0;
foreach (var cluster in possibleClusters)
{
selectedCluster = cluster;
//Preview Scores
if (clusterMap[selectedNode.GraphId] == selectedCluster)
{
clusterMappingScore.Add(selectedCluster, score);
continue;
}
var scoreLocal = 1.0;
var changeClusterEdges = 0;
foreach (var nb in selectedNode.Neighbours)
{
if (clusterMap[nb.GraphId] == clusterMap[selectedNode.GraphId])
{
changeClusterEdges--;
scoreLocal *= 0.3;
}
else if (clusterMap[nb.GraphId] == selectedCluster)
{
changeClusterEdges++;
scoreLocal *= 3.0;
}
}
var changePossibleClusterEdges = 0;
changePossibleClusterEdges -= clusterCounts[selectedNode.GraphId] > 1 ?
(clusterCounts[selectedNode.GraphId] * (clusterCounts[selectedNode.GraphId] - 1)) / 2 - ((clusterCounts[selectedNode.GraphId] - 1) * (clusterCounts[selectedNode.GraphId] - 2)) / 2 : 0;
changePossibleClusterEdges -= clusterCounts[selectedCluster] > 0 ?
(clusterCounts[selectedCluster] * (clusterCounts[selectedCluster] - 1)) / 2 - ((clusterCounts[selectedCluster] + 1) * (clusterCounts[selectedCluster])) / 2 : 0;
var clusterEdgeProbLocal = clusterEdgesPossible + changePossibleClusterEdges == 0 ? 0 : (ClusterEdges + changeClusterEdges) / (clusterEdgesPossible + changePossibleClusterEdges);
var interClusterEdgesProbLocal = (otherEdges - changeClusterEdges) / totalOtherEdges;
//var scoreLocal = Math.Max(0, changeClusterEdges); //(clusterEdgeProbLocal / interClusterEdgesProbLocal, 2);
clusterMappingScore.Add(selectedCluster, scoreLocal);
tempScore += scoreLocal;
}
//execute best score
selectedCluster = clusterMappingScore.ChooseByDistributionNormalize(); // clusterMappingScore.First(kvp => kvp.Value == clusterMappingScore.Values.Max()).Key;
if (clusterMap[selectedNode.GraphId] == selectedCluster)
{
continue;
}
var temp = step;
var changeClusterEdges2 = 0;
foreach (var nb in selectedNode.Neighbours)
{
if (clusterMap[nb.GraphId] == clusterMap[selectedNode.GraphId])
{
changeClusterEdges2--;
}
else if (clusterMap[nb.GraphId] == selectedCluster)
{
changeClusterEdges2++;
}
}
var changePossibleClusterEdges2 = 0;
changePossibleClusterEdges2 -= clusterCounts[selectedNode.GraphId] > 1 ?
(clusterCounts[selectedNode.GraphId] * (clusterCounts[selectedNode.GraphId] - 1)) / 2 - ((clusterCounts[selectedNode.GraphId] - 1) * (clusterCounts[selectedNode.GraphId] - 2)) / 2 : 0;
changePossibleClusterEdges2 -= clusterCounts[selectedCluster] > 0 ?
(clusterCounts[selectedCluster] * (clusterCounts[selectedCluster] - 1)) / 2 - ((clusterCounts[selectedCluster] + 1) * (clusterCounts[selectedCluster])) / 2 : 0;
var clusterEdgeProbLocal2 = clusterEdgesPossible + changePossibleClusterEdges2 == 0 ? 0 : (ClusterEdges + changeClusterEdges2) / (clusterEdgesPossible + changePossibleClusterEdges2);
var interClusterEdgesProbLocal2 = (otherEdges - changeClusterEdges2) / totalOtherEdges;
var scoreLocal2 = clusterEdgeProbLocal2 / interClusterEdgesProbLocal2;
score = scoreLocal2;
ClusterEdges += changeClusterEdges2;
clusterEdgesPossible += changePossibleClusterEdges2;
otherEdges -= changeClusterEdges2;
selectedNode.Data.ClusterId = selectedCluster;
clusterCounts[clusterMap[selectedNode.GraphId]]--;
clusterCounts[selectedCluster]++;
clusterMap[selectedNode.GraphId] = selectedCluster;
Thread.Sleep(10);
}
}
public static IGWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> ParseFileFormatTwo(string file)
{
var graph = new GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData>();
using (var reader = new StreamReader(file))
{
string line = string.Empty;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith("#"))
{
continue;
}
else if (line.StartsWith("NODE"))
{
string[] words = Regex.Split(line, "\\s").Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
var node = graph.CreateNode();
var scores = new List <double>();
for (int counter = 0; counter < 2; counter++)
{
try
{
scores.Add(double.Parse(words[counter + 5], CultureInfo.InvariantCulture));
}
catch (FormatException ex)
{
if (words[counter + 5].Equals("N_INF"))
{
scores.Add(double.NegativeInfinity);
}
else
{
throw ex;
}
}
}
graph.Nodes.Add(node);
node.Data = new CRFNodeData();
node.Data.Scores = scores.ToArray();
node.Data.Id = words[1];
node.Data.ReferenceLabel = int.Parse(words[7]);
}
else if (line.StartsWith("NEIGH"))
{
string[] words = Regex.Split(line, "\\s").Where(s => !string.IsNullOrWhiteSpace(s)).ToArray();
var stringNode = words[1].Substring(0, words[1].Length - 1);
for (int nb = 2; nb < words.Length; nb++)
{
//Don't use the double occurence edges
if (stringNode.CompareTo(words[nb]) > 0)
{
continue;
}
var edge = new GWEdge <ICRFNodeData, ICRFEdgeData, ICRFGraphData>(graph.Nodes.First((n) => n.Data.Id.Equals(stringNode)), graph.Nodes.First((n) => n.Data.Id.Equals(words[nb])));
edge.Data = new CRFEdgeData();
graph.Edges.Add(edge);
}
}
}
}
return(graph);
}
public static IGWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData> ParseFile(string file)
{
var graph = new GWGraph <ICRFNodeData, ICRFEdgeData, ICRFGraphData>();
using (var reader = new StreamReader(file))
{
if (reader.ReadLine() != "numlabels:")
{
throw new IOException("unbekanntes FileFormat - File sollte mit 'numlabels:' beginnen");
}
int numberLabels = int.Parse(reader.ReadLine());
if (reader.ReadLine() != "nodes:")
{
throw new IOException("unbekanntes FileFormat - File sollte 'nodes:' in Zeile 3 enthalten");
}
string line = string.Empty;
while ((line = reader.ReadLine()) != "edges:")
{
string[] words = Regex.Split(line, "\\s");
var node = graph.CreateNode();
var scores = new List <double>();
for (int counter = 1; counter < numberLabels + 1; counter++)
{
try
{
scores.Add(double.Parse(words[counter], CultureInfo.InvariantCulture));
}
catch (FormatException ex)
{
if (words[counter].Equals("N_INF"))
{
scores.Add(double.NegativeInfinity);
}
else
{
throw ex;
}
}
}
graph.Nodes.Add(node);
node.Data.Scores = scores.ToArray();
node.Data.Id = words[0];
}
while ((line = reader.ReadLine()) != null)
{
string[] words = Regex.Split(line, "\\s");
string name = words[0] + "_" + words[1];
string check = words[1] + "_" + words[0];
//Don't use the double occurence edges
if (words[0].CompareTo(words[1]) > 0)
{
continue;
}
var edge = new GWEdge <ICRFNodeData, ICRFEdgeData, ICRFGraphData>(graph.Nodes.First((n) => n.Data.Id.Equals(words[0])), graph.Nodes.First((n) => n.Data.Id.Equals(words[1])));
graph.Edges.Add(edge);
edge.Data.Scores = new double[numberLabels, numberLabels];
int word = 2;
for (int dounter = 0; dounter < numberLabels; dounter++)
{
for (int counter = 0; counter < numberLabels; counter++)
{
edge.Data.Scores[dounter, counter] = (double.Parse(words[word], CultureInfo.InvariantCulture));
word++;
}
}
}
}
return(graph);
}
