public async Task <string> classifyTest(weka.classifiers.Classifier cl) { string a = ""; double rate = 0; try { //instsTest = Instances.mergeInstances(ins,null); /*if (ins.classIndex() == -1) * ins.setClassIndex(insts.numAttributes() - 1);*/ System.Console.WriteLine("Performing " + percentSplit + "% split evaluation."); weka.filters.Filter normalized = new weka.filters.unsupervised.attribute.Normalize(); normalized.setInputFormat(insts); insts = weka.filters.Filter.useFilter(insts, normalized); //randomize the order of the instances in the dataset. weka.filters.Filter myRandom = new weka.filters.unsupervised.instance.Randomize(); myRandom.setInputFormat(insts); insts = weka.filters.Filter.useFilter(insts, myRandom); //replace missing values weka.filters.Filter replaceMissingValues = new weka.filters.unsupervised.attribute.ReplaceMissingValues(); replaceMissingValues.setInputFormat(insts); insts = weka.filters.Filter.useFilter(insts, replaceMissingValues); int trainSize = insts.numInstances() * percentSplit / 100; int testSize = insts.numInstances() - trainSize; weka.core.Instances train = new weka.core.Instances(insts, 0, trainSize); cl.buildClassifier(train); //double label = cl.classifyInstance(instsTest.instance(0)); double label = cl.classifyInstance(ins); ins.setClassValue(label); //instsTest.instance(0).setClassValue(label); a = ins.toString(ins.numAttributes() - 1); weka.core.SerializationHelper.write("mymodel.model", cl); int numCorrect = 0; for (int i = trainSize; i < insts.numInstances(); i++) { weka.core.Instance currentInst = insts.instance(i); double predictedClass = cl.classifyInstance(currentInst); if (predictedClass == insts.instance(i).classValue()) { numCorrect++; } } rate = (double)((double)numCorrect / (double)testSize * 100.0); } catch (java.lang.Exception ex) { //ex.printStackTrace(); rate = -1; } return(rate.ToString() + ";" + a ?? ""); }
/// <summary> Evaluates the classifier on a single instance. /// /// </summary> /// <param name="classifier">machine learning classifier /// </param> /// <param name="instance">the test instance to be classified /// </param> /// <returns> the prediction made by the clasifier /// </returns> /// <throws> Exception if model could not be evaluated </throws> /// <summary> successfully or the data contains string attributes /// </summary> public virtual double evaluateModelOnce(Classifier classifier, Instance instance) { Instance classMissing = (Instance) instance.copy(); double pred = 0; classMissing.Dataset = instance.dataset(); classMissing.setClassMissing(); if (m_ClassIsNominal) { double[] dist = classifier.distributionForInstance(classMissing); pred = Utils.maxIndex(dist); //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" if (dist[(int) pred] <= 0) { pred = Instance.missingValue(); } updateStatsForClassifier(dist, instance); } else { pred = classifier.classifyInstance(classMissing); updateStatsForPredictor(pred, instance); } return pred; }
public static void GenerarModelo() { // Fuente de datos DataSource source = new DataSource(DirectorioDatosPrueba()); // convertimos a instancias Instances data = source.getDataSet(); // generamos una copia Instances dataCopy = new Instances(data); // hay qeu decirle cual es el atributo de clase if (data.classIndex() == -1) { data.setClassIndex(data.numAttributes() - 1); } #region Discretizacion //// DISCRETIZACION //bool bHasNonNominal = true; //bool bHasMissingValues = true; //weka.filters.unsupervised.attribute.Discretize unSupervised = new weka.filters.unsupervised.attribute.Discretize(); //weka.filters.supervised.attribute.Discretize supervised = new weka.filters.supervised.attribute.Discretize(); ////Instances dataCopy = new Instances(data); //// Quitamos las missing classes de las instancias ////data.deleteWithMissingClass(); //// ////data = NormalizeDataset(data); //// si no hay missing values //if (bHasNonNominal) //{ // // Para los que son nominales y no son missing values // weka.filters.supervised.attribute.Discretize supervised2 = new weka.filters.supervised.attribute.Discretize(); // bool k = supervised2.getUseKononenko(); // supervised2.setUseKononenko(true); // k = supervised2.getUseKononenko(); // k= supervised2.setInputFormat(data); // data = weka.filters.Filter.useFilter(data, supervised2); //} //// si hay missing valyes //if (bHasMissingValues) //{ // //System.err.println("Warning: filling in missing values in data set"); // weka.filters.unsupervised.attribute.ReplaceMissingValues m_MissingValuesFilter = new weka.filters.unsupervised.attribute.ReplaceMissingValues(); // m_MissingValuesFilter.setInputFormat(data); // data = weka.filters.Filter.useFilter(data, m_MissingValuesFilter); //} //// EQUAL FREQUENCIES //// creamos el objeto para discretizar //weka.filters.unsupervised.attribute.Discretize discretizer = new weka.filters.unsupervised.attribute.Discretize(); //// Le decimos que use el metodo equal frequecies //discretizer.setUseEqualFrequency(true); //// ponemos el numero de bins que nos salga de las narices //discretizer.setBins(3); //// Este metodo es de la clase PotentialClassIgnorer //discretizer.setIgnoreClass(true);//Set the IgnoreClass value. Set this to true if the class index is to be unset before the filter is applied. //// Sets the format of the input instances. //bool val = discretizer.setInputFormat(data); //// Aplicamos la discretizacion //data = Filter.useFilter(data, discretizer); //// FIND NUM BINS //// creamos el discretizador //weka.filters.unsupervised.attribute.Discretize discretizer2 = new weka.filters.unsupervised.attribute.Discretize(); //// le decimos que use este metodo //discretizer2.setFindNumBins(true); //// esto es opcional //discretizer2.setIgnoreClass(true); //// //discretizer2.setInputFormat(data); //// //data = Filter.useFilter(data, discretizer2); #endregion #region Modelos #region Cadenas de texto // hay qeu decirle cual es el atributo de clase if (data.classIndex() == -1) { data.setClassIndex(data.numAttributes() - 1); } string k2 = "weka.classifiers.bayes.BayesNet -D -Q weka.classifiers.bayes.net.search.local.K2 -- -P 1 -S BAYES -E weka.classifiers.bayes.net.estimate.SimpleEstimator -- -A 0.5"; string HillClimber = "weka.classifiers.bayes.BayesNet -D -Q weka.classifiers.bayes.net.search.local.HillClimber -- -P 1 -S BAYES -E weka.classifiers.bayes.net.estimate.SimpleEstimator -- -A 0.5"; string TAN = "weka.classifiers.bayes.BayesNet -D -Q weka.classifiers.bayes.net.search.local.TAN -- -S BAYES -E weka.classifiers.bayes.net.estimate.SimpleEstimator -- -A 0.5"; string bayesNetworkNaiveBayes = "weka.classifiers.bayes.NaiveBayes"; string j48 = "weka.classifiers.trees.J48 -C 0.25 -M 2"; string rF = "weka.classifiers.trees.RandomForest -P 100 -I 100 -num-slots 1 -K 0 -M 1.0 -V 0.001 -S 1"; string knn = "weka.classifiers.lazy.IBk -K " + 1.ToString() + " -W 0 -A \"weka.core.neighboursearch.LinearNNSearch -A \\\"weka.core.EuclideanDistance -R first-last\\\"\""; string ann = "weka.classifiers.functions.MultilayerPerceptron -L 0.3 -M 0.2 -N 500 -V 0 -S 0 -E 20 -H a"; string polykernel = "weka.classifiers.functions.SMO -C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"weka.classifiers.functions.supportVector.PolyKernel -E 1.0 -C 250007\" -calibrator \"weka.classifiers.functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\""; string rbfkernell = "weka.classifiers.functions.SMO -C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"weka.classifiers.functions.supportVector.RBFKernel -G 0.01 -C 250007\" -calibrator \"weka.classifiers.functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\""; string normalized = "weka.classifiers.functions.SMO -C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"weka.classifiers.functions.supportVector.NormalizedPolyKernel -E 2.0 -C 250007\" -calibrator \"weka.classifiers.functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\""; string puk = "weka.classifiers.functions.SMO -C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"weka.classifiers.functions.supportVector.Puk -O 1.0 -S 1.0 -C 250007\" -calibrator \"weka.classifiers.functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\""; #endregion #region Clasificador // Separamos la cadena de texto del clasificador en un array string[] options = Utils.splitOptions("weka.classifiers.functions.SMO -C 1.0 -L 0.001 -P 1.0E-12 -N 0 -V -1 -W 1 -K \"weka.classifiers.functions.supportVector.PolyKernel -E 1.0 -C 250007\" -calibrator \"weka.classifiers.functions.Logistic -R 1.0E-8 -M -1 -num-decimal-places 4\""); string className = options[0]; options[0] = string.Empty; // Creamos el clasificador weka.classifiers.Classifier scheme = (Classifier)Utils.forName(java.lang.Class.forName("weka.classifiers.Classifier"), className, options); #endregion #region Evaluar #region Percentage split // porcentaje que queremos para predecir int trainingPercent = 80; // sacamos el numero de isntancias que se corresponden a ese procentaje int trainSize = (int)Math.Round(data.numInstances() * ((double)trainingPercent / (double)100)); // sacamos el porentajhe que queremos para probar int testSize = data.numInstances() - trainSize; // aleatoreizamos el dataset para asegurarnos que las instancias no estan ordenadas data.randomize(new java.util.Random(DateTime.Now.Ticks)); // Separamos las instancias en 2 grupos (entrenar con unas y predecri con otras) Instances train = new Instances(data, 0, trainSize); Instances test = new Instances(data, trainSize, testSize); // Generamos el clasificador con el training y lo evaluamos con el test Classifier clsCopyTest = AbstractClassifier.makeCopy(scheme); clsCopyTest.buildClassifier(train); Evaluation evalTest = new Evaluation(data); evalTest.evaluateModel(clsCopyTest, test); Console.WriteLine(); Console.WriteLine("Correct % = " + evalTest.pctCorrect()); Console.WriteLine("Incorrect % = " + evalTest.pctIncorrect()); Console.WriteLine("AUC = " + evalTest.areaUnderROC(1)); Console.WriteLine("kappa = " + evalTest.kappa()); Console.WriteLine("MAE = " + evalTest.meanAbsoluteError()); Console.WriteLine("RMSE = " + evalTest.rootMeanSquaredError()); Console.WriteLine("RAE = " + evalTest.relativeAbsoluteError()); Console.WriteLine("RRSE = " + evalTest.rootRelativeSquaredError()); Console.WriteLine("Precision = " + evalTest.precision(1)); Console.WriteLine("Recall = " + evalTest.recall(1)); Console.WriteLine("fMeasure = " + evalTest.fMeasure(1)); Console.WriteLine("Error Rate = " + evalTest.errorRate()); double[][] conf = evalTest.confusionMatrix(); #endregion #region Cross Validation long seed = DateTime.Now.Ticks; int folds = 15; // randomizamos los datos en funcion de la semilla java.util.Random rand = new java.util.Random(seed); data.randomize(rand); // estratificamso el dataset if (data.classAttribute().isNominal()) { data.stratify(folds); } // crear evaluador Evaluation eval3 = new Evaluation(data); // iteramos en funcion de los diferentes folds con los que querams hacer el CV para ver si mejora con mas folds for (int n = 0; n < folds; n++) { //dividimos aleatroiamente el numero de instancias en train y test en funcion de la validacion Instances train2 = data.trainCV(folds, n); Instances test2 = data.testCV(folds, n); // creamos y evaluamos el clasificador Classifier clsCopy = AbstractClassifier.makeCopy(scheme); clsCopy.buildClassifier(train); eval3.evaluateModel(clsCopy, test); } // output evaluation Console.WriteLine(); //Console.WriteLine(eval3.toMatrixString("=== Confusion matrix for fold " + (n + 1) + "/" + folds + " ===\n")); Console.WriteLine("Correct % = " + eval3.pctCorrect()); Console.WriteLine("Incorrect % = " + eval3.pctIncorrect()); Console.WriteLine("AUC = " + eval3.areaUnderROC(1)); Console.WriteLine("kappa = " + eval3.kappa()); Console.WriteLine("MAE = " + eval3.meanAbsoluteError()); Console.WriteLine("RMSE = " + eval3.rootMeanSquaredError()); Console.WriteLine("RAE = " + eval3.relativeAbsoluteError()); Console.WriteLine("RRSE = " + eval3.rootRelativeSquaredError()); Console.WriteLine("Precision = " + eval3.precision(1)); Console.WriteLine("Recall = " + eval3.recall(1)); Console.WriteLine("fMeasure = " + eval3.fMeasure(1)); Console.WriteLine("Error Rate = " + eval3.errorRate()); // Matriz de confusion Console.WriteLine(eval3.toMatrixString("=== Overall Confusion Matrix ===\n")); #endregion #region Predecir #region Clasificar // Le decimos cual es la clase sobre la que tiene que predecir data.setClassIndex(data.numAttributes() - 1); // Cogemos el numero de clases de ese atributo int numClasses = data.numClasses(); // Pintamos por consola cuales son las clases de un atributo for (int i = 0; i < numClasses; i++) { // Pintamos por consola String classValue = data.classAttribute().value(i); Console.WriteLine("Class Value " + i + " is " + classValue); } //creamos el clasificador scheme.buildClassifier(data); // TODO: aqui deberiamos cargar los nuevos datosque queremos que el modelo clasifique // nosotors lo hacemos con el Dtaset almacenado en la variable data2 que es el mismo que data // Le decimos que prediga sobre la ultima clase //data2.setClassIndex(data2.numAttributes() - 1); // Pintamos la cabecera Console.WriteLine("==================="); Console.WriteLine("Actual Class, Predicted Class"); // Clasificamos cada instancia del dataset data2 for (int i = 0; i < data.numInstances(); i++) { // coge el numero de la clase a la que pertenece esa instancia para un atributo (en el caso de Beta 0-1-2-3) double actualClass = data.instance(i).classValue(); //valor para esa clase en concreto (en el caso de B cogeria el intervalo correspondiente a la clase dentro de los 4 intervalos en los que puede estar) String actual = data.classAttribute().value((int)actualClass); // cogemos la instancia completa dle nuevo dataser Instance newInst = (Instance)data.instance(i).copy(); newInst.setClassMissing(); // TODO: hay que llamar a esto de forma recursiva, llamar a un metodo desde el otro // claificamso la instancia double predNB = scheme.classifyInstance(newInst); double[] distribution = scheme.distributionForInstance(newInst); // cogemos la clase a la que se ha predicho que pretende la instancia String predString = data.classAttribute().value((int)predNB); Console.WriteLine(actual + ", " + predString); } #endregion #region Regresion ////set class index to the last attribute //data.setClassIndex(data.numAttributes() - 1); ////build model //SMOreg smo = new SMOreg(); //smo.buildClassifier(data); ////output model //Console.WriteLine(smo); //// Cargar nuevos datos para predecir ////set class index to the last attribute //data2.setClassIndex(data2.numAttributes() - 1); ////loop through the new dataset and make predictions //Console.WriteLine("==================="); //Console.WriteLine("Actual Class, SMO Predicted"); //for (int i = 0; i < data2.numInstances(); i++) //{ // //get class double value for current instance // double actualValue = data2.instance(i).classValue(); // //get Instance object of current instance // Instance newInst = data2.instance(i); // //call classifyInstance, which returns a double value for the class // double predSMO = smo.classifyInstance(newInst); // Console.WriteLine(actualValue + ", " + predSMO); //} #endregion #endregion #endregion // Lo construimos scheme.buildClassifier(data); // Pintar datos en consola //Console.WriteLine(eval.toSummaryString()); //Console.WriteLine(System.Environment.NewLine); //Console.WriteLine(eval.toClassDetailsString()); #endregion }