Best code snippets using weka.classifiers.Classifier.classifyInstance(Showing top 15 results out of 315)

@Override
public double classifyInstance(Instance inst) throws Exception {
 Instance converted = constructMappedInstance(inst);
 return m_Classifier.classifyInstance(converted);
}

@Override
public double[] distributionForInstance(Instance instance) throws Exception {
  int c = instance.classIndex();
  double result[] = new double[c];
  Instance finstances[] = convertInstance(instance,c);
  for (int i = 0; i < c; i++) {
    result[i] = m_MultiClassifiers[i].classifyInstance(finstances[i]);
    //result[i] = m_MultiClassifiers[i].distributionForInstance(finstances[i])[1];
  }
  return result;
}

 //load model
String rootPath="/some/where/"; 
Classifier cls = (Classifier) weka.core.SerializationHelper.read(rootPath+"tree.model");

//predict instance class values
Instances originalTrain= //load or create Instances to predict

//which instance to predict class value
int s1=0;  

//perform your prediction
double value=cls.classifyInstance(originalTrain.instance(s1));

//get the name of the class value
String prediction=originalTrain.classAttribute().value((int)value); 

System.out.println("The predicted value of instance "+
          Integer.toString(s1)+
          ": "+prediction);

 public static void LoadAndTest(String filename_test, String filename_model) throws Exception {
  BufferedReader datafile_test = readDataFile(filename_test);
  Instances      data_test     = new Instances(datafile_test);
  data_test.setClassIndex(data_test.numAttributes() - 1);

  Classifier cls = (Classifier) weka.core.SerializationHelper.read(filename_model);
  int act = 0;
  for (int i = 0; i < data_test.numInstances(); i++) {
   double pred = cls.classifyInstance(data_test.instance(i));
   double real = data_test.instance(i).classValue();
   if (pred==real) {
    act = act + 1;
   }
  }  
  double pct = (double) act / (double) data_test.numInstances();
  System.out.println("Accuracy = " + pct);
}

/**
 * Add a label to an instance using a classifier
 *
 * @param classifier the classifier to use
 * @param inst the instance to append prediction to
 * @param instOrig the original instance
 * @throws WekaException if a problem occurs
 */
protected void predictLabelClassifier(weka.classifiers.Classifier classifier,
 Instance inst, Instance instOrig) throws WekaException {
 try {
  double pred = classifier.classifyInstance(instOrig);
  inst.setValue(inst.numAttributes() - 1, pred);
 } catch (Exception ex) {
  throw new WekaException(ex);
 }
}

@Override
public double[] distributionForInstance(Instance x) throws Exception {
  int L = x.classIndex();
  //if there is only one class (as for e.g. in some hier. mtds) predict it
  if(L == 1) return new double[]{1.0};
  Instance x_ = PSUtils.convertInstance(x,L,m_InstancesTemplate); //convertInstance(x,L);
  x_.setDataset(m_InstancesTemplate);
  //Get a classification
  double y[] = new double[x_.numClasses()];
  y[(int)m_Classifier.classifyInstance(x_)] = 1.0;
  return PSUtils.convertDistribution(y,L,m_InstancesTemplate);
}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
 response.setContentType("text/html");
 PrintWriter out = response.getWriter();
 // Get formula input
   ...
 // Read Classifier and predict Success
 try {
   Classifier J48 = getClassifier();
   if (klassifizierer != null) {out.println("KLASSIFIZIERER IS LOADED");}
   predictionResult = J48.classifyInstance(DATA.firstInstance());
   DATA.classAttribute().value((int) ergebnis);
 return PredicitonResult;
 } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
 }
}

private void classify(Instance test) throws Exception {
  // copy
  Instance copy = (Instance)test.copy();
  copy.setDataset(null);
  // delete attributes we don't need
  for(int i = excld.length-1; i >= 0; i--) {
    copy.deleteAttributeAt(this.excld[i]);
  }
  //set template
  copy.setDataset(this._template);
  //set class
  test.setValue(this.index,(int)(this.classifier.classifyInstance(copy))); 
  //carry on
  if (next!=null) next.classify(test);
}

 BufferedReader datafile = readDataFile(TrainingFile);
Instances train = new Instances(datafile);
data.setClassIndex(data.numAttributes() - 1);

Classifier cls = new J48();
cls.buildClassifier(train);

DataSource testDataset = new DataSource(Test);
Instances test = testDataset.getDataSet();
Testdata.setClassIndex(Testdata.numAttributes() - 1);

for(int i = 0; i < test.numInstances(); i++){

  Instance inst = test.instance(i);

  double actualClassValue  = test.instance(i).classValue();

  //it will print your class value
  String actual=test.classAttribute().value((int)actualClassValue);

  double result = cls.classifyInstance(inst);

  //will print your predicted value
  String prediction=test.classAttribute().value((int)result );


}

/**
 * Classifies the given test instance.
 *
 * @param instance     the instance to be classified
 * @return         the predicted most likely class for the instance or
 *                 Utils.missingValue() if no prediction is made
 * @throws Exception     if an error occurred during the prediction
 */
@Override
public double classifyInstance(Instance instance) throws Exception {
 return m_Classifier.classifyInstance(instance);
}

@Override
public double classifyInstance(Instance inst) throws Exception {
 Instance converted = constructMappedInstance(inst);
 return m_Classifier.classifyInstance(converted);
}

/**
 * Classifies the given test instance.
 *
 * @param instance     the instance to be classified
 * @return         the predicted most likely class for the instance or
 *                 Utils.missingValue() if no prediction is made
 * @throws Exception     if an error occurred during the prediction
 */
@Override
public double classifyInstance(Instance instance) throws Exception {
 return m_Classifier.classifyInstance(instance);
}

@Override
public double[] distributionForInstance(Instance x) throws Exception {
  int L = x.classIndex();
  //if there is only one class (as for e.g. in some hier. mtds) predict it
  if(L == 1) return new double[]{1.0};
  Instance x_ = PSUtils.convertInstance(x,L,m_InstancesTemplate); //convertInstance(x,L);
  x_.setDataset(m_InstancesTemplate);
  //Get a classification
  double y[] = new double[x_.numClasses()];
  y[(int)m_Classifier.classifyInstance(x_)] = 1.0;
  return PSUtils.convertDistribution(y,L,m_InstancesTemplate);
}

@Override
public double[] distributionForInstance(Instance instance) throws Exception {
  int c = instance.classIndex();
  double result[] = new double[c];
  Instance finstances[] = convertInstance(instance,c);
  for (int i = 0; i < c; i++) {
    result[i] = m_MultiClassifiers[i].classifyInstance(finstances[i]);
    //result[i] = m_MultiClassifiers[i].distributionForInstance(finstances[i])[1];
  }
  return result;
}

private void classify(Instance test) throws Exception {
  // copy
  Instance copy = (Instance)test.copy();
  copy.setDataset(null);
  // delete attributes we don't need
  for(int i = excld.length-1; i >= 0; i--) {
    copy.deleteAttributeAt(this.excld[i]);
  }
  //set template
  copy.setDataset(this._template);
  //set class
  test.setValue(this.index,(int)(this.classifier.classifyInstance(copy))); 
  //carry on
  if (next!=null) next.classify(test);
}