예제 #1
0
    def _run_holts_trend_corrected_exponential_smoothing(
            self, individual: tuple):
        f = Forecast(self.__orders, self.__average_order)
        holts_trend_corrected_smoothing = []
        demand = [{
            't': index,
            'demand': order
        } for index, order in enumerate(self.__orders, 1)]
        stats = LinearRegression(demand)
        log_stats = stats.least_squared_error(slice_end=6)

        for sm_lvl in individual:
            p = [
                i for i in f.holts_trend_corrected_exponential_smoothing(
                    alpha=sm_lvl[0],
                    gamma=sm_lvl[1],
                    intercept=log_stats.get('intercept'),
                    slope=log_stats.get('slope'))
            ]
            # print(p)
            holts_trend_corrected_smoothing.append(p)

        appraised_individual = {}
        for smoothing_level in individual:
            sum_squared_error = f.sum_squared_errors_indi_htces(
                squared_error=holts_trend_corrected_smoothing,
                alpha=smoothing_level[0],
                gamma=smoothing_level[1])
            standard_error = f.standard_error(sum_squared_error,
                                              len(self.__orders),
                                              smoothing_level)
            appraised_individual.update({smoothing_level: standard_error})
        # print('The standard error as a trait has been calculated {}'.format(appraised_individual))
        return appraised_individual
예제 #2
0
def _ses_forecast(smoothing_level_constant: float, forecast_demand: Forecast,
                  forecast_length: int, orders_length: int) -> dict:
    """ Private function for executing the simple exponential smoothing forecast.
    """
    forecast_breakdown = [
        i for i in forecast_demand.simple_exponential_smoothing(
            smoothing_level_constant)
    ]
    ape = LinearRegression(forecast_breakdown)
    mape = forecast_demand.mean_aboslute_percentage_error_opt(
        forecast_breakdown)
    stats = ape.least_squared_error()
    simple_forecast = forecast_demand.simple_exponential_smoothing_forecast(
        forecast=forecast_breakdown, forecast_length=forecast_length)

    sum_squared_error = forecast_demand.sum_squared_errors(
        simple_forecast, smoothing_level_constant)
    standard_error = forecast_demand.standard_error(sum_squared_error,
                                                    orders_length,
                                                    smoothing_level_constant)
    regression_line = _regr_ln(stats=stats)
    log.log(
        logging.WARNING,
        "A STANDARD simple exponential smoothing forecast has been completed.")
    return {
        'forecast_breakdown': forecast_breakdown,
        'mape': mape,
        'statistics': stats,
        'forecast': simple_forecast,
        'alpha': smoothing_level_constant,
        'standard_error': standard_error,
        'regression': [i for i in regression_line.get('regression')]
    }
예제 #3
0
def _ses_forecast(smoothing_level_constant, forecast_demand, forecast_length):
    """

    Args:
        smoothing_level_constant:
        forecast_demand:
        forecast_length:

    Returns:

    """
    forecast_breakdown = [i for i in forecast_demand.simple_exponential_smoothing(smoothing_level_constant)]
    ape = LinearRegression(forecast_breakdown)
    mape = forecast_demand.mean_aboslute_percentage_error_opt(forecast_breakdown)
    stats = ape.least_squared_error()
    simple_forecast = forecast_demand.simple_exponential_smoothing_forecast(forecast=forecast_breakdown,
                                                                            forecast_length=forecast_length)
    regression_line = regr_ln(stats=stats)
    log.log(logging.WARNING,
            "A STANDARD simple exponential smoothing forecast has been completed.")
    return {'forecast_breakdown': forecast_breakdown, 'mape': mape, 'statistics': stats,
            'forecast': simple_forecast, 'alpha': smoothing_level_constant,
            'regression': [i for i in regression_line.get('regression')]}
예제 #4
0
    def simple_exponential_smoothing_evo(
            self,
            smoothing_level_constant: float,
            initial_estimate_period: int,
            recombination_type: str = 'single_point',
            population_size: int = 10,
            forecast_length: int = 5) -> dict:
        """ Simple exponential smoothing using evolutionary algorithm for optimising smoothing level constant (alpha value)

            Args:
                initial_estimate_period (int):      The number of previous data points required for initial level estimate.
                smoothing_level_constant (float):   Best guess at smoothing level constant appropriate for forecast.

           Returns:
               dict:

            Example:

        """
        log.log(
            logging.INFO, "Executing simple exponential smoothing. "
            "SMOOTHING_LEVEL: {} "
            "INITIAL_ESTIMATE_PERIOD: {} "
            "RECOMBINATION_TYPE: {} "
            "POPULATION_SIZE: {} "
            "FORECAST_LENGTH: {}".format(smoothing_level_constant,
                                         initial_estimate_period,
                                         recombination_type, population_size,
                                         forecast_length))
        if None != self.__recombination_type:
            recombination_type = self.__recombination_type

        sum_orders = 0

        for demand in self.__orders[:initial_estimate_period]:
            sum_orders += demand

        avg_orders = sum_orders / initial_estimate_period

        forecast_demand = Forecast(self.__orders, avg_orders)

        #calls simple_exponential_smoothing method from Forecast object
        ses_forecast = [
            i for i in forecast_demand.simple_exponential_smoothing(
                *(smoothing_level_constant, ))
        ]

        sum_squared_error = forecast_demand.sum_squared_errors(
            ses_forecast, smoothing_level_constant)

        standard_error = forecast_demand.standard_error(
            sum_squared_error, len(self.__orders), smoothing_level_constant)

        evo_mod = OptimiseSmoothingLevelGeneticAlgorithm(
            orders=self.__orders,
            average_order=avg_orders,
            smoothing_level=smoothing_level_constant,
            population_size=population_size,
            standard_error=standard_error,
            recombination_type=recombination_type)

        optimal_alpha = evo_mod.initial_population()

        optimal_ses_forecast = [
            i for i in forecast_demand.simple_exponential_smoothing(
                optimal_alpha[1])
        ]

        ape = LinearRegression(optimal_ses_forecast)
        mape = forecast_demand.mean_aboslute_percentage_error_opt(
            optimal_ses_forecast)
        stats = ape.least_squared_error()
        simple_forecast = forecast_demand.simple_exponential_smoothing_forecast(
            forecast=optimal_ses_forecast, forecast_length=forecast_length)

        sum_squared_error = forecast_demand.sum_squared_errors(
            optimal_ses_forecast, optimal_alpha[1])
        standard_error = forecast_demand.standard_error(
            sum_squared_error, len(self.__orders), optimal_alpha[1])
        regression = {
            'regression': [(stats.get('slope') * i) + stats.get('intercept')
                           for i in range(0, 12)]
        }

        log.log(
            logging.INFO,
            "An OPTIMISED simple exponential smoothing forecast has been completed"
        )
        return {
            'forecast_breakdown': optimal_ses_forecast,
            'mape': mape,
            'statistics': stats,
            'forecast': simple_forecast,
            'optimal_alpha': optimal_alpha[1],
            'standard_error': standard_error,
            'regression': [i for i in regression.get('regression')]
        }
예제 #5
0
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')]}
예제 #6
0
def holts_trend_corrected_exponential_smoothing_forecast(
        demand: list,
        alpha: float,
        gamma: float,
        forecast_length: int = 4,
        initial_period: int = 6,
        optimise: bool = True) -> dict:
    """ Performs a holt's trend corrected exponential smoothing forecast on known demand

    Args:
        demand (list):  Original historical demand.
        alpha (float): smoothing constant
        gamma (float):
        forecast_length (int):
        initial_period (int):
        optimise (bool):    Flag for using solver. Default is set to True. 

    Returns:
        dict: Simple exponential forecast.

    """
    if 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')]
        }