Method classify

JSAT/src/jsat/classifiers/knn/DANN.java:235–360

(DataPoint data)

    }

    @Override
    public CategoricalResults classify(DataPoint data)
    {
        CategoricalResults cr = new CategoricalResults(predicting.getNumOfCategories());
        
        int n = data.numNumericalValues();
        Matrix sigma = Matrix.eye(n);
        Matrix B = new DenseMatrix(n, n);
        Matrix W = new DenseMatrix(n, n);
        Vec query = data.getNumericalValues();
        
        Vec scratch0 = new DenseVector(n);
        
        
        
        //TODO threadlocal DoubleList / DenseVec might be better in practice for memory use
        double[] weights = new double[kn];
        double[] priors = new double[predicting.getNumOfCategories()];
        int[] classCount = new int[priors.length];
        double sumOfWeights;
        Vec mean = new DenseVector(sigma.rows());
        Vec[] classMeans = new Vec[predicting.getNumOfCategories()];
        for(int i = 0; i < classMeans.length; i++)
            classMeans[i] = new DenseVector(mean.length());
        
        for(int iter = 0; iter < maxIterations; iter++)
        {
            //Zero out prev iter
            mean.zeroOut();
            Arrays.fill(priors, 0);
            Arrays.fill(classCount, 0);
            for(int i = 0; i < classMeans.length; i++)
                classMeans[i].zeroOut();
            sumOfWeights = 0;
            B.zeroOut();
            W.zeroOut();
            
            
            List<? extends VecPaired<VecPaired<Vec, Integer>, Double>> vecs = 
                    (iter == 0) ? vc.search(query, kn) : brute(query, sigma, kn);
            //Compute vector mean and weight sums, class weight sums, and the class means
            double h = vecs.get(vecs.size()-1).getPair();
            for(int i = 0; i < vecs.size(); i++)
            {
                VecPaired<? extends VecPaired<Vec, Integer>, Double> vec = vecs.get(i);
                //vecs contains the distances, we need the distance squared
                weights[i] = pow(pow(1-pow(vec.getPair(), 2) /h, 3), 3);
                sumOfWeights += weights[i];
                mean.mutableAdd(vec);
                
                int j = vec.getVector().getPair();
                priors[j] += weights[i];
                classMeans[j].mutableAdd(vec);
                classCount[j]++;
            }
            
            //Final divide for means and priors
            mean.mutableDivide(kn);