def test_optimise_smoothing_level_genetic_algorithm(self):
total_orders = 0
for order in self.__orders_ex[:12]:
total_orders += order
avg_orders = total_orders / 12
f = Forecast(self.__orders_ex, avg_orders)
alpha = [0.2, 0.3, 0.4, 0.5, 0.6]
s = [i for i in f.simple_exponential_smoothing(*alpha)]
sum_squared_error = f.sum_squared_errors(s, 0.5)
standard_error = f.standard_error(sum_squared_error, len(self.__orders_ex), 0.5, 2)
evo_mod = OptimiseSmoothingLevelGeneticAlgorithm(orders=self.__orders_ex,
average_order=avg_orders,
smoothing_level=0.5,
population_size=10,
standard_error=standard_error,
recombination_type='single_point')
pop = evo_mod.initial_population()
self.assertGreaterEqual(len(pop), 2)
self.assertNotAlmostEqual(pop[0], 20.72, places=3)
self.assertNotAlmostEqual(pop[1], 0.73, places=3)
def holts_trend_corrected_exponential_smoothing_forecast(demand: list, alpha: float, gamma: float,
forecast_length: int = 4, initial_period: int = 6, **kwargs):
if len(kwargs) != 0:
if kwargs['optimise']:
total_orders = 0
for order in demand[:initial_period]:
total_orders += order
avg_orders = total_orders / initial_period
forecast_demand = Forecast(demand)
processed_demand = [{'t': index, 'demand': order} for index, order in enumerate(demand, 1)]
stats = LinearRegression(processed_demand)
log_stats = stats.least_squared_error(slice_end=6)
htces_forecast = [i for i in
forecast_demand.holts_trend_corrected_exponential_smoothing(alpha=alpha, gamma=gamma,
intercept=log_stats.get(
'intercept'),
slope=log_stats.get(
'slope'))]
sum_squared_error = forecast_demand.sum_squared_errors_indi_htces(squared_error=[htces_forecast],
alpha=alpha, gamma=gamma)
standard_error = forecast_demand.standard_error(sum_squared_error, len(demand), (alpha, gamma), 2)
evo_mod = OptimiseSmoothingLevelGeneticAlgorithm(orders=demand,
average_order=avg_orders,
population_size=10,
standard_error=standard_error,
recombination_type='single_point')
optimal_alpha = evo_mod.initial_population(individual_type='htces')
log.log(logging.WARNING,
'An optimal alpha {} and optimal gamma {} have been found.'.format(optimal_alpha[1][0],
optimal_alpha[1][1]))
htces_forecast = [i for i in
forecast_demand.holts_trend_corrected_exponential_smoothing(alpha=optimal_alpha[1][0],
gamma=optimal_alpha[1][1],
intercept=log_stats.get(
'intercept'),
slope=log_stats.get('slope'))]
holts_forecast = forecast_demand.holts_trend_corrected_forecast(forecast=htces_forecast,
forecast_length=forecast_length)
log.log(logging.INFO, 'An OPTIMAL Holts trend exponential smoothing forecast has been generated.')
sum_squared_error_opt = forecast_demand.sum_squared_errors_indi_htces(squared_error=[htces_forecast],
alpha=optimal_alpha[1][0],
gamma=optimal_alpha[1][1])
standard_error_opt = forecast_demand.standard_error(sum_squared_error_opt, len(demand),
(optimal_alpha[1][0], optimal_alpha[1][1]), 2)
ape = LinearRegression(htces_forecast)
mape = forecast_demand.mean_aboslute_percentage_error_opt(htces_forecast)
stats = ape.least_squared_error()
regression_line = deepcopy(regr_ln(stats=stats))
return {'forecast_breakdown': htces_forecast, 'forecast': holts_forecast, 'mape': mape, 'statistics': stats,
'optimal_alpha': optimal_alpha[1][0],
'optimal_gamma': optimal_alpha[1][1],
'SSE': sum_squared_error_opt,
'standard_error': standard_error_opt,
'original_standard_error': standard_error,
'regression': [i for i in regression_line.get('regression')]}
else:
forecast_demand = Forecast(demand)
processed_demand = [{'t': index, 'demand': order} for index, order in enumerate(demand, 1)]
stats = LinearRegression(processed_demand)
log_stats = stats.least_squared_error(slice_end=6)
htces_forecast = [i for i in
forecast_demand.holts_trend_corrected_exponential_smoothing(alpha=alpha, gamma=gamma,
intercept=log_stats.get(
'intercept'),
slope=log_stats.get(
'slope'))]
holts_forecast = forecast_demand.holts_trend_corrected_forecast(forecast=htces_forecast,
forecast_length=forecast_length)
log.log(logging.INFO, 'A STANDARD Holts trend exponential smoothing forecast has been generated.')
sum_squared_error = forecast_demand.sum_squared_errors_indi_htces(squared_error=[htces_forecast],
alpha=alpha, gamma=gamma)
ape = LinearRegression(htces_forecast)
mape = forecast_demand.mean_aboslute_percentage_error_opt(htces_forecast)
stats = ape.least_squared_error()
regression_line = regr_ln(stats=stats)
log.log(logging.WARNING, "A STANDARD Holts trend exponential smoothing forecast has been completed.")
return {'forecast_breakdown': htces_forecast,
'forecast': holts_forecast,
'mape': mape,
'statistics': stats,
'sum_squared_errors': sum_squared_error,
'regression': [i for i in regression_line.get('regression')]}
