Java Code Examples for com.jstarcraft.ai.environment.EnvironmentContext#getContext()

@Override
protected void eStep() {
    EnvironmentContext context = EnvironmentContext.getContext();
    // 并发计算
    CountDownLatch latch = new CountDownLatch(userSize);
    for (int userIndex = 0; userIndex < userSize; userIndex++) {
        int user = userIndex;
        context.doAlgorithmByAny(userIndex, () -> {
            calculateGammaRho(user, dataMatrixes[user]);
            latch.countDown();
        });
    }
    try {
        latch.await();
    } catch (Exception exception) {
        throw new ModelException(exception);
    }
}
 

@Override
public final void practice() {
    EnvironmentContext context = EnvironmentContext.getContext();
    context.doAlgorithmByEvery(this::constructEnvironment);
    doPractice();
    context.doAlgorithmByEvery(this::destructEnvironment);
}
 

/**
 * 根据分数矩阵计算相关度
 * 
 * @param scoreMatrix
 * @param transpose
 * @param monitor
 */
default void calculateCoefficients(MathMatrix scoreMatrix, boolean transpose, CorrelationMonitor monitor) {
    EnvironmentContext context = EnvironmentContext.getContext();
    Semaphore semaphore = new Semaphore(0);
    int count = transpose ? scoreMatrix.getColumnSize() : scoreMatrix.getRowSize();
    for (int leftIndex = 0; leftIndex < count; leftIndex++) {
        MathVector thisVector = transpose ? scoreMatrix.getColumnVector(leftIndex) : scoreMatrix.getRowVector(leftIndex);
        if (thisVector.getElementSize() == 0) {
            continue;
        }
        monitor.notifyCoefficientCalculated(leftIndex, leftIndex, getIdentical());
        // user/item itself exclusive
        int permits = 0;
        for (int rightIndex = leftIndex + 1; rightIndex < count; rightIndex++) {
            MathVector thatVector = transpose ? scoreMatrix.getColumnVector(rightIndex) : scoreMatrix.getRowVector(rightIndex);
            if (thatVector.getElementSize() == 0) {
                continue;
            }
            int leftCursor = leftIndex;
            int rightCursor = rightIndex;
            context.doAlgorithmByAny(leftIndex * rightIndex, () -> {
                float coefficient = getCoefficient(thisVector, thatVector);
                if (!Float.isNaN(coefficient)) {
                    monitor.notifyCoefficientCalculated(leftCursor, rightCursor, coefficient);
                }
                semaphore.release();
            });
            permits++;
        }
        try {
            semaphore.acquire(permits);
        } catch (Exception exception) {
            throw new RuntimeException(exception);
        }
    }
}
 

@Override
protected void doPractice() {
    EnvironmentContext context = EnvironmentContext.getContext();
    Semaphore semaphore = new Semaphore(0);
    // simple rule: X => Y, given that each user vector is regarded as a
    // transaction
    for (int leftItemIndex = 0; leftItemIndex < itemSize; leftItemIndex++) {
        // all transactions for item itemIdx
        SparseVector leftVector = scoreMatrix.getColumnVector(leftItemIndex);
        for (int rightItemIndex = leftItemIndex + 1; rightItemIndex < itemSize; rightItemIndex++) {
            SparseVector rightVector = scoreMatrix.getColumnVector(rightItemIndex);
            int leftIndex = leftItemIndex;
            int rightIndex = rightItemIndex;
            context.doAlgorithmByAny(leftItemIndex * rightItemIndex, () -> {
                int leftCursor = 0, rightCursor = 0, leftSize = leftVector.getElementSize(), rightSize = rightVector.getElementSize();
                if (leftSize != 0 && rightSize != 0) {
                    // compute confidence where containing item assoItemIdx
                    // among
                    // userRatingsVector
                    int count = 0;
                    Iterator<VectorScalar> leftIterator = leftVector.iterator();
                    Iterator<VectorScalar> rightIterator = rightVector.iterator();
                    VectorScalar leftTerm = leftIterator.next();
                    VectorScalar rightTerm = rightIterator.next();
                    // 判断两个有序数组中是否存在相同的数字
                    while (leftCursor < leftSize && rightCursor < rightSize) {
                        if (leftTerm.getIndex() == rightTerm.getIndex()) {
                            count++;
                            if (leftIterator.hasNext()) {
                                leftTerm = leftIterator.next();
                            }
                            if (rightIterator.hasNext()) {
                                rightTerm = rightIterator.next();
                            }
                            leftCursor++;
                            rightCursor++;
                        } else if (leftTerm.getIndex() > rightTerm.getIndex()) {
                            if (rightIterator.hasNext()) {
                                rightTerm = rightIterator.next();
                            }
                            rightCursor++;
                        } else if (leftTerm.getIndex() < rightTerm.getIndex()) {
                            if (leftIterator.hasNext()) {
                                leftTerm = leftIterator.next();
                            }
                            leftCursor++;
                        }
                    }
                    float leftValue = (count + 0F) / leftVector.getElementSize();
                    float rightValue = (count + 0F) / rightVector.getElementSize();
                    associationMatrix.setValue(leftIndex, rightIndex, leftValue);
                    associationMatrix.setValue(rightIndex, leftIndex, rightValue);
                }
                semaphore.release();
            });
        }
        try {
            semaphore.acquire(itemSize - leftItemIndex - 1);
        } catch (Exception exception) {
            throw new ModelException(exception);
        }
    }
}
 

@Override
public void doForward() {
    MathMatrix weightParameters = parameters.get(WEIGHT_KEY);
    MathMatrix biasParameters = parameters.get(BIAS_KEY);

    MathMatrix inputData = inputKeyValue.getKey();
    MathMatrix middleData = middleKeyValue.getKey();
    middleData.setValues(0F);
    MathMatrix outputData = outputKeyValue.getKey();
    outputData.setValues(0F);
    outputData.getColumnVector(0).copyVector(inputData.getColumnVector(0));
    int numberOfRows = inputData.getRowSize();
    EnvironmentContext context = EnvironmentContext.getContext();
    CountDownLatch latch = new CountDownLatch(numberOfRows);
    for (int rowIndex = 0; rowIndex < numberOfRows; rowIndex++) {
        MathVector inputMajorData = inputData.getRowVector(rowIndex);
        MathVector middleMajorData = middleData.getRowVector(rowIndex);
        MathVector outputMajorData = outputData.getRowVector(rowIndex);
        int numberOfColumns = (int) inputMajorData.getValue(0);
        context.doStructureByAny(rowIndex, () -> {
            for (int columnIndex = 0; columnIndex < numberOfColumns; columnIndex++) {
                MathVector inputMinorData = GlobalVector.detachOf(GlobalVector.class.cast(inputMajorData), columnIndex * numberOfInputs + 1, (columnIndex + 1) * numberOfInputs + 1);
                MathVector middleMinorData = GlobalVector.detachOf(GlobalVector.class.cast(middleMajorData), columnIndex * numberOfOutputs, (columnIndex + 1) * numberOfOutputs);
                MathVector outputMinorData = GlobalVector.detachOf(GlobalVector.class.cast(outputMajorData), columnIndex * numberOfOutputs + 1, (columnIndex + 1) * numberOfOutputs + 1);
                middleMinorData.dotProduct(inputMinorData, weightParameters, false, MathCalculator.SERIAL);
                if (biasParameters != null) {
                    middleMinorData.iterateElement(MathCalculator.SERIAL, (scalar) -> {
                        int index = scalar.getIndex();
                        float value = scalar.getValue();
                        scalar.setValue(value + biasParameters.getValue(0, index));
                    });
                }
                function.forward(middleMajorData, outputMinorData);
            }
            latch.countDown();
        });
    }
    try {
        latch.await();
    } catch (Exception exception) {
        throw new RuntimeException(exception);
    }

    MathMatrix middleError = middleKeyValue.getValue();
    middleError.setValues(0F);

    MathMatrix innerError = outputKeyValue.getValue();
    innerError.setValues(0F);
}