def testHatMatrix(self):
expectedHatMatrix = np.array([[ 0.21264822, 0.20869565, 0.19683794, 0.1770751 , 0.14940711,
0.11383399, 0.07035573, 0.01897233, -0.04031621, -0.10750988],
[ 0.20869565, 0.20488177, 0.19344012, 0.17437071, 0.14767353,
0.11334859, 0.07139588, 0.02181541, -0.03539283, -0.10022883],
[ 0.19683794, 0.19344012, 0.18324665, 0.16625754, 0.14247278,
0.11189238, 0.07451633, 0.03034464, -0.0206227 , -0.07838569],
[ 0.1770751 , 0.17437071, 0.16625754, 0.15273559, 0.13380487,
0.10946536, 0.07971708, 0.04456002, 0.00399418, -0.04198045],
[ 0.14940711, 0.14767353, 0.14247278, 0.13380487, 0.12166979,
0.10606754, 0.08699813, 0.06446155, 0.0384578 , 0.00898689],
[ 0.11383399, 0.11334859, 0.11189238, 0.10946536, 0.10606754,
0.10169891, 0.09635948, 0.09004923, 0.08276819, 0.07451633],
[ 0.07035573, 0.07139588, 0.07451633, 0.07971708, 0.08699813,
0.09635948, 0.10780112, 0.12132307, 0.13692532, 0.15460786],
[ 0.01897233, 0.02181541, 0.03034464, 0.04456002, 0.06446155,
0.09004923, 0.12132307, 0.15828306, 0.2009292 , 0.24926149],
[-0.04031621, -0.03539283, -0.0206227 , 0.00399418, 0.0384578 ,
0.08276819, 0.13692532, 0.2009292 , 0.27477983, 0.35847722],
[-0.10750988, -0.10022883, -0.07838569, -0.04198045, 0.00898689,
0.07451633, 0.15460786, 0.24926149, 0.35847722, 0.48225504]])
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.hatMatrix(), expectedHatMatrix, rtol=1.0e-6, atol=1.e-08))
def testWeightedModelMatrix(self):
linearModel = LinearModel(
self.regressorList, self.regressorNames, self.covMatrixObserv2, regressorsAreWeighted=True
)
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.unweightedDesignMatrix))
linearModel = LinearModel(
self.regressorList, self.regressorNames, self.covMatrixObserv2, regressorsAreWeighted=False
)
self.assertFalse(np.alltrue(linearModel.designMatrix() == self.unweightedDesignMatrix))
expectedWeightedDesignMatrix = np.array(
[
[3.16227766e00, 4.73643073e-15],
[4.23376727e-01, 2.79508497e00],
[-2.67843095e-01, 3.79299210e00],
[-5.45288776e-01, 4.39760881e00],
[-6.78144517e-01, 4.84809047e00],
[-7.46997591e-01, 5.21965041e00],
[-7.83412990e-01, 5.54374745e00],
[-8.01896636e-01, 5.83605564e00],
[-8.09868157e-01, 6.10538773e00],
[-8.11425366e-01, 6.35716086e00],
]
)
self.assertTrue(
np.allclose(linearModel.designMatrix(), expectedWeightedDesignMatrix, rtol=1.0e-6, atol=1.0e-08)
)
def testPseudoInverse(self):
expectedPseudoInverse = np.array(
[
[
0.21264822,
0.20869565,
0.19683794,
0.1770751,
0.14940711,
0.11383399,
0.07035573,
0.01897233,
-0.04031621,
-0.10750988,
],
[
-0.00395257,
-0.00381388,
-0.00339782,
-0.00270439,
-0.00173358,
-0.0004854,
0.00104015,
0.00284308,
0.00492338,
0.00728105,
],
]
)
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.pseudoInverse(), expectedPseudoInverse, rtol=1.0e-6, atol=1.0e-08))
def testWeightedHatMatrix(self):
expectedWeightedHatMatrix = np.array([[ 0.93746979, 0.22625449, 0.05730702, -0.00315076, -0.02629974,
-0.03331944, -0.03243355, -0.02737749, -0.02003319, -0.01142021],
[ 0.22625449, 0.08788299, 0.05898899, 0.05159613, 0.05137251,
0.05410201, 0.05817441, 0.0628748 , 0.0678539 , 0.07293014],
[ 0.05730702, 0.05898899, 0.06478378, 0.07085639, 0.07671941,
0.08229333, 0.08758368, 0.09261537, 0.09741573, 0.10200995],
[-0.00315076, 0.05159613, 0.07085639, 0.08238505, 0.09090112,
0.09788464, 0.10395253, 0.10941096, 0.11443131, 0.11911848],
[-0.02629974, 0.05137251, 0.07671941, 0.09090112, 0.1008532 ,
0.10872302, 0.11539093, 0.12128539, 0.12664119, 0.13159879],
[-0.03331944, 0.05410201, 0.08229333, 0.09788464, 0.10872302,
0.11723346, 0.12440767, 0.13072689, 0.13645396, 0.14174555],
[-0.03243355, 0.05817441, 0.08758368, 0.10395253, 0.11539093,
0.12440767, 0.13203013, 0.13875766, 0.14486348, 0.15051078],
[-0.02737749, 0.0628748 , 0.09261537, 0.10941096, 0.12128539,
0.13072689, 0.13875766, 0.14587641, 0.15235719, 0.15836442],
[-0.02003319, 0.0678539 , 0.09741573, 0.11443131, 0.12664119,
0.13645396, 0.14486348, 0.15235719, 0.15920448, 0.16556802],
[-0.01142021, 0.07293014, 0.10200995, 0.11911848, 0.13159879,
0.14174555, 0.15051078, 0.15836442, 0.16556802, 0.17228071]])
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2)
self.assertTrue(np.allclose(linearModel.hatMatrix(), expectedWeightedHatMatrix, rtol=1.0e-6, atol=1.e-08))
def testStandardCovarianceMatrix(self):
expectedStandardCovarianceMatrix = np.array([[ 2.12648221e-01, -3.95256917e-03],
[-3.95256917e-03, 1.38686638e-04]])
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.standardCovarianceMatrix(),
expectedStandardCovarianceMatrix, rtol=1.0e-6, atol=1.e-08))
def setUp(self):
self.nObservations = 10
self.x = np.arange(self.nObservations)
x = self.x # local shorter alias
ones= np.ones_like(x)
self.linearModel1 = LinearModel([ones,x,x**2], ["1", "x", "x^2"])
self.linearModel2 = LinearModel([ones,x,np.sin(x),np.cos(x)], ["1","x","sin(x)","cos(x)"])
def testInitLinearModel(self):
self.assertRaises(ValueError, lambda: LinearModel(self.regressorList, ["only 1 name"]))
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.nParameters() == self.nParameters)
self.assertTrue(linearModel.regressorNames() == self.regressorNames)
self.assertTrue(linearModel.nObservations() == self.nObservations)
def testCopyWeightedLinearModel(self):
linearModel = LinearModel(
self.regressorList, self.regressorNames, self.covMatrixObserv2, regressorsAreWeighted=False
)
linearModel2 = linearModel.copy()
self.assertTrue(np.alltrue(linearModel2._covMatrixObserv == self.covMatrixObserv2))
self.assertTrue(id(linearModel2._covMatrixObserv) != id(linearModel._covMatrixObserv))
def setUp(self):
self.nObservations = 10
self.x = np.arange(self.nObservations)
x = self.x # local shorter alias
ones = np.ones_like(x)
self.linearModel1 = LinearModel([ones, x, x ** 2], ["1", "x", "x^2"])
self.linearModel2 = LinearModel([ones, x, np.sin(x), np.cos(x)], ["1", "x", "sin(x)", "cos(x)"])
def testCopyLinearModel(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
linearModel2 = linearModel.copy()
self.assertTrue(linearModel2.nParameters() == self.nParameters)
self.assertTrue(np.alltrue(linearModel2.designMatrix() == self.designMatrix))
self.assertTrue(linearModel2.regressorNames() == self.regressorNames)
self.assertTrue(id(linearModel2.designMatrix()) != id(linearModel.designMatrix()))
self.assertTrue(id(linearModel2.regressorNames()) != id(linearModel.regressorNames()))
def testPseudoInverse(self):
expectedPseudoInverse = np.array([[ 0.21264822, 0.20869565, 0.19683794, 0.1770751, 0.14940711,
0.11383399, 0.07035573, 0.01897233, -0.04031621, -0.10750988],
[-0.00395257, -0.00381388, -0.00339782, -0.00270439, -0.00173358,
-0.0004854, 0.00104015, 0.00284308, 0.00492338, 0.00728105]])
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.pseudoInverse(), expectedPseudoInverse,
rtol=1.0e-6, atol=1.e-08))
def testCopyLinearModel(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
linearModel2 = linearModel.copy()
self.assertTrue(linearModel2.nParameters() == self.nParameters)
self.assertTrue(np.alltrue(linearModel2.designMatrix() == self.designMatrix))
self.assertTrue(linearModel2.regressorNames() == self.regressorNames)
self.assertTrue(id(linearModel2.designMatrix()) != id(linearModel.designMatrix()))
self.assertTrue(id(linearModel2.regressorNames()) != id(linearModel.regressorNames()))
def testWithIntercept(self):
# Test a model with an intercept
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.withIntercept())
# Test a model without intercept
linearModel = LinearModel(self.RegressorList2, self.RegressorNames2)
self.assertFalse(linearModel.withIntercept())
def testStandardCovarianceMatrix(self):
expectedStandardCovarianceMatrix = np.array(
[[2.12648221e-01, -3.95256917e-03], [-3.95256917e-03, 1.38686638e-04]]
)
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(
np.allclose(
linearModel.standardCovarianceMatrix(), expectedStandardCovarianceMatrix, rtol=1.0e-6, atol=1.0e-08
)
)
def testCoefficientOfDetermination(self):
# Test using a model with an intercept
expectedCoefficientOfDetermination = 0.99983550516908659
self.assertAlmostEqual(self.linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7)
# Test using a model without an intercept
linearModel = LinearModel([self.time**2], ["t^2"])
linearFit = linearModel.fitData(self.observations)
expectedCoefficientOfDetermination = 0.99948312767720937
self.assertAlmostEqual(linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7)
def testFstatistic(self):
# Test on a model with more than one regressor
expectedFstatistic = 48625.747064132738
self.assertAlmostEqual(self.linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
# Test on a model with only one regressor
expectedFstatistic = 17403.423925909559
linearModel = LinearModel([np.square(self.time)], ["t^2"])
linearFit = linearModel.fitData(self.observations)
self.assertAlmostEqual(linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
def testFstatistic(self):
# Test on a model with more than one regressor
expectedFstatistic = 48625.747064132738
self.assertAlmostEqual(self.linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
# Test on a model with only one regressor
expectedFstatistic = 17403.423925909559
linearModel = LinearModel([np.square(self.time)], ["t^2"])
linearFit = linearModel.fitData(self.observations)
self.assertAlmostEqual(linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
def setUp(self):
# Generate a simple dataset.
# Noise-values are drawn from a N(0,1), but are truncated.
self.nObservations = 10
self.nParameters = 2
self.time = np.arange(self.nObservations, dtype=np.double)
self.noise = np.array([-.72, -1.02, .52, .24, -.17, -1.78, .56, .33, .19, 1.03])
self.observations = 3.0 + 2.0 * self.time**2 + self.noise
regressorList = [np.ones_like(self.time), self.time**2]
regressorNames = ["1", "t^2"]
self.linearModel = LinearModel(regressorList, regressorNames)
self.linearFit = self.linearModel.fitData(self.observations)
def testThypothesisTest(self):
regressorList = [np.ones_like(self.time), self.time**2, self.time**3]
regressorNames = ["1", "t^2", "t^3"]
linearModel = LinearModel(regressorList, regressorNames)
linearFit = linearModel.fitData(self.observations)
alpha = 0.05 # significance level
expectedOutput = np.array([True, True, False])
nullRejected = linearFit.regressorTtest(alpha)
self.assertTrue(isinstance(nullRejected, np.ndarray))
self.assertTrue(nullRejected.dtype == np.bool)
self.assertEqual(len(nullRejected), len(regressorList))
self.assertTrue(np.all(nullRejected == expectedOutput))
def testThypothesisTest(self):
regressorList = [np.ones_like(self.time), self.time ** 2, self.time ** 3]
regressorNames = ["1", "t^2", "t^3"]
linearModel = LinearModel(regressorList, regressorNames)
linearFit = linearModel.fitData(self.observations)
alpha = 0.05 # significance level
expectedOutput = np.array([True, True, False])
nullRejected = linearFit.regressorTtest(alpha)
self.assertTrue(isinstance(nullRejected, np.ndarray))
self.assertTrue(nullRejected.dtype == np.bool)
self.assertEqual(len(nullRejected), len(regressorList))
self.assertTrue(np.all(nullRejected == expectedOutput))
def testCoefficientOfDetermination(self):
# Test using a model with an intercept
expectedCoefficientOfDetermination = 0.99983550516908659
self.assertAlmostEqual(
self.linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7
)
# Test using a model without an intercept
linearModel = LinearModel([self.time ** 2], ["t^2"])
linearFit = linearModel.fitData(self.observations)
expectedCoefficientOfDetermination = 0.99948312767720937
self.assertAlmostEqual(
linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7
)
def testModelMatrix(self):
# With a list of regressor arrays as input
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(isinstance(linearModel.designMatrix(), np.ndarray))
self.assertTrue(linearModel.designMatrix().dtype == np.double)
self.assertTrue(linearModel.designMatrix().shape == (self.nObservations, self.nParameters))
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.designMatrix))
# With a design matrix as input
linearModel = LinearModel(self.designMatrix, self.regressorNames)
self.assertTrue(isinstance(linearModel.designMatrix(), np.ndarray))
self.assertTrue(linearModel.designMatrix().dtype == np.double)
self.assertTrue(linearModel.designMatrix().shape == (self.nObservations, self.nParameters))
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.designMatrix))
def testAddLinearModel(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
linearModel2 = LinearModel(self.RegressorList2, self.RegressorNames2)
linearModel = linearModel + linearModel2
self.assertTrue(linearModel.nParameters() == self.newnParameters)
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.newModelMatrix))
self.assertTrue(linearModel.regressorNames() == self.regressorNames + self.RegressorNames2)
self.assertTrue(linearModel._covMatrixObserv == None)
self.assertRaises(TypeError, lambda lm: lm + 1.0, linearModel)
self.assertRaises(
ValueError,
lambda x, y: LinearModel(x, y) + LinearModel(x[:-1, :], y),
self.designMatrix,
self.regressorNames,
)
def setUp(self):
# Generate simple noiseless dataset
self.nObservations = 10
self.nParameters = 2
time = np.arange(self.nObservations, dtype=np.double)
self.observations1 = 1.0 + 0.3 * time
self.observations2 = 1.0 + 0.3 * time
self.regressorList = [np.ones_like(time), time]
self.regressorNames = ["1", "t"]
self.designMatrix = np.column_stack(self.regressorList)
# First covariance matrix: different weights, no correlations
covMatrixObserv1 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
# Second covariance matrix: different weights and correlations
# Correlation coefficient: 0.6
covMatrixObserv2 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
for i in range(self.nObservations):
for j in range(self.nObservations):
if i>=j: continue
covMatrixObserv2[i,j] = 0.6 * sqrt(covMatrixObserv2[i,i] * covMatrixObserv2[j,j])
covMatrixObserv2[j,i] = covMatrixObserv2[i,j]
# Add noise according to the different covariance matrices
noise1 = np.array([-0.26944792, -0.56542802, 0.62106263, -0.03113657, 0.98090236, \
0.02678669, 1.2237701 , -0.50112787, -0.47742454, 1.16351356])
noise2 = np.array([ 0.24484502, -0.22979797, 0.40639882, 0.12137103, 0.20694025, \
0.68952746, -0.30300402, -0.11136982, 0.3549814 , 0.20528704])
self.observations1 += noise1
self.observations2 += noise2
# Instantiate the (weighted) linear models and their linear fits
self.linearModel1 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv1)
self.linearModel2 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv2)
self.linearFit1 = self.linearModel1.fitData(self.observations1)
self.linearFit2 = self.linearModel2.fitData(self.observations2)
def testAddLinearModel(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
linearModel2 = LinearModel(self.RegressorList2, self.RegressorNames2)
linearModel = linearModel + linearModel2
self.assertTrue(linearModel.nParameters() == self.newnParameters)
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.newModelMatrix))
self.assertTrue(linearModel.regressorNames() == self.regressorNames + self.RegressorNames2)
self.assertTrue(linearModel._covMatrixObserv == None)
self.assertRaises(TypeError, lambda lm : lm + 1.0, linearModel)
self.assertRaises(ValueError, lambda x,y : LinearModel(x,y) + LinearModel(x[:-1,:],y),
self.designMatrix, self.regressorNames)
def testInitLinearModel(self):
self.assertRaises(ValueError, lambda : LinearModel(self.regressorList, ["only 1 name"]))
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.nParameters() == self.nParameters)
self.assertTrue(linearModel.regressorNames() == self.regressorNames)
self.assertTrue(linearModel.nObservations() == self.nObservations)
def setUp(self):
# Generate a simple dataset.
# Noise-values are drawn from a N(0,1), but are truncated.
self.nObservations = 10
self.nParameters = 2
self.time = np.arange(self.nObservations, dtype=np.double)
self.noise = np.array([-0.72, -1.02, 0.52, 0.24, -0.17, -1.78, 0.56, 0.33, 0.19, 1.03])
self.observations = 3.0 + 2.0 * self.time ** 2 + self.noise
regressorList = [np.ones_like(self.time), self.time ** 2]
regressorNames = ["1", "t^2"]
self.linearModel = LinearModel(regressorList, regressorNames)
self.linearFit = self.linearModel.fitData(self.observations)
def testInitWeightedLinearModel(self):
# The covariance matrix of the observations should be 1) a numpy array
# 2) with the proper dimensions, and 3) with the correct size.
self.assertRaises(TypeError, lambda x,y,z : LinearModel(x,y,z), \
self.regressorList, self.regressorNames, [1,2,3])
self.assertRaises(TypeError, lambda x,y,z : LinearModel(x,y,z), \
self.regressorList, self.regressorNames, np.arange(10))
self.assertRaises(TypeError, lambda x,y,z : LinearModel(x,y,z), \
self.regressorList, self.regressorNames, \
np.arange(self.nObservations*5).reshape(self.nObservations,5))
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv1, regressorsAreWeighted=True)
self.assertTrue(isinstance(linearModel._covMatrixObserv, np.ndarray))
self.assertTrue(linearModel._covMatrixObserv.dtype == np.double)
self.assertTrue(linearModel._covMatrixObserv.shape == (self.nObservations, self.nObservations))
self.assertTrue(np.alltrue(linearModel._covMatrixObserv == self.covMatrixObserv1))
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv1, regressorsAreWeighted=False)
self.assertTrue(isinstance(linearModel._covMatrixObserv, np.ndarray))
self.assertTrue(linearModel._covMatrixObserv.dtype == np.double)
self.assertTrue(linearModel._covMatrixObserv.shape == (self.nObservations, self.nObservations))
self.assertTrue(np.alltrue(linearModel._covMatrixObserv == self.covMatrixObserv1))
def testModelMatrix(self):
# With a list of regressor arrays as input
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(isinstance(linearModel.designMatrix(), np.ndarray))
self.assertTrue(linearModel.designMatrix().dtype == np.double)
self.assertTrue(linearModel.designMatrix().shape == (self.nObservations, self.nParameters))
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.designMatrix))
# With a design matrix as input
linearModel = LinearModel(self.designMatrix, self.regressorNames)
self.assertTrue(isinstance(linearModel.designMatrix(), np.ndarray))
self.assertTrue(linearModel.designMatrix().dtype == np.double)
self.assertTrue(linearModel.designMatrix().shape == (self.nObservations, self.nParameters))
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.designMatrix))
def testWithIntercept(self):
# Test a model with an intercept
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.withIntercept())
# Test a model without intercept
linearModel = LinearModel(self.RegressorList2, self.RegressorNames2)
self.assertFalse(linearModel.withIntercept())
def testWeightedModelMatrix(self):
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2, regressorsAreWeighted=True)
self.assertTrue(np.alltrue(linearModel.designMatrix() == self.unweightedDesignMatrix))
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2, regressorsAreWeighted=False)
self.assertFalse(np.alltrue(linearModel.designMatrix() == self.unweightedDesignMatrix))
expectedWeightedDesignMatrix = np.array([[ 3.16227766e+00, 4.73643073e-15],
[ 4.23376727e-01, 2.79508497e+00],
[-2.67843095e-01, 3.79299210e+00],
[-5.45288776e-01, 4.39760881e+00],
[-6.78144517e-01, 4.84809047e+00],
[-7.46997591e-01, 5.21965041e+00],
[-7.83412990e-01, 5.54374745e+00],
[-8.01896636e-01, 5.83605564e+00],
[-8.09868157e-01, 6.10538773e+00],
[-8.11425366e-01, 6.35716086e+00]])
self.assertTrue(np.allclose(linearModel.designMatrix(), expectedWeightedDesignMatrix, rtol=1.0e-6, atol=1.e-08))
def testAddWeigthedLinearModel(self):
regressorList2 = [self.time**2]
regressorNames2 = ["t^2"]
self.assertRaises(ValueError, lambda v,w,x,y,z : LinearModel(v,w) + LinearModel(x,y,z),
self.regressorList, self.regressorNames,
regressorList2, regressorNames2, self.covMatrixObserv1)
self.assertRaises(ValueError, lambda u,v,w,x,y,z : LinearModel(u,v,w) + LinearModel(x,y,z),
self.regressorList, self.regressorNames, self.covMatrixObserv1,
regressorList2, regressorNames2, self.covMatrixObserv2)
linearModel1 = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2)
linearModel2 = LinearModel(regressorList2, regressorNames2, self.covMatrixObserv2)
linearModel = linearModel1 + linearModel2
self.assertTrue(np.alltrue(linearModel._covMatrixObserv == self.covMatrixObserv2))
def testWeightedHatMatrix(self):
expectedWeightedHatMatrix = np.array(
[
[
0.93746979,
0.22625449,
0.05730702,
-0.00315076,
-0.02629974,
-0.03331944,
-0.03243355,
-0.02737749,
-0.02003319,
-0.01142021,
],
[
0.22625449,
0.08788299,
0.05898899,
0.05159613,
0.05137251,
0.05410201,
0.05817441,
0.0628748,
0.0678539,
0.07293014,
],
[
0.05730702,
0.05898899,
0.06478378,
0.07085639,
0.07671941,
0.08229333,
0.08758368,
0.09261537,
0.09741573,
0.10200995,
],
[
-0.00315076,
0.05159613,
0.07085639,
0.08238505,
0.09090112,
0.09788464,
0.10395253,
0.10941096,
0.11443131,
0.11911848,
],
[
-0.02629974,
0.05137251,
0.07671941,
0.09090112,
0.1008532,
0.10872302,
0.11539093,
0.12128539,
0.12664119,
0.13159879,
],
[
-0.03331944,
0.05410201,
0.08229333,
0.09788464,
0.10872302,
0.11723346,
0.12440767,
0.13072689,
0.13645396,
0.14174555,
],
[
-0.03243355,
0.05817441,
0.08758368,
0.10395253,
0.11539093,
0.12440767,
0.13203013,
0.13875766,
0.14486348,
0.15051078,
],
[
-0.02737749,
0.0628748,
0.09261537,
0.10941096,
0.12128539,
0.13072689,
0.13875766,
0.14587641,
0.15235719,
0.15836442,
],
[
-0.02003319,
0.0678539,
0.09741573,
0.11443131,
0.12664119,
0.13645396,
0.14486348,
0.15235719,
0.15920448,
0.16556802,
],
[
-0.01142021,
0.07293014,
0.10200995,
0.11911848,
0.13159879,
0.14174555,
0.15051078,
0.15836442,
0.16556802,
0.17228071,
],
]
)
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2)
self.assertTrue(np.allclose(linearModel.hatMatrix(), expectedWeightedHatMatrix, rtol=1.0e-6, atol=1.0e-08))
class LinearSubmodelGeneratorTestCase(unittest.TestCase):
"""
Test the LinearModel.submodels() method
"""
def setUp(self):
self.nObservations = 10
self.x = np.arange(self.nObservations)
x = self.x # local shorter alias
ones= np.ones_like(x)
self.linearModel1 = LinearModel([ones,x,x**2], ["1", "x", "x^2"])
self.linearModel2 = LinearModel([ones,x,np.sin(x),np.cos(x)], ["1","x","sin(x)","cos(x)"])
def tearDown(self):
pass
def testSubmodel(self):
generator = self.linearModel1.submodels(Nmin=3, nested=True, ranks=[1,0,3])
self.assertTrue(generator.__class__.__name__ == "generator")
submodel = generator.next()
self.assertTrue(isinstance(submodel, LinearModel))
designMatrix = np.column_stack([self.x,np.ones(len(self.x)),self.x**2])
self.assertTrue(np.alltrue(submodel.designMatrix() == designMatrix))
self.assertTrue(submodel.regressorNames() == ["x","1","x^2"])
def testSubmodelGenerator(self):
names = []
for model in self.linearModel1.submodels(Nmin=1, nested=False, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1"], ["x"], ["x^2"], ["1","x"], ["1","x^2"], ["x","x^2"], ["1","x","x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=1, Nmax=2, nested=False, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1"], ["x"], ["x^2"], ["1","x"], ["1","x^2"], ["x","x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=2, nested=False, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1","x"], ["1","x^2"], ["x","x^2"], ["1","x","x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=3, nested=True, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1","x","x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=3, nested=True, ranks=[1,0,3]):
names += [model.regressorNames()]
self.assertTrue(names == [["x","1","x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=2, nested=False, ranks=[1,0,3]):
names += [model.regressorNames()]
self.assertTrue(names == [["x","1"], ["x","x^2"], ["1","x^2"], ["x","1","x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=2, nested=True, ranks=[1,0,3]):
names += [model.regressorNames()]
self.assertTrue(names == [["x","1"], ["x","1","x^2"]])
names = []
for model in self.linearModel2.submodels(Nmin=3, nested=True, ranks=[0,1,2,2]):
names += [model.regressorNames()]
self.assertTrue(names == [["1","x","sin(x)","cos(x)"]])
names = []
for model in self.linearModel2.submodels(Nmin=2, nested=True, ranks=[0,1,2,2]):
names += [model.regressorNames()]
self.assertTrue(names == [["1","x"], ["1","x","sin(x)","cos(x)"]])
names = []
for model in self.linearModel2.submodels(Nmin=2, nested=False, ranks=[0,1,2,2]):
names += [model.regressorNames()]
self.assertTrue(names == [["1","x"], ["1","sin(x)","cos(x)"], ["x","sin(x)","cos(x)"], ["1","x","sin(x)","cos(x)"]])
names = []
for model in self.linearModel2.submodels(Nmin=1, Nmax=2, nested=False, ranks=[0,1,2,2]):
names += [model.regressorNames()]
self.assertTrue(names == [["1"], ["x"], ["sin(x)","cos(x)"], ["1","x"], ["1","sin(x)","cos(x)"], ["x","sin(x)","cos(x)"]])
class WeightedLinearFitTestCase(unittest.TestCase):
"""
Test the LinearFit class with a specified covariance matrix for the
observations. Test only those method affected by weights.
"""
def setUp(self):
# Generate simple noiseless dataset
self.nObservations = 10
self.nParameters = 2
time = np.arange(self.nObservations, dtype=np.double)
self.observations1 = 1.0 + 0.3 * time
self.observations2 = 1.0 + 0.3 * time
self.regressorList = [np.ones_like(time), time]
self.regressorNames = ["1", "t"]
self.designMatrix = np.column_stack(self.regressorList)
# First covariance matrix: different weights, no correlations
covMatrixObserv1 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
# Second covariance matrix: different weights and correlations
# Correlation coefficient: 0.6
covMatrixObserv2 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
for i in range(self.nObservations):
for j in range(self.nObservations):
if i >= j:
continue
covMatrixObserv2[i, j] = 0.6 * sqrt(covMatrixObserv2[i, i] * covMatrixObserv2[j, j])
covMatrixObserv2[j, i] = covMatrixObserv2[i, j]
# Add noise according to the different covariance matrices
noise1 = np.array(
[
-0.26944792,
-0.56542802,
0.62106263,
-0.03113657,
0.98090236,
0.02678669,
1.2237701,
-0.50112787,
-0.47742454,
1.16351356,
]
)
noise2 = np.array(
[
0.24484502,
-0.22979797,
0.40639882,
0.12137103,
0.20694025,
0.68952746,
-0.30300402,
-0.11136982,
0.3549814,
0.20528704,
]
)
self.observations1 += noise1
self.observations2 += noise2
# Instantiate the (weighted) linear models and their linear fits
self.linearModel1 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv1)
self.linearModel2 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv2)
self.linearFit1 = self.linearModel1.fitData(self.observations1)
self.linearFit2 = self.linearModel2.fitData(self.observations2)
def tearDown(self):
pass
def testDecorrelatedObservations(self):
expectedObservations = np.array(
[
3.9365456,
0.03889641,
1.73885587,
0.65979961,
0.82899163,
1.73402234,
-0.1799988,
0.37289876,
1.25537791,
1.05209144,
]
)
self.assertTrue(isinstance(self.linearFit2.observations(weighted=True), np.ndarray))
self.assertEqual(self.linearFit2.observations(weighted=True).shape, (self.nObservations,))
self.assertTrue(
np.allclose(expectedObservations, self.linearFit2.observations(weighted=True), rtol=1.0e-6, atol=1.0e-08)
)
def testWeightedRegressionCoefficients(self):
# A test with a diagonal covariance matrix
expectedWeightedCoeff = np.array([0.76576446, 0.40030724])
self.assertTrue(
np.allclose(self.linearFit1.regressionCoefficients(), expectedWeightedCoeff, rtol=1.0e-6, atol=1.0e-08)
)
# A test with a non-diagonal covariance matrix
expectedWeightedCoeff = np.array([1.1623421, 0.3040605])
self.assertTrue(
np.allclose(self.linearFit2.regressionCoefficients(), expectedWeightedCoeff, rtol=1.0e-6, atol=1.0e-08)
)
def testResiduals(self):
# A test with a diagonal covariance matrix
expectedResiduals = np.array(
[
-0.03521238,
-0.43149972,
0.65468369,
-0.09782275,
0.81390894,
-0.24051397,
0.85616220,
-0.96904301,
-1.04564692,
0.49498394,
]
)
self.assertTrue(
np.allclose(self.linearFit1.residuals(weighted=False), expectedResiduals, rtol=1.0e-6, atol=1.0e-08)
)
# A test with a non-diagonal covariance matrix
expectedResiduals = np.array(
[
0.082502896,
-0.396200554,
0.235935777,
-0.053152473,
0.028356288,
0.506883039,
-0.489708901,
-0.302135160,
0.160155600,
0.006400781,
]
)
self.assertTrue(
np.allclose(self.linearFit2.residuals(weighted=False), expectedResiduals, rtol=1.0e-6, atol=1.0e-08)
)
class LinearFitTestCase(unittest.TestCase):
"""
Test the LinearFit class and its methods
"""
def setUp(self):
# Generate a simple dataset.
# Noise-values are drawn from a N(0,1), but are truncated.
self.nObservations = 10
self.nParameters = 2
self.time = np.arange(self.nObservations, dtype=np.double)
self.noise = np.array([-0.72, -1.02, 0.52, 0.24, -0.17, -1.78, 0.56, 0.33, 0.19, 1.03])
self.observations = 3.0 + 2.0 * self.time ** 2 + self.noise
regressorList = [np.ones_like(self.time), self.time ** 2]
regressorNames = ["1", "t^2"]
self.linearModel = LinearModel(regressorList, regressorNames)
self.linearFit = self.linearModel.fitData(self.observations)
def tearDown(self):
pass
def testLinearFit(self):
self.assertTrue(isinstance(self.linearFit, LinearFit))
def testObservations(self):
# Since the linear model did not have a covariance matrix specified, the
# decorrelated observations, should be simply the original observations
self.assertTrue(isinstance(self.linearFit.observations(weighted=True), np.ndarray))
self.assertEqual(self.linearFit.observations(weighted=True).shape, (self.nObservations,))
self.assertTrue(np.alltrue(self.observations == self.linearFit.observations(weighted=True)))
self.assertTrue(np.alltrue(self.observations == self.linearFit.observations(weighted=False)))
def testRegressionCoefficients(self):
expectedCoeff = np.array([2.47811858, 2.01543444])
self.assertTrue(isinstance(self.linearFit.regressionCoefficients(), np.ndarray))
self.assertEqual(self.linearFit.regressionCoefficients().shape, (self.nParameters,))
self.assertTrue(np.allclose(self.linearFit.regressionCoefficients(), expectedCoeff, rtol=1.0e-6, atol=1.0e-08))
def testResiduals(self):
expectedResiduals = np.array(
[
-0.19811858,
-0.51355301,
0.98014368,
0.6229715,
0.10493045,
-1.64397947,
0.52624173,
0.09559406,
-0.27592247,
0.30169212,
]
)
self.assertTrue(isinstance(self.linearFit.residuals(weighted=False), np.ndarray))
self.assertEqual(self.linearFit.residuals(weighted=False).shape, (self.nObservations,))
self.assertTrue(
np.allclose(self.linearFit.residuals(weighted=False), expectedResiduals, rtol=1.0e-6, atol=1.0e-08)
)
def testPredictions(self):
expectedPredictions = np.array(
[
2.47811858,
4.49355301,
10.53985632,
20.6170285,
34.72506955,
52.86397947,
75.03375827,
101.23440594,
131.46592247,
165.72830788,
]
)
self.assertTrue(isinstance(self.linearFit.predictions(weighted=False), np.ndarray))
self.assertEqual(self.linearFit.predictions(weighted=False).shape, (self.nObservations,))
self.assertTrue(
np.allclose(self.linearFit.predictions(weighted=False), expectedPredictions, rtol=1.0e-6, atol=1.0e-08)
)
def testCovarianceMatrix(self):
expectedCovMatrix = np.array([[1.28084978e-01, -2.38076167e-03], [-2.38076167e-03, 8.35354974e-05]])
self.assertTrue(isinstance(self.linearFit.covarianceMatrix(), np.ndarray))
self.assertEqual(self.linearFit.covarianceMatrix().shape, (self.nParameters, self.nParameters))
self.assertTrue(np.allclose(self.linearFit.covarianceMatrix(), expectedCovMatrix, rtol=1.0e-6, atol=1.0e-08))
def testErrorBars(self):
expectedErrors = np.array([0.35788962, 0.00913978])
self.assertTrue(isinstance(self.linearFit.errorBars(), np.ndarray))
self.assertEqual(self.linearFit.errorBars().shape, (self.nParameters,))
self.assertTrue(np.allclose(self.linearFit.errorBars(), expectedErrors, rtol=1.0e-6, atol=1.0e-08))
def testConfidenceIntervals(self):
alpha = 0.05
expectedLower = np.array([1.65282364, 1.99435808])
expectedUpper = np.array([3.30341351, 2.0365108])
self.assertEqual(len(self.linearFit.confidenceIntervals(0.05)), 2)
lower, upper = self.linearFit.confidenceIntervals(0.05)
self.assertTrue(isinstance(lower, np.ndarray))
self.assertTrue(isinstance(upper, np.ndarray))
self.assertEqual(len(lower), self.nParameters)
self.assertEqual(len(upper), self.nParameters)
self.assertTrue(np.allclose(lower, expectedLower, rtol=1.0e-6, atol=1.0e-08))
self.assertTrue(np.allclose(upper, expectedUpper, rtol=1.0e-6, atol=1.0e-08))
def testT_values(self):
expectedTvalues = np.array([6.92425385, 220.51235807])
self.assertTrue(isinstance(self.linearFit.t_values(), np.ndarray))
self.assertEqual(self.linearFit.t_values().shape, (self.nParameters,))
self.assertTrue(np.allclose(self.linearFit.t_values(), expectedTvalues, rtol=1.0e-6, atol=1.0e-08))
def testSumOfSquaredResiduals(self):
expectedSumSqResiduals = 4.81866162957
self.assertAlmostEqual(self.linearFit.sumSqResiduals(weighted=False), expectedSumSqResiduals, places=7)
def testResidualVariance(self):
expectedResidualVariance = 0.60233270369599989
self.assertAlmostEqual(self.linearFit.residualVariance(weighted=False), expectedResidualVariance, places=7)
def testCorrelationMatrix(self):
expectedCorrelationMatrix = np.array([[1.0, -0.72783225], [-0.72783225, 1.0]])
self.assertTrue(
np.allclose(self.linearFit.correlationMatrix(), expectedCorrelationMatrix, rtol=1.0e-6, atol=1.0e-08)
)
def testCoefficientOfDetermination(self):
# Test using a model with an intercept
expectedCoefficientOfDetermination = 0.99983550516908659
self.assertAlmostEqual(
self.linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7
)
# Test using a model without an intercept
linearModel = LinearModel([self.time ** 2], ["t^2"])
linearFit = linearModel.fitData(self.observations)
expectedCoefficientOfDetermination = 0.99948312767720937
self.assertAlmostEqual(
linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7
)
def testBICvalue(self):
expectedBICvalue = -0.39313345804942657
self.assertAlmostEqual(self.linearFit.BICvalue(), expectedBICvalue, places=7)
def testAICvalue(self):
expectedAICvalue = 2.6991112629684357
self.assertAlmostEqual(self.linearFit.AICvalue(), expectedAICvalue, places=7)
def testThypothesisTest(self):
regressorList = [np.ones_like(self.time), self.time ** 2, self.time ** 3]
regressorNames = ["1", "t^2", "t^3"]
linearModel = LinearModel(regressorList, regressorNames)
linearFit = linearModel.fitData(self.observations)
alpha = 0.05 # significance level
expectedOutput = np.array([True, True, False])
nullRejected = linearFit.regressorTtest(alpha)
self.assertTrue(isinstance(nullRejected, np.ndarray))
self.assertTrue(nullRejected.dtype == np.bool)
self.assertEqual(len(nullRejected), len(regressorList))
self.assertTrue(np.all(nullRejected == expectedOutput))
def testFstatistic(self):
# Test on a model with more than one regressor
expectedFstatistic = 48625.747064132738
self.assertAlmostEqual(self.linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
# Test on a model with only one regressor
expectedFstatistic = 17403.423925909559
linearModel = LinearModel([np.square(self.time)], ["t^2"])
linearFit = linearModel.fitData(self.observations)
self.assertAlmostEqual(linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
def testFstatisticTest(self):
# with tested model the same as the true model
alpha = 0.05
expectedOutput = True # null hypothesis rejected
self.assertTrue(self.linearFit.FstatisticTest(alpha) == expectedOutput)
# with a fit on pure noise noise
alpha = 0.05
expectedOutput = False # null hypothesis could not be rejected
linearFit = self.linearModel.fitData(self.noise)
self.assertTrue(linearFit.FstatisticTest(alpha) == expectedOutput)
def testEvaluate(self):
expectedOutput = np.array(
[
52.86397947,
42.8147219,
33.8820485,
26.06595927,
19.36645422,
13.78353335,
9.31719665,
5.96744412,
3.73427577,
2.6176916,
2.6176916,
3.73427577,
5.96744412,
9.31719665,
13.78353335,
19.36645422,
26.06595927,
33.8820485,
42.8147219,
52.86397947,
]
)
xnew = np.linspace(-5.0, +5.0, 20)
newRegressorList = [np.ones_like(xnew), xnew ** 2]
output = self.linearFit.evaluate(newRegressorList)
self.assertTrue(np.allclose(output, expectedOutput, rtol=1.0e-6, atol=1.0e-08))
class LinearSubmodelGeneratorTestCase(unittest.TestCase):
"""
Test the LinearModel.submodels() method
"""
def setUp(self):
self.nObservations = 10
self.x = np.arange(self.nObservations)
x = self.x # local shorter alias
ones = np.ones_like(x)
self.linearModel1 = LinearModel([ones, x, x ** 2], ["1", "x", "x^2"])
self.linearModel2 = LinearModel([ones, x, np.sin(x), np.cos(x)], ["1", "x", "sin(x)", "cos(x)"])
def tearDown(self):
pass
def testSubmodel(self):
generator = self.linearModel1.submodels(Nmin=3, nested=True, ranks=[1, 0, 3])
self.assertTrue(generator.__class__.__name__ == "generator")
submodel = generator.next()
self.assertTrue(isinstance(submodel, LinearModel))
designMatrix = np.column_stack([self.x, np.ones(len(self.x)), self.x ** 2])
self.assertTrue(np.alltrue(submodel.designMatrix() == designMatrix))
self.assertTrue(submodel.regressorNames() == ["x", "1", "x^2"])
def testSubmodelGenerator(self):
names = []
for model in self.linearModel1.submodels(Nmin=1, nested=False, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1"], ["x"], ["x^2"], ["1", "x"], ["1", "x^2"], ["x", "x^2"], ["1", "x", "x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=1, Nmax=2, nested=False, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1"], ["x"], ["x^2"], ["1", "x"], ["1", "x^2"], ["x", "x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=2, nested=False, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1", "x"], ["1", "x^2"], ["x", "x^2"], ["1", "x", "x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=3, nested=True, ranks=None):
names += [model.regressorNames()]
self.assertTrue(names == [["1", "x", "x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=3, nested=True, ranks=[1, 0, 3]):
names += [model.regressorNames()]
self.assertTrue(names == [["x", "1", "x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=2, nested=False, ranks=[1, 0, 3]):
names += [model.regressorNames()]
self.assertTrue(names == [["x", "1"], ["x", "x^2"], ["1", "x^2"], ["x", "1", "x^2"]])
names = []
for model in self.linearModel1.submodels(Nmin=2, nested=True, ranks=[1, 0, 3]):
names += [model.regressorNames()]
self.assertTrue(names == [["x", "1"], ["x", "1", "x^2"]])
names = []
for model in self.linearModel2.submodels(Nmin=3, nested=True, ranks=[0, 1, 2, 2]):
names += [model.regressorNames()]
self.assertTrue(names == [["1", "x", "sin(x)", "cos(x)"]])
names = []
for model in self.linearModel2.submodels(Nmin=2, nested=True, ranks=[0, 1, 2, 2]):
names += [model.regressorNames()]
self.assertTrue(names == [["1", "x"], ["1", "x", "sin(x)", "cos(x)"]])
names = []
for model in self.linearModel2.submodels(Nmin=2, nested=False, ranks=[0, 1, 2, 2]):
names += [model.regressorNames()]
self.assertTrue(
names == [["1", "x"], ["1", "sin(x)", "cos(x)"], ["x", "sin(x)", "cos(x)"], ["1", "x", "sin(x)", "cos(x)"]]
)
names = []
for model in self.linearModel2.submodels(Nmin=1, Nmax=2, nested=False, ranks=[0, 1, 2, 2]):
names += [model.regressorNames()]
self.assertTrue(
names
== [["1"], ["x"], ["sin(x)", "cos(x)"], ["1", "x"], ["1", "sin(x)", "cos(x)"], ["x", "sin(x)", "cos(x)"]]
)
def testDegreesOfFreedom(self):
expectedDegreesOfFreedom = 8
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertEqual(linearModel.degreesOfFreedom(), expectedDegreesOfFreedom)
def testWeightedDegreesOfFreedom(self):
expectedDegreesOfFreedom = 8
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2)
self.assertAlmostEqual(linearModel.degreesOfFreedom(), expectedDegreesOfFreedom, places=6)
def testSingularValues(self):
expectedSingularValues = np.array([123.84788663, 2.16817379])
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.singularValues(), expectedSingularValues,
rtol=1.0e-6, atol=1.e-08))
def testHatMatrix(self):
expectedHatMatrix = np.array(
[
[
0.21264822,
0.20869565,
0.19683794,
0.1770751,
0.14940711,
0.11383399,
0.07035573,
0.01897233,
-0.04031621,
-0.10750988,
],
[
0.20869565,
0.20488177,
0.19344012,
0.17437071,
0.14767353,
0.11334859,
0.07139588,
0.02181541,
-0.03539283,
-0.10022883,
],
[
0.19683794,
0.19344012,
0.18324665,
0.16625754,
0.14247278,
0.11189238,
0.07451633,
0.03034464,
-0.0206227,
-0.07838569,
],
[
0.1770751,
0.17437071,
0.16625754,
0.15273559,
0.13380487,
0.10946536,
0.07971708,
0.04456002,
0.00399418,
-0.04198045,
],
[
0.14940711,
0.14767353,
0.14247278,
0.13380487,
0.12166979,
0.10606754,
0.08699813,
0.06446155,
0.0384578,
0.00898689,
],
[
0.11383399,
0.11334859,
0.11189238,
0.10946536,
0.10606754,
0.10169891,
0.09635948,
0.09004923,
0.08276819,
0.07451633,
],
[
0.07035573,
0.07139588,
0.07451633,
0.07971708,
0.08699813,
0.09635948,
0.10780112,
0.12132307,
0.13692532,
0.15460786,
],
[
0.01897233,
0.02181541,
0.03034464,
0.04456002,
0.06446155,
0.09004923,
0.12132307,
0.15828306,
0.2009292,
0.24926149,
],
[
-0.04031621,
-0.03539283,
-0.0206227,
0.00399418,
0.0384578,
0.08276819,
0.13692532,
0.2009292,
0.27477983,
0.35847722,
],
[
-0.10750988,
-0.10022883,
-0.07838569,
-0.04198045,
0.00898689,
0.07451633,
0.15460786,
0.24926149,
0.35847722,
0.48225504,
],
]
)
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.hatMatrix(), expectedHatMatrix, rtol=1.0e-6, atol=1.0e-08))
def testSingularValues(self):
expectedSingularValues = np.array([123.84788663, 2.16817379])
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(np.allclose(linearModel.singularValues(), expectedSingularValues, rtol=1.0e-6, atol=1.0e-08))
def testConditionNumber(self):
expectedConditionNumber = 57.120830024
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertAlmostEqual(linearModel.conditionNumber(), expectedConditionNumber, places=5)
def testWeightedDegreesOfFreedom(self):
expectedDegreesOfFreedom = 8
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2)
self.assertAlmostEqual(linearModel.degreesOfFreedom(), expectedDegreesOfFreedom, places=6)
def setUp(self):
# Generate simple noiseless dataset
self.nObservations = 10
self.nParameters = 2
time = np.arange(self.nObservations, dtype=np.double)
self.observations1 = 1.0 + 0.3 * time
self.observations2 = 1.0 + 0.3 * time
self.regressorList = [np.ones_like(time), time]
self.regressorNames = ["1", "t"]
self.designMatrix = np.column_stack(self.regressorList)
# First covariance matrix: different weights, no correlations
covMatrixObserv1 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
# Second covariance matrix: different weights and correlations
# Correlation coefficient: 0.6
covMatrixObserv2 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
for i in range(self.nObservations):
for j in range(self.nObservations):
if i >= j:
continue
covMatrixObserv2[i, j] = 0.6 * sqrt(covMatrixObserv2[i, i] * covMatrixObserv2[j, j])
covMatrixObserv2[j, i] = covMatrixObserv2[i, j]
# Add noise according to the different covariance matrices
noise1 = np.array(
[
-0.26944792,
-0.56542802,
0.62106263,
-0.03113657,
0.98090236,
0.02678669,
1.2237701,
-0.50112787,
-0.47742454,
1.16351356,
]
)
noise2 = np.array(
[
0.24484502,
-0.22979797,
0.40639882,
0.12137103,
0.20694025,
0.68952746,
-0.30300402,
-0.11136982,
0.3549814,
0.20528704,
]
)
self.observations1 += noise1
self.observations2 += noise2
# Instantiate the (weighted) linear models and their linear fits
self.linearModel1 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv1)
self.linearModel2 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv2)
self.linearFit1 = self.linearModel1.fitData(self.observations1)
self.linearFit2 = self.linearModel2.fitData(self.observations2)
def testContainsRegressorName(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.containsRegressorName("t^2"))
self.assertFalse(linearModel.containsRegressorName("x"))
def testSomeRegressorNameContains(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.someRegressorNameContains("^2"))
self.assertFalse(linearModel.someRegressorNameContains("**2"))
def testConditionNumber(self):
expectedConditionNumber = 57.120830024
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertAlmostEqual(linearModel.conditionNumber(), expectedConditionNumber, places = 5)
class WeightedLinearFitTestCase(unittest.TestCase):
"""
Test the LinearFit class with a specified covariance matrix for the
observations. Test only those method affected by weights.
"""
def setUp(self):
# Generate simple noiseless dataset
self.nObservations = 10
self.nParameters = 2
time = np.arange(self.nObservations, dtype=np.double)
self.observations1 = 1.0 + 0.3 * time
self.observations2 = 1.0 + 0.3 * time
self.regressorList = [np.ones_like(time), time]
self.regressorNames = ["1", "t"]
self.designMatrix = np.column_stack(self.regressorList)
# First covariance matrix: different weights, no correlations
covMatrixObserv1 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
# Second covariance matrix: different weights and correlations
# Correlation coefficient: 0.6
covMatrixObserv2 = np.diag(0.1 + 0.1 * np.arange(self.nObservations))
for i in range(self.nObservations):
for j in range(self.nObservations):
if i>=j: continue
covMatrixObserv2[i,j] = 0.6 * sqrt(covMatrixObserv2[i,i] * covMatrixObserv2[j,j])
covMatrixObserv2[j,i] = covMatrixObserv2[i,j]
# Add noise according to the different covariance matrices
noise1 = np.array([-0.26944792, -0.56542802, 0.62106263, -0.03113657, 0.98090236, \
0.02678669, 1.2237701 , -0.50112787, -0.47742454, 1.16351356])
noise2 = np.array([ 0.24484502, -0.22979797, 0.40639882, 0.12137103, 0.20694025, \
0.68952746, -0.30300402, -0.11136982, 0.3549814 , 0.20528704])
self.observations1 += noise1
self.observations2 += noise2
# Instantiate the (weighted) linear models and their linear fits
self.linearModel1 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv1)
self.linearModel2 = LinearModel(self.regressorList, self.regressorNames, covMatrixObserv2)
self.linearFit1 = self.linearModel1.fitData(self.observations1)
self.linearFit2 = self.linearModel2.fitData(self.observations2)
def tearDown(self):
pass
def testDecorrelatedObservations(self):
expectedObservations = np.array([3.9365456, 0.03889641, 1.73885587, 0.65979961, 0.82899163,
1.73402234, -0.1799988, 0.37289876, 1.25537791, 1.05209144])
self.assertTrue(isinstance(self.linearFit2.observations(weighted=True), np.ndarray))
self.assertEqual(self.linearFit2.observations(weighted=True).shape, (self.nObservations,))
self.assertTrue(np.allclose(expectedObservations, self.linearFit2.observations(weighted=True), rtol=1.0e-6, atol=1.e-08))
def testWeightedRegressionCoefficients(self):
# A test with a diagonal covariance matrix
expectedWeightedCoeff = np.array([0.76576446, 0.40030724])
self.assertTrue(np.allclose(self.linearFit1.regressionCoefficients(), expectedWeightedCoeff, rtol=1.0e-6, atol=1.e-08))
# A test with a non-diagonal covariance matrix
expectedWeightedCoeff = np.array([1.1623421, 0.3040605])
self.assertTrue(np.allclose(self.linearFit2.regressionCoefficients(), expectedWeightedCoeff, rtol=1.0e-6, atol=1.e-08))
def testResiduals(self):
# A test with a diagonal covariance matrix
expectedResiduals = np.array([-0.03521238, -0.43149972, 0.65468369, -0.09782275, 0.81390894, -0.24051397, 0.85616220, -0.96904301, -1.04564692, 0.49498394])
self.assertTrue(np.allclose(self.linearFit1.residuals(weighted=False), expectedResiduals, rtol=1.0e-6, atol=1.e-08))
# A test with a non-diagonal covariance matrix
expectedResiduals = np.array([0.082502896, -0.396200554, 0.235935777, -0.053152473, 0.028356288, 0.506883039, -0.489708901, -0.302135160, 0.160155600, 0.006400781])
self.assertTrue(np.allclose(self.linearFit2.residuals(weighted=False), expectedResiduals, rtol=1.0e-6, atol=1.e-08))
def testCopyWeightedLinearModel(self):
linearModel = LinearModel(self.regressorList, self.regressorNames, self.covMatrixObserv2, regressorsAreWeighted=False)
linearModel2 = linearModel.copy()
self.assertTrue(np.alltrue(linearModel2._covMatrixObserv == self.covMatrixObserv2))
self.assertTrue(id(linearModel2._covMatrixObserv) != id(linearModel._covMatrixObserv))
def testSomeRegressorNameContains(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.someRegressorNameContains("^2"))
self.assertFalse(linearModel.someRegressorNameContains("**2"))
def testFitData(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(isinstance(linearModel.fitData(self.observations), LinearFit))
def testTraceHatMatrix(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
expectedTrace = 2.0
self.assertAlmostEqual(linearModel.traceHatMatrix(), expectedTrace, places=7)
def testFitData(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(isinstance(linearModel.fitData(self.observations), LinearFit))
def testTraceHatMatrix(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
expectedTrace = 2.0
self.assertAlmostEqual(linearModel.traceHatMatrix(), expectedTrace, places=7)
def testContainsRegressorName(self):
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertTrue(linearModel.containsRegressorName("t^2"))
self.assertFalse(linearModel.containsRegressorName("x"))
def testDegreesOfFreedom(self):
expectedDegreesOfFreedom = 8
linearModel = LinearModel(self.regressorList, self.regressorNames)
self.assertEqual(linearModel.degreesOfFreedom(), expectedDegreesOfFreedom)
class LinearFitTestCase(unittest.TestCase):
"""
Test the LinearFit class and its methods
"""
def setUp(self):
# Generate a simple dataset.
# Noise-values are drawn from a N(0,1), but are truncated.
self.nObservations = 10
self.nParameters = 2
self.time = np.arange(self.nObservations, dtype=np.double)
self.noise = np.array([-.72, -1.02, .52, .24, -.17, -1.78, .56, .33, .19, 1.03])
self.observations = 3.0 + 2.0 * self.time**2 + self.noise
regressorList = [np.ones_like(self.time), self.time**2]
regressorNames = ["1", "t^2"]
self.linearModel = LinearModel(regressorList, regressorNames)
self.linearFit = self.linearModel.fitData(self.observations)
def tearDown(self):
pass
def testLinearFit(self):
self.assertTrue(isinstance(self.linearFit, LinearFit))
def testObservations(self):
# Since the linear model did not have a covariance matrix specified, the
# decorrelated observations, should be simply the original observations
self.assertTrue(isinstance(self.linearFit.observations(weighted=True), np.ndarray))
self.assertEqual(self.linearFit.observations(weighted=True).shape, (self.nObservations,))
self.assertTrue(np.alltrue(self.observations == self.linearFit.observations(weighted=True)))
self.assertTrue(np.alltrue(self.observations == self.linearFit.observations(weighted=False)))
def testRegressionCoefficients(self):
expectedCoeff = np.array([2.47811858, 2.01543444])
self.assertTrue(isinstance(self.linearFit.regressionCoefficients(), np.ndarray))
self.assertEqual(self.linearFit.regressionCoefficients().shape, (self.nParameters,))
self.assertTrue(np.allclose(self.linearFit.regressionCoefficients(), expectedCoeff, rtol=1.0e-6, atol=1.e-08))
def testResiduals(self):
expectedResiduals = np.array([-0.19811858, -0.51355301, 0.98014368, 0.6229715,
0.10493045, -1.64397947, 0.52624173, 0.09559406,
-0.27592247, 0.30169212])
self.assertTrue(isinstance(self.linearFit.residuals(weighted=False), np.ndarray))
self.assertEqual(self.linearFit.residuals(weighted=False).shape, (self.nObservations,))
self.assertTrue(np.allclose(self.linearFit.residuals(weighted=False), expectedResiduals, rtol=1.0e-6, atol=1.e-08))
def testPredictions(self):
expectedPredictions = np.array([2.47811858, 4.49355301, 10.53985632, 20.6170285,
34.72506955, 52.86397947, 75.03375827,
101.23440594, 131.46592247, 165.72830788])
self.assertTrue(isinstance(self.linearFit.predictions(weighted=False), np.ndarray))
self.assertEqual(self.linearFit.predictions(weighted=False).shape, (self.nObservations,))
self.assertTrue(np.allclose(self.linearFit.predictions(weighted=False), expectedPredictions, rtol=1.0e-6, atol=1.e-08))
def testCovarianceMatrix(self):
expectedCovMatrix = np.array([[1.28084978e-01, -2.38076167e-03],
[-2.38076167e-03, 8.35354974e-05]])
self.assertTrue(isinstance(self.linearFit.covarianceMatrix(), np.ndarray))
self.assertEqual(self.linearFit.covarianceMatrix().shape, (self.nParameters,self.nParameters))
self.assertTrue(np.allclose(self.linearFit.covarianceMatrix(), expectedCovMatrix, rtol=1.0e-6, atol=1.e-08))
def testErrorBars(self):
expectedErrors = np.array([0.35788962, 0.00913978])
self.assertTrue(isinstance(self.linearFit.errorBars(), np.ndarray))
self.assertEqual(self.linearFit.errorBars().shape, (self.nParameters,))
self.assertTrue(np.allclose(self.linearFit.errorBars(), expectedErrors, rtol=1.0e-6, atol=1.e-08))
def testConfidenceIntervals(self):
alpha = 0.05
expectedLower = np.array([1.65282364, 1.99435808])
expectedUpper = np.array([3.30341351, 2.0365108 ])
self.assertEqual(len(self.linearFit.confidenceIntervals(0.05)), 2)
lower, upper = self.linearFit.confidenceIntervals(0.05)
self.assertTrue(isinstance(lower, np.ndarray))
self.assertTrue(isinstance(upper, np.ndarray))
self.assertEqual(len(lower), self.nParameters)
self.assertEqual(len(upper), self.nParameters)
self.assertTrue(np.allclose(lower, expectedLower, rtol=1.0e-6, atol=1.e-08))
self.assertTrue(np.allclose(upper, expectedUpper, rtol=1.0e-6, atol=1.e-08))
def testT_values(self):
expectedTvalues = np.array([6.92425385, 220.51235807])
self.assertTrue(isinstance(self.linearFit.t_values(), np.ndarray))
self.assertEqual(self.linearFit.t_values().shape, (self.nParameters,))
self.assertTrue(np.allclose(self.linearFit.t_values(), expectedTvalues, rtol=1.0e-6, atol=1.e-08))
def testSumOfSquaredResiduals(self):
expectedSumSqResiduals = 4.81866162957
self.assertAlmostEqual(self.linearFit.sumSqResiduals(weighted=False), expectedSumSqResiduals, places=7)
def testResidualVariance(self):
expectedResidualVariance = 0.60233270369599989
self.assertAlmostEqual(self.linearFit.residualVariance(weighted=False), expectedResidualVariance, places=7)
def testCorrelationMatrix(self):
expectedCorrelationMatrix = np.array([[1., -0.72783225], [-0.72783225, 1.]])
self.assertTrue(np.allclose(self.linearFit.correlationMatrix(), expectedCorrelationMatrix, rtol=1.0e-6, atol=1.e-08))
def testCoefficientOfDetermination(self):
# Test using a model with an intercept
expectedCoefficientOfDetermination = 0.99983550516908659
self.assertAlmostEqual(self.linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7)
# Test using a model without an intercept
linearModel = LinearModel([self.time**2], ["t^2"])
linearFit = linearModel.fitData(self.observations)
expectedCoefficientOfDetermination = 0.99948312767720937
self.assertAlmostEqual(linearFit.coefficientOfDetermination(weighted=False), expectedCoefficientOfDetermination, places=7)
def testBICvalue(self):
expectedBICvalue = -0.39313345804942657
self.assertAlmostEqual(self.linearFit.BICvalue(), expectedBICvalue, places=7)
def testAICvalue(self):
expectedAICvalue = 2.6991112629684357
self.assertAlmostEqual(self.linearFit.AICvalue(), expectedAICvalue, places=7)
def testThypothesisTest(self):
regressorList = [np.ones_like(self.time), self.time**2, self.time**3]
regressorNames = ["1", "t^2", "t^3"]
linearModel = LinearModel(regressorList, regressorNames)
linearFit = linearModel.fitData(self.observations)
alpha = 0.05 # significance level
expectedOutput = np.array([True, True, False])
nullRejected = linearFit.regressorTtest(alpha)
self.assertTrue(isinstance(nullRejected, np.ndarray))
self.assertTrue(nullRejected.dtype == np.bool)
self.assertEqual(len(nullRejected), len(regressorList))
self.assertTrue(np.all(nullRejected == expectedOutput))
def testFstatistic(self):
# Test on a model with more than one regressor
expectedFstatistic = 48625.747064132738
self.assertAlmostEqual(self.linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
# Test on a model with only one regressor
expectedFstatistic = 17403.423925909559
linearModel = LinearModel([np.square(self.time)], ["t^2"])
linearFit = linearModel.fitData(self.observations)
self.assertAlmostEqual(linearFit.Fstatistic(weighted=False), expectedFstatistic, places=7)
def testFstatisticTest(self):
# with tested model the same as the true model
alpha = 0.05
expectedOutput = True # null hypothesis rejected
self.assertTrue(self.linearFit.FstatisticTest(alpha) == expectedOutput)
# with a fit on pure noise noise
alpha = 0.05
expectedOutput = False # null hypothesis could not be rejected
linearFit = self.linearModel.fitData(self.noise)
self.assertTrue(linearFit.FstatisticTest(alpha) == expectedOutput)
def testEvaluate(self):
expectedOutput = np.array([ 52.86397947, 42.8147219 , 33.8820485 , 26.06595927,
19.36645422, 13.78353335, 9.31719665, 5.96744412,
3.73427577, 2.6176916 , 2.6176916 , 3.73427577,
5.96744412, 9.31719665, 13.78353335, 19.36645422,
26.06595927, 33.8820485 , 42.8147219 , 52.86397947])
xnew = np.linspace(-5.0, +5.0, 20)
newRegressorList = [np.ones_like(xnew), xnew**2]
output = self.linearFit.evaluate(newRegressorList)
self.assertTrue(np.allclose(output, expectedOutput, rtol=1.0e-6, atol=1.e-08))
