我正在开发一个用 Java 编写的系统，该系统能够使用历史数据执行预测。使用的算法是这个 Holt-Winters 实现（乘法季节性）的 Java 端口。
我有几个要分析的时间序列，我们需要为这些时间序列设置不同的平滑系数。该算法目前似乎运行良好，唯一的问题是如何确定平滑系数（alpha、beta、gamma）的最合理值。
我知道我需要某种非线性优化，但我根本不是数学家，所以我有点迷失在所有这些理论和概念中。
编辑：
我有很多不同的时间序列要分析，我想知道是否有标准/足够好的技术（图书馆会更好）来计算我应该给 Holt-Winters 算法的平滑参数。
你看过JMulTi吗？
这个 SO question可能与您非常相关。
任何研究 Holt-Winters 的人都应该查看Hyndman 教授的网站。他是一位领域专家，也是forecast()R 语言库的创建者。
你说你想更好地理解这项技术。好消息是 Hyndman 正在编写一本教科书，我们可以免费查阅。关于 Holt-winters 的具体章节位于：http: //otexts.com/fpp/7/5/
我知道你想要在 Java 中使用它，但如果 R 是一个选项，你应该试一试。（有些人建议从 R 编写并将其读入您的 Java 程序。）
更新：
如果是您关心的初始硬件参数，我只能想到ets实现最大似然搜索以得出参数的包。如果您发现没有 Java 实现，最好的选择可能是使用JRI (rJava)并在其中调用ets或调用HoltWinters。
希望有帮助。
您可以使用 Apache 实现的Nelder Mead Optimizer (SimplexOptimizer)
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;
}
};
}