Exemplo n.º 1
0
    def test_exponentialSmoothing_05(self):
        ts_data = self.statsmodels_data_helper.getData1()
        f_name = 'exponential_smoothing5.pmml'
        model_obj = ExponentialSmoothing(ts_data,
                                         trend='mul',
                                         damped=True,
                                         seasonal='add',
                                         seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(self.schema.is_valid(f_name), True)
Exemplo n.º 2
0
    def test_exponentialSmoothing_17(self):
        ts_data = self.statsmodels_data_helper.getData3()
        f_name = 'exponential_smoothing17.pmml'
        model_obj = ExponentialSmoothing(ts_data,
                                         trend=None,
                                         damped=False,
                                         seasonal=None,
                                         seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(self.schema.is_valid(f_name), True)
    def test_exponentialSmoothing_05(self):
        ts_data = self.getData1()
        f_name = 'exponential_smoothing5.pmml'
        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=True,
                                            seasonal='add',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
    def test_exponentialSmoothing_17(self):
        ts_data = self.getData3()
        f_name = 'exponential_smoothing17.pmml'
        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend=None,
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
Exemplo n.º 5
0
 def test_exponentialSmoothing_01(self):
     ts_data = self.getData1()        
     f_name='exponential_smoothing1.pmml'
     model_obj = ExponentialSmoothing(ts_data, 
                                     trend='add', 
                                     damped=True, 
                                     seasonal='add', 
                                     seasonal_periods=2)
     results_obj = model_obj.fit(optimized=True)
     
     ExponentialSmoothingToPMML(results_obj, f_name, model_name="Test2", description="test model")
     self.assertEqual(os.path.isfile(f_name),True)
    def test_exponentialSmoothing_03(self):

        # data with no trend and no seasonality

        # Oil production in Saudi Arabia
        data = [
            446.6565, 454.4733, 455.663, 423.6322, 456.2713, 440.5881,
            425.3325, 485.1494, 506.0482, 526.792, 514.2689, 494.211
        ]
        index = pd.DatetimeIndex(start='1996', end='2008', freq='A')
        ts_data = pd.Series(data, index)
        ts_data.index.name = 'datetime_index'
        ts_data.name = 'oil_production'

        f_name = 'exponential_smoothing.pmml'

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend=None,
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend=None,
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)
    def test_keras_01(self):
        def import_data(trend=False, seasonality=False):
            """
            Returns a dataframe with time series values.
            :param trend: boolean
                If True, returns data with trend
            :param seasonality: boolean
                If True, returns data with seasonality
            :return: ts_data: DataFrame
                Index of the data frame is either a time-index or an integer index. First column has time series values
            """
            if trend and seasonality:
                # no of international visitors in Australia
                data = [
                    41.7275, 24.0418, 32.3281, 37.3287, 46.2132, 29.3463,
                    36.4829, 42.9777, 48.9015, 31.1802, 37.7179, 40.4202,
                    51.2069, 31.8872, 40.9783, 43.7725, 55.5586, 33.8509,
                    42.0764, 45.6423, 59.7668, 35.1919, 44.3197, 47.9137
                ]
                index = pd.DatetimeIndex(start='2005',
                                         end='2010-Q4',
                                         freq='QS')
                ts_data = pd.Series(data, index)
                ts_data.index.name = 'datetime_index'
                ts_data.name = 'n_visitors'
                return ts_data
            elif trend:
                # no. of annual passengers of air carriers registered in Australia
                data = [
                    17.5534, 21.86, 23.8866, 26.9293, 26.8885, 28.8314,
                    30.0751, 30.9535, 30.1857, 31.5797, 32.5776, 33.4774,
                    39.0216, 41.3864, 41.5966
                ]
                index = pd.DatetimeIndex(start='1990', end='2005', freq='A')
                ts_data = pd.Series(data, index)
                ts_data.index.name = 'datetime_index'
                ts_data.name = 'n_passengers'
                return ts_data
            elif seasonality:
                pass
            else:
                # Oil production in Saudi Arabia
                data = [
                    446.6565, 454.4733, 455.663, 423.6322, 456.2713, 440.5881,
                    425.3325, 485.1494, 506.0482, 526.792, 514.2689, 494.211
                ]
                index = pd.DatetimeIndex(start='1996', end='2008', freq='A')
                ts_data = pd.Series(data, index)
                ts_data.index.name = 'datetime_index'
                ts_data.name = 'oil_production'
                return ts_data

        ts_data = import_data(trend=False, seasonality=False)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend=None,
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        ts_data = import_data(trend=True, seasonality=False)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=True,
                                            seasonal=None,
                                            seasonal_periods=None)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        ts_data = import_data(trend=True, seasonality=True)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal='add',
                                            seasonal_periods=4)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=True,
                                            seasonal='add',
                                            seasonal_periods=4)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal='mul',
                                            seasonal_periods=4)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal='mul',
                                            seasonal_periods=4)

        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj,
                                   'exponential_smoothing.pmml')

        self.assertEqual(os.path.isfile("exponential_smoothing.pmml"), True)
    def test_exponentialSmoothing_01(self):

        # data with trend and seasonality present

        # no of international visitors in Australia
        data = [
            41.7275, 24.0418, 32.3281, 37.3287, 46.2132, 29.3463, 36.4829,
            42.9777, 48.9015, 31.1802, 37.7179, 40.4202, 51.2069, 31.8872,
            40.9783, 43.7725, 55.5586, 33.8509, 42.0764, 45.6423, 59.7668,
            35.1919, 44.3197, 47.9137
        ]
        index = pd.DatetimeIndex(start='2005', end='2010-Q4', freq='QS')
        ts_data = pd.Series(data, index)
        ts_data.index.name = 'datetime_index'
        ts_data.name = 'n_visitors'

        f_name = 'exponential_smoothing.pmml'

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=True,
                                            seasonal='add',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal='add',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=True,
                                            seasonal='mul',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal='mul',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=True,
                                            seasonal='add',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=False,
                                            seasonal='add',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=True,
                                            seasonal='mul',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=False,
                                            seasonal='mul',
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)
    def test_exponentialSmoothing_02(self):

        # data with trend but no seasonality

        # no. of annual passengers of air carriers registered in Australia
        data = [
            17.5534, 21.86, 23.8866, 26.9293, 26.8885, 28.8314, 30.0751,
            30.9535, 30.1857, 31.5797, 32.5776, 33.4774, 39.0216, 41.3864,
            41.5966
        ]
        index = pd.DatetimeIndex(start='1990', end='2005', freq='A')
        ts_data = pd.Series(data, index)
        ts_data.index.name = 'datetime_index'
        ts_data.name = 'n_passengers'

        f_name = 'exponential_smoothing.pmml'

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=True,
                                            seasonal=None,
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=True,
                                            seasonal=None,
                                            seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='add',
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=True,
                                            seasonal=None,
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=True,
                                            seasonal=None,
                                            seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=2)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)

        model_obj = hw.ExponentialSmoothing(ts_data,
                                            trend='mul',
                                            damped=False,
                                            seasonal=None,
                                            seasonal_periods=None)
        results_obj = model_obj.fit(optimized=True)

        ExponentialSmoothingToPMML(ts_data, model_obj, results_obj, f_name)
        self.assertEqual(os.path.isfile(f_name), True)
        os.remove(f_name)