Example #1
0
def test2_bbvi_mini_batch_elbo():
    """
    Tests that the ELBO increases
    """
    model = pf.GASX(formula="y ~ x1 + x2", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("BBVI", iterations=500, mini_batch=32, record_elbo=True, map_start=False)
    assert x.elbo_records[-1] > x.elbo_records[0]
Example #2
0
def test2_normal_predict_is_length():
    """
    Tests that the length of the predict IS dataframe is equal to no of steps h
    """
    model = pf.GASReg(formula="y ~ x1 + x2", data=data, family=pf.t())
    x = model.fit()
    assert(model.predict_is(h=5).shape[0] == 5)
Example #3
0
def test_t_predict_is_length():
    """
    Tests that the prediction IS dataframe length is equal to the number of steps h
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit()
    assert(model.predict_is(h=5).shape[0] == 5)
Example #4
0
def test_t_bbvi_mini_batch_elbo():
    """
    Tests that the ELBO increases
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('BBVI',iterations=100, mini_batch=32, record_elbo=True, map_start=False)
    assert(x.elbo_records[-1]>x.elbo_records[0])
Example #5
0
def test_t_bbvi_elbo():
    """
    Tests that the ELBO increases
    """
    model = pf.GAS(data=data, ar=1, sc=1, family=pf.t())
    x = model.fit('BBVI',iterations=100, record_elbo=True)
    assert(x.elbo_records[-1]>x.elbo_records[0])
Example #6
0
def test_normal_bbvi_mini_batch_elbo():
    """
    Tests that the ELBO increases
    """
    model = pf.GASReg(formula="y ~ x1 + x2", data=data, family=pf.t())
    x = model.fit('BBVI',iterations=100, mini_batch=32, record_elbo=True)
    assert(x.elbo_records[-1]>x.elbo_records[0])
Example #7
0
def test2_ppc():
    """
    Tests PPC value
    """
    model = pf.GASReg(formula="y ~ x1  + x2", data=data, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    p_value = model.ppc()
    assert(0.0 <= p_value <= 1.0)
Example #8
0
def test2_normal_predict_is_nans():
    """
    Tests that the predictions in-sample are not NaNs
    """
    model = pf.GASReg(formula="y ~ x1 + x2", data=data, family=pf.t())
    x = model.fit()
    x.summary()
    assert(len(model.predict_is(h=5).values[np.isnan(model.predict_is(h=5).values)]) == 0)
Example #9
0
def test_normal_predict_length():
    """
    Tests that the length of the predict dataframe is equal to no of steps h
    """
    model = pf.GASReg(formula="y ~ x1", data=data, family=pf.t())
    x = model.fit()
    x.summary()
    assert(model.predict(h=5, oos_data=data_oos).shape[0] == 5)
Example #10
0
def test2_ppc():
    """
    Tests PPC value
    """
    model = pf.GASX(formula="y ~ x1 + x2", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("BBVI", iterations=100)
    p_value = model.ppc()
    assert 0.0 <= p_value <= 1.0
Example #11
0
def test_t_predict_nans():
	"""
	Tests that the predictions are not nans
	"""
	model = pf.GAS(data=data, ar=2, sc=2, family=pf.t())
	x = model.fit()
	x.summary()
	assert(len(model.predict(h=5).values[np.isnan(model.predict(h=5).values)]) == 0)
Example #12
0
def test_t_predict_length():
	"""
	Tests that the prediction dataframe length is equal to the number of steps h
	"""
	model = pf.GAS(data=data, ar=2, sc=2, family=pf.t())
	x = model.fit()
	x.summary()
	assert(model.predict(h=5).shape[0] == 5)
Example #13
0
def test_t_ppc():
    """
    Tests PPC value
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    p_value = model.ppc()
    assert(0.0 <= p_value <= 1.0)
Example #14
0
def test_t_predict_is_nans():
    """
    Tests that the in-sample predictions are not nans
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit()
    x.summary()
    assert(len(model.predict_is(h=5).values[np.isnan(model.predict_is(h=5).values)]) == 0)
Example #15
0
def test_normal_predict_nans():
    """
    Tests that the predictions are not NaNs
    """
    model = pf.GASReg(formula="y ~ x1", data=data, family=pf.t())
    x = model.fit()
    x.summary()
    assert(len(model.predict(h=5, oos_data=data_oos).values[np.isnan(model.predict(h=5, 
        oos_data=data_oos).values)]) == 0)
Example #16
0
def test2_sample_model():
    """
    Tests sampling function
    """
    model = pf.GASReg(formula="y ~ x1 + x2", data=data, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    sample = model.sample(nsims=100)
    assert(sample.shape[0]==100)
    assert(sample.shape[1]==len(data))
Example #17
0
def test_predict_nonconstant():
    """
    We should not really have predictions that are constant (should be some difference)...
    This captures bugs with the predict function not iterating forward
    """
    model = pf.GASX(formula="y ~ x1", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit()
    predictions = model.predict(h=10, oos_data=data_oos, intervals=False)
    assert not np.all(predictions.values == predictions.values[0])
Example #18
0
def test_t_sample_model():
    """
    Tests sampling function
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    sample = model.sample(nsims=100)
    assert(sample.shape[0]==100)
    assert(sample.shape[1]==len(data)-1)
Example #19
0
def test2_sample_model():
    """
    Tests sampling function
    """
    model = pf.GASX(formula="y ~ x1 + x2", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("BBVI", iterations=100)
    sample = model.sample(nsims=100)
    assert sample.shape[0] == 100
    assert sample.shape[1] == len(data) - 1
Example #20
0
def test_t_predict_is_intervals_mh():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('M-H', nsims=400)
    predictions = model.predict_is(h=10, intervals=True)
    assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
    assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
    assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
Example #21
0
def test_t_mh():
    """
    Tests an GAS model estimated with Metropolis-Hastings and that the length of the 
    latent variable list is correct, and that the estimated latent variables are not nan
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('M-H',nsims=300)
    assert(len(model.latent_variables.z_list) == 3)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert(len(lvs[np.isnan(lvs)]) == 0)
Example #22
0
def test_t_pml():
    """
    Tests a PML model estimated with Laplace approximation and that the length of the 
    latent variable list is correct, and that the estimated latent variables are not nan
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('PML')
    assert(len(model.latent_variables.z_list) == 3)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert(len(lvs[np.isnan(lvs)]) == 0)
Example #23
0
def test_normal_pml():
    """
    Tests an GASReg model estimated with PML, and tests that the latent variable
    vector length is correct, and that value are not nan
    """
    model = pf.GASReg(formula="y ~ x1", data=data, family=pf.t())
    x = model.fit('PML')
    assert(len(model.latent_variables.z_list) == 4)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert(len(lvs[np.isnan(lvs)]) == 0)
Example #24
0
def test_t_bbvi_mini_batch():
    """
    Tests an ARIMA model estimated with BBVI and that the length of the latent variable
    list is correct, and that the estimated latent variables are not nan
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('BBVI',iterations=100, mini_batch=32)
    assert(len(model.latent_variables.z_list) == 3)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert(len(lvs[np.isnan(lvs)]) == 0)
Example #25
0
def test_t_predict_is_intervals_bbvi():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASLLT(data=data, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    predictions = model.predict_is(h=10, intervals=True)
    assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
    assert(np.all(predictions['95% Prediction Interval'].values > predictions['5% Prediction Interval'].values))
    assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
Example #26
0
def test2_pml():
    """
    Tests an GASX model estimated with PML, with multiple predictors, and 
    tests that the latent variable vector length is correct, and that value are not nan
    """
    model = pf.GASX(formula="y ~ x1 + x2", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("PML")
    assert len(model.latent_variables.z_list) == 7
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert len(lvs[np.isnan(lvs)]) == 0
Example #27
0
def test_mh():
    """
    Tests an GASX model estimated with Metropolis-Hastings, and tests that the latent variable
    vector length is correct, and that value are not nan
    """
    model = pf.GASX(formula="y ~ x1", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("M-H", nsims=300)
    assert len(model.latent_variables.z_list) == 6
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert len(lvs[np.isnan(lvs)]) == 0
Example #28
0
def test_bbvi():
    """
    Tests an GASX model estimated with BBVI, and tests that the latent variable
    vector length is correct, and that value are not nan
    """
    model = pf.GASX(formula="y ~ x1", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("BBVI", iterations=100)
    assert len(model.latent_variables.z_list) == 6
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert len(lvs[np.isnan(lvs)]) == 0
Example #29
0
def test_t_couple_terms():
    """
    Tests latent variable list length is correct, and that the estimated
    latent variables are not nan
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit()
    assert(len(model.latent_variables.z_list) == 3)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert(len(lvs[np.isnan(lvs)]) == 0)
Example #30
0
def test2_bbvi_mini_batch():
    """
    Tests an GASX model estimated with BBVI and that the length of the latent variable
    list is correct, and that the estimated latent variables are not nan
    """
    model = pf.GASX(formula="y ~ x1 + x2", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit("BBVI", iterations=500, mini_batch=32)
    assert len(model.latent_variables.z_list) == 7
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert len(lvs[np.isnan(lvs)]) == 0
Example #31
0
def test_predict_is_intervals_mh():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.ARIMAX(formula="y ~ x1", data=data, ar=2, ma=2, family=pf.t())
    x = model.fit('M-H', nsims=400)
    predictions = model.predict_is(h=10, intervals=True)
    assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
    assert(np.all(predictions['95% Prediction Interval'].values > predictions[model.data_name].values))
    assert(np.all(predictions[model.data_name].values > predictions['5% Prediction Interval'].values))
    assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
Example #32
0
def test_t_bbvi_mini_batch_elbo():
    """
    Tests that the ELBO increases
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('BBVI',
                  iterations=100,
                  mini_batch=32,
                  record_elbo=True,
                  map_start=False)
    assert (x.elbo_records[-1] > x.elbo_records[0])
Example #33
0
def test_t_couple_terms_integ():
    """
    Tests an GAS model with 1 AR and 1 MA term, integrated once, and that
    the latent variable list length is correct, and that the estimated
    latent variables are not nan
    """
    model = pf.GASLLEV(data=data, integ=1, family=pf.t())
    x = model.fit()
    assert (len(model.latent_variables.z_list) == 3)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
def test2_bbvi_elbo():
    """
    Tests that the ELBO increases
    """
    model = pf.GASX(formula="y ~ x1 + x2",
                    data=data,
                    ar=1,
                    sc=1,
                    family=pf.t())
    x = model.fit('BBVI', iterations=500, record_elbo=True, map_start=False)
    assert (x.elbo_records[-1] > x.elbo_records[0])
Example #35
0
def test_no_terms():
    """
    Tests an ARIMA model with no AR or MA terms, and that
    the latent variable list length is correct, and that the estimated
    latent variables are not nan
    """
    model = pf.ARIMA(data=data, ar=0, ma=0, family=pf.t())
    x = model.fit()
    assert (len(model.latent_variables.z_list) == 3)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
def test_t_couple_terms():
    """
	Tests an GAS model with 1 AR and 1 SC term and that
	the latent variable list length is correct, and that the estimated
	latent variables are not nan
	"""
    model = pf.GAS(data=data, ar=1, sc=1, family=pf.t())
    x = model.fit()
    assert (len(model.latent_variables.z_list) == 5)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
Example #37
0
def test2_normal_no_terms():
    """
    Tests the length of the latent variable vector for an GASReg model
    with no AR or MA terms, and two predictors, and tests that the values 
    are not nan
    """
    model = pf.GASReg(formula="y ~ x1 + x2", data=data, family=pf.t())
    x = model.fit()
    assert (len(model.latent_variables.z_list) == 5)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
def test2_ppc():
    """
    Tests PPC value
    """
    model = pf.GASX(formula="y ~ x1 + x2",
                    data=data,
                    ar=1,
                    sc=1,
                    family=pf.t())
    x = model.fit('BBVI', iterations=100)
    p_value = model.ppc()
    assert (0.0 <= p_value <= 1.0)
Example #39
0
def test2_predict_intervals_bbvi():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.ARIMAX(formula="y ~ x1 + x2", data=data, ar=2, ma=2, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    predictions = model.predict(h=10, oos_data=data_oos, intervals=True)

    assert(np.all(predictions['99% Prediction Interval'].values > predictions['95% Prediction Interval'].values))
    assert(np.all(predictions['95% Prediction Interval'].values > predictions[model.data_name].values))
    assert(np.all(predictions[model.data_name].values > predictions['5% Prediction Interval'].values))
    assert(np.all(predictions['5% Prediction Interval'].values > predictions['1% Prediction Interval'].values))
def test_t_predict_is_intervals():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GAS(data=data, ar=1, sc=1, family=pf.t())
    x = model.fit()
    predictions = model.predict_is(h=10, intervals=True)
    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
def test2_sample_model():
    """
    Tests sampling function
    """
    model = pf.GASX(formula="y ~ x1 + x2",
                    data=data,
                    ar=1,
                    sc=1,
                    family=pf.t())
    x = model.fit('BBVI', iterations=100)
    sample = model.sample(nsims=100)
    assert (sample.shape[0] == 100)
    assert (sample.shape[1] == len(data) - 1)
Example #42
0
def test_t_predict_is_intervals_mh():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASLLEV(data=data, family=pf.t())
    x = model.fit('M-H', nsims=400)
    predictions = model.predict_is(h=10, intervals=True)
    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
Example #43
0
def test2_predict_is_intervals():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASReg(formula="y ~ x1  + x2", data=data, family=pf.t())
    x = model.fit()
    predictions = model.predict_is(h=10, intervals=True)
    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
Example #44
0
def test_t_predict_is_intervals_bbvi():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASLLT(data=data, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    predictions = model.predict_is(h=10, intervals=True)
    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
def test2_bbvi_mini_batch():
    """
    Tests an GASX model estimated with BBVI and that the length of the latent variable
    list is correct, and that the estimated latent variables are not nan
    """
    model = pf.GASX(formula="y ~ x1 + x2",
                    data=data,
                    ar=1,
                    sc=1,
                    family=pf.t())
    x = model.fit('BBVI', iterations=500, mini_batch=32)
    assert (len(model.latent_variables.z_list) == 7)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
def test_t_bbvi():
    """
    Tests latent variable list length is correct, and that the estimated
    latent variables are not nan
    """
    model = pf.GASRank(data=data,
                       team_1="HomeTeam",
                       team_2="AwayTeam",
                       score_diff="PointsDiff",
                       family=pf.t())
    x = model.fit('BBVI', iterations=100)
    assert (len(model.latent_variables.z_list) == 4)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
def test2_pml():
    """
    Tests an GASX model estimated with PML, with multiple predictors, and 
    tests that the latent variable vector length is correct, and that value are not nan
    """
    model = pf.GASX(formula="y ~ x1 + x2",
                    data=data,
                    ar=1,
                    sc=1,
                    family=pf.t())
    x = model.fit('PML')
    assert (len(model.latent_variables.z_list) == 7)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
def test_predict_is_intervals_bbvi():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASX(formula="y ~ x1", data=data, ar=1, sc=1, family=pf.t())
    x = model.fit('BBVI', iterations=100)
    predictions = model.predict_is(h=10, intervals=True)
    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values > predictions[
        model.data_name].values))
    assert (np.all(predictions[model.data_name].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
Example #49
0
def test_predict_is_intervals():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.ARIMA(data=data, ar=2, ma=2, family=pf.t())
    x = model.fit()
    predictions = model.predict_is(h=10, intervals=True)
    print(predictions)
    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values > predictions[
        model.data_name].values))
    assert (np.all(predictions[model.data_name].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
def test2_predict_intervals_mh():
    """
    Tests prediction intervals are ordered correctly
    """
    model = pf.GASX(formula="y ~ x1 + x2",
                    data=data,
                    ar=1,
                    sc=1,
                    family=pf.t())
    x = model.fit('M-H', nsims=400)
    predictions = model.predict(h=10, oos_data=data_oos, intervals=True)

    assert (np.all(predictions['99% Prediction Interval'].values >
                   predictions['95% Prediction Interval'].values))
    assert (np.all(predictions['95% Prediction Interval'].values > predictions[
        model.data_name].values))
    assert (np.all(predictions[model.data_name].values >
                   predictions['5% Prediction Interval'].values))
    assert (np.all(predictions['5% Prediction Interval'].values >
                   predictions['1% Prediction Interval'].values))
def test_t_mle_two_components():
    """
    Tests latent variable list length is correct, and that the estimated
    latent variables are not nan
    """
    model = pf.GASRank(data=data.iloc[0:300, :],
                       team_1="HomeTeam",
                       team_2="AwayTeam",
                       score_diff="PointsDiff",
                       family=pf.t())
    model.add_second_component("HQB", "AQB")
    x = model.fit('BBVI', iterations=50, map_start=False)
    assert (len(model.latent_variables.z_list) == 5)
    lvs = np.array([i.value for i in model.latent_variables.z_list])
    assert (len(lvs[np.isnan(lvs)]) == 0)
    prediction = model.predict("Denver Broncos",
                               "Carolina Panthers",
                               "Peyton Manning",
                               "Cam Newton",
                               neutral=True)
    assert (len(prediction[np.isnan(prediction)]) == 0)
x2 = np.random.normal(0, 1, 300)
data2 = pd.DataFrame([countdata, x1, x2]).T
data2.columns = ['y', 'x1', 'x2']

y_oos = np.random.normal(0, 1, 30)
x1_oos = np.random.normal(0, 1, 30)
x2_oos = np.random.normal(0, 1, 30)
countdata_oos = np.random.poisson(3, 30)

data_oos = pd.DataFrame([y_oos, x1_oos, x2_oos]).T
data_oos.columns = ['y', 'x1', 'x2']

data2_oos = pd.DataFrame([countdata_oos, x1_oos, x2_oos]).T
data2_oos.columns = ['y', 'x1', 'x2']

model_1 = pf.GASX(formula="y ~ x1", data=data, ar=0, sc=0, family=pf.t())
x_1 = model_1.fit()

model_2 = pf.GASX(formula="y ~ x1", data=data, ar=1, sc=1, family=pf.t())
x_2 = model_2.fit()

model_3 = pf.GASX(formula="y ~ x1",
                  data=data,
                  ar=1,
                  sc=1,
                  integ=1,
                  family=pf.t())
x_3 = model_3.fit()

model_4 = pf.GASX(formula="y ~ x1", data=data, ar=2, sc=2, family=pf.t())
x_4 = model_4.fit()