def test_se_no_fit(self): my_pwlf_0 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) try: my_pwlf_0.standard_errors() self.assertTrue(False) except AttributeError: self.assertTrue(True)
def test_break_point_diff_x0_2(self): # check if my duplicate is in a different location x0 = self.x_small.copy() my_fit4 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) x0[1] = 1.1 ssr4 = my_fit4.fit_with_breaks(x0) self.assertTrue(np.isclose(ssr4, 0.0))
def test_pv_no_fit(self): my_pwlf_0 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) try: my_pwlf_0.prediction_variance(self.x_small) self.assertTrue(False) except AttributeError: self.assertTrue(True)
def test_p(self): # check to see if it will let me calculate p-values my_pwlf = pwlf.PiecewiseLinFitTF(np.linspace(0, 100, num=100), np.linspace(0, 100, num=100)) my_pwlf.fitfast(2) my_pwlf.p_values() self.assertTrue(True)
def test_break_point_spot_on_r2(self): # test r squared value with known solution my_fit1 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) x0 = self.x_small.copy() my_fit1.fit_with_breaks(x0) rsq = my_fit1.r_squared() self.assertTrue(np.isclose(rsq, 1.0))
def test_r2_no_fit(self): my_pwlf_0 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) try: my_pwlf_0.r_squared() self.assertTrue(False) except AttributeError: self.assertTrue(True)
def test_se(self): # check to see if it will let me calculate standard errors my_pwlf = pwlf.PiecewiseLinFitTF(np.linspace(0, 100, num=100), np.linspace(0, 100, num=100)) my_pwlf.fitfast(2) my_pwlf.standard_errors() self.assertTrue(True)
def test_single_force_break_point2(self): my_fit = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) x_c = [2.0] y_c = [1.5] my_fit.fit_with_breaks_force_points([0.2, 1.0], x_c, y_c) yhat = my_fit.predict(x_c) self.assertTrue(np.isclose(y_c, yhat))
def test_predict(self): my_pwlf = pwlf.PiecewiseLinFitTF(self.xk, self.yk) my_pwlf.fit_with_breaks([0.5]) x = np.linspace(self.xk.min(), self.xk.max(), 10) yHat = my_pwlf.predict(x) e = np.sum(np.abs(yHat - self.yk)) self.assertTrue(np.isclose(e, 0.0))
def test_pvalue_no_fit(self): my_pwlf_0 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) try: my_pwlf_0.p_values() self.assertTrue(False) except AttributeError: self.assertTrue(True)
def test_fast_false(self): # check that I can fit when break points spot on a my_fit1 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small, fast=False) x0 = self.x_small.copy() ssr = my_fit1.fit_with_breaks(x0) self.assertTrue(np.isclose(ssr, 0.0))
def test_pv(self): # check to see if it will let me calculate prediction variance for # random data my_pwlf = pwlf.PiecewiseLinFitTF(np.linspace(0, 100, num=100), np.linspace(0, 100, num=100)) my_pwlf.fitfast(2) my_pwlf.prediction_variance(np.random.random(20)) self.assertTrue(True)
def test_custom_opt(self): my_pwlf = pwlf.PiecewiseLinFitTF(self.xk, self.yk) my_pwlf.use_custom_opt(3) x_guess = np.array((0.7, 0.9)) from scipy.optimize import minimize with tf.Session(): res = minimize(my_pwlf.fit_with_breaks_opt, x_guess) self.assertTrue(np.isclose(res['fun'], 0.0))
def test_single_precision(self): # check that I can fit when break points spot on a my_fit1 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small, dtype='float32') x0 = self.x_small.copy() ssr = my_fit1.fit_with_breaks(x0) self.assertTrue(np.isclose(ssr, 0.0))
def test_predict_with_custom_param(self): # check to see if predict runs with custom parameters x = np.random.random(20) my_pwlf = pwlf.PiecewiseLinFitTF(x, np.random.random(20)) my_pwlf.predict(x, beta=np.array((1e-4, 1e-2, 1e-3)), breaks=np.array((0.0, 0.5, 1.0))) self.assertTrue(True)
def test_break_point_diff_x0_0(self): # check diff loc my_fit2 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) x0 = self.x_small.copy() x0[1] = 1.00001 x0[2] = 1.50001 ssr2 = my_fit2.fit_with_breaks(x0) self.assertTrue(np.isclose(ssr2, 0.0))
def test_assembly_list(self): # check that I can fit when break points spot on a my_fit = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) x0 = self.x_small.copy() A = my_fit.assemble_regression_matrix(list(x0), my_fit.x_data) Asb = np.array([[1., 0., 0., 0.], [1., x0[1] - x0[0], 0., 0.], [1., x0[2] - x0[0], x0[2] - x0[1], 0.], [1., x0[3] - x0[0], x0[3] - x0[1], x0[3] - x0[2]]]) with tf.Session(): A = A.eval() self.assertTrue(np.allclose(A, Asb))
def test_opt_fit_with_force_points(self): # I need more data points to test this function because of # ill conditioning in the least squares problem... x = np.linspace(0.0, 1.0, num=100) y = np.sin(6.0 * x) my_fit = pwlf.PiecewiseLinFitTF(x, y, disp_res=True) np.random.seed(1231) x_c = [0.0] y_c = [0.0] my_fit.fit(3, x_c, y_c, popsize=2, maxiter=2, disp=False, polish=False) yhat = my_fit.predict(x_c) self.assertTrue(np.isclose(y_c, yhat))
def test_fit_guess_kwrds(self): my_pwlf = pwlf.PiecewiseLinFitTF(self.x, self.y) breaks = my_pwlf.fit_guess([6.0], m=10, factr=1e2, pgtol=1e-05, epsilon=1e-6, iprint=-1, maxfun=1500000, maxiter=150000, disp=None) self.assertTrue(np.isclose(breaks[1], 5.99819559))
def test_multi_start_fitfast(self): my_pwlf = pwlf.PiecewiseLinFitTF(self.xk, self.yk) my_pwlf.fitfast(2) self.assertTrue(np.isclose(my_pwlf.ssr, 0.0))
def test_diff_evo(self): my_pwlf = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) np.random.seed(12) my_pwlf.fit(3, atol=1e-6) self.assertTrue(np.isclose(my_pwlf.ssr, 0.0))
def test_fit_guess(self): # x = np.array([4., 5., 6., 7., 8.]) # y = np.array([11., 13., 16., 28.92, 42.81]) my_pwlf = pwlf.PiecewiseLinFitTF(self.x, self.y) breaks = my_pwlf.fit_guess([6.0]) self.assertTrue(np.isclose(breaks[1], 5.99819559))
def test_pv_list(self): my_fit1 = pwlf.PiecewiseLinFitTF(self.x_small, self.y_small) x0 = self.x_small.copy() _ = my_fit1.fit_with_breaks(x0) my_fit1.prediction_variance(list(self.x_small))
breaks = np.linspace(0.0, 10.0, num=21) n = np.logspace(3, 7, num=15, dtype=np.int) n_repeats = 10 run_times = np.zeros((3, n.size, n_repeats)) for i, n_data in enumerate(n): # set random seed np.random.seed(256) # generate sin wave data x = np.linspace(0, 10, num=n_data) y = np.sin(x * np.pi / 2) # add noise to the data y = np.random.normal(0, 0.05, size=n_data) + y for j in range(n_repeats): # normal PWLF fit t0 = time() my_pwlf = pwlf.PiecewiseLinFit(x, y) ssr = my_pwlf.fit_with_breaks(breaks) t1 = time() # PWLF TF fit t2 = time() my_pwlf = pwlf.PiecewiseLinFitTF(x, y) ssr = my_pwlf.fit_with_breaks(breaks) t3 = time() run_times[0, i, j] = t1 - t0 run_times[1, i, j] = t3 - t2 np.save('bench_run_times/20_break_times.npy', run_times) np.save('bench_run_times/n.npy', n)
7.03872000e-03, 1.85494500e-02, 3.00926700e-02, 4.17617000e-02, 5.37279600e-02, 6.54941000e-02, 7.68092100e-02, 8.76596300e-02, 9.80525800e-02, 1.07961810e-01, 1.17305210e-01, 1.26063930e-01, 1.34180360e-01, 1.41725010e-01, 1.48629710e-01, 1.55374770e-01, 0.00000000e+00, 1.65610200e-02, 3.91016100e-02, 6.18679400e-02, 8.30997400e-02, 1.02132890e-01, 1.19011260e-01, 1.34620080e-01, 1.49429370e-01, 1.63539960e-01, -0.00000000e+00, 1.01980300e-02, 3.28642800e-02, 5.59461900e-02, 7.81388400e-02, 9.84458400e-02, 1.16270210e-01, 1.31279040e-01, 1.45437090e-01, 1.59627540e-01, 0.00000000e+00, 1.63404300e-02, 4.00086000e-02, 6.34390200e-02, 8.51085900e-02, 1.04787860e-01, 1.22120350e-01, 1.36931660e-01, 1.50958760e-01, 1.65299640e-01, 1.79942720e-01 ]) # initialize piecewise linear fit with your x and y data my_pwlf = pwlf.PiecewiseLinFitTF(x, y, disp_res=True) # fit the function with four line segments # force the function to go through the data points # (0.0, 0.0) and (0.19, 0.16) # where the data points are of the form (x, y) x_c = [0.0, 0.19] y_c = [0.0, 0.2] breaks = [0.00711605, 0.12014667, 0.1799223] L = my_pwlf.fit_with_breaks_force_points(breaks, x_c, y_c) # predict for the determined points xHat = np.linspace(min(x), 0.19, num=10000) yHat = my_pwlf.predict(xHat) # plot the results