static void PerformAlg01param02()
{
var table = new FuzzyTable();
try
{
using (StreamReader sr = new StreamReader(filePath))
{
String json = sr.ReadToEnd();
dynamic array = JsonConvert.DeserializeObject(json);
// Console.WriteLine(array.attributes);
var aa = array.attributes;
for (int i = 0; i < array.attributes.Count - 1; i++)
{
table.addAttribute(array.attributes[i]);
}
addClass(table, array);
table.AddData(array.data);
performAlg01(table, 1);
}
}
catch (Exception e)
{
Console.WriteLine("The file could not be read:");
Console.WriteLine(e.Message);
Console.WriteLine(e);
}
}
public void init(FuzzyTable table)
{
this.table = table;
this.t = 0;
this.rules = new List <Rule>();
this.Q = new List <List <string> >();
this.Q.Add(this.table.getAllAttributes());
this.Q1 = new List <List <string> >();
this.Q2 = new List <List <string> >();
this.L = new List <List <string> >(this.Q);;
this.maxLength = this.Q[this.t].Count - 1;
this.currentLength = new List <int>();
this.currentLength.Add(1);
this.isVariableNotRemoved = new List <bool>();
this.isVariableNotRemoved.Add(false);
this.C = this.table.getClassAttribute();
this.P = new List <int>(this.table.GetTable().Rows.Count);
for (int i = 0; i < this.table.GetTable().Rows.Count; i++)
{
this.P.Add(i);
}
this.I = new List <List <int> >();
this.I.Add(P);
this.Z = new List <List <int> >();
this.Z.Add(P);
this.I1 = new List <List <int> >();
this.I2 = new List <List <int> >();
this.Lreduced = new List <List <string> >();
this.R = new List <Rule>();
this.stepsStack = new Stack <StepData>();
}
public void CalculateResultForRules(FuzzyTable testData, List <Rule> rules, ConfusionMatrix confusionMatrix, double tolerance = .5)
{
Classificator classificator = new Classificator();
for (int i = 0; i < testData.GetTable().Rows.Count; i++)
{
var predictedResult = classificator.Classify(testData, i, rules);
var predicterPositiveResult = predictedResult[testData.PositiveColumn.Id];
var predicterNegativeResult = predictedResult[testData.NegativeColumn.Id];
var actualPositiveResult = testData.GetPositiveColumn(i);
var actualNegativeResult = testData.GetNegativeColumn(i);
if (Math.Abs(predicterPositiveResult - actualPositiveResult) < tolerance)
{
confusionMatrix.TruePositiveCount++;
}
else
{
confusionMatrix.FalseNegativeCount++;
}
if (Math.Abs(predicterNegativeResult - actualNegativeResult) < tolerance)
{
confusionMatrix.TrueNegativeCount++;
}
else
{
confusionMatrix.FalsePositiveCount++;
}
}
}
private void addFoldsDataToTableAndTestTable(FuzzyTable table, FuzzyTable testDataTable, ArrayList[] foldsInstances, int fold, int numberOfFolds, FuzzyTable fuzzyTable)
{
for (int i = 0; i < numberOfFolds; i++)
{
if (i != fold)
{
var foldData = foldsInstances[i];
for (int j = 0; j < foldData.Count; j++)
{
var index = (int)foldData[j];
var data = fuzzyTable.GetTable().Rows[index];
table.GetTable().ImportRow(data);
}
}
else
{
var foldData = foldsInstances[i];
for (int j = 0; j < foldData.Count; j++)
{
var index = (int)foldData[j];
var data = fuzzyTable.GetTable().Rows[index];
testDataTable.GetTable().ImportRow(data);
}
}
}
}
public Dictionary <string, double> Classify(FuzzyTable table, int rowId, List <Rule> fuzzyRules)
{
var classAttribs = table.getClassAttribute();
// K2 Ak min {1.0, 0.9} Potom C is c1, find min
var Ei = new Dictionary <Rule, double>();
foreach (var rule in fuzzyRules)
{
var membershipDegree = double.MaxValue;
foreach (var attr in rule.Items)
{
var value = table.getData(attr.Id, rowId);
if (value < membershipDegree)
{
membershipDegree = value;
}
}
if (!Ei.ContainsKey(rule))
{
Ei.Add(rule, membershipDegree);
}
}
//K3
var gcj = new Dictionary <string, List <Rule> >();
for (var i = 0; i < table.getClassAttribute().Labels.Length; i++)
{
gcj[table.getClassAttribute().Labels[i].Id.ToString()] = new List <Rule>();
}
foreach (var rule in fuzzyRules)
{
gcj[rule.C.Id].Add(rule);
}
//K4 Ak max{0.9, 0, 0, 0.4} Potom C is c1
var returnValue = new Dictionary <string, double>();
foreach (var classAttr in classAttribs.Labels)
{
returnValue.Add(classAttr.Id.ToString(), double.MinValue);
}
foreach (var cj in gcj.Keys)
{
foreach (var rule in gcj[cj])
{
var value = Ei[rule];
if (value > returnValue[rule.C.Id])
{
returnValue[rule.C.Id] = value;
}
}
}
return(returnValue);
}
public void Algorithm02TestFromPublication()
{
var table = new FuzzyTable();
output.WriteLine("Algorithm02TestFromPublication STARTED");
try
{ // Open the text file using a stream reader.
using (StreamReader sr = new StreamReader("../../../Algorithms/tests/test.txt"))
{
String json = sr.ReadToEnd();
dynamic array = JsonConvert.DeserializeObject(json);
// Console.WriteLine(array.attributes);
Assert.True(true);
var aa = array.attributes;
for (int i = 0; i < array.attributes.Count - 1; i++)
{
table.addAttribute(array.attributes[i]);
}
table.addClassAttribute(array.attributes[array.attributes.Count - 1], "Name0", "Name1");
table.AddData(array.data);
var p = new int[20];
for (int i = 0; i < p.Length; i++)
{
p[i] = i;
}
alg02.init(table);
var rules = alg02.process();
for (int i = 0; i < rules.Count; i++)
{
output.WriteLine(rules[i].ToString());
}
var rulesString = "a11 a33 ->c1;a12 a33 ->c2;a12 a31 ->c2;a11 a31 ->c1;a12 a32 ->c1;a11 a32 ->c2;a23 a34 ->c1;a21 a34 ->c2;a22 a34 a54 ->c2;a22 a34 a52 ->c1;a34 a42 ->c2;a11 a23 a32 a41 a54 ->c2;";
var currentRulesString = "";
for (int i = 0; i < rules.Count; i++)
{
currentRulesString += rules[i].ToStringOnlyTerm() + ";";
}
Assert.Equal(rulesString, currentRulesString);
}
}
catch (Exception e)
{
output.WriteLine(e.Message.ToString());
Assert.True(false);
}
}
static void performAlg02(FuzzyTable table, int indexForParam)
{
Console.WriteLine("performAlg02Exp: " + indexForParam);
int size = 11;
Double[] kriteriaArray = new Double[size];
var psi = new Dictionary <string, double>();
psi["no"] = 0.7;
psi["yes"] = 0.7;
for (int i = 0; i < size; i++)
{
var beta = 0.0 + 0.1 * i;
var dataSize = 0;
for (int j = 0; j < 40; j++)
{
Algorithm02 alg02;
switch (indexForParam)
{
case 0:
psi["no"] = beta;
alg02 = new Algorithm02(0, psi);
break;
case 1:
psi["yes"] = beta;
alg02 = new Algorithm02(0, psi);
break;
default:
alg02 = new Algorithm02(0, psi);
break;
}
alg02.init(table);
var validation02 = new TenCrossValidation();
var matrix02 = validation02.Validate(10, table, alg02);
if (matrix02 != null)
{
var kriteria = (matrix02.Sensitivity() + matrix02.Specificity()) / 2;
kriteriaArray[i] += kriteria;
dataSize++;
}
}
Console.WriteLine(indexForParam + " CURRENT beta: " + (beta) + " :" + kriteriaArray[i] / dataSize);
}
}
static void performAlg01Modif(FuzzyTable table, int indexForParam)
{
Console.WriteLine("performAlg01ModifExp: " + indexForParam);
int size = 4;
Double[] kriteriaArray = new Double[size];
for (int i = 0; i < size; i++)
{
var beta = 0.6 + 0.05 * i;
var dataSize = 0;
for (int j = 0; j < 100; j++)
{
// Algorithm04 alg02 = new Algorithm04(beta, 0.7, 0.9);
Algorithm01Modification alg02;
switch (indexForParam)
{
case 0:
alg02 = new Algorithm01Modification(beta, 0.7, 0.97);
break;
case 1:
alg02 = new Algorithm01Modification(0, beta, 0.2);
break;
default:
alg02 = new Algorithm01Modification(0, 0.62, beta);
break;
}
alg02.init(table);
var validation02 = new TenCrossValidation();
var matrix02 = validation02.Validate(10, table, alg02);
if (matrix02 != null)
{
var kriteria = (matrix02.Sensitivity() + matrix02.Specificity()) / 2;
kriteriaArray[i] += kriteria;
dataSize++;
}
}
Console.WriteLine(indexForParam + " CURRENT beta: " + (beta) + " :" + kriteriaArray[i] / dataSize);
}
}
private bool ExistsAtLeastOneRuleForEachClassAttribute(FuzzyTable table, List <Rule> rules)
{
foreach (var classAttr in table.getClassAttribute().Labels)
{
var classAttrExistsInRules = false;
foreach (var rule in rules)
{
if (rule.C.Id.Equals(classAttr.Id.ToString()))
{
classAttrExistsInRules = true;
break;
}
}
if (!classAttrExistsInRules)
{
return(false);
}
}
return(true);
}
static void performAlg01(FuzzyTable table, int indexForParam)
{
Console.WriteLine("performAlg01: " + indexForParam);
int size = 11;
Double[] kriteriaArray = new Double[size];
for (int i = 0; i < size; i++)
{
var beta = 0.0 + 0.1 * i;
var dataSize = 0;
for (int j = 0; j < 200; j++)
{
Algorithm01 alg01;
switch (indexForParam)
{
case 0:
alg01 = new Algorithm01(beta, 0.7);
break;
case 1:
default:
alg01 = new Algorithm01(0, beta);
break;
}
alg01.init(table);
var validation02 = new TenCrossValidation();
var matrix02 = validation02.Validate(10, table, alg01);
if (matrix02 != null)
{
var kriteria = (matrix02.Sensitivity() + matrix02.Specificity()) / 2;
kriteriaArray[i] += kriteria;
dataSize++;
}
}
Console.WriteLine(indexForParam + " CURRENT beta: " + (beta) + " :" + kriteriaArray[i] / dataSize);
}
}
private static void addClass(FuzzyTable table, dynamic array)
{
table.addClassAttribute(array.attributes[array.attributes.Count - 1], "yes", "no");
}
public double getData(FuzzyTable fuzzyTable, FuzzyAttributeLabel attributeLabel, int row)
{
return((double)fuzzyTable.getDataByAttribute(attributeLabel, row));
}
public double[] getClassValuesNumber(FuzzyAttributeLabel[] classValues, int numberOfClassValues, FuzzyTable fuzzyTable)
{
double[] countClass = new double[numberOfClassValues];
for (int i = 0; i < classValues.Length; i++)
{
var data = this.getData(fuzzyTable, classValues[i], i);
}
for (int i = 0; i < fuzzyTable.GetTable().Rows.Count; i++)
{
var instance = fuzzyTable.GetTable().Rows[i];
for (int j = 0; j < classValues.Length; j++)
{
countClass[j] += this.getData(fuzzyTable, classValues[j], i);
// var classAttributeValue = this.getData(fuzzyTable, classValues[j], i);
// if (classValues[j].Equals( ""+((int)classAttributeValue))) {
// countClass[j] += this.getData(fuzzyTable, classValues[i], i);
// }
}
}
return(countClass);
}
public ConfusionMatrix Validate(int numberOfFolds, FuzzyTable fuzzyTable, IProcessable algorithm, double tolerance = .5)
{
int instancesSize = fuzzyTable.GetTable().Rows.Count;
ArrayList[] foldsInstances = new ArrayList[numberOfFolds];
for (int i = 0; i < numberOfFolds; i++)
{
foldsInstances[i] = new ArrayList();
}
int numberOfClassValues = fuzzyTable.getClassAttribute().Labels.Length;
FuzzyAttributeLabel[] classValues = new FuzzyAttributeLabel[numberOfClassValues];
for (int i = 0; i < numberOfClassValues; i++)
{
classValues[i] = fuzzyTable.getClassAttribute().Labels[i];
}
double[] countClass = getClassValuesNumber(classValues, numberOfClassValues, fuzzyTable);
int foldSize = instancesSize / numberOfFolds;
double[] foldClassSize = new double[countClass.Length];
for (int i = 0; i < foldClassSize.Length; i++)
{
double perc = countClass[i] / (double)instancesSize;
foldClassSize[i] = (foldSize * perc);
}
var dataCountInOneReplication = fuzzyTable.DataCount() / numberOfFolds; // the size of the fold
var confusionMatrix = new ConfusionMatrix();
var noDataTable = fuzzyTable.CloneNoData();
var rngIndexes = getRNGIndexes(instancesSize);
for (int i = 0; i < numberOfFolds; i++)
{
var instancesAdded = new ArrayList(foldSize); // what will be deleted
double[] foldClassSizeAdded = new double[foldClassSize.Length];
foreach (int index in rngIndexes)
{
var label1Value = this.getData(fuzzyTable, classValues[0], index); // e.g c1= 0.8
var label2Value = this.getData(fuzzyTable, classValues[1], index); // e.g c2= 0.2
if (label1Value > 0.5) // c1 > 0.5
{
if (foldClassSizeAdded[0] < foldClassSize[0])
{
foldClassSizeAdded[0] += label1Value;
foldsInstances[i].Add(index); // add the index to the fold
instancesAdded.Add(index);
}
}
else // c2 > 0.5
{
if (foldClassSizeAdded[1] < foldClassSize[1])
{
foldClassSizeAdded[1] += label2Value;
foldsInstances[i].Add(index); // add the index to the fold
instancesAdded.Add(index);
}
}
if (foldClassSizeAdded[0] >= foldClassSize[0] && foldClassSizeAdded[1] >= foldClassSize[1])
{
break;
}
}
// remove indexes that were used in this fold
foreach (var item in instancesAdded)
{
rngIndexes.Remove(item);
}
}
// now i have the folds
for (var fold = 0; fold < numberOfFolds; fold++)
{
var table = (FuzzyTable)fuzzyTable.CloneNoData();
var testDataTable = (FuzzyTable)table.CloneNoData();
addFoldsDataToTableAndTestTable(table, testDataTable, foldsInstances, fold, numberOfFolds, fuzzyTable);
algorithm.init(table);
var rules = algorithm.process();
if (!ExistsAtLeastOneRuleForEachClassAttribute(table, rules))
{
return(null);
}
CalculateResultForRules(testDataTable, rules, confusionMatrix, tolerance);
}
// Console.WriteLine("Accuracy: "+confusionMatrix.Accuracy());
// Console.WriteLine("Sensitivity: "+confusionMatrix.Sensitivity());
// Console.WriteLine("Specificity: "+confusionMatrix.Specificity());
// Console.WriteLine("Precision: "+confusionMatrix.Precision());
// Console.WriteLine("Krit: "+confusionMatrix.Criteria());
// Console.WriteLine("Kriteria: "+(confusionMatrix.Sensitivity() + confusionMatrix.Specificity()) / 2);
confusionMatrix.CalculatePercentNumbers();
return(confusionMatrix);
}
public double Classify(FuzzyTable table, string cj, int rowId, List <Rule> fuzzyRules)
{
return(Classify(table, rowId, fuzzyRules)[cj]);
}
