public void increment(K key){ Value<V> value = ensureValue(key); value.add(1d); } }
static public <V extends Number> Value<V> sum(Iterable<Value<V>> values){ Value<V> sum = null; for(Value<V> value : values){ if(sum == null){ sum = value.copy(); } else { sum.add(value); } } return sum; }
private Fraction(ValueFactory<V> valueFactory, List<SegmentResult> segmentResults){ this.weightSum = valueFactory.newValue(); this.missingWeightSum = valueFactory.newValue(); for(int i = 0, max = segmentResults.size(); i < max; i++){ SegmentResult segmentResult = segmentResults.get(i); this.weightSum.add(segmentResult.getWeight()); } }
numerator.add(a11 + a00); denominator.add(a11 + a10 + a01 + a00); } else numerator.add(a11); denominator.add(a11 + a10 + a01); } else numerator.add(a11 + a00); denominator.add(a11).add(2d, (a10 + a01)).add(a00); } else BinarySimilarity binarySimilarity = (BinarySimilarity)measure; numerator.add(binarySimilarity.getC11Parameter(), a11).add(binarySimilarity.getC10Parameter(), a10).add(binarySimilarity.getC01Parameter(), a01).add(binarySimilarity.getC00Parameter(), a00); denominator.add(binarySimilarity.getD11Parameter(), a11).add(binarySimilarity.getD10Parameter(), a10).add(binarySimilarity.getD01Parameter(), a01).add(binarySimilarity.getD00Parameter(), a00); } else
static public <V extends Number> Value<V> calculateAdjustment(ValueFactory<V> valueFactory, List<FieldValue> values, List<? extends Number> adjustmentValues){ Value<V> sum = valueFactory.newValue(); Value<V> nonmissingSum = valueFactory.newValue(); for(int i = 0; i < values.size(); i++){ FieldValue value = values.get(i); double adjustmentValue = (adjustmentValues != null ? (adjustmentValues.get(i)).doubleValue() : 1d); if(adjustmentValue != 0d){ sum.add(adjustmentValue); if(value != null){ nonmissingSum.add(adjustmentValue); } } } if(nonmissingSum.equals(0d)){ throw new UndefinedResultException(); } return sum.divide(nonmissingSum); } }
public Value<V> getWeight(double threshold){ Value<V> value = getValue(); value = value.copy(); if(threshold != 0d){ value.add(threshold); } return value.reciprocal(); } }
public boolean update(SegmentResult segmentResult, double missingThreshold){ this.missingWeightSum.add(segmentResult.getWeight()); return (this.missingWeightSum.doubleValue() / this.weightSum.doubleValue()) > missingThreshold; } }
private <V extends Number> Value<V> computeDotProduct(ValueFactory<V> valueFactory, Iterable<PCell> parameterCells, Map<String, Row> parameterPredictorRows, EvaluationContext context){ Value<V> result = null; for(PCell parameterCell : parameterCells){ Row parameterPredictorRow = parameterPredictorRows.get(parameterCell.getParameterName()); if(result == null){ result = valueFactory.newValue(); } // End if if(parameterPredictorRow != null){ Value<V> x = parameterPredictorRow.evaluate(valueFactory, context); if(x == null){ return null; } result.add(parameterCell.getBeta(), x.getValue()); } else { result.add(parameterCell.getBeta()); } } return result; }
static public <V extends Number> Value<V> evaluatePolynomialKernel(PolynomialKernel polynomialKernel, ValueFactory<V> valueFactory, Object input, Object vector){ Value<V> result = valueFactory.newValue(dotProduct(input, vector)); Double gamma = polynomialKernel.getGamma(); if(gamma.doubleValue() != 1d){ result.multiply(gamma); } Double coef0 = polynomialKernel.getCoef0(); if(coef0.doubleValue() != 1d){ result.add(coef0); } Double degree = polynomialKernel.getDegree(); if(degree.doubleValue() != 1d){ result.power(degree); } return result; }
@Override public void multiply(String key, double probability){ ValueFactory<V> valueFactory = getValueFactory(); Value<V> value = ensureValue(key); Value<V> probabilityValue = valueFactory.newValue(probability); probabilityValue.ln(); value.add(probabilityValue); } };
sum.add(value);
private <V extends Number> Value<V> computeCumulativeLink(Value<V> value, EvaluationContext context){ GeneralRegressionModel generalRegressionModel = getModel(); GeneralRegressionModel.CumulativeLinkFunction cumulativeLinkFunction = generalRegressionModel.getCumulativeLinkFunction(); if(cumulativeLinkFunction == null){ throw new MissingAttributeException(generalRegressionModel, PMMLAttributes.GENERALREGRESSIONMODEL_CUMULATIVELINKFUNCTION); } Double offset = getOffset(generalRegressionModel, context); if(offset != null && offset != 0d){ value.add(offset.doubleValue()); } switch(cumulativeLinkFunction){ case LOGIT: case PROBIT: case CLOGLOG: case LOGLOG: case CAUCHIT: GeneralRegressionModelUtil.computeCumulativeLink(cumulativeLinkFunction, value); break; default: throw new UnsupportedAttributeException(generalRegressionModel, cumulativeLinkFunction); } return value; }
private <V extends Number> Value<V> computeReferencePoint(ValueFactory<V> valueFactory){ GeneralRegressionModel generalRegressionModel = getModel(); BiMap<String, Parameter> parameters = getParameterRegistry(); Map<String, List<PCell>> paramMatrixMap = getParamMatrixMap(); Iterable<PCell> parameterCells = paramMatrixMap.get(null); if(paramMatrixMap.size() != 1 || parameterCells == null){ ParamMatrix paramMatrix = generalRegressionModel.getParamMatrix(); throw new InvalidElementException(paramMatrix); } Value<V> result = null; for(PCell parameterCell : parameterCells){ Parameter parameter = parameters.get(parameterCell.getParameterName()); if(result == null){ result = valueFactory.newValue(); } // End if if(parameter != null){ result.add(parameterCell.getBeta(), parameter.getReferencePoint()); } else { return null; } } return result; }
sum.add(value);
static public <V extends Number> Value<V> evaluateSigmoidKernel(SigmoidKernel sigmoidKernel, ValueFactory<V> valueFactory, Object input, Object vector){ Value<V> result = valueFactory.newValue(dotProduct(input, vector)); Double gamma = sigmoidKernel.getGamma(); if(gamma != 1d){ result.multiply(gamma); } Double coef0 = sigmoidKernel.getCoef0(); if(coef0 != 1d){ result.add(coef0); } result.tanh(); return result; }
sum.add(value);
static public <V extends Number> Value<V> processValue(Target target, Value<V> value){ Double min = target.getMin(); Double max = target.getMax(); if(min != null || max != null){ value.restrict((min != null ? min : Double.NEGATIVE_INFINITY), (max != null ? max : Double.POSITIVE_INFINITY)); } double rescaleFactor = target.getRescaleFactor(); if(rescaleFactor != 1d){ value.multiply(rescaleFactor); } double rescaleConstant = target.getRescaleConstant(); if(rescaleConstant != 0d){ value.add(rescaleConstant); } Target.CastInteger castInteger = target.getCastInteger(); if(castInteger == null){ return value; } switch(castInteger){ case ROUND: return value.round(); case CEILING: return value.ceiling(); case FLOOR: return value.floor(); default: throw new UnsupportedAttributeException(target, castInteger); } }
sum.add(value);
value.add(offset);