Examples with IntDoubleVector com.tencent.angel.ml.math2.vector.IntDoubleVector used on opensource projects

Example 46 with IntDoubleVector

use of com.tencent.angel.ml.math2.vector.IntDoubleVector in project angel by Tencent.

the class SimpleBinaryOutNonZAExecutor method apply.

public static Vector apply(IntDoubleVector v1, IntLongVector v2, Binary op) {
    IntDoubleVectorStorage newStorage = (IntDoubleVectorStorage) StorageSwitch.apply(v1, v2, op);
    if (v1.isDense() && v2.isDense()) {
        double[] resValues = newStorage.getValues();
        double[] v1Values = v1.getStorage().getValues();
        long[] v2Values = v2.getStorage().getValues();
        for (int idx = 0; idx < resValues.length; idx++) {
            resValues[idx] = op.apply(v1Values[idx], v2Values[idx]);
        }
    } else if (v1.isDense() && v2.isSparse()) {
        double[] resValues = newStorage.getValues();
        double[] v1Values = v1.getStorage().getValues();
        ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
        while (iter.hasNext()) {
            Int2LongMap.Entry entry = iter.next();
            int idx = entry.getIntKey();
            resValues[idx] = op.apply(v1Values[idx], entry.getLongValue());
        }
    } else if (v1.isDense() && v2.isSorted()) {
        double[] resValues = newStorage.getValues();
        double[] v1Values = v1.getStorage().getValues();
        int[] v2Indices = v2.getStorage().getIndices();
        long[] v2Values = v2.getStorage().getValues();
        int size = v2.size();
        for (int i = 0; i < size; i++) {
            int idx = v2Indices[i];
            resValues[idx] = op.apply(v1Values[idx], v2Values[i]);
        }
    } else if (v1.isSparse() && v2.isDense()) {
        if (op.isKeepStorage()) {
            int dim = v1.getDim();
            long[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                for (int i = 0; i < dim; i++) {
                    newStorage.set(i, op.apply(0, v2Values[i]));
                }
                ObjectIterator<Int2DoubleMap.Entry> iter = v1.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2DoubleMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(entry.getDoubleValue(), v2Values[idx]));
                }
            } else {
                for (int i = 0; i < dim; i++) {
                    if (v1.getStorage().hasKey(i)) {
                        newStorage.set(i, op.apply(v1.get(i), v2Values[i]));
                    } else {
                        newStorage.set(i, op.apply(0, v2Values[i]));
                    }
                }
            }
        } else {
            double[] resValues = newStorage.getValues();
            long[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(0, v2Values[i]);
                }
                ObjectIterator<Int2DoubleMap.Entry> iter = v1.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2DoubleMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    resValues[idx] = op.apply(entry.getDoubleValue(), v2Values[idx]);
                }
            } else {
                for (int i = 0; i < resValues.length; i++) {
                    if (v1.getStorage().hasKey(i)) {
                        resValues[i] = op.apply(v1.get(i), v2Values[i]);
                    } else {
                        resValues[i] = op.apply(0, v2Values[i]);
                    }
                }
            }
        }
    } else if (v1.isSorted() && v2.isDense()) {
        if (op.isKeepStorage()) {
            int dim = v1.getDim();
            int[] resIndices = newStorage.getIndices();
            double[] resValues = newStorage.getValues();
            long[] v2Values = v2.getStorage().getValues();
            int[] v1Indices = v1.getStorage().getIndices();
            double[] v1Values = v1.getStorage().getValues();
            for (int i = 0; i < dim; i++) {
                resIndices[i] = i;
                resValues[i] = op.apply(0, v2Values[i]);
            }
            int size = v1.size();
            for (int i = 0; i < size; i++) {
                int idx = v1Indices[i];
                resValues[idx] = op.apply(v1Values[i], v2Values[idx]);
            }
        } else {
            double[] resValues = newStorage.getValues();
            long[] v2Values = v2.getStorage().getValues();
            if (v1.size() < Constant.denseLoopThreshold * v1.getDim()) {
                int[] v1Indices = v1.getStorage().getIndices();
                double[] v1Values = v1.getStorage().getValues();
                for (int i = 0; i < resValues.length; i++) {
                    resValues[i] = op.apply(0, v2Values[i]);
                }
                int size = v1.size();
                for (int i = 0; i < size; i++) {
                    int idx = v1Indices[i];
                    resValues[idx] = op.apply(v1Values[i], v2Values[idx]);
                }
            } else {
                IntDoubleVectorStorage v1Storage = v1.getStorage();
                for (int i = 0; i < resValues.length; i++) {
                    if (v1Storage.hasKey(i)) {
                        resValues[i] = op.apply(v1.get(i), v2Values[i]);
                    } else {
                        resValues[i] = op.apply(0, v2Values[i]);
                    }
                }
            }
        }
    } else if (v1.isSparse() && v2.isSparse()) {
        int v1Size = v1.size();
        int v2Size = v2.size();
        if (v1Size >= v2Size * Constant.sparseThreshold && (v1Size + v2Size) * Constant.intersectionCoeff <= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss the indices of v2 maybe is a subset of v1, or overlap is very large
            ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2LongMap.Entry entry = iter.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, op.apply(v1.get(idx), entry.getLongValue()));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss dense storage is more efficient
            ObjectIterator<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2DoubleMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, entry.getDoubleValue());
            }
            ObjectIterator<Int2LongMap.Entry> iter2 = v2.getStorage().entryIterator();
            while (iter2.hasNext()) {
                Int2LongMap.Entry entry = iter2.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, op.apply(v1.get(idx), entry.getLongValue()));
            }
        } else {
            // to avoid multi-rehash
            int capacity = 1 << (32 - Integer.numberOfLeadingZeros((int) (v1.size() / 0.75)));
            if (v1.size() + v2.size() <= 1.5 * capacity) {
                // no rehashor one onle rehash is required, nothing to optimization
                ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getLongValue()));
                }
            } else {
                // multi-rehash
                ObjectIterator<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2DoubleMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getDoubleValue());
                }
                ObjectIterator<Int2LongMap.Entry> iter2 = v2.getStorage().entryIterator();
                while (iter2.hasNext()) {
                    Int2LongMap.Entry entry = iter2.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(v1.get(idx), entry.getLongValue()));
                }
            }
        }
    } else if (v1.isSparse() && v2.isSorted()) {
        int v1Size = v1.size();
        int v2Size = v2.size();
        if (v1Size >= v2Size * Constant.sparseThreshold && (v1Size + v2Size) * Constant.intersectionCoeff <= Constant.sparseDenseStorageThreshold * v1.dim()) {
            // we gauss the indices of v2 maybe is a subset of v1, or overlap is very large
            int[] v2Indices = v2.getStorage().getIndices();
            long[] v2Values = v2.getStorage().getValues();
            for (int i = 0; i < v2.size(); i++) {
                int idx = v2Indices[i];
                newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
            }
        } else if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sparseDenseStorageThreshold * v1.dim()) {
            ObjectIterator<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
            while (iter1.hasNext()) {
                Int2DoubleMap.Entry entry = iter1.next();
                int idx = entry.getIntKey();
                newStorage.set(idx, entry.getDoubleValue());
            }
            int[] v2Indices = v2.getStorage().getIndices();
            long[] v2Values = v2.getStorage().getValues();
            int size = v2.size();
            for (int i = 0; i < size; i++) {
                int idx = v2Indices[i];
                newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
            }
        } else {
            // to avoid multi-rehash
            int capacity = 1 << (32 - Integer.numberOfLeadingZeros((int) (v1.size() / 0.75)));
            if (v1.size() + v2.size() <= 1.5 * capacity) {
                int[] v2Indices = v2.getStorage().getIndices();
                long[] v2Values = v2.getStorage().getValues();
                for (int i = 0; i < v2.size(); i++) {
                    int idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            } else {
                ObjectIterator<Int2DoubleMap.Entry> iter1 = v1.getStorage().entryIterator();
                while (iter1.hasNext()) {
                    Int2DoubleMap.Entry entry = iter1.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, entry.getDoubleValue());
                }
                int[] v2Indices = v2.getStorage().getIndices();
                long[] v2Values = v2.getStorage().getValues();
                int size = v2.size();
                for (int i = 0; i < size; i++) {
                    int idx = v2Indices[i];
                    newStorage.set(idx, op.apply(v1.get(idx), v2Values[i]));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSparse()) {
        int v1Size = v1.size();
        int v2Size = v2.size();
        if ((v1Size + v2Size) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                int[] v1Indices = v1.getStorage().getIndices();
                int[] idxiter = v2.getStorage().indexIterator().toIntArray();
                int[] indices = new int[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                IntAVLTreeSet avl = new IntAVLTreeSet(indices);
                IntBidirectionalIterator iter = avl.iterator();
                double[] values = new double[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    int idx = iter.nextInt();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new IntDoubleSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                int[] v1Indices = v1.getStorage().getIndices();
                double[] v1Values = v1.getStorage().getValues();
                int size = v1.size();
                for (int i = 0; i < size; i++) {
                    int idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getLongValue()));
                }
            }
        } else {
            if (op.isKeepStorage()) {
                int[] v1Indices = v1.getStorage().getIndices();
                int[] idxiter = v2.getStorage().indexIterator().toIntArray();
                int[] indices = new int[(int) (v1Size + v2Size)];
                System.arraycopy(v1Indices, 0, indices, 0, (int) v1.size());
                System.arraycopy(idxiter, 0, indices, (int) v1.size(), (int) v2.size());
                IntAVLTreeSet avl = new IntAVLTreeSet(indices);
                IntBidirectionalIterator iter = avl.iterator();
                double[] values = new double[indices.length];
                int i = 0;
                while (iter.hasNext()) {
                    int idx = iter.nextInt();
                    indices[i] = idx;
                    values[i] = op.apply(v1.get(idx), v2.get(idx));
                    i++;
                }
                while (i < indices.length) {
                    indices[i] = 0;
                    i++;
                }
                newStorage = new IntDoubleSortedVectorStorage(v1.getDim(), (int) avl.size(), indices, values);
            } else {
                int[] v1Indices = v1.getStorage().getIndices();
                double[] v1Values = v1.getStorage().getValues();
                int size = v1.size();
                for (int i = 0; i < size; i++) {
                    int idx = v1Indices[i];
                    newStorage.set(idx, v1Values[i]);
                }
                ObjectIterator<Int2LongMap.Entry> iter = v2.getStorage().entryIterator();
                while (iter.hasNext()) {
                    Int2LongMap.Entry entry = iter.next();
                    int idx = entry.getIntKey();
                    newStorage.set(idx, op.apply(newStorage.get(idx), entry.getLongValue()));
                }
            }
        }
    } else if (v1.isSorted() && v2.isSorted()) {
        int v1Pointor = 0;
        int v2Pointor = 0;
        int size1 = v1.size();
        int size2 = v2.size();
        int[] v1Indices = v1.getStorage().getIndices();
        double[] v1Values = v1.getStorage().getValues();
        int[] v2Indices = v2.getStorage().getIndices();
        long[] v2Values = v2.getStorage().getValues();
        if ((size1 + size2) * Constant.intersectionCoeff >= Constant.sortedDenseStorageThreshold * v1.dim()) {
            if (op.isKeepStorage()) {
                // sorted
                int[] resIndices = newStorage.getIndices();
                double[] resValues = newStorage.getValues();
                int global = 0;
                while (v1Pointor < size1 && v2Pointor < size2) {
                    if (v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        resIndices[global] = v1Indices[v1Pointor];
                        resValues[global] = op.apply(v1Values[v1Pointor], v2Values[v2Pointor]);
                        global++;
                        v1Pointor++;
                        v2Pointor++;
                    } else if (v1Indices[v1Pointor] < v2Indices[v2Pointor]) {
                        resIndices[global] = v1Indices[v1Pointor];
                        resValues[global] = v1Values[v1Pointor];
                        global++;
                        v1Pointor++;
                    } else {
                        // v1Indices[v1Pointor] > v2Indices[v2Pointor]
                        resIndices[global] = v2Indices[v2Pointor];
                        resValues[global] = op.apply(0, v2Values[v2Pointor]);
                        global++;
                        v2Pointor++;
                    }
                }
            } else {
                // dense
                while (v1Pointor < size1 || v2Pointor < size2) {
                    if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        newStorage.set(v1Indices[v1Pointor], op.apply(v1Values[v1Pointor], v2Values[v2Pointor]));
                        v1Pointor++;
                        v2Pointor++;
                    } else if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] < v2Indices[v2Pointor] || (v1Pointor < size1 && v2Pointor >= size2)) {
                        newStorage.set(v1Indices[v1Pointor], v1Values[v1Pointor]);
                        v1Pointor++;
                    } else if (((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] >= v2Indices[v2Pointor]) || (v1Pointor >= size1 && v2Pointor < size2)) {
                        newStorage.set(v2Indices[v2Pointor], op.apply(0, v2Values[v2Pointor]));
                        v2Pointor++;
                    }
                }
            }
        } else {
            if (op.isKeepStorage()) {
                int[] resIndices = newStorage.getIndices();
                double[] resValues = newStorage.getValues();
                int globalPointor = 0;
                while (v1Pointor < size1 && v2Pointor < size2) {
                    if (v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        resIndices[globalPointor] = v1Indices[v1Pointor];
                        resValues[globalPointor] = op.apply(v1Values[v1Pointor], v2Values[v2Pointor]);
                        v1Pointor++;
                        v2Pointor++;
                        globalPointor++;
                    } else if (v1Indices[v1Pointor] < v2Indices[v2Pointor]) {
                        resIndices[globalPointor] = v1Indices[v1Pointor];
                        resValues[globalPointor] = v1Values[v1Pointor];
                        v1Pointor++;
                        globalPointor++;
                    } else {
                        // v1Indices[v1Pointor] > v2Indices[v2Pointor]
                        resIndices[globalPointor] = v2Indices[v2Pointor];
                        resValues[globalPointor] = op.apply(0, v2Values[v2Pointor]);
                        v2Pointor++;
                        globalPointor++;
                    }
                }
            } else {
                while (v1Pointor < size1 || v2Pointor < size2) {
                    if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] == v2Indices[v2Pointor]) {
                        newStorage.set(v1Indices[v1Pointor], op.apply(v1Values[v1Pointor], v2Values[v2Pointor]));
                        v1Pointor++;
                        v2Pointor++;
                    } else if ((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] < v2Indices[v2Pointor] || (v1Pointor < size1 && v2Pointor >= size2)) {
                        newStorage.set(v1Indices[v1Pointor], v1Values[v1Pointor]);
                        v1Pointor++;
                    } else if (((v1Pointor < size1 && v2Pointor < size2) && v1Indices[v1Pointor] >= v2Indices[v2Pointor]) || (v1Pointor >= size1 && v2Pointor < size2)) {
                        newStorage.set(v2Indices[v2Pointor], op.apply(0, v2Values[v2Pointor]));
                        v2Pointor++;
                    }
                }
            }
        }
    } else {
        throw new AngelException("The operation is not support!");
    }
    return new IntDoubleVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newStorage);
}

Example 47 with IntDoubleVector

use of com.tencent.angel.ml.math2.vector.IntDoubleVector in project angel by Tencent.

the class SimpleUnaryExecutor method apply.

private static Vector apply(IntDoubleVector v1, Unary op) {
    IntDoubleVector res;
    if (op.isOrigin() || v1.isDense()) {
        if (!op.isInplace()) {
            res = v1.copy();
        } else {
            res = v1;
        }
        if (v1.isDense()) {
            double[] values = res.getStorage().getValues();
            for (int i = 0; i < values.length; i++) {
                values[i] = op.apply(values[i]);
            }
        } else if (v1.isSparse()) {
            ObjectIterator<Int2DoubleMap.Entry> iter = res.getStorage().entryIterator();
            while (iter.hasNext()) {
                Int2DoubleMap.Entry entry = iter.next();
                entry.setValue(op.apply(entry.getDoubleValue()));
            }
        } else if (v1.isSorted()) {
            double[] values = res.getStorage().getValues();
            for (int i = 0; i < v1.size(); i++) {
                values[i] = op.apply(values[i]);
            }
        } else {
            throw new AngelException("The operation is not support!");
        }
    } else {
        IntDoubleVectorStorage newstorage = v1.getStorage().emptyDense();
        IntDoubleVectorStorage storage = v1.getStorage();
        double[] values = newstorage.getValues();
        double tmp = op.apply((double) 0);
        int dim = v1.getDim();
        for (int i = 0; i < dim; i++) {
            values[i] = tmp;
        }
        if (v1.isSparse()) {
            ObjectIterator<Int2DoubleMap.Entry> iter = storage.entryIterator();
            while (iter.hasNext()) {
                Int2DoubleMap.Entry entry = iter.next();
                values[entry.getIntKey()] = op.apply(entry.getDoubleValue());
            }
        } else {
            // sort
            int[] idxs = storage.getIndices();
            double[] v1Values = storage.getValues();
            for (int k = 0; k < idxs.length; k++) {
                values[idxs[k]] = op.apply(v1Values[k]);
            }
        }
        if (op.isInplace()) {
            v1.setStorage(newstorage);
            res = v1;
        } else {
            res = new IntDoubleVector(v1.getMatrixId(), v1.getRowId(), v1.getClock(), v1.getDim(), newstorage);
        }
    }
    return res;
}

Example 48 with IntDoubleVector

use of com.tencent.angel.ml.math2.vector.IntDoubleVector in project angel by Tencent.

the class MatrixUtils method rbCompDense2Blas.

public static BlasDoubleMatrix rbCompDense2Blas(RBCompIntDoubleMatrix mat) {
    assert mat != null;
    int dim = (int) mat.getDim();
    int subDim = mat.getSubDim();
    CompIntDoubleVector[] rows = mat.getRows();
    double[] data = new double[rows.length * dim];
    int rowId = 0;
    for (CompIntDoubleVector row : rows) {
        IntDoubleVector[] partitions = row.getPartitions();
        int partId = 0;
        for (IntDoubleVector part : partitions) {
            assert part.isDense();
            double[] src = part.getStorage().getValues();
            System.arraycopy(src, 0, data, rowId * dim + partId * subDim, src.length);
            partId += 1;
        }
        rowId += 1;
    }
    return MFactory.denseDoubleMatrix(rows.length, dim, data);
}

Example 49 with IntDoubleVector

use of com.tencent.angel.ml.math2.vector.IntDoubleVector in project angel by Tencent.

the class RangeRouterUtils method splitIntDoubleVector.

public static KeyValuePart[] splitIntDoubleVector(MatrixMeta matrixMeta, IntDoubleVector vector) {
    IntDoubleVectorStorage storage = vector.getStorage();
    if (storage.isSparse()) {
        // Get keys and values
        IntDoubleSparseVectorStorage sparseStorage = (IntDoubleSparseVectorStorage) storage;
        int[] keys = sparseStorage.getIndices();
        double[] values = sparseStorage.getValues();
        return split(matrixMeta, vector.getRowId(), keys, values, false);
    } else if (storage.isDense()) {
        // Get values
        IntDoubleDenseVectorStorage denseStorage = (IntDoubleDenseVectorStorage) storage;
        double[] values = denseStorage.getValues();
        return split(matrixMeta, vector.getRowId(), values);
    } else {
        // Key and value array pair
        IntDoubleSortedVectorStorage sortStorage = (IntDoubleSortedVectorStorage) storage;
        int[] keys = sortStorage.getIndices();
        double[] values = sortStorage.getValues();
        return split(matrixMeta, vector.getRowId(), keys, values, true);
    }
}

Example 50 with IntDoubleVector

use of com.tencent.angel.ml.math2.vector.IntDoubleVector in project angel by Tencent.

the class GBDTController method updateNodeGradStats.

// update node's grad stats on PS
// called during splitting in GradHistHelper, update the grad stats of children nodes after finding the best split
// the root node's stats is updated by leader worker
public void updateNodeGradStats(int nid, GradStats gradStats) throws Exception {
    LOG.debug(String.format("Update gradStats of node[%d]: sumGrad[%f], sumHess[%f]", nid, gradStats.sumGrad, gradStats.sumHess));
    // 1. create the update
    IntDoubleVector vec = new IntDoubleVector(2 * this.activeNode.length, new IntDoubleDenseVectorStorage(2 * this.activeNode.length));
    vec.set(nid, gradStats.sumGrad);
    vec.set(nid + this.activeNode.length, gradStats.sumHess);
    // 2. push the update to PS
    PSModel nodeGradStats = this.model.getPSModel(this.param.nodeGradStatsName);
    nodeGradStats.increment(this.currentTree, vec);
}