List of usage examples for weka.core Instances deleteWithMissingClass
public void deleteWithMissingClass()
From source file:REPTree.java
License:Open Source License
/** * Builds classifier./* w w w .j a v a 2s. com*/ * * @param data the data to train with * @throws Exception if building fails */ public void buildClassifier(Instances data) throws Exception { // can classifier handle the data? getCapabilities().testWithFail(data); // remove instances with missing class data = new Instances(data); data.deleteWithMissingClass(); Random random = new Random(m_Seed); m_zeroR = null; if (data.numAttributes() == 1) { m_zeroR = new ZeroR(); m_zeroR.buildClassifier(data); return; } // Randomize and stratify data.randomize(random); if (data.classAttribute().isNominal()) { data.stratify(m_NumFolds); } // Split data into training and pruning set Instances train = null; Instances prune = null; if (!m_NoPruning) { train = data.trainCV(m_NumFolds, 0, random); prune = data.testCV(m_NumFolds, 0); } else { train = data; } // Create array of sorted indices and weights int[][][] sortedIndices = new int[1][train.numAttributes()][0]; double[][][] weights = new double[1][train.numAttributes()][0]; double[] vals = new double[train.numInstances()]; for (int j = 0; j < train.numAttributes(); j++) { if (j != train.classIndex()) { weights[0][j] = new double[train.numInstances()]; if (train.attribute(j).isNominal()) { // Handling nominal attributes. Putting indices of // instances with missing values at the end. sortedIndices[0][j] = new int[train.numInstances()]; int count = 0; for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); if (!inst.isMissing(j)) { sortedIndices[0][j][count] = i; weights[0][j][count] = inst.weight(); count++; } } for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); if (inst.isMissing(j)) { sortedIndices[0][j][count] = i; weights[0][j][count] = inst.weight(); count++; } } } else { // Sorted indices are computed for numeric attributes for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); vals[i] = inst.value(j); } sortedIndices[0][j] = Utils.sort(vals); for (int i = 0; i < train.numInstances(); i++) { weights[0][j][i] = train.instance(sortedIndices[0][j][i]).weight(); } } } } // Compute initial class counts double[] classProbs = new double[train.numClasses()]; double totalWeight = 0, totalSumSquared = 0; for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); if (data.classAttribute().isNominal()) { classProbs[(int) inst.classValue()] += inst.weight(); totalWeight += inst.weight(); } else { classProbs[0] += inst.classValue() * inst.weight(); totalSumSquared += inst.classValue() * inst.classValue() * inst.weight(); totalWeight += inst.weight(); } } m_Tree = new Tree(); double trainVariance = 0; if (data.classAttribute().isNumeric()) { trainVariance = m_Tree.singleVariance(classProbs[0], totalSumSquared, totalWeight) / totalWeight; classProbs[0] /= totalWeight; } // Build tree m_Tree.buildTree(sortedIndices, weights, train, totalWeight, classProbs, new Instances(train, 0), m_MinNum, m_MinVarianceProp * trainVariance, 0, m_MaxDepth); // Insert pruning data and perform reduced error pruning if (!m_NoPruning) { m_Tree.insertHoldOutSet(prune); m_Tree.reducedErrorPrune(); m_Tree.backfitHoldOutSet(); } }
From source file:Pair.java
License:Open Source License
/** * Boosting method./* ww w. ja v a 2s . c o m*/ * * @param data the training data to be used for generating the * boosted classifier. * @exception Exception if the classifier could not be built successfully */ public void buildClassifier(Instances data) throws Exception { super.buildClassifier(data); if (data.checkForStringAttributes()) { throw new UnsupportedAttributeTypeException("Cannot handle string attributes!"); } data = new Instances(data); data.deleteWithMissingClass(); if (data.numInstances() == 0) { throw new Exception("No train instances without class missing!"); } if (!data.classAttribute().isNumeric()) { throw new UnsupportedClassTypeException("TrAdaBoostR2 can only handle a numeric class!"); } if (m_SourceInstances == null) { throw new Exception("Source data has not been specified!"); } m_NumClasses = data.numClasses(); try { doCV(data); } catch (Exception e) { e.printStackTrace(); } }
From source file:REPRandomTree.java
License:Open Source License
/** * Builds classifier./* www .j av a 2 s .c o m*/ * * @param data the data to train with * @throws Exception if building fails */ public void buildClassifier(Instances data) throws Exception { // can classifier handle the data? getCapabilities().testWithFail(data); // remove instances with missing class data = new Instances(data); data.deleteWithMissingClass(); Random random = new Random(m_Seed); m_zeroR = null; if (data.numAttributes() == 1) { m_zeroR = new ZeroR(); m_zeroR.buildClassifier(data); return; } // Randomize and stratify data.randomize(random); if (data.classAttribute().isNominal()) { data.stratify(m_NumFolds); } // Split data into training and pruning set Instances train = null; Instances prune = null; if (!m_NoPruning) { train = data.trainCV(m_NumFolds, 0, random); prune = data.testCV(m_NumFolds, 0); } else { train = data; } // Create array of sorted indices and weights int[][][] sortedIndices = new int[1][train.numAttributes()][0]; double[][][] weights = new double[1][train.numAttributes()][0]; double[] vals = new double[train.numInstances()]; for (int j = 0; j < train.numAttributes(); j++) { if (j != train.classIndex()) { weights[0][j] = new double[train.numInstances()]; if (train.attribute(j).isNominal()) { // Handling nominal attributes. Putting indices of // instances with missing values at the end. sortedIndices[0][j] = new int[train.numInstances()]; int count = 0; for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); if (!inst.isMissing(j)) { sortedIndices[0][j][count] = i; weights[0][j][count] = inst.weight(); count++; } } for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); if (inst.isMissing(j)) { sortedIndices[0][j][count] = i; weights[0][j][count] = inst.weight(); count++; } } } else { // Sorted indices are computed for numeric attributes for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); vals[i] = inst.value(j); } sortedIndices[0][j] = Utils.sort(vals); for (int i = 0; i < train.numInstances(); i++) { weights[0][j][i] = train.instance(sortedIndices[0][j][i]).weight(); } } } } // Compute initial class counts double[] classProbs = new double[train.numClasses()]; double totalWeight = 0, totalSumSquared = 0; for (int i = 0; i < train.numInstances(); i++) { Instance inst = train.instance(i); if (data.classAttribute().isNominal()) { classProbs[(int) inst.classValue()] += inst.weight(); totalWeight += inst.weight(); } else { classProbs[0] += inst.classValue() * inst.weight(); totalSumSquared += inst.classValue() * inst.classValue() * inst.weight(); totalWeight += inst.weight(); } } m_Tree = new Tree(); double trainVariance = 0; if (data.classAttribute().isNumeric()) { trainVariance = m_Tree.singleVariance(classProbs[0], totalSumSquared, totalWeight) / totalWeight; classProbs[0] /= totalWeight; } // Build tree m_Tree.buildTree(sortedIndices, weights, train, totalWeight, classProbs, new Instances(train, 0), m_MinNum, m_MinVarianceProp * trainVariance, 0, m_MaxDepth, m_FeatureFrac, random); // Insert pruning data and perform reduced error pruning if (!m_NoPruning) { m_Tree.insertHoldOutSet(prune); m_Tree.reducedErrorPrune(); m_Tree.backfitHoldOutSet(); } }
From source file:CJWeka.java
License:Open Source License
public void buildClassifier(Instances i) throws Exception { // can classifier handle the data? getCapabilities().testWithFail(i);/* w w w. ja va 2 s. c om*/ // remove instances with missing class i = new Instances(i); i.deleteWithMissingClass(); // only class? -> build ZeroR model if (i.numAttributes() == 1) { System.err.println( "Cannot build model (only class attribute present in data!), " + "using ZeroR model instead!"); m_ZeroR = new weka.classifiers.rules.ZeroR(); m_ZeroR.buildClassifier(i); return; } else { m_ZeroR = null; } m_instances = null; m_currentInstance = null; m_outputs = new NeuralEnd[0]; m_inputs = new NeuralEnd[0]; m_numAttributes = 0; m_numClasses = 0; m_neuralNodes = new NeuralConnection[0]; m_nextId = 0; m_instances = new Instances(i); m_random = new Random(m_randomSeed); if (m_useNomToBin) { m_nominalToBinaryFilter = new NominalToBinary(); m_nominalToBinaryFilter.setInputFormat(m_instances); m_instances = Filter.useFilter(m_instances, m_nominalToBinaryFilter); } m_numAttributes = m_instances.numAttributes() - 1; m_numClasses = m_instances.numClasses(); setClassType(m_instances); setupInputs(); setupOutputs(); setupHiddenLayer(); //For silly situations in which the network gets accepted before training //commenses if (m_numeric) { setEndsToLinear(); } //connections done. double right = 0; double tempRate; double totalWeight = 0; m_hiddenValues = new double[m_hiddenLayers]; resetNetwork(); saveValues(); for (int noa = 1; noa < m_numEpochs + 1; noa++) { // System.out.println(noa); resetNetwork(); totalWeight = 0; right = 0; for (int nob = 0; nob < m_instances.numInstances(); nob++) { m_currentInstance = m_instances.instance(nob); if (!m_currentInstance.classIsMissing()) { totalWeight += m_currentInstance.weight(); //this is where the network updating (and training occurs, for the //training set resetNetwork(); calculateOutputs(); tempRate = m_learningRate * m_currentInstance.weight(); if (m_decay) { tempRate /= noa; } right += (calculateErrors() / m_instances.numClasses()) * m_currentInstance.weight(); updateNetworkWeights(tempRate, m_momentum); saveValues(); } } right /= totalWeight; if (Double.isInfinite(right) || Double.isNaN(right)) { m_instances = null; throw new Exception("Network cannot train. Try restarting with a" + " smaller learning rate."); } // System.out.println(noa+ ": " +right); } resetNetwork(); if (m_resetAfterTraining) { // in that point it saves Double.NaN saveValues(); } }
From source file:MultiClassClassifier.java
License:Open Source License
/** * Builds the classifiers./*from w w w . j ava 2s. c om*/ * * @param insts the training data. * @throws Exception if a classifier can't be built */ public void buildClassifier(Instances insts) throws Exception { Instances newInsts; // can classifier handle the data? getCapabilities().testWithFail(insts); // remove instances with missing class insts = new Instances(insts); insts.deleteWithMissingClass(); if (m_Classifier == null) { throw new Exception("No base classifier has been set!"); } m_ZeroR = new ZeroR(); m_ZeroR.buildClassifier(insts); m_TwoClassDataset = null; int numClassifiers = insts.numClasses(); if (numClassifiers <= 2) { m_Classifiers = Classifier.makeCopies(m_Classifier, 1); m_Classifiers[0].buildClassifier(insts); m_ClassFilters = null; } else if (m_Method == METHOD_1_AGAINST_1) { // generate fastvector of pairs FastVector pairs = new FastVector(); for (int i = 0; i < insts.numClasses(); i++) { for (int j = 0; j < insts.numClasses(); j++) { if (j <= i) continue; int[] pair = new int[2]; pair[0] = i; pair[1] = j; pairs.addElement(pair); } } numClassifiers = pairs.size(); m_Classifiers = Classifier.makeCopies(m_Classifier, numClassifiers); m_ClassFilters = new Filter[numClassifiers]; m_SumOfWeights = new double[numClassifiers]; // generate the classifiers for (int i = 0; i < numClassifiers; i++) { RemoveWithValues classFilter = new RemoveWithValues(); classFilter.setAttributeIndex("" + (insts.classIndex() + 1)); classFilter.setModifyHeader(true); classFilter.setInvertSelection(true); classFilter.setNominalIndicesArr((int[]) pairs.elementAt(i)); Instances tempInstances = new Instances(insts, 0); tempInstances.setClassIndex(-1); classFilter.setInputFormat(tempInstances); newInsts = Filter.useFilter(insts, classFilter); if (newInsts.numInstances() > 0) { newInsts.setClassIndex(insts.classIndex()); m_Classifiers[i].buildClassifier(newInsts); m_ClassFilters[i] = classFilter; m_SumOfWeights[i] = newInsts.sumOfWeights(); } else { m_Classifiers[i] = null; m_ClassFilters[i] = null; } } // construct a two-class header version of the dataset m_TwoClassDataset = new Instances(insts, 0); int classIndex = m_TwoClassDataset.classIndex(); m_TwoClassDataset.setClassIndex(-1); m_TwoClassDataset.deleteAttributeAt(classIndex); FastVector classLabels = new FastVector(); classLabels.addElement("class0"); classLabels.addElement("class1"); m_TwoClassDataset.insertAttributeAt(new Attribute("class", classLabels), classIndex); m_TwoClassDataset.setClassIndex(classIndex); } else { // use error correcting code style methods Code code = null; switch (m_Method) { case METHOD_ERROR_EXHAUSTIVE: code = new ExhaustiveCode(numClassifiers); break; case METHOD_ERROR_RANDOM: code = new RandomCode(numClassifiers, (int) (numClassifiers * m_RandomWidthFactor), insts); break; case METHOD_1_AGAINST_ALL: code = new StandardCode(numClassifiers); break; default: throw new Exception("Unrecognized correction code type"); } numClassifiers = code.size(); m_Classifiers = Classifier.makeCopies(m_Classifier, numClassifiers); m_ClassFilters = new MakeIndicator[numClassifiers]; for (int i = 0; i < m_Classifiers.length; i++) { m_ClassFilters[i] = new MakeIndicator(); MakeIndicator classFilter = (MakeIndicator) m_ClassFilters[i]; classFilter.setAttributeIndex("" + (insts.classIndex() + 1)); classFilter.setValueIndices(code.getIndices(i)); classFilter.setNumeric(false); classFilter.setInputFormat(insts); newInsts = Filter.useFilter(insts, m_ClassFilters[i]); m_Classifiers[i].buildClassifier(newInsts); } } m_ClassAttribute = insts.classAttribute(); }
From source file:SMO.java
License:Open Source License
/** * Method for building the classifier. Implements a one-against-one * wrapper for multi-class problems./* www . j av a 2s . co m*/ * * @param insts the set of training instances * @throws Exception if the classifier can't be built successfully */ public void buildClassifier(Instances insts) throws Exception { if (!m_checksTurnedOff) { // can classifier handle the data? getCapabilities().testWithFail(insts); // remove instances with missing class insts = new Instances(insts); insts.deleteWithMissingClass(); /* Removes all the instances with weight equal to 0. MUST be done since condition (8) of Keerthi's paper is made with the assertion Ci > 0 (See equation (3a). */ Instances data = new Instances(insts, insts.numInstances()); for (int i = 0; i < insts.numInstances(); i++) { if (insts.instance(i).weight() > 0) data.add(insts.instance(i)); } if (data.numInstances() == 0) { throw new Exception("No training instances left after removing " + "instances with weight 0!"); } insts = data; } if (!m_checksTurnedOff) { m_Missing = new ReplaceMissingValues(); m_Missing.setInputFormat(insts); insts = Filter.useFilter(insts, m_Missing); } else { m_Missing = null; } if (getCapabilities().handles(Capability.NUMERIC_ATTRIBUTES)) { boolean onlyNumeric = true; if (!m_checksTurnedOff) { for (int i = 0; i < insts.numAttributes(); i++) { if (i != insts.classIndex()) { if (!insts.attribute(i).isNumeric()) { onlyNumeric = false; break; } } } } if (!onlyNumeric) { m_NominalToBinary = new NominalToBinary(); m_NominalToBinary.setInputFormat(insts); insts = Filter.useFilter(insts, m_NominalToBinary); } else { m_NominalToBinary = null; } } else { m_NominalToBinary = null; } if (m_filterType == FILTER_STANDARDIZE) { m_Filter = new Standardize(); m_Filter.setInputFormat(insts); insts = Filter.useFilter(insts, m_Filter); } else if (m_filterType == FILTER_NORMALIZE) { m_Filter = new Normalize(); m_Filter.setInputFormat(insts); insts = Filter.useFilter(insts, m_Filter); } else { m_Filter = null; } m_classIndex = insts.classIndex(); m_classAttribute = insts.classAttribute(); m_KernelIsLinear = (m_kernel instanceof PolyKernel) && (((PolyKernel) m_kernel).getExponent() == 1.0); // Generate subsets representing each class Instances[] subsets = new Instances[insts.numClasses()]; for (int i = 0; i < insts.numClasses(); i++) { subsets[i] = new Instances(insts, insts.numInstances()); } for (int j = 0; j < insts.numInstances(); j++) { Instance inst = insts.instance(j); subsets[(int) inst.classValue()].add(inst); } for (int i = 0; i < insts.numClasses(); i++) { subsets[i].compactify(); } // Build the binary classifiers Random rand = new Random(m_randomSeed); m_classifiers = new BinarySMO[insts.numClasses()][insts.numClasses()]; for (int i = 0; i < insts.numClasses(); i++) { for (int j = i + 1; j < insts.numClasses(); j++) { m_classifiers[i][j] = new BinarySMO(); m_classifiers[i][j].setKernel(Kernel.makeCopy(getKernel())); Instances data = new Instances(insts, insts.numInstances()); for (int k = 0; k < subsets[i].numInstances(); k++) { data.add(subsets[i].instance(k)); } for (int k = 0; k < subsets[j].numInstances(); k++) { data.add(subsets[j].instance(k)); } data.compactify(); data.randomize(rand); m_classifiers[i][j].buildClassifier(data, i, j, m_fitLogisticModels, m_numFolds, m_randomSeed); } } }
From source file:ID3Chi.java
License:Open Source License
/** * Builds ID3Chi decision tree classifier. * * @param data//w ww.j a va2s .co m * the training data * @exception Exception * if classifier can't be built successfully */ public void buildClassifier(Instances data) throws Exception { // can classifier handle the data? getCapabilities().testWithFail(data); // remove instances with missing class data = new Instances(data); data.deleteWithMissingClass(); makeTree(data); }
From source file:adams.data.instancesanalysis.PLS.java
License:Open Source License
/** * Performs the actual analysis./*from w w w . j av a 2s . co m*/ * * @param data the data to analyze * @return null if successful, otherwise error message * @throws Exception if analysis fails */ @Override protected String doAnalyze(Instances data) throws Exception { String result; Remove remove; weka.filters.supervised.attribute.PLS pls; WekaInstancesToSpreadSheet conv; SpreadSheet transformed; Matrix matrix; SpreadSheet loadings; Row row; int i; int n; m_Loadings = null; m_Scores = null; data = new Instances(data); data.deleteWithMissingClass(); if (!m_AttributeRange.isAllRange()) { if (isLoggingEnabled()) getLogger().info("Filtering attribute range: " + m_AttributeRange.getRange()); remove = new Remove(); remove.setAttributeIndicesArray(m_AttributeRange.getIntIndices()); remove.setInvertSelection(true); remove.setInputFormat(data); data = Filter.useFilter(data, remove); } if (isLoggingEnabled()) getLogger().info("Performing PLS..."); pls = new weka.filters.supervised.attribute.PLS(); pls.setAlgorithm(m_Algorithm); pls.setInputFormat(data); data = Filter.useFilter(data, pls); conv = new WekaInstancesToSpreadSheet(); conv.setInput(data); result = conv.convert(); if (result == null) { transformed = (SpreadSheet) conv.getOutput(); matrix = pls.getLoadings(); loadings = new DefaultSpreadSheet(); for (i = 0; i < matrix.getColumnDimension(); i++) loadings.getHeaderRow().addCell("L-" + (i + 1)).setContentAsString("Loading-" + (i + 1)); for (n = 0; n < matrix.getRowDimension(); n++) { row = loadings.addRow(); for (i = 0; i < matrix.getColumnDimension(); i++) row.addCell("L-" + (i + 1)).setContent(matrix.get(n, i)); } m_Loadings = loadings; m_Scores = transformed; } return result; }
From source file:AnDE.wdAnDEonline.java
License:Open Source License
@Override public void buildClassifier(Instances instances) throws Exception { // can classifier handle the data? getCapabilities().testWithFail(instances); // remove instances with missing class instances.deleteWithMissingClass(); nInstances = instances.numInstances(); nAttributes = instances.numAttributes() - 1; nc = instances.numClasses();//from w w w .j av a 2 s . co m probs = new double[nc]; paramsPerAtt = new int[nAttributes]; for (int u = 0; u < nAttributes; u++) { paramsPerAtt[u] = instances.attribute(u).numValues(); } /* * Initialize structure array based on m_S */ if (m_S.equalsIgnoreCase("A0DE")) { // A0DE numTuples = 0; } else if (m_S.equalsIgnoreCase("A1DE")) { // A1DE numTuples = 1; } else if (m_S.equalsIgnoreCase("A2DE")) { // A2DE numTuples = 2; } /* * ---------------------------------------------------------------------------------------- * Start Parameter Learning Process * ---------------------------------------------------------------------------------------- */ int scheme = 1; /* * --------------------------------------------------------------------------------------------- * Intitialize data structure * --------------------------------------------------------------------------------------------- */ scheme = plTechniques.MAP; logDComputer = LogDistributionComputerAnDE.getDistributionComputer(numTuples, scheme); dParameters_ = new wdAnDEParametersFlat(nAttributes, nc, nInstances, paramsPerAtt, scheme, numTuples, m_MVerb); if (m_MVerb) System.out.println("All data structures are initialized. Starting to estimate parameters."); if (nInstances > 0) { for (int i = 0; i < nInstances; i++) { Instance instance = instances.instance(i); dParameters_.updateFirstPass(instance); } } }
From source file:ann.MyANN.java
/** * Melakukan training dengan data yang diberikan * @param instances training data//from w ww. ja v a 2s . c om * @throws Exception Exception apapun yang menyebabkan training gagal */ @Override public void buildClassifier(Instances instances) throws Exception { // cek apakah sesuai dengan data input getCapabilities().testWithFail(instances); // copy data dan buang semua missing class instances = new Instances(instances); instances.deleteWithMissingClass(); // filter NumericToBinary ntb = new NumericToBinary(); ntb.setInputFormat(instances); instances = Filter.useFilter(instances, ntb); // ubah instances ke data instancesToDatas(instances); // membangun ANN berdasarkan nbLayers // membuat layer ArrayList<ArrayList<Node>> layers = new ArrayList<>(); for (int i = 0; i < nbLayers.length; i++) { layers.add(new ArrayList<>()); } // inisialisasi bagian input layer for (int i = 0; i < nbLayers[0]; i++) { // set id, prevLayer = null, nextLayer = layers[1] layers.get(0).add(new Node("node-0" + "-" + i, null, layers.get(1))); } // inisialisasi bagian hidden layer for (int i = 1; i < nbLayers.length - 1; i++) { for (int j = 0; j < nbLayers[i]; j++) { // set id, prevLayer = layers[i-1], nextLayer = layers[i+1] layers.get(i).add(new Node("node-" + i + "-" + j, layers.get(i - 1), layers.get(i + 1))); } } // inisialisasi bagian output layer for (int i = 0; i < nbLayers[nbLayers.length - 1]; i++) { // set id, prevLayer = layers[n-1], nextLayer = null layers.get(nbLayers.length - 1).add( new Node("node-" + (nbLayers.length - 1) + "-" + i, layers.get(nbLayers.length - 2), null)); } // tambah weight tiap neuron // siapin bobot bias, jumlah layer bias adalah nbLayers - 1 ArrayList<Double> bias = new ArrayList<>(); for (int i = 0; i < nbLayers.length - 1; i++) { bias.add(1.0); } // jumlah bobot setiap layer sama dengan jumlah node setiap layer double[][] biasWeight = new double[nbLayers.length - 1][]; for (int i = 1; i < biasWeight.length; i++) { biasWeight[i] = new double[nbLayers[i]]; } // masukin setiap bobot dengan angka random //Random rand = new Random(System.currentTimeMillis()); Random rand = new Random(1); // masukin bobot bias int j = 0; Map<Integer, Map<Node, Double>> biasesWeight = new HashMap<>(); for (int i = 0; i < nbLayers.length - 1; i++) { ArrayList<Node> arrNode = layers.get(i + 1); Map<Node, Double> map = new HashMap<>(); for (Node node : arrNode) { if (isInitialWeightSet) { map.put(node, weights[1][j]); } else { map.put(node, rand.nextDouble()); } j++; } biasesWeight.put(i, map); } j = 0; // masukin bobot tiap neuron Map<Node, Map<Node, Double>> mapWeight = new HashMap<>(); for (int i = 0; i < nbLayers.length - 1; i++) { ArrayList<Node> arrNode = layers.get(i); for (Node node : arrNode) { Map<Node, Double> map = new HashMap<>(); for (Node nextNode : node.getNextNodes()) { if (isInitialWeightSet) { map.put(nextNode, weights[0][j]); } else { map.put(nextNode, rand.nextDouble()); } j++; } mapWeight.put(node, map); } } // buat model ANN berdasarkan nilai di atas annModel = new ANNModel(layers, mapWeight, bias, biasesWeight); // set konfigurasi awal model // debug // System.out.println("debug"); // for (Data d : datas) { // for (Double dd : d.input) { // System.out.print(dd+" "); // } // System.out.print(" | "); // for (Double dd : d.target) { // System.out.print(dd+" "); // } // System.out.println(""); // } // System.out.println("debug"); annModel.setDataSet(datas); annModel.setLearningRate(learningRate); annModel.setMomentum(momentum); switch (activationFunction) { case SIGMOID_FUNCTION: annModel.setActivationFunction(ANNModel.SIGMOID); break; case SIGN_FUNCTION: // ubah target jadi -1 dan 1 for (Data d : datas) { for (Double dd : d.target) { if (dd == 0.0) { dd = -1.0; } } } annModel.setActivationFunction(ANNModel.SIGN); break; case STEP_FUNCTION: annModel.setActivationFunction(ANNModel.STEP); break; default: break; } if (learningRule == BATCH_GRADIENT_DESCENT || learningRule == DELTA_RULE) annModel.setActivationFunction(ANNModel.NO_FUNC); if (topology == MULTILAYER_PERCEPTRON) { annModel.setActivationFunction(ANNModel.SIGMOID); } annModel.setThreshold(threshold); // jalankan algoritma boolean stop = false; iteration = 0; //annModel.print(); annModel.resetDeltaWeight(); do { if (topology == ONE_PERCEPTRON) { switch (learningRule) { case PERCEPTRON_TRAINING_RULE: annModel.perceptronTrainingRule(); break; case BATCH_GRADIENT_DESCENT: annModel.batchGradienDescent(); break; case DELTA_RULE: annModel.deltaRule(); break; default: break; } } else if (topology == MULTILAYER_PERCEPTRON) { annModel.backProp(); } iteration++; // berhenti jika terminateCondition terpenuhi switch (terminationCondition) { case TERMINATE_MAX_ITERATION: if (iteration >= maxIteration) stop = true; break; case TERMINATE_MSE: if (annModel.error < deltaMSE) stop = true; break; case TERMINATE_BOTH: if (iteration > maxIteration || annModel.error < deltaMSE) stop = true; break; default: break; } // System.out.println(annModel.error); } while (!stop); // annModel.print(); }