public void buildClassifier() { try { if ((classifier instanceof UpdateableClassifier) == false) { Classifier auxclassifier = weka.classifiers.AbstractClassifier.makeCopy(classifier); auxclassifier.buildClassifier(instancesBuffer); classifier = auxclassifier; isBufferStoring = false; } } catch (Exception e) { System.err.println("Building WEKA Classifier: " + e.getMessage()); } }
public void setOptions(String... options) throws Exception { wekaClassifier.setOptions(options); }
public Link2(int chain[], int j, Instances train) throws Exception { this.j = j; this.index = chain[j]; // sort out excludes [4|5,1,0,2,3] this.excld = Arrays.copyOfRange(chain,j+1,chain.length); // sort out excludes [0,1,2,3,5] Arrays.sort(this.excld); //Instances new_train = new Instances(train); Instances new_train = CCUtils.linkTransform(train,j,this.index,this.excld); _template = new Instances(new_train,0); this.classifier = (AbstractClassifier)AbstractClassifier.forName(getClassifier().getClass().getName(),((AbstractClassifier)getClassifier()).getOptions()); this.classifier.buildClassifier(new_train); new_train = null; if(j+1 < chain.length) next = new Link2(chain, ++j, train); }
/** * Returns default capabilities of the classifier. * * @return the capabilities of this classifier */ public Capabilities getCapabilities() { Capabilities result = super.getCapabilities(); // attributes result.enable(Capability.NUMERIC_ATTRIBUTES); // class result.enable(Capability.NOMINAL_CLASS); return result; }
/** * Gets the current settings of the OneR classifier. * * @return an array of strings suitable for passing to setOptions */ @Override public String[] getOptions() { Vector<String> options = new Vector<String>(1); options.add("-B"); options.add("" + m_minBucketSize); Collections.addAll(options, super.getOptions()); return options.toArray(new String[0]); }
/** * Returns the class probability distribution for an instance. * * @param instance the instance to be classified * * @return the distribution the forest generates for the instance * * @throws Exception if computation fails */ public double[] distributionForInstance(Instance instance) throws Exception{ if(m_ZeroR != null){ // default model? return m_ZeroR.distributionForInstance(instance); } return m_bagger.distributionForInstance(instance); }
/** * Get classifier for string. * * @return a classifier * @throws Exception if a problem occurs */ protected IterativeClassifier getIterativeClassifier(String name, String[] options) throws Exception { Classifier c = AbstractClassifier.forName(name, options); if (c instanceof IterativeClassifier) { return (IterativeClassifier) c; } else { throw new IllegalArgumentException(name + " is not an IterativeClassifier."); } }
/** * Sets the type of the meta classifier and initializes the ensemble * * @param metaClassifier * @throws Exception */ public void setMetaAlgorithm(Classifier metaClassifier) throws Exception { this.metaClassifier = metaClassifier; metaLevelEnsemble = AbstractClassifier.makeCopies(metaClassifier, numLabels); }
/** * Returns an enumeration describing the available options. * * @return an enumeration of all the available options. */ @Override public Enumeration<Option> listOptions() { Vector<Option> newVector = new Vector<Option>(); newVector.addElement(new Option("\tOutput additional statistics.", "additional-stats", 0, "-additional-stats")); newVector.addAll(Collections.list(super.listOptions())); return newVector.elements(); }
double[] prob = classifier.distributionForInstance(data.get(i)); for(int k = 0 ; k < numClasses; k++) classificationResult[k][i] = prob[k]; classificationResult[0][i] = classifier.classifyInstance(data.get(i));
public double[] call(){ final int numInstances = data.numInstances(); final double[] classificationResult = new double[numInstances]; for (int i=0; i<numInstances; i++) { try{ if (0 == i % 4000) counter.addAndGet(4000); classificationResult[i] = classifier.classifyInstance(data.instance(i)); }catch(Exception e){ IJ.showMessage("Could not apply Classifier!"); e.printStackTrace(); return null; } } return classificationResult; } };
public void trainAll(ListDataSet dataSet) { try { instances = new DataSetToInstancesWrapper(dataSet, discrete, true); wekaClassifier.buildClassifier(instances); } catch (Exception e) { throw new RuntimeException(e); } }
/** * Returns default capabilities of the classifier. * * @return the capabilities of this classifier */ public Capabilities getCapabilities() { Capabilities result = super.getCapabilities(); // attributes result.enable(Capability.NUMERIC_ATTRIBUTES); // class result.enable(Capability.NOMINAL_CLASS); return result; }
/** * Gets the current settings of the classifier. * * @return an array of strings suitable for passing to setOptions */ @Override public String[] getOptions() { Vector<String> result = new Vector<String>(); result.add("-N"); result.add("" + m_filterType); Collections.addAll(result, super.getOptions()); return result.toArray(new String[result.size()]); }
/** * Returns the class probability distribution for an instance. * * @param instance the instance to be classified * * @return the distribution the forest generates for the instance * * @throws Exception if computation fails */ public double[] distributionForInstance(Instance instance) throws Exception{ if(m_ZeroR != null){ // default model? return m_ZeroR.distributionForInstance(instance); } return m_bagger.distributionForInstance(instance); }
public void createWekaClassifier(String[] options) throws Exception { String classifierName = options[0]; String[] newoptions = options.clone(); newoptions[0] = ""; this.classifier = weka.classifiers.AbstractClassifier.forName(classifierName, newoptions); } }
/** * Stump method for building the classifiers. * * @param data the training data to be used for generating the * bagged classifier. * @exception Exception if the classifier could not be built successfully */ public void buildClassifier(Instances data) throws Exception { if (m_Classifier == null) { throw new Exception("A base classifier has not been specified!"); } m_Classifiers = AbstractClassifier.makeCopies(m_Classifier, m_NumIterations); }
/** * Returns an enumeration describing the available options.. * * @return an enumeration of all the available options. */ @Override public Enumeration<Option> listOptions() { String string = "\tThe minimum number of objects in a bucket (default: 6)."; Vector<Option> newVector = new Vector<Option>(1); newVector .addElement(new Option(string, "B", 1, "-B <minimum bucket size>")); newVector.addAll(Collections.list(super.listOptions())); return newVector.elements(); }
double[] prob = classifier.distributionForInstance(data.get(i)); for(int k = 0 ; k < numClasses; k++) classificationResult[k][i] = prob[k]; classificationResult[0][i] = classifier.classifyInstance(data.get(i));
public double[] call(){ final int numInstances = data.numInstances(); final double[] classificationResult = new double[numInstances]; for (int i=0; i<numInstances; i++) { try{ if (0 == i % 4000) counter.addAndGet(4000); classificationResult[i] = classifier.classifyInstance(data.instance(i)); }catch(Exception e){ IJ.showMessage("Could not apply Classifier!"); e.printStackTrace(); return null; } } return classificationResult; } };