Source code for pyFTS.models.incremental.IncrementalEnsemble

'''
Time Variant/Incremental Ensemble of FTS methods
'''


import numpy as np
import pandas as pd
from pyFTS.common import FuzzySet, FLR, fts, flrg
from pyFTS.partitioners import Grid
from pyFTS.models import hofts
from pyFTS.models.ensemble import ensemble


class IncrementalEnsembleFTS(ensemble.EnsembleFTS):
    """
    Time Variant/Incremental Ensemble of FTS methods
    """
    def __init__(self, **kwargs):
        super(IncrementalEnsembleFTS, self).__init__(**kwargs)
        self.shortname = "IncrementalEnsembleFTS"
        self.name = "Incremental Ensemble FTS"

        self.order = kwargs.get('order',1)

        self.partitioner_method = kwargs.get('partitioner_method', Grid.GridPartitioner)
        """The partitioner method to be called when a new model is build"""
        self.partitioner_params = kwargs.get('partitioner_params', {'npart': 10})
        """The partitioner method parameters"""

        self.fts_method = kwargs.get('fts_method', hofts.WeightedHighOrderFTS)
        """The FTS method to be called when a new model is build"""
        self.fts_params = kwargs.get('fts_params', {})
        """The FTS method specific parameters"""

        self.window_length = kwargs.get('window_length', 100)
        """The memory window length"""

        self.batch_size = kwargs.get('batch_size', 10)
        """The batch interval between each retraining"""

        self.num_models = kwargs.get('num_models', 5)
        """The number of models to hold in the ensemble"""

        self.point_method = kwargs.get('point_method', 'exponential')

        self.is_high_order = True
        self.uod_clip = False
        self.max_lag = self.window_length + self.order

    def offset(self):
        return self.max_lag

    def train(self, data, **kwargs):

        partitioner = self.partitioner_method(data=data, **self.partitioner_params)
        model = self.fts_method(partitioner=partitioner, **self.fts_params)
        if model.is_high_order:
            model = self.fts_method(partitioner=partitioner, order=self.order, **self.fts_params)
        model.fit(data, **kwargs)
        self.append_model(model)
        if len(self.models) > self.num_models:
            self.models.pop(0)

    def forecast(self, data, **kwargs):
        l = len(data)
        no_update = kwargs.get('no_update', False)
        if no_update:
            ret = []
            for k in np.arange(self.order, l+1):
                sample = data[k-self.order: k]
                tmp = self.get_models_forecasts(sample)
                point = self.get_point(tmp)
                ret.append(point)
            return ret

        data_window = []

        ret = []

        for k in np.arange(self.max_lag, l):

            k2 = k - self.max_lag

            data_window.append(data[k2])

            if k2 >= self.window_length:
                data_window.pop(0)

            if k % self.batch_size == 0 and k2 >= self.window_length:
                self.train(data_window, **kwargs)

            if len(self.models) > 0:
                sample = data[k2: k]
                tmp = self.get_models_forecasts(sample)
                point = self.get_point(tmp)
                ret.append(point)

        return ret

    def forecast_ahead(self, data, steps, **kwargs):
        if len(data) < self.order:
            return data

        if isinstance(data, np.ndarray):
            data = data.tolist()

        start = kwargs.get('start_at',0)

        ret = data[:start+self.order]
        for k in np.arange(start+self.order, steps+start+self.order):
            tmp = self.forecast(ret[k-self.order:k], no_update=True, **kwargs)

            if isinstance(tmp,(list, np.ndarray)):
                tmp = tmp[-1]

            ret.append(tmp)
            data.append(tmp)

        return ret[-steps:]