@Override public List<Classifier> buildClassifiers(User user, List<Sample> validSamples) { Instances trainingSet = new TrainingSetBuilder() .setAttributes(user.getBssids()) .setClassAttribute( "Location", user.getLocations().stream().map(Location::getName).collect(Collectors.toList())) .build("TrainingSet", validSamples.size()); // Create instances validSamples.forEach( sample -> { Map<String, Integer> BSSIDLevelMap = getBSSIDLevelMap(sample); Instance instance = new Instance(trainingSet.numAttributes()); for (Enumeration e = trainingSet.enumerateAttributes(); e.hasMoreElements(); ) { Attribute attribute = (Attribute) e.nextElement(); String bssid = attribute.name(); int level = (BSSIDLevelMap.containsKey(bssid)) ? BSSIDLevelMap.get(bssid) : 0; instance.setValue(attribute, level); } instance.setValue(trainingSet.classAttribute(), sample.getLocation()); instance.setDataset(trainingSet); trainingSet.add(instance); }); // Build classifiers List<Classifier> classifiers = buildClassifiers(trainingSet); return classifiers; }
@Override public String classify(User user, Sample sample) { Instances trainingSet = new TrainingSetBuilder() .setAttributes(user.getBssids()) .setClassAttribute( "Location", user.getLocations().stream().map(Location::getName).collect(Collectors.toList())) .build("TrainingSet", 1); // Create instance Map<String, Integer> BSSIDLevelMap = getBSSIDLevelMap(sample); Instance instance = new Instance(trainingSet.numAttributes()); for (Enumeration e = trainingSet.enumerateAttributes(); e.hasMoreElements(); ) { Attribute attribute = (Attribute) e.nextElement(); String bssid = attribute.name(); int level = (BSSIDLevelMap.containsKey(bssid)) ? BSSIDLevelMap.get(bssid) : 0; instance.setValue(attribute, level); } if (sample.getLocation() != null) instance.setValue(trainingSet.classAttribute(), sample.getLocation()); instance.setDataset(trainingSet); trainingSet.add(instance); int predictedClass = classify(fromBase64(user.getClassifiers()), instance); return trainingSet.classAttribute().value(predictedClass); }
private static void loadattributes( String s, Instance instclassificationpickup, Instance instclassificationdropoff, Instance instregressionpickup, Instance instregressiondropoff) { String[] attributes = s.split(","); for (int i = 0; i < 8; i++) { if (attributes[i].equals("?")) { instclassificationpickup.setMissing(i); instclassificationdropoff.setMissing(i); instregressionpickup.setMissing(i); instregressiondropoff.setMissing(i); } else { if ((i == 2) || (i == 3) || (i == 5)) { instclassificationpickup.setValue(i, attributes[i]); instclassificationdropoff.setValue(i, attributes[i]); instregressionpickup.setValue(i, attributes[i]); instregressiondropoff.setValue(i, attributes[i]); } else { instclassificationpickup.setValue(i, Double.parseDouble(attributes[i])); instclassificationdropoff.setValue(i, Double.parseDouble(attributes[i])); instregressionpickup.setValue(i, Double.parseDouble(attributes[i])); instregressiondropoff.setValue(i, Double.parseDouble(attributes[i])); } } } instclassificationpickup.setMissing(8); instclassificationdropoff.setMissing(8); instregressionpickup.setMissing(8); instregressiondropoff.setMissing(8); }
private void addInstance( final double min, final double max, final double mean, final double stdDev, final String label) { Instance dataInstance = new Instance(NUMBER_OF_ATTRIBUTES); dataInstance.setValue(minAttribute, min); dataInstance.setValue(maxAttribute, max); dataInstance.setValue(meanAttribute, mean); dataInstance.setValue(stdDevAttribute, stdDev); dataInstance.setValue(activityAttribute, label); instances.add(dataInstance); }
// 将一个文本数据转换成weka可以识别的Instance private Instance makeInstance(String text, Instances data) { Instance instance = new Instance(2); Attribute messageAtt = data.attribute("Message"); instance.setValue(messageAtt, messageAtt.addStringValue(text)); instance.setDataset(data); return instance; }
private Instance instanceFromStream(StreamElement data) { try { Instance i = new Instance(data.getFieldNames().length); for (int j = 0; j < data.getFieldNames().length; j++) { i.setValue(j, ((Double) data.getData()[j])); } // scaling specific to opensense data!! should be put in the parameters? i.setValue(0, i.value(0) / 1400.0); i.setValue(2, i.value(2) / 50); i.setValue(3, i.value(3) / 100.0); i.setValue(4, i.value(4) / 100.0 - 4); return i; } catch (Exception e) { return null; } }
/** * Input an instance for filtering. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws Exception if the input format was not set or the date format cannot be parsed */ public boolean input(Instance instance) throws Exception { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance newInstance = (Instance) instance.copy(); int index = m_AttIndex.getIndex(); if (!newInstance.isMissing(index)) { double value = instance.value(index); try { // Format and parse under the new format to force any required // loss in precision. value = m_OutputAttribute.parseDate(m_OutputAttribute.formatDate(value)); } catch (ParseException pe) { throw new RuntimeException("Output date format couldn't parse its own output!!"); } newInstance.setValue(index, value); } push(newInstance); return true; }
private void createLimbInstance( Skeleton skeleton, int limb, int[] limb_about, List<Attribute> limb_att) { int att = 1; Instance ist = new DenseInstance((SPATIAL_COORD * limb_about.length) + 1); limb_att = classifier.getLimbFeatureDataSet(limb); for (int i = 0; i < limb_about.length; i++) { if (limb_about[i] != TORSO) { /* * il punto di riferimento per tutti i joint (meno che per il * TORSO), ossia il centro degli assi che descrivono lo spazio * in cui si possono muovere è il TORSO stesso. */ Point3D<Float> joint = skeleton.getJoint(SKELETON_JOINT(limb_about[i])).getPosition(); ist.setValue((Attribute) limb_att.get(att), (joint.getX() - x_torso)); ist.setValue((Attribute) limb_att.get(att + 1), (joint.getY() - y_torso)); ist.setValue((Attribute) limb_att.get(att + 2), (joint.getZ() - z_torso)); att += 3; } else { /* * il punto di riferimento per il BODY invece è il punto con * coordinate (0, -Ytorso, 0), e cioè, il punto sul pavimento * esattamente perpendicolare al TORSO stesso */ Point3D<Float> left_foot = skeleton.getJoint(JointType.LEFT_FOOT).getPosition(); Point3D<Float> right_foot = skeleton.getJoint(JointType.RIGHT_FOOT).getPosition(); // save the two probably torso's new coordinates float torso_footSX = y_torso - left_foot.getY(); float torso_footDX = y_torso - right_foot.getY(); float y_torso_rifFoot = (torso_footSX > torso_footDX) ? torso_footSX : torso_footDX; ist.setValue((Attribute) limb_att.get(att), 0); ist.setValue((Attribute) limb_att.get(att + 1), y_torso_rifFoot); ist.setValue((Attribute) limb_att.get(att + 2), 0); att += 3; } } skeletonIstances.add(ist); }
protected void imputeMedian(Instances instances) { Attribute indicator = instances.attribute(ATTNAME_INDICATOR); for (int i = 0; i < instances.numInstances(); ++i) { Instance current = instances.get(i); current.setValue(indicator, 0.0); // 0.0 means "false" for (int j = 0; j < instances.numAttributes(); ++j) { if (instances.attribute(j).isNumeric() == false) { continue; } if (Utils.isMissingValue(current.value(j))) { current.setValue(j, medians[j]); current.setValue(indicator, 1.0); imputations[j] += 1; } } } }
/** * Input an instance for filtering. The instance is processed and made available for output * immediately. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input format has been set. */ public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance newInstance = (Instance) instance.copy(); if ((int) newInstance.value(m_AttIndex.getIndex()) == m_SecondIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), (double) m_FirstIndex.getIndex()); } else if ((int) newInstance.value(m_AttIndex.getIndex()) > m_SecondIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), newInstance.value(m_AttIndex.getIndex()) - 1); } push(newInstance); return true; }
// create an instance in the format of CreateAppInsertIntoVm.arff // eval can either be a Instance - MissingValue or the evaluation value private Instance createInstance(double eval, VirtualMachine vm) { Instance instance = new Instance(64); LinkedList<Integer> cpuallhist = vm.getCpuAllocationHistory(10); LinkedList<Integer> cpuusehist = vm.getCpuUsageHistory(10); LinkedList<Integer> memallhist = vm.getMemoryAllocationHistory(10); LinkedList<Integer> memusehist = vm.getMemoryUsageHistory(10); LinkedList<Integer> storageallhist = vm.getStorageAllocationHistory(10); LinkedList<Integer> storageusehist = vm.getStorageUsageHistory(10); // CPU/Memory/Storage - Allocation history before the new vm was created for (int i = 0; i < 10; i++) { // cpu allocation instance.setValue(getKnowledgeBase().attribute(i), clusterValue(cpuallhist.get(i))); // cpu usage instance.setValue(getKnowledgeBase().attribute(i + 10), clusterValue(cpuusehist.get(i))); // memory allocation instance.setValue(getKnowledgeBase().attribute(i + 20), clusterValue(memallhist.get(i))); // memory usage instance.setValue(getKnowledgeBase().attribute(i + 30), clusterValue(memusehist.get(i))); // storage allocation instance.setValue(getKnowledgeBase().attribute(i + 40), clusterValue(storageallhist.get(i))); // storage usage instance.setValue(getKnowledgeBase().attribute(i + 50), clusterValue(storageusehist.get(i))); } // SLAs // CPU instance.setValue(getKnowledgeBase().attribute(60), clusterValue(app.getCpu())); // Memory instance.setValue(getKnowledgeBase().attribute(61), clusterValue(app.getMemory())); // Storage instance.setValue(getKnowledgeBase().attribute(62), clusterValue(app.getStorage())); // Evaluation instance.setValue(getKnowledgeBase().attribute(63), eval); return instance; }
/** * method to set a new value * * @param r random function * @param numOfValues * @param instance * @param useMissing */ private void changeValueRandomly( Random r, int numOfValues, int indexOfAtt, Instance instance, boolean useMissing) { int currValue; // get current value // if value is missing set current value to number of values // whiche is the highest possible value plus one if (instance.isMissing(indexOfAtt)) { currValue = numOfValues; } else { currValue = (int) instance.value(indexOfAtt); } // with only two possible values it is easier if ((numOfValues == 2) && (!instance.isMissing(indexOfAtt))) { instance.setValue(indexOfAtt, (double) ((currValue + 1) % 2)); } else { // get randomly a new value not equal to the current value // if missing values are used as values they must be treated // in a special way while (true) { int newValue; if (useMissing) { newValue = (int) (r.nextDouble() * (double) (numOfValues + 1)); } else { newValue = (int) (r.nextDouble() * (double) numOfValues); } // have we found a new value? if (newValue != currValue) { // the value 1 above the highest possible value (=numOfValues) // is used as missing value if (newValue == numOfValues) { instance.setMissing(indexOfAtt); } else { instance.setValue(indexOfAtt, (double) newValue); } break; } } } }
/** * Input an instance for filtering. The instance is processed and made available for output * immediately. * * @param instance the input instance * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input structure has been defined. */ @Override public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } Instance newInstance = (Instance) instance.copy(); if (!newInstance.isMissing(m_AttIndex.getIndex())) { if ((int) newInstance.value(m_AttIndex.getIndex()) == m_SecondIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), m_FirstIndex.getIndex()); } else if ((int) newInstance.value(m_AttIndex.getIndex()) == m_FirstIndex.getIndex()) { newInstance.setValue(m_AttIndex.getIndex(), m_SecondIndex.getIndex()); } } push(newInstance, false); // No need to copy return true; }
/** * classifies a tweet * * @param stringa the tweet to classify * @return the tweet polarity */ public double classifyDouble(String stringa) throws FileNotFoundException, IOException, Exception { String string_new; Preprocesser pre = new Preprocesser(); string_new = pre.preprocessDocument(stringa); String tmp = ""; StringTokenizer st = new StringTokenizer(string_new, " "); // Instances unlabeled = new Instances(new BufferedReader(new // FileReader("D:/prova.arff"))); Instances unlabeled = new Instances(_train, 1); Instance inst = new Instance(unlabeled.numAttributes()); // load unlabeled data inst.setDataset(unlabeled); int j = 0; while (j < unlabeled.numAttributes()) { inst.setValue(j, "0"); j++; } while (st.hasMoreTokens()) { tmp = st.nextToken(); if (unlabeled.attribute(tmp) != null) inst.setValue(unlabeled.attribute(tmp), "1"); } unlabeled.add(inst); // set class attribute unlabeled.setClassIndex(unlabeled.numAttributes() - 1); // create copy Instances labeled = new Instances(unlabeled); // label instances for (int i = 0; i < unlabeled.numInstances(); i++) { double clsLabel = _cl.classifyInstance(unlabeled.instance(i)); labeled.instance(i).setClassValue(clsLabel); } // return labeled.instance(0).stringValue(unlabeled.numAttributes()-1); // System.out.println("weight: " + labeled.instance(0).weight()); return labeled.instance(0).classValue(); }
@Override public Instance nextInstance() { InstancesHeader header = getHeader(); Instance inst = new DenseInstance(header.numAttributes()); inst.setDataset(header); int waveform = this.instanceRandom.nextInt(NUM_CLASSES); int choiceA = 0, choiceB = 0; switch (waveform) { case 0: choiceA = 0; choiceB = 1; break; case 1: choiceA = 0; choiceB = 2; break; case 2: choiceA = 1; choiceB = 2; break; } double multiplierA = this.instanceRandom.nextDouble(); double multiplierB = 1.0 - multiplierA; for (int i = 0; i < NUM_BASE_ATTRIBUTES; i++) { inst.setValue( this.numberAttribute[i], (multiplierA * hFunctions[choiceA][i]) + (multiplierB * hFunctions[choiceB][i]) + this.instanceRandom.nextGaussian()); } if (this.addNoiseOption.isSet()) { for (int i = NUM_BASE_ATTRIBUTES; i < TOTAL_ATTRIBUTES_INCLUDING_NOISE; i++) { inst.setValue(this.numberAttribute[i], this.instanceRandom.nextGaussian()); } } inst.setClassValue(waveform); return inst; }
private static Instance createInstance(double[] ds, String string, Instances instances) { int l = ds.length; // Create the instance Instance instance = new Instance(1 + l); instance.setDataset(instances); for (int i = 1; i <= l; i++) { instance.setValue(i, ds[i - 1]); } if (string == null) { instance.setClassMissing(); } else { instance.setClassValue(string); } return instance; }
/** * Call this function to predict the class of an instance once a classification model has been * built with the buildClassifier call. * * @param i The instance to classify. * @return A double array filled with the probabilities of each class type. * @throws Exception if can't classify instance. */ public double[] distributionForInstance(Instance i) throws Exception { // Make a copy of the instance so that it isn't modified m_currentInstance = (Instance) i.copy(); if (m_normalizeAttributes) { for (int noa = 0; noa < m_currentInstance.dataset().numAttributes(); noa++) { if (noa != m_currentInstance.classIndex()) { if (m_attributeRanges[noa] != 0) { m_currentInstance.setValue( noa, (m_currentInstance.value(noa) - m_attributeBases[noa]) / m_attributeRanges[noa]); } else { m_currentInstance.setValue(noa, m_currentInstance.value(noa) - m_attributeBases[noa]); } } } } resetNetwork(); // since all the output values are needed. // They are calculated manually here and the values collected. double[] theArray = new double[m_numClasses]; double count = 0; for (int noa = 0; noa < m_numClasses; noa++) { theArray[noa] = m_outputs[noa].outputValue(true); count += theArray[noa]; } if (count <= 0) { return m_ZeroR.m_Counts; } return theArray; }
/** * Transform - turn [y1,y2,y3,x1,x2] into [y1,y2,x1,x2]. * * @return transformed Instance */ public Instance transform(Instance x, double ypred[]) throws Exception { x = (Instance) x.copy(); int L = x.classIndex(); int L_c = (paY.length + 1); x.setDataset(null); for (int j = 0; j < (L - L_c); j++) { x.deleteAttributeAt(0); } for (int pa : paY) { // System.out.println("x_["+map[pa]+"] <- "+ypred[pa]); x.setValue(map[pa], ypred[pa]); } x.setDataset(T); x.setClassMissing(); return x; }
@Override public boolean evaluate() { if (curInstance == null) { curInstance = createInstance(0, selectedVm); // create a Instance with the past values } if (app.getSuspendedTicks() > 0 || app.getVm().getSuspendedTicks() > 0 || app.getVm().getPm().getSuspendedTicks() > 0) { return false; } else if (waitForEvaluation > 0) { waitForEvaluation--; return false; } else { // System.out.println("APP - Running Ticks: " + app.getRunningTicks()); LinkedList<Integer> cpuusagehist = selectedVm.getPm().getCpuUsageHistory(10); LinkedList<Integer> memusagehist = selectedVm.getPm().getMemoryUsageHistory(10); LinkedList<Integer> storageusagehist = selectedVm.getPm().getStorageUsageHistory(10); double evaluation = (255 - calculateUsageRatio(cpuusagehist, 85) - calculateUsageRatio(memusagehist, 85) - calculateUsageRatio(storageusagehist, 85)) / 255; // subtract SLA Violations evaluation -= (app.getCpuSlaErrorcount() + app.getMemorySlaErrorcount() + app.getStorageSlaErrorcount()) / 10; // minimum of 0 // evaluation = Math.max(0, evaluation); Monitor.getInstance().logExecution(app, this, evaluation, this.globalTickExecution); curInstance.setValue(getKnowledgeBase().attribute(63), evaluation); this.setLocalEvaluation(evaluation); getKnowledgeBase().add(curInstance); } return true; }
@Override public void setAttributeValue(Attribute attribute, Instance instance, Patient patient) { RegaService rs = ruleService.getRegaService(); DataService ds = ruleService.getDataService(); List<TestResult> postTreatmentCD4Counts = rs.getPostTreatmentCD4Counts(patient); Double leastSquaresRegressionGradient = ds.getLeastSquaresFitGradient(postTreatmentCD4Counts); logger.info( "PTCD4 #: " + postTreatmentCD4Counts.size() + ", Gradient: " + leastSquaresRegressionGradient); if (leastSquaresRegressionGradient != null) instance.setValue(attribute, leastSquaresRegressionGradient); }
private Instance getFVSFilteredInstance( Instances output, Instance old_inst, List<List<Value>> list, Double[] substitution) { double[] oldValues = old_inst.toDoubleArray(); Instance instance = new Instance(old_inst); // Change with value that is available for (int i = 0; i < oldValues.length - 1; i++) { // System.out.println(oldValues[i]); // System.out.println(list.get(i)); // System.out.println("############################"); // If list doesn't contain, then delete Value v = new Value(oldValues[i]); int idx = list.get(i).indexOf(v); // If not found in the index if (idx == -1) { // Change with substitution instance.setValue(i, substitution[i]); // Change into missing // instance.setMissing(i); } } return instance; }
private static Instance makeInstance(Instances instances, String inputLine) { inputLine = inputLine.trim(); // We need to store the lastName as well... String[] parts = inputLine.split("\\s+"); String label = parts[0]; String firstName = parts[1].toLowerCase(); String lastName = parts[2].toLowerCase(); Instance instance = new Instance(features.length + 1); instance.setDataset(instances); Set<String> feats = new HashSet<String>(); /* feats.add("firstName0=" + firstName.charAt(0)); feats.add("firstNameN=" + firstName.charAt(firstName.length() - 1)); */ for (int f = 0; f < 9; f++) { if (firstName.length() > f) feats.add("firstName" + f + "=" + firstName.charAt(f)); } for (int l = 0; l < 9; l++) { if (lastName.length() > l) feats.add("lastName" + l + "=" + lastName.charAt(l)); } ///////////////////////////////////////////////////////////////// for (int featureId = 0; featureId < features.length; featureId++) { Attribute att = instances.attribute(features[featureId]); String name = att.name(); String featureLabel; if (feats.contains(name)) { featureLabel = "1"; } else featureLabel = "0"; instance.setValue(att, featureLabel); } instance.setClassValue(label); return instance; }
/** * Create an Instance of the same type as the Instances object you are searching in. * * @param p - a 3D point * @param dataset - the dataset you are searching in, which was used to build the KDTree * @return an Instance that the nearest neighbor can be found for */ public Instance createInstance(Integer points[], final Instances dataset) { // Create numeric attributes "x" and "y" and "z" Attribute attr[] = new Attribute[10]; for (int i = 0; i < points.length; i++) { attr[i] = new Attribute("p" + i); attr[i] = dataset.attribute(i); } // Create vector of the above attributes FastVector attributes = new FastVector(points.length); for (int i = 0; i < points.length; i++) attributes.addElement(attr[i]); // Create empty instance with X attribute values Instance inst = new Instance(points.length); // Set instance's values for the attributes "x", "y", and "z" for (int i = 0; i < points.length; i++) inst.setValue(attr[i], points[i]); // Set instance's dataset to be the dataset "points1" inst.setDataset(dataset); return inst; }
public void buildClusterer(ArrayList<String> seqDB, double[][] sm) { seqList = seqDB; this.setSimMatrix(sm); Attribute seqString = new Attribute("sequence", (FastVector) null); FastVector attrInfo = new FastVector(); attrInfo.addElement(seqString); Instances data = new Instances("data", attrInfo, 0); for (int i = 0; i < seqList.size(); i++) { Instance currentInst = new Instance(1); currentInst.setDataset(data); currentInst.setValue(0, seqList.get(i)); data.add(currentInst); } try { buildClusterer(data); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } }
@Override public void setAttributeValue(Attribute attribute, Instance instance, Patient patient) { RegaService rs = ruleService.getRegaService(); PatientAttributeValue pav = rs.getPatientAttributeValue( patient, ClinicalAttributeFactory.CLINICAL_REGA_ATTRIBUTE_RECENT_BLOOD_HB); if (pav == null) return; // The is no recent blood hb for this patient String strVal = pav.getValue(); Double dVal; if (strVal.equals("N/A")) { return; // There is no value } else if (strVal.contains("/")) { dVal = Double.parseDouble(strVal.replace('/', '.')); } else { dVal = Double.parseDouble(strVal); } logger.info("Recent Blood HB for " + patient.getPatientId() + " is " + dVal); instance.setValue(attribute, dVal); }
/** * Input an instance for filtering. The instance is processed and made available for output * immediately. * * @param instance the input instance. * @return true if the filtered instance may now be collected with output(). * @throws IllegalStateException if no input structure has been defined. */ public boolean input(Instance instance) { if (getInputFormat() == null) { throw new IllegalStateException("No input instance format defined"); } if (m_NewBatch) { resetQueue(); m_NewBatch = false; } if (isOutputFormatDefined()) { Instance newInstance = (Instance) instance.copy(); // make sure that we get the right indexes set for the converted // string attributes when operating on a second batch of instances for (int i = 0; i < newInstance.numAttributes(); i++) { if (newInstance.attribute(i).isString() && !newInstance.isMissing(i) && m_AttIndices.isInRange(i)) { Attribute outAtt = getOutputFormat().attribute(newInstance.attribute(i).name()); String inVal = newInstance.stringValue(i); int outIndex = outAtt.indexOfValue(inVal); if (outIndex < 0) { newInstance.setMissing(i); } else { newInstance.setValue(i, outIndex); } } } push(newInstance); return true; } bufferInput(instance); return false; }
/** * Processes the given data (may change the provided dataset) and returns the modified version. * This method is called in batchFinished(). This implementation only calls process(Instance) for * each instance in the given dataset. * * @param instances the data to process * @return the modified data * @throws Exception in case the processing goes wrong * @see #batchFinished() */ protected Instances process(Instances instances) throws Exception { Instances result; Instance instOld; Instance instNew; int i; int n; double[] values; int numAttNew; int numAttOld; if (!isFirstBatchDone()) computeThresholds(instances); result = getOutputFormat(); numAttOld = instances.numAttributes(); numAttNew = result.numAttributes(); for (n = 0; n < instances.numInstances(); n++) { instOld = instances.instance(n); values = new double[numAttNew]; System.arraycopy(instOld.toDoubleArray(), 0, values, 0, numAttOld); // generate new instance instNew = new Instance(1.0, values); instNew.setDataset(result); // per attribute? if (!getDetectionPerAttribute()) { // outlier? if (isOutlier(instOld)) instNew.setValue(m_OutlierAttributePosition[0], 1); // extreme value? if (isExtremeValue(instOld)) { instNew.setValue(m_OutlierAttributePosition[0] + 1, 1); // tag extreme values also as outliers? if (getExtremeValuesAsOutliers()) instNew.setValue(m_OutlierAttributePosition[0], 1); } } else { for (i = 0; i < m_AttributeIndices.length; i++) { // non-numeric attribute? if (m_AttributeIndices[i] == NON_NUMERIC) continue; // outlier? if (isOutlier(instOld, m_AttributeIndices[i])) instNew.setValue(m_OutlierAttributePosition[i], 1); // extreme value? if (isExtremeValue(instOld, m_AttributeIndices[i])) { instNew.setValue(m_OutlierAttributePosition[i] + 1, 1); // tag extreme values also as outliers? if (getExtremeValuesAsOutliers()) instNew.setValue(m_OutlierAttributePosition[i], 1); } // add multiplier? if (getOutputOffsetMultiplier()) instNew.setValue( m_OutlierAttributePosition[i] + 2, calculateMultiplier(instOld, m_AttributeIndices[i])); } } // copy possible strings, relational values... copyValues(instNew, false, instOld.dataset(), getOutputFormat()); // add to output result.add(instNew); } return result; }
public static void main(String[] args) throws Exception { // NaiveBayesSimple nb = new NaiveBayesSimple(); // BufferedReader br_train = new BufferedReader(new FileReader("src/train.arff.txt")); // String s = null; // long st_time = System.currentTimeMillis(); // Instances inst_train = new Instances(br_train); // System.out.println(inst_train.numAttributes()); // inst_train.setClassIndex(inst_train.numAttributes()-1); // System.out.println("train time"+(System.currentTimeMillis()-st_time)); // NaiveBayes nb1 = new NaiveBayes(); // nb1.buildClassifier(inst_train); // br_train.close(); long st_time = System.currentTimeMillis(); st_time = System.currentTimeMillis(); Classifier classifier = (Classifier) SerializationHelper.read("NaiveBayes.model"); // BufferedReader br_test = new BufferedReader(new FileReader("src/test.arff.txt")); // Instances inst_test = new Instances(br_test); // inst_test.setClassIndex(inst_test.numAttributes()-1); // System.out.println("test time"+(System.currentTimeMillis()-st_time)); // ArffLoader testLoader = new ArffLoader(); testLoader.setSource(new File("src/test.arff")); testLoader.setRetrieval(Loader.BATCH); Instances testDataSet = testLoader.getDataSet(); Attribute testAttribute = testDataSet.attribute("class"); testDataSet.setClass(testAttribute); int correct = 0; int incorrect = 0; FastVector attInfo = new FastVector(); attInfo.addElement(new Attribute("Id")); attInfo.addElement(new Attribute("Category")); Instances outputInstances = new Instances("predict", attInfo, testDataSet.numInstances()); Enumeration testInstances = testDataSet.enumerateInstances(); int index = 1; while (testInstances.hasMoreElements()) { Instance instance = (Instance) testInstances.nextElement(); double classification = classifier.classifyInstance(instance); Instance predictInstance = new Instance(outputInstances.numAttributes()); predictInstance.setValue(0, index++); predictInstance.setValue(1, (int) classification + 1); outputInstances.add(predictInstance); } System.out.println("Correct Instance: " + correct); System.out.println("IncCorrect Instance: " + incorrect); double accuracy = (double) (correct) / (double) (correct + incorrect); System.out.println("Accuracy: " + accuracy); CSVSaver predictedCsvSaver = new CSVSaver(); predictedCsvSaver.setFile(new File("predict.csv")); predictedCsvSaver.setInstances(outputInstances); predictedCsvSaver.writeBatch(); System.out.println("Prediciton saved to predict.csv"); }
public static void classify(Instances train, File file) throws Exception { FastVector atts = new FastVector(); String[] classes = {"classical", "hiphop", "pop", "rock"}; double[] val; FastVector attValsRel = new FastVector(); // Setting attributes for the test data Attribute attributeZero = new Attribute("Zero_Crossings"); atts.addElement(attributeZero); Attribute attributeLPC = new Attribute("LPC"); atts.addElement(attributeLPC); Attribute attributeCentroid = new Attribute("Spectral_Centroid"); atts.addElement(attributeCentroid); Attribute attributeRollOff = new Attribute("Spectral_Rolloff_Point"); atts.addElement(attributeRollOff); Attribute attributePeakDetection = new Attribute("Peak_Detection"); atts.addElement(attributePeakDetection); Attribute attributeStrongestBeat = new Attribute("Strongest_Beat"); atts.addElement(attributeStrongestBeat); Attribute attributeBeatSum = new Attribute("Beat_Sum"); atts.addElement(attributeBeatSum); Attribute attributeRMS = new Attribute("RMS"); atts.addElement(attributeRMS); Attribute attributeConstantQ = new Attribute("ConstantQ"); atts.addElement(attributeConstantQ); Attribute attributeMFT = new Attribute("MagnitudeFFT"); atts.addElement(attributeMFT); Attribute attributeMFCC = new Attribute("MFCC"); atts.addElement(attributeMFCC); for (int i = 0; i < classes.length; i++) attValsRel.addElement(classes[i]); atts.addElement(new Attribute("class", attValsRel)); // Adding instances to the test dataset Instances test = new Instances("AudioSamples", atts, 0); val = makeData(file, null, attValsRel, test.numAttributes()); Instance instance = new Instance(test.numAttributes()); instance.setValue(attributeZero, val[0]); instance.setValue(attributeLPC, val[1]); instance.setValue(attributeCentroid, val[2]); instance.setValue(attributeRollOff, val[3]); instance.setValue(attributePeakDetection, val[4]); instance.setValue(attributeStrongestBeat, val[5]); instance.setValue(attributeBeatSum, val[6]); instance.setValue(attributeRMS, val[7]); instance.setValue(attributeConstantQ, val[8]); instance.setValue(attributeMFT, val[9]); instance.setValue(attributeMFCC, val[10]); test.add(instance); // Setting the class attribute test.setClassIndex(test.numAttributes() - 1); System.out.println(test); // Trainging the classifier with train dataset classifier = new FilteredClassifier(); classifier.buildClassifier(train); // Classifying the test data with the train data for (int i = 0; i < test.numInstances(); i++) { double pred = classifier.classifyInstance(test.instance(i)); System.out.println("===== Classified instance ====="); System.out.println("Class predicted: " + test.classAttribute().value((int) pred)); } }
public void updateTransform(Instance t_, double ypred[]) throws Exception { for (int pa : this.paY) { t_.setValue(this.map[pa], ypred[pa]); } }