mirror of
https://github.com/Karaka-Management/phpOMS.git
synced 2026-01-17 04:18:41 +00:00
622 lines
22 KiB
PHP
622 lines
22 KiB
PHP
<?php
|
|
/**
|
|
* Orange Management
|
|
*
|
|
* PHP Version 7.1
|
|
*
|
|
* @category Framework
|
|
* @package phpOMS\Business\Finance\Forecasting\ExponentialSmoothing
|
|
* @copyright Dennis Eichhorn
|
|
* @license OMS License 1.0
|
|
* @version 1.0.0
|
|
* @link http://website.orange-management.de
|
|
*/
|
|
declare(strict_types = 1);
|
|
|
|
namespace phpOMS\Business\Finance\Forecasting\ExponentialSmoothing;
|
|
|
|
use phpOMS\Business\Finance\Forecasting\SmoothingType;
|
|
use phpOMS\Math\Statistic\Average;
|
|
use phpOMS\Math\Statistic\Forecast\Error;
|
|
|
|
class ExponentialSmoothing
|
|
{
|
|
private $data = [];
|
|
|
|
private $errors = [];
|
|
|
|
private $rmse = 0.0;
|
|
|
|
private $mse = 0.0;
|
|
|
|
private $mae = 0.0;
|
|
|
|
private $sse = 0.0;
|
|
|
|
public function __construct(array $data)
|
|
{
|
|
$this->data = $data;
|
|
}
|
|
|
|
public function getRMSE() : float
|
|
{
|
|
return $this->rmse;
|
|
}
|
|
|
|
public function getMSE() : float
|
|
{
|
|
return $this->mse;
|
|
}
|
|
|
|
public function getMAE() : float
|
|
{
|
|
return $this->mae;
|
|
}
|
|
|
|
public function getSSE() : float
|
|
{
|
|
return $this->sse;
|
|
}
|
|
|
|
public function getErrors() : array
|
|
{
|
|
return $this->errors;
|
|
}
|
|
|
|
public function getForecast(int $future, int $trendType = TrendType::NONE, int $seasonalType = SeasonalType::NONE, int $cycle = 12, float $damping = 1) : array
|
|
{
|
|
$this->rmse = PHP_INT_MAX;
|
|
|
|
if ($trendType === TrendType::ALL || $seasonalType === SeasonalType::ALL) {
|
|
$trends = [$trendType];
|
|
if ($trendType === TrendType::ALL) {
|
|
$trends = [TrendType::NONE, TrendType::ADDITIVE, TrendType::MULTIPLICATIVE];
|
|
}
|
|
|
|
$seasonals = [$seasonalType];
|
|
if ($seasonalType === SeasonalType::ALL) {
|
|
$seasonals = [SeasonalType::NONE, SeasonalType::ADDITIVE, SeasonalType::MULTIPLICATIVE];
|
|
}
|
|
|
|
$forecast = [];
|
|
$bestError = PHP_INT_MAX;
|
|
foreach ($trends as $trend) {
|
|
foreach ($seasonals as $seasonal) {
|
|
$tempForecast = $this->getForecast($future, $trend, $seasonal, $cycle, $damping);
|
|
|
|
if ($this->rmse < $bestError) {
|
|
$bestError = $this->rmse;
|
|
$forecast = $tempForecast;
|
|
}
|
|
}
|
|
}
|
|
|
|
return $forecast;
|
|
} elseif ($trendType === TrendType::NONE && $seasonalType === SeasonalType::NONE) {
|
|
return $this->getNoneNone($future);
|
|
} elseif ($trendType === TrendType::NONE && $seasonalType === SeasonalType::ADDITIVE) {
|
|
return $this->getNoneAdditive($future, $cycle);
|
|
} elseif ($trendType === TrendType::NONE && $seasonalType === SeasonalType::MULTIPLICATIVE) {
|
|
return $this->getNoneMultiplicative($future, $cycle);
|
|
} elseif ($trendType === TrendType::ADDITIVE && $seasonalType === SeasonalType::NONE) {
|
|
return $this->getAdditiveNone($future, $damping);
|
|
} elseif ($trendType === TrendType::ADDITIVE && $seasonalType === SeasonalType::ADDITIVE) {
|
|
return $this->getAdditiveAdditive($future, $cycle, $damping);
|
|
} elseif ($trendType === TrendType::ADDITIVE && $seasonalType === SeasonalType::MULTIPLICATIVE) {
|
|
return $this->getAdditiveMultiplicative($future, $cycle, $damping);
|
|
} elseif ($trendType === TrendType::MULTIPLICATIVE && $seasonalType === SeasonalType::NONE) {
|
|
return $this->getMultiplicativeNone($future, $damping);
|
|
} elseif ($trendType === TrendType::MULTIPLICATIVE && $seasonalType === SeasonalType::ADDITIVE) {
|
|
return $this->getMultiplicativeAdditive($future, $cycle, $damping);
|
|
} elseif ($trendType === TrendType::MULTIPLICATIVE && $seasonalType === SeasonalType::MULTIPLICATIVE) {
|
|
return $this->getMultiplicativeMultiplicative($future, $cycle, $damping);
|
|
}
|
|
|
|
throw new \Exception();
|
|
}
|
|
|
|
private function dampingSum(float $damping, int $length) : float
|
|
{
|
|
if (abs($damping - 1) < 0.001) {
|
|
return $length;
|
|
}
|
|
|
|
$sum = 0;
|
|
for ($i = 0; $i < $length; $i++) {
|
|
$sum += pow($damping, $i);
|
|
}
|
|
|
|
return $sum;
|
|
}
|
|
|
|
public function getNoneNone(int $future) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$level[$i] = $alpha * ($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) + (1 - $alpha) * $level[$i - 1];
|
|
|
|
$tempForecast[$i] = $level[$i];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getNoneAdditive(int $future, int $cycle) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
$seasonal = [];
|
|
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$seasonal[$i] = $this->data[$i - 1] - $level[0];
|
|
}
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$gamma = 0.00;
|
|
|
|
while ($gamma < 1) {
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$hm = (int) floor(($i - 1) % $cycle) + 1;
|
|
|
|
$level[$i] = $alpha * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) - $seasonal[$i]) + (1 - $alpha) * $level[$i - 1];
|
|
$seasonal[$i + $cycle] = $gamma_ * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) - $level[$i - 1]) + (1 - $gamma_) * $seasonal[$i];
|
|
|
|
$tempForecast[$i] = $level[$i] + $seasonal[$i + $hm];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$gamma += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getNoneMultiplicative(int $future, int $cycle) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
$seasonal = [];
|
|
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$seasonal[$i] = $this->data[$i] / $level[0];
|
|
}
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$gamma = 0.00;
|
|
|
|
while ($gamma < 1) {
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$hm = (int) floor(($i - 1) % $cycle) + 1;
|
|
|
|
$level[$i] = $alpha * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) / $seasonal[$i]) + (1 - $alpha) * $level[$i - 1];
|
|
$seasonal[$i + $cycle] = $gamma_ * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) / $level[$i - 1]) + (1 - $gamma_) * $seasonal[$i];
|
|
|
|
$tempForecast[$i] = $level[$i] + $seasonal[$i + $hm];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$gamma += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getAdditiveNone(int $future, float $damping) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$trend = [$this->data[1] - $this->data[0]];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$beta = 0.00;
|
|
|
|
while ($beta < 1) {
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$level[$i] = $alpha * ($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) + (1 - $alpha) * ($level[$i - 1] + $damping * $trend[$i - 1]);
|
|
$trend[$i] = $beta * ($level[$i] - $level[$i - 1]) + (1 - $beta) * $damping * $trend[$i - 1];
|
|
|
|
$tempForecast[$i] = $level[$i] + $this->dampingSum($damping, $i) * $trend[$i];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$beta += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getAdditiveAdditive(int $future, int $cycle, float $damping) : array
|
|
{
|
|
$level = [1 / $cycle * array_sum(array_slice($this->data, 0, $cycle))];
|
|
$trend = [1 / $cycle];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
$seasonal = [];
|
|
|
|
$sum = 0;
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$sum += ($this->data[$cycle] - $this->data[$i]) / $cycle;
|
|
}
|
|
|
|
$trend[0] *= $sum;
|
|
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$seasonal[$i] = $this->data[$i - 1] - $level[0];
|
|
}
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$beta = 0.00;
|
|
|
|
while ($beta < 1) {
|
|
$gamma = 0.00;
|
|
|
|
while ($gamma < 1) {
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$hm = (int) floor(($i - 1) % $cycle) + 1;
|
|
|
|
$level[$i] = $alpha * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) - $seasonal[$i]) + (1 - $alpha) * ($level[$i - 1] + $damping * $trend[$i - 1]);
|
|
$trend[$i] = $beta * ($level[$i] - $level[$i - 1]) + (1 - $beta) * $damping * $trend[$i - 1];
|
|
$seasonal[$i + $cycle] = $gamma_ * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) - $level[$i - 1]) + (1 - $gamma_) * $seasonal[$i];
|
|
|
|
$tempForecast[$i] = $level[$i] + $this->dampingSum($damping, $i) * $trend[$i] + $seasonal[$i + $hm];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$gamma += 0.01;
|
|
}
|
|
|
|
$beta += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getAdditiveMultiplicative(int $future, int $cycle, float $damping) : array
|
|
{
|
|
$level = [1 / $cycle * array_sum(array_slice($this->data, 0, $cycle))];
|
|
$trend = [1 / $cycle];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
$seasonal = [];
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
|
|
$sum = 0;
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$sum += ($this->data[$cycle] - $this->data[$i]) / $cycle;
|
|
}
|
|
|
|
$trend[0] *= $sum;
|
|
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$seasonal[$i] = $this->data[$i] / $level[0];
|
|
}
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$beta = 0.00;
|
|
|
|
while ($beta < 1) {
|
|
$gamma = 0.00;
|
|
|
|
while ($gamma < 1) {
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$hm = (int) floor(($i - 1) % $cycle) + 1;
|
|
|
|
$level[$i] = $alpha * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) / $seasonal[$i]) + (1 - $alpha) * ($level[$i - 1] + $damping * $trend[$i - 1]);
|
|
$trend[$i] = $beta * ($level[$i] - $level[$i - 1]) + (1 - $beta) * $damping * $trend[$i - 1];
|
|
$seasonal[$i + $cycle] = $gamma_ * ($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) / ($level[$i - 1] + $damping * $trend[$i - 1]) + (1 - $gamma_) * $seasonal[$i];
|
|
|
|
$tempForecast[] = ($level[$i] + $this->dampingSum($damping, $i) * $trend[$i - 1]) * $seasonal[$i + $hm];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$gamma += 0.01;
|
|
}
|
|
|
|
$beta += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getMultiplicativeNone(int $future, float $damping) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$trend = [$this->data[1] / $this->data[0]];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$beta = 0.00;
|
|
|
|
while ($beta < 1) {
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$level[$i] = $alpha * ($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) + (1 - $alpha) * $level[$i - 1] * pow($trend[$i - 1], $damping);
|
|
$trend[$i] = $beta * ($level[$i] / $level[$i - 1]) + (1 - $beta) * pow($trend[$i - 1], $damping);
|
|
|
|
$tempForecast[$i] = $level[$i] * pow($trend[$i], $this->dampingSum($damping, $i));
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$beta += 0.01;
|
|
}
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getMultiplicativeAdditive(int $future, int $cycle, float $damping) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$trend = [1 / $cycle];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
$seasonal = [];
|
|
|
|
$sum = 0;
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$sum += ($this->data[$cycle] - $this->data[$i]) / $cycle;
|
|
}
|
|
|
|
$trend[0] *= $sum;
|
|
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$seasonal[$i] = $this->data[$i - 1] - $level[0];
|
|
}
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$beta = 0.00;
|
|
|
|
while ($beta < 1) {
|
|
$gamma = 0.00;
|
|
|
|
while ($gamma < 1) {
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$hm = (int) floor(($i - 1) % $cycle) + 1;
|
|
|
|
$level[$i] = $alpha * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) - $seasonal[$i]) + (1 - $alpha) * $level[$i - 1] * pow($trend[$i - 1], $damping);
|
|
$trend[$i] = $beta * ($level[$i] / $level[$i - 1]) + (1 - $beta) * pow($trend[$i - 1], $damping);
|
|
$seasonal[$i + $cycle] = $gamma_ * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) - $level[$i - 1] * pow($trend[$i - 1], $damping)) + (1 - $gamma_) * $seasonal[$i];
|
|
|
|
$tempForecast[$i] = $level[$i] * pow($trend[$i], $this->dampingSum($damping, $i)) + $seasonal[$i + $hm];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$gamma += 0.01;
|
|
}
|
|
|
|
$beta += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
public function getMultiplicativeMultiplicative(int $future, int $cycle, float $damping) : array
|
|
{
|
|
$level = [$this->data[0]];
|
|
$trend = [1 / $cycle];
|
|
$dataLength = count($this->data) + $future;
|
|
$forecast = [];
|
|
$seasonal = [];
|
|
|
|
$sum = 0;
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$sum += ($this->data[$cycle] - $this->data[$i]) / $cycle;
|
|
}
|
|
|
|
$trend[0] *= $sum;
|
|
|
|
for ($i = 1; $i < $cycle + 1; $i++) {
|
|
$seasonal[$i] = $this->data[$i] / $level[0];
|
|
}
|
|
|
|
$alpha = 0.00;
|
|
while ($alpha < 1) {
|
|
$beta = 0.00;
|
|
|
|
while ($beta < 1) {
|
|
$gamma = 0.00;
|
|
|
|
while ($gamma < 1) {
|
|
$gamma_ = $gamma * (1 - $alpha);
|
|
$error = [];
|
|
$tempForecast = [];
|
|
|
|
for ($i = 1; $i < $dataLength; $i++) {
|
|
$hm = (int) floor(($i - 1) % $cycle) + 1;
|
|
|
|
$level[$i] = $alpha * (($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) / $seasonal[$i]) + (1 - $alpha) * $level[$i - 1] * pow($trend[$i - 1], $damping);
|
|
$trend[$i] = $beta * ($level[$i] / $level[$i - 1]) + (1 - $beta) * pow($trend[$i - 1], $damping);
|
|
$seasonal[$i + $cycle] = $gamma_ * ($i < $dataLength - $future ? $this->data[$i - 1] : $tempForecast[$i - 1]) / ($level[$i - 1] * pow($trend[$i - 1], $damping)) + (1 - $gamma_) * $seasonal[$i];
|
|
|
|
$tempForecast[$i] = $level[$i] * pow($trend[$i], $this->dampingSum($damping, $i)) * $seasonal[$i + $hm];
|
|
$error[] = $i < $dataLength - $future ? $this->data[$i] - $tempForecast[$i] : 0;
|
|
}
|
|
|
|
$tempRMSE = Error::getRootMeanSquaredError($error);
|
|
|
|
if ($tempRMSE < $this->rmse) {
|
|
$this->rmse = $tempRMSE;
|
|
$forecast = $tempForecast;
|
|
}
|
|
|
|
$gamma += 0.01;
|
|
}
|
|
|
|
$beta += 0.01;
|
|
}
|
|
|
|
$alpha += 0.01;
|
|
}
|
|
|
|
$this->errors = $error;
|
|
$this->mse = Error::getMeanSquaredError($error);
|
|
$this->mae = Error::getMeanAbsoulteError($error);
|
|
$this->sse = Error::getSumSquaredError($error);
|
|
|
|
return $forecast;
|
|
}
|
|
|
|
} |