def get_composite_chain(composite_flag: bool = True) -> Chain:
node_first = PrimaryNode('cnn')
node_first.custom_params = {
'image_shape': (28, 28, 1),
'architecture': 'deep',
'num_classes': 10,
'epochs': 15,
'batch_size': 128
}
node_second = PrimaryNode('cnn')
node_second.custom_params = {
'image_shape': (28, 28, 1),
'architecture_type': 'simplified',
'num_classes': 10,
'epochs': 10,
'batch_size': 128
}
node_final = SecondaryNode('rf', nodes_from=[node_first, node_second])
if not composite_flag:
node_final = SecondaryNode('rf', nodes_from=[node_first])
chain = Chain(node_final)
return chain
def create_chain() -> Chain:
node_logit = PrimaryNode('logit')
node_lda = PrimaryNode('lda')
node_lda.custom_params = {'n_components': 1}
node_xgboost = PrimaryNode('xgboost')
node_knn = PrimaryNode('knn')
node_knn.custom_params = {'n_neighbors': 9}
node_knn_second = SecondaryNode('knn')
node_knn_second.custom_params = {'n_neighbors': 5}
node_knn_second.nodes_from = [node_lda, node_knn]
node_logit_second = SecondaryNode('logit')
node_logit_second.nodes_from = [node_xgboost, node_lda]
node_lda_second = SecondaryNode('lda')
node_lda_second.custom_params = {'n_components': 1}
node_lda_second.nodes_from = [
node_logit_second, node_knn_second, node_logit
]
node_xgboost_second = SecondaryNode('xgboost')
node_xgboost_second.nodes_from = [node_logit, node_logit_second, node_knn]
node_knn_third = SecondaryNode('knn')
node_knn_third.custom_params = {'n_neighbors': 8}
node_knn_third.nodes_from = [node_lda_second, node_xgboost_second]
chain = Chain(node_knn_third)
return chain
def get_chain():
node_lagged_1 = PrimaryNode('lagged')
node_lagged_1.custom_params = {'window_size': 120}
node_lagged_2 = PrimaryNode('lagged')
node_lagged_2.custom_params = {'window_size': 10}
node_first = SecondaryNode('ridge', nodes_from=[node_lagged_1])
node_second = SecondaryNode('dtreg', nodes_from=[node_lagged_2])
node_final = SecondaryNode('ridge', nodes_from=[node_first, node_second])
chain = Chain(node_final)
return chain
def get_simple_chain():
""" Function returns simple chain """
node_lagged = PrimaryNode('lagged')
node_lagged.custom_params = {'window_size': 150}
node_ridge = SecondaryNode('ridge', nodes_from=[node_lagged])
ridge_chain = Chain(node_ridge)
return ridge_chain
def test_forecast_with_exog():
train_source_ts, predict_source_ts, train_exog_ts, predict_exog_ts, ts_test = synthetic_with_exogenous_ts(
)
# Source data for lagged node
node_lagged = PrimaryNode('lagged',
node_data={
'fit': train_source_ts,
'predict': predict_source_ts
})
# Set window size for lagged transformation
node_lagged.custom_params = {'window_size': window_size}
# Exogenous variable for exog node
node_exog = PrimaryNode('exog',
node_data={
'fit': train_exog_ts,
'predict': predict_exog_ts
})
node_final = SecondaryNode('linear', nodes_from=[node_lagged, node_exog])
chain = Chain(node_final)
chain.fit()
forecast = chain.predict()
prediction = np.ravel(np.array(forecast.predict))
assert tuple(prediction) == tuple(ts_test)
def get_ts_chain(window_size):
""" Function return chain with lagged transformation in it """
node_lagged = PrimaryNode('lagged')
node_lagged.custom_params = {'window_size': window_size}
node_final = SecondaryNode('ridge', nodes_from=[node_lagged])
chain = Chain(node_final)
return chain
def get_simple_ts_chain(model_root: str = 'ridge', window_size: int = 20):
node_lagged = PrimaryNode('lagged')
node_lagged.custom_params = {'window_size': window_size}
node_root = SecondaryNode(model_root, nodes_from=[node_lagged])
chain = Chain(node_root)
return chain
def get_composite_chain():
"""
The function returns prepared chain of 5 models
:return: Chain object
"""
node_1 = PrimaryNode('lagged')
node_1.custom_params = {'window_size': 150}
node_2 = PrimaryNode('lagged')
node_2.custom_params = {'window_size': 100}
node_linear_1 = SecondaryNode('linear', nodes_from=[node_1])
node_linear_2 = SecondaryNode('linear', nodes_from=[node_2])
node_final = SecondaryNode('ridge',
nodes_from=[node_linear_1, node_linear_2])
chain = Chain(node_final)
return chain
def get_composite_chain():
""" Function return complex chain with the following structure
lagged -> ridge \
ridge
lagged -> treg |
"""
chain = Chain()
node_lagged_1 = PrimaryNode('lagged')
node_lagged_1.custom_params = {'window_size': 110}
node_ridge = SecondaryNode('ridge', nodes_from=[node_lagged_1])
node_lagged_2 = PrimaryNode('lagged')
node_lagged_2.custom_params = {'window_size': 20}
node_treg = SecondaryNode('treg', nodes_from=[node_lagged_2])
node_final = SecondaryNode('ridge', nodes_from=[node_treg, node_ridge])
chain.add_node(node_final)
return chain
def get_simple_short_lagged_chain():
# Create simple chain for forecasting
node_lagged = PrimaryNode('lagged')
# Use 4 elements in time series as predictors
node_lagged.custom_params = {'window_size': 4}
node_final = SecondaryNode('linear', nodes_from=[node_lagged])
chain = Chain(node_final)
return chain
def get_multiscale_chain():
# First branch
node_lagged_1 = PrimaryNode('lagged')
node_lagged_1.custom_params = {'window_size': 20}
node_ridge_1 = SecondaryNode('ridge', nodes_from=[node_lagged_1])
# Second branch, which will try to make prediction based on smoothed ts
node_filtering = PrimaryNode('gaussian_filter')
node_filtering.custom_params = {'sigma': 3}
node_lagged_2 = SecondaryNode('lagged', nodes_from=[node_filtering])
node_lagged_2.custom_params = {'window_size': 100}
node_ridge_2 = SecondaryNode('ridge', nodes_from=[node_lagged_2])
node_final = SecondaryNode('linear', nodes_from=[node_ridge_1, node_ridge_2])
chain = Chain(node_final)
return chain
def create_chain() -> Chain:
chain = Chain()
node_logit = PrimaryNode('logit')
node_lda = PrimaryNode('lda')
node_lda.custom_params = {'n_components': 1}
node_xgboost = SecondaryNode('xgboost')
node_xgboost.custom_params = {'n_components': 1}
node_xgboost.nodes_from = [node_logit, node_lda]
chain.add_node(node_xgboost)
return chain
def run_gapfilling_example():
"""
This function runs an example of filling in gaps in synthetic data
:return arrays_dict: dictionary with 4 keys ('ridge', 'local_poly',
'batch_poly', 'linear') that can be used to get arrays without gaps
:return gap_data: an array with gaps
:return real_data: an array with actual values in gaps
"""
# Get synthetic time series
gap_data, real_data = get_array_with_gaps()
# Filling in gaps using chain from FEDOT
node_lagged = PrimaryNode('lagged')
node_lagged.custom_params = {'window_size': 100}
node_ridge = SecondaryNode('ridge', nodes_from=[node_lagged])
ridge_chain = Chain(node_ridge)
ridge_gapfiller = ModelGapFiller(gap_value=-100.0, chain=ridge_chain)
without_gap_arr_ridge = \
ridge_gapfiller.forward_inverse_filling(gap_data)
# Filling in gaps using simple methods such as polynomial approximation
simple_gapfill = SimpleGapFiller(gap_value=-100.0)
without_gap_local_poly = \
simple_gapfill.local_poly_approximation(gap_data, 4, 150)
without_gap_batch_poly = \
simple_gapfill.batch_poly_approximation(gap_data, 4, 150)
without_gap_linear = \
simple_gapfill.linear_interpolation(gap_data)
arrays_dict = {
'ridge': without_gap_arr_ridge,
'local_poly': without_gap_local_poly,
'batch_poly': without_gap_batch_poly,
'linear': without_gap_linear
}
return arrays_dict, gap_data, real_data
def get_statsmodels_chain():
node_ar = PrimaryNode('ar')
node_ar.custom_params = {'lag_1': 20, 'lag_2': 100}
chain = Chain(node_ar)
return chain
