public List <double> testMLPUsingWeka(string[] attributeArray, string[] classNames, double[] dataValues, string classHeader, string defaultclass, string modelName, int hiddelLayers = 7, double learningRate = 0.03, double momentum = 0.4, int decimalPlaces = 2, int trainingTime = 1000)
{
java.util.ArrayList classLabel = new java.util.ArrayList();
foreach (string className in classNames)
{
classLabel.Add(className);
}
weka.core.Attribute classHeaderName = new weka.core.Attribute(classHeader, classLabel);
java.util.ArrayList attributeList = new java.util.ArrayList();
foreach (string attribute in attributeArray)
{
weka.core.Attribute newAttribute = new weka.core.Attribute(attribute);
attributeList.Add(newAttribute);
}
attributeList.add(classHeaderName);
weka.core.Instances data = new weka.core.Instances("TestInstances", attributeList, 0);
data.setClassIndex(data.numAttributes() - 1);
// Set instance's values for the attributes
weka.core.Instance inst_co = new DenseInstance(data.numAttributes());
for (int i = 0; i < data.numAttributes() - 1; i++)
{
inst_co.setValue(i, dataValues.ElementAt(i));
}
inst_co.setValue(classHeaderName, defaultclass);
data.add(inst_co);
java.io.File path = new java.io.File("/models/");
weka.classifiers.functions.MultilayerPerceptron clRead = loadModel(modelName, path);
clRead.setHiddenLayers(hiddelLayers.ToString());
clRead.setLearningRate(learningRate);
clRead.setMomentum(momentum);
clRead.setNumDecimalPlaces(decimalPlaces);
clRead.setTrainingTime(trainingTime);
weka.filters.Filter myRandom = new weka.filters.unsupervised.instance.Randomize();
myRandom.setInputFormat(data);
data = weka.filters.Filter.useFilter(data, myRandom);
double classValue = clRead.classifyInstance(data.get(0));
double[] predictionDistribution = clRead.distributionForInstance(data.get(0));
List <double> predictionDistributions = new List <double>();
for (int predictionDistributionIndex = 0;
predictionDistributionIndex < predictionDistribution.Count();
predictionDistributionIndex++)
{
string classValueString1 = classLabel.get(predictionDistributionIndex).ToString();
double prob = predictionDistribution[predictionDistributionIndex] * 100;
predictionDistributions.Add(prob);
}
List <double> prediction = new List <double>();
prediction.Add(classValue);
prediction.AddRange(predictionDistributions);
return(prediction);
}
public string testHybridEmotionUsingWeka(string[] attributeArray, string[] classNames, double[] dataValues, string classHeader, string defaultclass, string modelName)
{
java.util.ArrayList classLabel = new java.util.ArrayList();
foreach (string className in classNames)
{
classLabel.Add(className);
}
weka.core.Attribute classHeaderName = new weka.core.Attribute(classHeader, classLabel);
java.util.ArrayList attributeList = new java.util.ArrayList();
foreach (string attribute in attributeArray)
{
weka.core.Attribute newAttribute = new weka.core.Attribute(attribute);
attributeList.Add(newAttribute);
}
attributeList.add(classHeaderName);
weka.core.Instances data = new weka.core.Instances("TestInstances", attributeList, 0);
data.setClassIndex(data.numAttributes() - 1);
// Set instance's values for the attributes
weka.core.Instance inst_co = new DenseInstance(data.numAttributes());
for (int i = 0; i < data.numAttributes() - 1; i++)
{
inst_co.setValue(i, dataValues.ElementAt(i));
}
inst_co.setValue(classHeaderName, defaultclass);
data.add(inst_co);
java.io.File path = new java.io.File("/models/");
weka.classifiers.meta.Bagging clRead = loadBaggingModel(modelName, path);
weka.filters.Filter myRandom = new weka.filters.unsupervised.instance.Randomize();
myRandom.setInputFormat(data);
data = weka.filters.Filter.useFilter(data, myRandom);
double classValue = clRead.classifyInstance(data.get(0));
string classValueString = classLabel.get(Int32.Parse(classValue.ToString())).ToString();
return(classValueString);
}
/// <summary>
/// Build the learning model for classification
/// </summary>
/// <param name="InstancesList">list of instances </param>
/// <param name="NumberofClusters">Number of Clusters</param>
/// <param name="TextBoxForFeedback">Text box for the results (can be NULL)</param>
/// <param name="PanelForVisualFeedback">Panel to display visual results if avalaible (can be NULL)</param>
public Classifier PerformTraining(FormForClassificationInfo WindowForClassificationParam, Instances InstancesList, /*int NumberofClusters,*/ RichTextBox TextBoxForFeedback,
Panel PanelForVisualFeedback, out weka.classifiers.Evaluation ModelEvaluation, bool IsCellular)
{
// weka.classifiers.Evaluation ModelEvaluation = null;
// FormForClassificationInfo WindowForClassificationParam = new FormForClassificationInfo(GlobalInfo);
ModelEvaluation = null;
// if (WindowForClassificationParam.ShowDialog() != System.Windows.Forms.DialogResult.OK) return null;
// weka.classifiers.Evaluation ModelEvaluation = new Evaluation(
cParamAlgo ClassifAlgoParams = WindowForClassificationParam.GetSelectedAlgoAndParameters();
if (ClassifAlgoParams == null) return null;
//this.Cursor = Cursors.WaitCursor;
// cParamAlgo ClassificationAlgo = WindowForClassificationParam.GetSelectedAlgoAndParameters();
cListValuesParam Parameters = ClassifAlgoParams.GetListValuesParam();
//Classifier this.CurrentClassifier = null;
// -------------------------- Classification -------------------------------
// create the instances
// InstancesList = this.ListInstances;
this.attValsWithoutClasses = new FastVector();
if (IsCellular)
for (int i = 0; i < cGlobalInfo.ListCellularPhenotypes.Count; i++)
this.attValsWithoutClasses.addElement(cGlobalInfo.ListCellularPhenotypes[i].Name);
else
for (int i = 0; i < cGlobalInfo.ListWellClasses.Count; i++)
this.attValsWithoutClasses.addElement(cGlobalInfo.ListWellClasses[i].Name);
InstancesList.insertAttributeAt(new weka.core.Attribute("Class", this.attValsWithoutClasses), InstancesList.numAttributes());
//int A = Classes.Count;
for (int i = 0; i < Classes.Count; i++)
InstancesList.get(i).setValue(InstancesList.numAttributes() - 1, Classes[i]);
InstancesList.setClassIndex(InstancesList.numAttributes() - 1);
weka.core.Instances train = new weka.core.Instances(InstancesList, 0, InstancesList.numInstances());
if (PanelForVisualFeedback != null)
PanelForVisualFeedback.Controls.Clear();
#region List classifiers
#region J48
if (ClassifAlgoParams.Name == "J48")
{
this.CurrentClassifier = new weka.classifiers.trees.J48();
((J48)this.CurrentClassifier).setMinNumObj((int)Parameters.ListDoubleValues.Get("numericUpDownMinInstLeaf").Value);
((J48)this.CurrentClassifier).setConfidenceFactor((float)Parameters.ListDoubleValues.Get("numericUpDownConfFactor").Value);
((J48)this.CurrentClassifier).setNumFolds((int)Parameters.ListDoubleValues.Get("numericUpDownNumFolds").Value);
((J48)this.CurrentClassifier).setUnpruned((bool)Parameters.ListCheckValues.Get("checkBoxUnPruned").Value);
((J48)this.CurrentClassifier).setUseLaplace((bool)Parameters.ListCheckValues.Get("checkBoxLaplacianSmoothing").Value);
((J48)this.CurrentClassifier).setSeed((int)Parameters.ListDoubleValues.Get("numericUpDownSeedNumber").Value);
((J48)this.CurrentClassifier).setSubtreeRaising((bool)Parameters.ListCheckValues.Get("checkBoxSubTreeRaising").Value);
// CurrentClassif.SetJ48Tree((J48)this.CurrentClassifier, Classes.Length);
this.CurrentClassifier.buildClassifier(train);
// display results training
// display tree
if (PanelForVisualFeedback != null)
{
GViewer GraphView = DisplayTree(GlobalInfo, ((J48)this.CurrentClassifier), IsCellular).gViewerForTreeClassif;
GraphView.Size = new System.Drawing.Size(PanelForVisualFeedback.Width, PanelForVisualFeedback.Height);
GraphView.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
PanelForVisualFeedback.Controls.Clear();
PanelForVisualFeedback.Controls.Add(GraphView);
}
}
#endregion
#region Random Tree
else if (ClassifAlgoParams.Name == "RandomTree")
{
this.CurrentClassifier = new weka.classifiers.trees.RandomTree();
if ((bool)Parameters.ListCheckValues.Get("checkBoxMaxDepthUnlimited").Value)
((RandomTree)this.CurrentClassifier).setMaxDepth(0);
else
((RandomTree)this.CurrentClassifier).setMaxDepth((int)Parameters.ListDoubleValues.Get("numericUpDownMaxDepth").Value);
((RandomTree)this.CurrentClassifier).setSeed((int)Parameters.ListDoubleValues.Get("numericUpDownSeed").Value);
((RandomTree)this.CurrentClassifier).setMinNum((double)Parameters.ListDoubleValues.Get("numericUpDownMinWeight").Value);
if ((bool)Parameters.ListCheckValues.Get("checkBoxIsBackfitting").Value)
{
((RandomTree)this.CurrentClassifier).setNumFolds((int)Parameters.ListDoubleValues.Get("numericUpDownBackFittingFolds").Value);
}
else
{
((RandomTree)this.CurrentClassifier).setNumFolds(0);
}
this.CurrentClassifier.buildClassifier(train);
//string StringForTree = ((RandomTree)this.CurrentClassifier).graph().Remove(0, ((RandomTree)this.CurrentClassifier).graph().IndexOf("{") + 2);
//Microsoft.Msagl.GraphViewerGdi.GViewer GraphView = new GViewer();
//GraphView.Graph = GlobalInfo.WindowHCSAnalyzer.ComputeAndDisplayGraph(StringForTree);//.Remove(StringForTree.Length - 3, 3));
//GraphView.Size = new System.Drawing.Size(panelForGraphicalResults.Width, panelForGraphicalResults.Height);
//GraphView.Anchor = (AnchorStyles.Bottom | AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right);
//this.panelForGraphicalResults.Controls.Clear();
//this.panelForGraphicalResults.Controls.Add(GraphView);
}
#endregion
#region Random Forest
else if (ClassifAlgoParams.Name == "RandomForest")
{
this.CurrentClassifier = new weka.classifiers.trees.RandomForest();
if ((bool)Parameters.ListCheckValues.Get("checkBoxMaxDepthUnlimited").Value)
((RandomForest)this.CurrentClassifier).setMaxDepth(0);
else
((RandomForest)this.CurrentClassifier).setMaxDepth((int)Parameters.ListDoubleValues.Get("numericUpDownMaxDepth").Value);
((RandomForest)this.CurrentClassifier).setNumTrees((int)Parameters.ListDoubleValues.Get("numericUpDownNumTrees").Value);
((RandomForest)this.CurrentClassifier).setSeed((int)Parameters.ListDoubleValues.Get("numericUpDownSeed").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region KStar
else if (ClassifAlgoParams.Name == "KStar")
{
this.CurrentClassifier = new weka.classifiers.lazy.KStar();
((KStar)this.CurrentClassifier).setGlobalBlend((int)Parameters.ListDoubleValues.Get("numericUpDownGlobalBlend").Value);
((KStar)this.CurrentClassifier).setEntropicAutoBlend((bool)Parameters.ListCheckValues.Get("checkBoxBlendAuto").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region SVM
else if (ClassifAlgoParams.Name == "SVM")
{
this.CurrentClassifier = new weka.classifiers.functions.SMO();
((SMO)this.CurrentClassifier).setC((double)Parameters.ListDoubleValues.Get("numericUpDownC").Value);
((SMO)this.CurrentClassifier).setKernel(WindowForClassificationParam.GeneratedKernel);
((SMO)this.CurrentClassifier).setRandomSeed((int)Parameters.ListDoubleValues.Get("numericUpDownSeed").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region KNN
else if (ClassifAlgoParams.Name == "KNN")
{
this.CurrentClassifier = new weka.classifiers.lazy.IBk();
string OptionDistance = " -K " + (int)Parameters.ListDoubleValues.Get("numericUpDownKNN").Value + " -W 0 ";
string WeightType = (string)Parameters.ListTextValues.Get("comboBoxDistanceWeight").Value;
switch (WeightType)
{
case "No Weighting":
OptionDistance += "";
break;
case "1/Distance":
OptionDistance += "-I";
break;
case "1-Distance":
OptionDistance += "-F";
break;
default:
break;
}
OptionDistance += " -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.";
string DistanceType = (string)Parameters.ListTextValues.Get("comboBoxDistance").Value;
// OptionDistance += " -A \"weka.core.";
switch (DistanceType)
{
case "Euclidean":
OptionDistance += "EuclideanDistance";
break;
case "Manhattan":
OptionDistance += "ManhattanDistance";
break;
case "Chebyshev":
OptionDistance += "ChebyshevDistance";
break;
default:
break;
}
if (!(bool)Parameters.ListCheckValues.Get("checkBoxNormalize").Value)
OptionDistance += " -D";
OptionDistance += " -R ";
OptionDistance += "first-last\\\"\"";
((IBk)this.CurrentClassifier).setOptions(weka.core.Utils.splitOptions(OptionDistance));
//((IBk)this.CurrentClassifier).setKNN((int)Parameters.ListDoubleValues.Get("numericUpDownKNN").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region Multilayer Perceptron
else if (ClassifAlgoParams.Name == "Perceptron")
{
this.CurrentClassifier = new weka.classifiers.functions.MultilayerPerceptron();
((MultilayerPerceptron)this.CurrentClassifier).setMomentum((double)Parameters.ListDoubleValues.Get("numericUpDownMomentum").Value);
((MultilayerPerceptron)this.CurrentClassifier).setLearningRate((double)Parameters.ListDoubleValues.Get("numericUpDownLearningRate").Value);
((MultilayerPerceptron)this.CurrentClassifier).setSeed((int)Parameters.ListDoubleValues.Get("numericUpDownSeed").Value);
((MultilayerPerceptron)this.CurrentClassifier).setTrainingTime((int)Parameters.ListDoubleValues.Get("numericUpDownTrainingTime").Value);
((MultilayerPerceptron)this.CurrentClassifier).setNormalizeAttributes((bool)Parameters.ListCheckValues.Get("checkBoxNormAttribute").Value);
((MultilayerPerceptron)this.CurrentClassifier).setNormalizeNumericClass((bool)Parameters.ListCheckValues.Get("checkBoxNormNumericClasses").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region ZeroR
else if (ClassifAlgoParams.Name == "ZeroR")
{
this.CurrentClassifier = new weka.classifiers.rules.OneR();
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region OneR
else if (ClassifAlgoParams.Name == "OneR")
{
this.CurrentClassifier = new weka.classifiers.rules.OneR();
((OneR)this.CurrentClassifier).setMinBucketSize((int)Parameters.ListDoubleValues.Get("numericUpDownMinBucketSize").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region Naive Bayes
else if (ClassifAlgoParams.Name == "NaiveBayes")
{
this.CurrentClassifier = new weka.classifiers.bayes.NaiveBayes();
((NaiveBayes)this.CurrentClassifier).setUseKernelEstimator((bool)Parameters.ListCheckValues.Get("checkBoxKernelEstimator").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
#region Logistic
else if (ClassifAlgoParams.Name == "Logistic")
{
this.CurrentClassifier = new weka.classifiers.functions.Logistic();
((Logistic)this.CurrentClassifier).setUseConjugateGradientDescent((bool)Parameters.ListCheckValues.Get("checkBoxUseConjugateGradientDescent").Value);
((Logistic)this.CurrentClassifier).setRidge((double)Parameters.ListDoubleValues.Get("numericUpDownRidge").Value);
this.CurrentClassifier.buildClassifier(train);
}
#endregion
//weka.classifiers.functions.SMO
//BayesNet
#endregion
if (TextBoxForFeedback != null)
{
TextBoxForFeedback.Clear();
TextBoxForFeedback.AppendText(this.CurrentClassifier.ToString());
}
TextBoxForFeedback.AppendText("\n" + (InstancesList.numAttributes() - 1) + " attributes:\n\n");
for (int IdxAttributes = 0; IdxAttributes < InstancesList.numAttributes() - 1; IdxAttributes++)
{
TextBoxForFeedback.AppendText(IdxAttributes + "\t: " + InstancesList.attribute(IdxAttributes).name() + "\n");
}
#region evaluation of the model and results display
if ((WindowForClassificationParam.numericUpDownFoldNumber.Enabled) && (TextBoxForFeedback != null))
{
TextBoxForFeedback.AppendText("\n-----------------------------\nModel validation\n-----------------------------\n");
ModelEvaluation = new weka.classifiers.Evaluation(InstancesList);
ModelEvaluation.crossValidateModel(this.CurrentClassifier, InstancesList, (int)WindowForClassificationParam.numericUpDownFoldNumber.Value, new java.util.Random(1));
TextBoxForFeedback.AppendText(ModelEvaluation.toSummaryString());
TextBoxForFeedback.AppendText("\n-----------------------------\nConfusion Matrix:\n-----------------------------\n");
double[][] ConfusionMatrix = ModelEvaluation.confusionMatrix();
string NewLine = "";
for (int i = 0; i < ConfusionMatrix[0].Length; i++)
{
NewLine += "c" + i + "\t";
}
TextBoxForFeedback.AppendText(NewLine + "\n\n");
for (int j = 0; j < ConfusionMatrix.Length; j++)
{
NewLine = "";
for (int i = 0; i < ConfusionMatrix[0].Length; i++)
{
NewLine += ConfusionMatrix[j][i] + "\t";
}
// if
TextBoxForFeedback.AppendText(NewLine + "| c" + j + " <=> " + cGlobalInfo.ListCellularPhenotypes[j].Name + "\n");
}
}
#endregion
return this.CurrentClassifier;
}
public List <double> testSMOUsingWeka(string[] attributeArray, string[] classNames, double[] dataValues, string classHeader, string defaultclass, string modelName, int hiddelLayers = 7, double learningRate = 0.03, double momentum = 0.4, int decimalPlaces = 2, int trainingTime = 1000)
{
java.util.ArrayList classLabel = new java.util.ArrayList();
foreach (string className in classNames)
{
classLabel.Add(className);
}
weka.core.Attribute classHeaderName = new weka.core.Attribute(classHeader, classLabel);
java.util.ArrayList attributeList = new java.util.ArrayList();
foreach (string attribute in attributeArray)
{
weka.core.Attribute newAttribute = new weka.core.Attribute(attribute);
attributeList.Add(newAttribute);
}
attributeList.add(classHeaderName);
weka.core.Instances data = new weka.core.Instances("TestInstances", attributeList, 0);
data.setClassIndex(data.numAttributes() - 1);
// Set instance's values for the attributes
weka.core.Instance inst_co = new DenseInstance(data.numAttributes());
for (int i = 0; i < data.numAttributes() - 1; i++)
{
inst_co.setValue(i, Math.Round(dataValues.ElementAt(i), 5));
}
inst_co.setValue(classHeaderName, defaultclass);
data.add(inst_co);
weka.core.Instance currentInst = data.get(0);
int j = 0;
//foreach (float value in dataValues)
//{
// // double roundedValue = Math.Round(value);
// //var rounded = Math.Floor(value * 100) / 100;
// if (array.ElementAt(j) != value)
// {
// System.Console.WriteLine("Masla occur");
// }
// j++;
//}
//double predictedClass = cl.classifyInstance(data.get(0));
weka.classifiers.functions.SMO clRead = new weka.classifiers.functions.SMO();
try
{
java.io.File path = new java.io.File("/models/");
clRead = loadSMOModel(modelName, path);
}
catch (Exception e)
{
//string p1 = Assembly.GetExecutingAssembly().Location;
string ClassifierName = Path.GetFileName(Path.GetFileName(modelName));
string Path1 = HostingEnvironment.MapPath(@"~//libs//models//" + ClassifierName);
//string Path1 = HostingEnvironment.MapPath(@"~//libs//models//FusionCustomized.model");
clRead = (weka.classifiers.functions.SMO)weka.core.SerializationHelper.read(modelName);
}
// weka.classifiers.functions.SMO clRead = loadSMOModel(modelName, path);
clRead.setBatchSize("100");
clRead.setCalibrator(new weka.classifiers.functions.Logistic());
clRead.setKernel(new weka.classifiers.functions.supportVector.PolyKernel());
clRead.setEpsilon(1.02E-12);
clRead.setC(1.0);
clRead.setDebug(false);
clRead.setChecksTurnedOff(false);
clRead.setFilterType(new SelectedTag(weka.classifiers.functions.SMO.FILTER_NORMALIZE, weka.classifiers.functions.SMO.TAGS_FILTER));
double classValue = clRead.classifyInstance(data.get(0));
double[] predictionDistribution = clRead.distributionForInstance(data.get(0));
//for (int predictionDistributionIndex = 0;
// predictionDistributionIndex < predictionDistribution.Count();
// predictionDistributionIndex++)
//{
// string classValueString1 = classLabel.get(predictionDistributionIndex).ToString();
// double prob= predictionDistribution[predictionDistributionIndex]*100;
// System.Console.WriteLine(classValueString1 + ":" + prob);
//}
List <double> prediction = new List <double>();
prediction.Add(classValue);
//prediction.AddRange(predictionDistribution);
return(prediction);
}
