private static void LogAPV(AlgoritamPredictiveValues annPV)
{
Console.Out.WriteLine("================================");
Console.Out.WriteLine($"LEARN PPV: {annPV.LearnPPV}");
Console.Out.WriteLine($"LEARN NPV: {annPV.LearnNPV}");
Console.Out.WriteLine($"LEARN SPEC: {annPV.LearnSPEC}");
Console.Out.WriteLine($"LEARN SENS: {annPV.LearnSENS}");
Console.Out.WriteLine($"VALIDATE PPV: {annPV.ValidatePPV}");
Console.Out.WriteLine($"VALIDATE NPV: {annPV.ValidateNPV}");
Console.Out.WriteLine($"VALIDATE SPEC: {annPV.ValidateSPEC}");
Console.Out.WriteLine($"VALIDATE SENS: {annPV.ValidateSENS}");
Console.Out.WriteLine($"TEST PPV: {annPV.TestPPV}");
Console.Out.WriteLine($"TEST NPV: {annPV.TestNPV}");
Console.Out.WriteLine($"TEST SPEC: {annPV.TestSPEC}");
Console.Out.WriteLine($"TEST SENS: {annPV.TestSENS}");
Console.Out.WriteLine("================================");
}
private static Experiment3Output Experiment3(int neuronCount, decimal minAnnPPV, decimal minAnnNPV, int treeCount, decimal minForestPPV, decimal minForestNPV)
{
var result = new Experiment3Output();
result.NeuronCount = neuronCount;
var metsRecords = LoadDataRecords(TRAINING_DATA_FILE, 0);
DateTime et = DateTime.Now;
var currentMinPPV = 0m;
var currentMinNPV = 0m;
Data data = null;
var learningData = new List<AnnLearningRecord>();
var annPV = new AlgoritamPredictiveValues();
var forestPV = new AlgoritamPredictiveValues();
while (currentMinPPV < minAnnPPV || currentMinNPV < minAnnNPV || currentMinPPV <= currentMinNPV || currentMinPPV < minForestPPV || currentMinNPV < minForestNPV)
{
var es = DateTime.Now;
data = CreateData(metsRecords, 0.8, 0.1);
result.Means = data.Means;
result.StandardDeviations = data.StandardDeviations;
Console.Out.WriteLine("================================");
Console.Out.WriteLine($" ANN PPV, NC:{neuronCount}");
Console.Out.WriteLine("================================");
learningData.Clear();
annPV = Ann(data, neuronCount, learningData, out var ann);
currentMinPPV = annPV.TestPPV;
currentMinNPV = annPV.TestNPV;
result.Ann = ann;
LogAPV(annPV);
LogMessage($"Experiment time: {DateTime.Now - es}, total time {DateTime.Now - et}");
}
var experimentPV = new ExperimentPredictiveValues()
{
AnnPpvLearnNPV = annPV.LearnNPV,
AnnPpvLearnPPV = annPV.LearnPPV,
AnnPpvValidateNPV = annPV.ValidateNPV,
AnnPpvValidatePPV = annPV.ValidatePPV,
AnnPpvTestNPV = annPV.TestNPV,
AnnPpvTestPPV = annPV.TestPPV,
};
using (var tw = File.CreateText($"d:\\mets_experiment_3_{neuronCount}_{DateTime.Now:yyyy_MM_dd_hh_mm}_rndfrst.csv"))
{
var csv = new CsvHelper.CsvWriter(tw);
csv.WriteHeader<AnnLearningRecord>();
csv.NextRecord();
csv.WriteRecords(learningData);
}
using (var tw = File.CreateText($"d:\\mets_experiment_3_PV_{neuronCount}_{DateTime.Now:yyyy_MM_dd_hh_mm}_rndfrst.csv"))
{
var csv = new CsvHelper.CsvWriter(tw);
csv.WriteHeader<ExperimentPredictiveValues>();
csv.NextRecord();
csv.WriteRecords(new ExperimentPredictiveValues[] { experimentPV });
}
return result;
}
private static void Experiment2(int neuronCountPPV, int neuronCountNPV, int repeats)
{
var metsRecords = LoadDataRecords(TRAINING_DATA_FILE, 0);
var results = new List<ExperimentPredictiveValues>();
DateTime et = DateTime.Now;
for (int i = 0; i < repeats; i++)
{
var es = DateTime.Now;
var data = CreateData(metsRecords, 0.8, 0.1);
Console.Out.WriteLine("================================");
Console.Out.WriteLine($" EXPERIMENT #{i:000}");
Console.Out.WriteLine("================================");
Console.Out.WriteLine();
Console.Out.WriteLine("================================");
Console.Out.WriteLine($" ANN PPV, NC:{neuronCountPPV}");
Console.Out.WriteLine("================================");
var ann_PPV_PV = Ann(data, neuronCountPPV, null, out var ann);
LogAPV(ann_PPV_PV);
var ann_NPV_PV = new AlgoritamPredictiveValues();
if (neuronCountNPV != neuronCountPPV)
{
Console.Out.WriteLine("================================");
Console.Out.WriteLine($" ANN NPV, NC:{neuronCountNPV}");
Console.Out.WriteLine("================================");
ann_NPV_PV = Ann(data, neuronCountNPV, null, out ann);
LogAPV(ann_NPV_PV);
}
var experimentPV = new ExperimentPredictiveValues()
{
AnnPpvLearnNPV = ann_PPV_PV.LearnNPV,
AnnPpvLearnPPV = ann_PPV_PV.LearnPPV,
AnnPpvLearnSENS = ann_PPV_PV.LearnSENS,
AnnPpvLearnSPEC = ann_PPV_PV.LearnSPEC,
AnnPpvValidateNPV = ann_PPV_PV.ValidateNPV,
AnnPpvValidatePPV = ann_PPV_PV.ValidatePPV,
AnnPpvValidateSENS = ann_PPV_PV.ValidateSENS,
AnnPpvValidateSPEC = ann_PPV_PV.ValidateSPEC,
AnnPpvTestNPV = ann_PPV_PV.TestNPV,
AnnPpvTestPPV = ann_PPV_PV.TestPPV,
AnnPpvTestSENS = ann_PPV_PV.TestSENS,
AnnPpvTestSPEC = ann_PPV_PV.TestSPEC,
AnnNpvLearnNPV = ann_NPV_PV.LearnNPV,
AnnNpvLearnPPV = ann_NPV_PV.LearnPPV,
AnnNpvLearnSENS = ann_NPV_PV.LearnSENS,
AnnNpvLearnSPEC = ann_NPV_PV.LearnSPEC,
AnnNpvValidateNPV = ann_NPV_PV.ValidateNPV,
AnnNpvValidatePPV = ann_NPV_PV.ValidatePPV,
AnnNpvValidateSENS = ann_NPV_PV.ValidateSENS,
AnnNpvValidateSPEC = ann_NPV_PV.ValidateSPEC,
AnnNpvTestNPV = ann_NPV_PV.TestNPV,
AnnNpvTestPPV = ann_NPV_PV.TestPPV,
AnnNpvTestSENS = ann_NPV_PV.TestSENS,
AnnNpvTestSPEC = ann_NPV_PV.TestSPEC,
};
LogEPV(experimentPV);
results.Add(experimentPV);
LogMessage($"Experiment time: {DateTime.Now - es}, total time {DateTime.Now - et}");
}
LogAvgEPV(results);
using (var tw = File.CreateText($"d:\\mets_experiment_2_{neuronCountPPV}_{neuronCountNPV}_R{repeats}{DateTime.Now:yyyy_MM_dd_hh_mm}.csv"))
{
var csv = new CsvHelper.CsvWriter(tw);
csv.WriteHeader<ExperimentPredictiveValues>();
csv.NextRecord();
csv.WriteRecords(results);
}
}
private static AlgoritamPredictiveValues Ann(Data data, int neuronCount, List<AnnLearningRecord> learningData, out ActivationNetwork resultAnn)
{
// za aktivacionu funkciju uzimamo standardnu sigmoidnu
var activationFunction = new SigmoidFunction();
// kreiramo neuronsku mrežu sa 6 neurona u ulazniom sloju i jednim u izlaznom
// broj skrivenih neurona je određen parametrom neuronCount
var ann = new ActivationNetwork(activationFunction, INPUT_COUNT, neuronCount, OUTPUT_COUNT);
// postavljanje inicijalnih težinski faktora
new NguyenWidrow(ann).Randomize();
// algoritam za obučavanje
var teacher = new LevenbergMarquardtLearning(ann);
teacher.LearningRate = 0.001;
// uključujemo regularizaciju
teacher.UseRegularization = true;
double err;
int count = 0;
int failCount = 0;
PredictiveValues lastPredictiveValues = null;
int epochCounter = 1;
while (true)
{
err = teacher.RunEpoch(data.LearnInputs, data.LearnOutputs);
// izracunavamo prediktivne vrednosti
var pv = CalculatePredictiveValues(ann, data);
LogMessage($"Epoch #{count + 1:000}, PPV: {pv.PPV,10:#0.000000}, NPV: {pv.NPV,10:#0.000000}, SPEC: {pv.SPEC,10:#0.000000}, SENS: {pv.SENS,10:#0.000000}");
if (learningData != null)
{
learningData.Add(new AnnLearningRecord()
{
EpochNumber = epochCounter++,
NPV = pv.NPV,
PPV = pv.PPV,
N_FN = pv.N_FN,
N_FP = pv.N_FP,
N_TN = pv.N_TN,
N_TP = pv.N_TP
});
}
if (lastPredictiveValues != null)
{
// proveravamo da li se performansa poboljsala ili ne
if (lastPredictiveValues.PPV >= pv.PPV && lastPredictiveValues.NPV >= pv.NPV)
{
failCount++;
// obuka se prekida ukoliko do poboljsanja nije doslo u poslednjih 10 epoha
if (failCount >= 10)
break;
}
else
failCount = 0;
}
lastPredictiveValues = pv;
count++;
if (count >= 500)
break;
}
// izracunavanje izlaza
double[][] AnnCompute(double[][] inputs, double[][] outputs)
{
var res = new double[inputs.Length][];
for (int i = 0; i < inputs.Length; i++)
{
var annr = ann.Compute(inputs[i])[0];
var to = Math.Round(outputs[i][0], 0);
var anno = Math.Round(annr, 0);
res[i] = new double[] { anno };
}
return res;
}
var learnOutputs = AnnCompute(data.LearnInputs, data.LearnOutputs);
var validateOutputs = AnnCompute(data.ValidateInputs, data.ValidateOutputs);
var testOutputs = AnnCompute(data.TestInputs, data.TestOutputs);
var learnPV = CalculatePredictiveValues(data.LearnOutputs, learnOutputs);
var validatePV = CalculatePredictiveValues(data.ValidateOutputs, validateOutputs);
var testPV = CalculatePredictiveValues(data.TestOutputs, testOutputs);
var result = new AlgoritamPredictiveValues()
{
LearnNPV = learnPV.NPV,
LearnPPV = learnPV.PPV,
LearnSENS = learnPV.SENS,
LearnSPEC = learnPV.SPEC,
ValidateNPV = validatePV.NPV,
ValidatePPV = validatePV.PPV,
ValidateSENS = validatePV.SENS,
ValidateSPEC = validatePV.SPEC,
TestNPV = testPV.NPV,
TestPPV = testPV.PPV,
TestSENS = testPV.SENS,
TestSPEC = testPV.SPEC,
};
resultAnn = ann;
return result;
}
