Metadata-Version: 2.1
Name: nbeats-forecast
Version: 1.3.7
Summary: This library uses nbeats-pytorch as base and simplifies the task of univariate time series forecasting using N-BEATS by providing a interface similar to scikit-learn and keras.
Home-page: https://github.com/amitesh863/nbeats_forecast
Author: Amitesh Sharma
Author-email: amitesh863@gmail.com
License: MIT
Download-URL: https://github.com/amitesh863/nbeats_forecast/archive/1.3.7.tar.gz
Description: # nbeats_forecast
        
        ##### Neural Beats implementation library
        
        nbeats_forecast is an end to end library for univariate time series forecasting using N-BEATS (https://arxiv.org/pdf/1905.10437v3.pdf - Published as conference paper in ICLR).
        This library uses nbeats-pytorch (https://github.com/philipperemy/n-beats) as base and simplifies the task of forecasting using N-BEATS by providing a interface similar to scikit-learn and keras.
        
        
        ### Required: Python >=3.6
        
        ### Installation
        
        ```sh
        $ pip install nbeats_forecast
        ```
        
        #### Import
        ```sh
        from nbeats_forecast import NBeats
        ```
        
        #### Input
        numpy array of size nx1 
        
        #### Output
        Forecasted values as numpy array of size mx1 
        
        Mandatory Parameters for the model:
        - data
        - period_to_forecast
        
        Basic model with only mandatory parameters can be used to get forecasted values as shown below:
        ```sh
        import pandas as pd
        from nbeats_forecast import NBeats
        
        data = pd.read_csv('data.csv')   
        data = data.values        #univariate time series data of shape nx1 (numpy array)
        
        model = NBeats(data=data, period_to_forecast=12)
        model.fit()
        forecast = model.predict()
        ```
        
        Other optional parameters for the object of the model  (as described in the paper) can be tweaked for better performance. If these parameters are not passed, default values as mentioned in the table below are considered.
        
        #### Optional parameters
        | Parameter | Type | Default Value| Description|
        | ------ | ------ | --------------|------------|
        | backcast_length | integer | 3* period_to_forecast |Explained in the paper|
        | path | string | '  ' |path to save intermediate training checkpoint |
        | checkpoint_file_name | string | 'nbeats-training-checkpoint.th'| name for checkpoint file ending in format  .th |
        |mode| string| 'cpu'| Any of the torch.device modes|
        | batch_size | integer | len(data)/15 | size of batch|
        |  thetas_dims | list of integers | [7, 8] | Explained in the paper|
        | nb_blocks_per_stack | integer | 3| Explained in the paper|
        | share_weights_in_stack | boolean | False | Explained in the paper|
        | train_percent | float(below 1)  | 0.8 | Percentage of data to be used for training |
        | save_checkpoint| boolean | False | save intermediate checkpoint files|
        | hidden_layer_units | integer | 128 | hissen layer units|
        | stack | list of integers | [1,1] | adding stacks in the model as per the paper passed in list as integer. Mapping is as follows -- 1: GENERIC_BLOCK,  2: TREND_BLOCK , 3: SEASONALITY_BLOCK|
        
        
        #### Methods
        
        #### fit(epoch,optimiser,plot,verbose):
        This method is used to train the model for number of gradient steps passed in the object of the model.
        
        ###### Parameter - epoch : integer
        
        epoch is 100 * gradient steps. 25 epoch means 2500 weight updation steps.
        If optimizer is not passed, default value is 25.
        
        ###### Parameter - optimiser
        
        optimizer from torch.optim can be passed as a parameter by including model.parameters as the variable.
        
        Example: 
        
        model.fit(epoch=5,optimiser=torch.optim.AdamW(model.parameters, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False))
        
        If optimizer is not passed, default optimizer used is Adam.
        
        ###### Parameter- plot : boolean
        Default value - False
        
        If True, plots during training are shown.
        
        ###### Parameter- verbose : boolean
        
        Default value - True
        
        If True, training details are printed.
        
        #### predict(predict_data):
        
        ###### Parameter - predict_data (optional) : numpy array of size backcast_length x 1
        
        If predict_data is not passed, forecasted values returned will be continued from the last value of data passed in fit() during training.
        
        
        ### UPDATE:
        ##### Added functionality:
        ##### Predicting for other data
        
        Passing predict_data:
        
        To get predictions for the some other data from trained model, pass the predict_data as a numpy array of shape backcast_length x 1 (default value for backcast length is 3* preiod_to_forecast).
        
        #### Example:
        You have trained a model for temperature forecast with hourly temperature data, period_to_forecast=4 and backcast_length=16 for Timestamp "13-12-2019 08:00:00" to "31-12-2019 08:00:00". 
        
        Now you want to predict temperature from Timestamp "14-01-2020 17:00:00" using the trained model. You need to pass past data as predict_data with window equal to backcast_length(16 here). Here you need to pass values from "14-01-2020 01:00:00" to "14-01-2020 16:00:00"(16 values here) as numpy array of shape backcast_length x 1 (Here 16 x 1).
        
        
         
        Returns forecasted values.
        
        #### save(file):
        Saves the current step model after training. File needs to be passed a string. Format of the model to be saved is .th
        
        Example: model.save('model.th')
        
        #### load(file,optimizer):
        ###### Parameter - file
        Load the saved model with format .th 
        
        ###### Parameter - optimiser
        
        optimizer from torch.optim can be passed as a parameter by including model.parameters as the variable.
        
        Example: model.load('model.th')
        
        ## EXAMPLES BELOW
        1. Model with a different optimiser and different stack is shown here.
        2. Predicting for other data
        3. Continue training via the saved file or retrain with new data(load saved model and retrain)
        4. Load saved model and predict with data
        
        
        ### Example 1
        Model with a different optimiser and different stack is shown here.
        
        Here  2: TREND_BLOCK and 3: SEASONALITY_BLOCK stacks are used.
        ```sh
        import pandas as pd
        from nbeats_forecast import NBeats
        from torch import optim
        
        data = pd.read_csv('data.csv')   
        data = data.values #univariate time series data of shape nx1(numpy array)
        
        model=NBeats(data=data,period_to_forecast=12,stack=[2,3],nb_blocks_per_stack=3,thetas_dims=[2,8])
        
        model.fit(epoch=5,optimiser=optim.AdamW(model.parameters, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False))
        
        forecast=model.predict()
        ```
        
        
        ### Example 2
        Predicting for other data with backcast_length=12.
        
        ```sh
        import pandas as pd
        from nbeats_forecast import NBeats
        from torch import optim
        
        data = pd.read_csv('new_data.csv')   
        data = data.values #univariate time series data of shape nx1(numpy array)
        
        model=NBeats(data=data,period_to_forecast=12,stack=[2,3],nb_blocks_per_stack=3,thetas_dims=[2,8]) 
        
        model.fit()
        
        list1=[36.7,38.5,39.4,36.75,38,39,38,37.45,38,39,39.5,40]
        pred=np.asarray(list1)
        
        forecast=model.predict(predict_data=pred)
        ```
        
        ### Example 3
        Continue training via the saved file or retrain with new data
        
        ```sh
        import pandas as pd
        from nbeats_forecast import NBeats
        from torch import optim
        
        new_datdata = pd.read_csv('new_data.csv')   
        data = data.values #univariate time series data of shape nx1(numpy array)
        
        model=NBeats(data=data,period_to_forecast=12,stack=[2,3],nb_blocks_per_stack=3,thetas_dims=[2,8]) 
        # use same model definition as saved model
        model.load('nbeats.th',optimiser=optim.AdamW(model.parameters, lr=0.001, betas=(0.9, 0.999), eps=1e-08, weight_decay=0.01, amsgrad=False))
        )
        model.fit()
        
        
        forecast=model.predict()
        ```
        
        ### Example 4
        Load saved model and predict with data
        
        ```sh
        from nbeats_forecast import NBeats
        import numpy as np
        
        # use same model definition as saved model
        model=NBeats(period_to_forecast=4,stack=[2,3],nb_blocks_per_stack=3,thetas_dims=[2,8]) 
        
        model.load(file='nbeats.th')
        
        list1=[36.7,38.5,39.4,36.75,38,39,38,37.45,38,39,39.5,40]
        pred=np.asarray(list1)
        forecast=model.predict(pred)
        
        ```
        
Keywords: nbeats,timeseries,forecast,nueral beats,univariate timeseries forecast ,timeseries forecast,univariate timeseries forecast
Platform: UNKNOWN
Classifier: Development Status :: 5 - Production/Stable
Classifier: Topic :: Software Development :: Build Tools
Classifier: License :: OSI Approved :: MIT License
Requires-Python: >=3.6, <4
Description-Content-Type: text/markdown
