我正在研究一个用Java编写的系统，它能够使用历史数据执行预测。正在使用的算法是this Holt-Winters implementation的Java端口（乘法季节性）。
我有几个时间序列我们想分析，我们需要不同的时间序列平滑系数。该算法目前看起来效果很好，唯一的问题是如何确定平滑系数（alpha，beta，gamma）的最合理值。
我知道我需要某种非线性优化，但我根本不是数学家，所以我在所有这些理论和概念中都有点迷失。
修改：
我有很多不同的时间序列要分析，我想知道是否有一个标准/足够好的技术（库会更好）来计算我应该给Holt-Winters算法的平滑参数
答案 0 :(得分：4)
你有没有看过JMulTi？
This SO question可能与您非常相关。
任何关注Holt-Winters的人都应该查看Prof. Hyndman's site。
他是领域专家，也是R的forecast()库的创建者。
你说你想更好地理解这种技术。好消息是，Hyndman正在编写一本免费供我们查阅的教科书。关于Holt-winters的具体章节在：http://otexts.com/fpp/7/5/
我知道你想要它用Java，但如果R是一个选项，你应该试一试。 （有些人建议从R写入并将其读入Java程序。）
<强>更新
如果它是您关心的初始HW参数，我只能想到实现最大似然搜索的ets包来获得参数。如果您没有找到Java实现，最好的办法是使用JRI (rJava)并从其中调用ets或HoltWinters。
希望有所帮助。
答案 1 :(得分：2)
您可以使用Apache（SimplexOptimizer）实施的 Nelder Mead Optimizer
double[] dataPoints = {
141, 53, 78, 137, 182, 161, 177,
164, 70, 67, 129, 187, 161, 136,
167, 57, 61, 159, 158, 152, 169,
181, 65, 60, 146, 186, 180, 181,
167, 70, 62, 170, 193, 167, 176,
149, 69, 68, 168, 181, 200, 179,
181, 83, 72, 157, 188, 193, 173,
184, 61, 59, 158, 158, 143, 208,
172, 82, 86, 158, 194, 193, 159
};
NelderMeadOptimizer.Parameters op = NelderMeadOptimizer.optimize(dataPoints, 7);
op.getAlpha();
op.getBeta();
op.getGamma();
现在你需要NelderMeadOptimizer：
import org.apache.commons.math3.analysis.MultivariateFunction;
import org.apache.commons.math3.optim.InitialGuess;
import org.apache.commons.math3.optim.MaxEval;
import org.apache.commons.math3.optim.MaxIter;
import org.apache.commons.math3.optim.PointValuePair;
import org.apache.commons.math3.optim.nonlinear.scalar.GoalType;
import org.apache.commons.math3.optim.nonlinear.scalar.MultivariateFunctionMappingAdapter;
import org.apache.commons.math3.optim.nonlinear.scalar.ObjectiveFunction;
import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.NelderMeadSimplex;
import org.apache.commons.math3.optim.nonlinear.scalar.noderiv.SimplexOptimizer;
import java.util.List;
public class NelderMeadOptimizer {
// configuration
private static final double minValueForOptimizedParameters = 0.001;
private static final double maxValueForOptimizedParameters = 0.99;
private static final double simplexRelativeThreshold = 0.0001;
private static final double simplexAbsoluteThreshold = 0.0001;
private static final double DEFAULT_LEVEL_SMOOTHING = 0.01;
private static final double DEFAULT_TREND_SMOOTHING = 0.01;
private static final double DEFAULT_SEASONAL_SMOOTHING = 0.01;
private static final int MAX_ALLOWED_NUMBER_OF_ITERATION = 1000;
private static final int MAX_ALLOWED_NUMBER_OF_EVALUATION = 1000;
/**
*
* @param dataPoints the observed data points
* @param seasonLength the amount of data points per season
* @return the optimized parameters
*/
public static Parameters optimize(double[] dataPoints, int seasonLength) {
MultivariateFunctionMappingAdapter costFunc = getCostFunction(dataPoints, seasonLength);
double[] initialGuess = getInitialGuess(dataPoints, seasonLength);
double[] optimizedValues = optimize(initialGuess, costFunc);
double alpha = optimizedValues[0];
double beta = optimizedValues[1];
double gamma = optimizedValues[2];
return new Parameters(alpha, beta, gamma);
}
/**
* Optimizes parameters using the Nelder-Mead Method
* @param initialGuess initial guess / state required for Nelder-Mead-Method
* @param costFunction which defines that the Mean Squared Error has to be minimized
* @return the optimized values
*/
private static double[] optimize(double[] initialGuess, MultivariateFunctionMappingAdapter costFunction) {
double[] result;
SimplexOptimizer optimizer = new SimplexOptimizer(simplexRelativeThreshold, simplexAbsoluteThreshold);
PointValuePair unBoundedResult = optimizer.optimize(
GoalType.MINIMIZE,
new MaxIter(MAX_ALLOWED_NUMBER_OF_ITERATION),
new MaxEval(MAX_ALLOWED_NUMBER_OF_EVALUATION),
new InitialGuess(initialGuess),
new ObjectiveFunction(costFunction),
new NelderMeadSimplex(initialGuess.length));
result = costFunction.unboundedToBounded(unBoundedResult.getPoint());
return result;
}
/**
* Defines that the Mean Squared Error has to be minimized
* in order to get optimized / good parameters for alpha, betta and gamma.
* It also defines the minimum and maximum values for the parameters to optimize.
* @param dataPoints the data points
* @param seasonLength the amount of data points per season
* @return a cost function {@link MultivariateFunctionMappingAdapter} which
* defines that the Mean Squared Error has to be minimized
* in order to get optimized / good parameters for alpha, betta and gamma
*/
private static MultivariateFunctionMappingAdapter getCostFunction(final double[] dataPoints, final int seasonLength) {
MultivariateFunction multivariateFunction = new MultivariateFunction() {
@Override
public double value(double[] point) {
double alpha = point[0];
double beta = point[1];
double gamma = point[2];
if (beta >= alpha) {
return Double.POSITIVE_INFINITY;
}
List<Double> predictedValues = TripleExponentialSmoothing.getSmoothedDataPointsWithPredictions(dataPoints, seasonLength, alpha, beta, gamma, 1);
predictedValues.remove(predictedValues.size()-1);
double meanSquaredError = getMeanSquaredError(dataPoints, predictedValues);
return meanSquaredError;
}
};
double[][] minMax = getMinMaxValues();
return new MultivariateFunctionMappingAdapter(multivariateFunction, minMax[0], minMax[1]);
}
/**
* Generates an initial guess/state required for Nelder-Mead-Method.
* @param dataPoints the data points
* @param seasonLength the amount of data points per season
* @return array containing initial guess/state required for Nelder-Mead-Method
*/
public static double[] getInitialGuess(double[] dataPoints, int seasonLength){
double[] initialGuess = new double[3];
initialGuess[0] = DEFAULT_LEVEL_SMOOTHING;
initialGuess[1] = DEFAULT_TREND_SMOOTHING;
initialGuess[2] = DEFAULT_SEASONAL_SMOOTHING;
return initialGuess;
}
/**
* Get minimum and maximum values for the parameters alpha (level coefficient),
* beta (trend coefficient) and gamma (seasonality coefficient)
* @return array containing all minimum and maximum values for the parameters alpha, beta and gamma
*/
private static double[][] getMinMaxValues() {
double[] min = new double[3];
double[] max = new double[3];
min[0] = minValueForOptimizedParameters;
min[1] = minValueForOptimizedParameters;
min[2] = minValueForOptimizedParameters;
max[0] = maxValueForOptimizedParameters;
max[1] = maxValueForOptimizedParameters;
max[2] = maxValueForOptimizedParameters;
return new double[][]{min, max};
}
/**
* Compares observed data points from the past and predicted data points
* in order to calculate the Mean Squared Error (MSE)
* @param observedData the observed data points from the past
* @param predictedData the predicted data points
* @return the Mean Squared Error (MSE)
*/
public static double getMeanSquaredError(double[] observedData, List<Double> predictedData){
double sum = 0;
for(int i=0; i<observedData.length; i++){
double error = observedData[i] - predictedData.get(i);
double sumSquaredError = error * error; // SSE
sum += sumSquaredError;
}
return sum / observedData.length;
}
/**
* Holds the parameters alpha (level coefficient), beta (trend coefficient)
* and gamma (seasonality coefficient) for Triple Exponential Smoothing.
*/
public static class Parameters {
public final double alpha;
public final double beta;
public final double gamma;
public Parameters(double alpha, double beta, double gamma) {
this.alpha = alpha;
this.beta = beta;
this.gamma = gamma;
}
public double getAlpha() {
return alpha;
}
public double getBeta() {
return beta;
}
public double getGamma() {
return gamma;
}
};
}