def test_bfgs_madsen(self):
from ch import SumOfSquares
import scipy.optimize
obj = Ch(lambda x: SumOfSquares(Madsen(x=x)))
def errfunc(x):
obj.x = Ch(x)
return obj.r
def gradfunc(x):
obj.x = Ch(x)
return obj.dr_wrt(obj.x).ravel()
x0 = np.array((3., 1.))
# Optimize with built-in bfgs.
# Note: with 8 iters, this actually requires 14 gradient evaluations.
# This can be verified by setting "disp" to 1.
#tm = time.time()
x1 = scipy.optimize.fmin_bfgs(errfunc,
x0,
fprime=gradfunc,
maxiter=8,
disp=0)
#print 'forward: took %.es' % (time.time() - tm,)
self.assertTrue(obj.r / 2. < 0.386599528247)
# Optimize with chumpy's minimize (which uses scipy's bfgs).
obj.x = x0
minimize(fun=obj, x0=[obj.x], method='bfgs', options={'maxiter': 8})
self.assertTrue(obj.r / 2. < 0.386599528247)
def test_bfgs_madsen(self):
from ch import SumOfSquares
import scipy.optimize
obj = Ch(lambda x : SumOfSquares(Madsen(x = x)) )
def errfunc(x):
obj.x = Ch(x)
return obj.r
def gradfunc(x):
obj.x = Ch(x)
return obj.dr_wrt(obj.x).ravel()
x0 = np.array((3., 1.))
# Optimize with built-in bfgs.
# Note: with 8 iters, this actually requires 14 gradient evaluations.
# This can be verified by setting "disp" to 1.
#tm = time.time()
x1 = scipy.optimize.fmin_bfgs(errfunc, x0, fprime=gradfunc, maxiter=8, disp=0)
#print 'forward: took %.es' % (time.time() - tm,)
self.assertLess(obj.r/2., 0.4)
# Optimize with chumpy's minimize (which uses scipy's bfgs).
obj.x = x0
minimize(fun=obj, x0=[obj.x], method='bfgs', options={'maxiter': 8, 'disp': False})
self.assertLess(obj.r/2., 0.4)
def Rosen():
args = {'x1': Ch(-120.), 'x2': Ch(-100.)}
r1 = Ch(lambda x1, x2: (x2 - x1**2.) * 10., args)
r2 = Ch(lambda x1: x1 * -1. + 1, args)
func = [r1, r2]
return func, [args['x1'], args['x2']]
def lstsq(a, b, rcond=-1):
if rcond != -1:
raise Exception('non-default rcond not yet implemented')
x = Ch(lambda a, b : pinv(a).dot(b))
x.a = a
x.b = b
residuals = ch.sum( (x.a.dot(x) - x.b) **2 , axis=0)
rank = NotImplementedError
s = NotImplementedError
return x, residuals, rank, s
def test_inv3(self):
"""Test linalg.inv with broadcasting support."""
from linalg import Inv
mtx1 = Ch(np.sin(2**np.arange(12)).reshape((3, 2, 2)))
mtx1_inv = Inv(mtx1)
dr = mtx1_inv.dr_wrt(mtx1)
eps = 1e-5
mtx2 = mtx1.r.copy()
input_diff = np.sin(np.arange(mtx2.size)).reshape(mtx2.shape) * eps
mtx2 += input_diff
mtx2_inv = Inv(mtx2)
output_diff_emp = (np.linalg.inv(mtx2) - np.linalg.inv(mtx1.r)).ravel()
output_diff_pred = Inv(mtx1).dr_wrt(mtx1).dot(input_diff.ravel())
# print output_diff_emp
# print output_diff_pred
self.assertTrue(
np.max(np.abs(output_diff_emp.ravel() -
output_diff_pred.ravel())) < eps * 1e-3)
self.assertTrue(
np.max(np.abs(mtx1_inv.r - np.linalg.inv(mtx1.r)).ravel()) == 0)
def test_dogleg_madsen(self):
obj = Madsen(x=Ch(np.array((3., 1.))))
minimize(fun=obj,
x0=[obj.x],
method='dogleg',
options={
'maxiter': 34,
'disp': False
})
self.assertTrue(np.sum(obj.r**2) / 2 < 0.386599528247)
def test_ic(self):
child = Child(a=Ch(10))
parent = Parent(child=child, aliased=Ch(50))
junk = [parent.aliased_dependency for k in range(3)]
self.assertTrue(parent.dcount == 1)
self.assertTrue(parent.ocount == 0)
self.assertTrue(parent.rcount == 0)
junk = [parent.r for k in range(3)]
self.assertTrue(parent.dcount == 1)
self.assertTrue(parent.ocount == 1)
self.assertTrue(parent.rcount == 1)
parent.aliased = Ch(20)
junk = [parent.aliased_dependency for k in range(3)]
self.assertTrue(parent.dcount == 2)
self.assertTrue(parent.ocount == 1)
self.assertTrue(parent.rcount == 1)
junk = [parent.r for k in range(3)]
self.assertTrue(parent.dcount == 2)
self.assertTrue(parent.ocount == 2)
self.assertTrue(parent.rcount == 2)
def test_inv2(self):
from linalg import Inv
eps = 1e-8
idx = 13
mtx1 = np.random.rand(100).reshape((10, 10))
mtx2 = mtx1.copy()
mtx2.ravel()[idx] += eps
diff_emp = (np.linalg.inv(mtx2) - np.linalg.inv(mtx1)) / eps
mtx1 = Ch(mtx1)
diff_pred = Inv(mtx1).dr_wrt(mtx1)[:, 13].reshape(diff_emp.shape)
#print diff_emp
#print diff_pred
#print diff_emp - diff_pred
self.assertTrue(
np.max(np.abs(diff_pred.ravel() - diff_emp.ravel())) < 1e-4)
def test_svd(self):
from linalg import Svd
eps = 1e-3
idx = 10
data = np.sin(np.arange(300) * 100 + 10).reshape((-1, 3))
data[3, :] = data[3, :] * 0 + 10
data[:, 1] *= 2
data[:, 2] *= 4
data = data.copy()
u, s, v = np.linalg.svd(data, full_matrices=False)
data = Ch(data)
data2 = data.r.copy()
data2.ravel()[idx] += eps
u2, s2, v2 = np.linalg.svd(data2, full_matrices=False)
svdu, svdd, svdv = Svd(x=data)
# test singular values
diff_emp = (s2 - s) / eps
diff_pred = svdd.dr_wrt(data)[:, idx]
#print diff_emp
#print diff_pred
ratio = diff_emp / diff_pred
#print ratio
self.assertTrue(np.max(np.abs(ratio - 1.)) < 1e-4)
# test V
diff_emp = (v2 - v) / eps
diff_pred = svdv.dr_wrt(data)[:, idx].reshape(diff_emp.shape)
ratio = diff_emp / diff_pred
#print ratio
self.assertTrue(np.max(np.abs(ratio - 1.)) < 1e-2)
# test U
diff_emp = (u2 - u) / eps
diff_pred = svdu.dr_wrt(data)[:, idx].reshape(diff_emp.shape)
ratio = diff_emp / diff_pred
#print ratio
self.assertTrue(np.max(np.abs(ratio - 1.)) < 1e-2)
def test_inv1(self):
from linalg import Inv
mtx1 = Ch(np.sin(2**np.arange(9)).reshape((3, 3)))
mtx1_inv = Inv(mtx1)
dr = mtx1_inv.dr_wrt(mtx1)
eps = 1e-5
mtx2 = mtx1.r.copy()
input_diff = np.sin(np.arange(mtx2.size)).reshape(mtx2.shape) * eps
mtx2 += input_diff
mtx2_inv = Inv(mtx2)
output_diff_emp = (np.linalg.inv(mtx2) - np.linalg.inv(mtx1.r)).ravel()
output_diff_pred = Inv(mtx1).dr_wrt(mtx1).dot(input_diff.ravel())
#print output_diff_emp
#print output_diff_pred
self.assertTrue(
np.max(np.abs(output_diff_emp - output_diff_pred)) < eps * 1e-4)
self.assertTrue(
np.max(np.abs(mtx1_inv.r - np.linalg.inv(mtx1.r)).ravel()) == 0)
def set_and_get_dr(self, x_in):
self.x = Ch(x_in)
return self.dr_wrt(self.x).flatten()
def set_and_get_r(self, x_in):
self.x = Ch(x_in)
return col(self.r)
def gradfunc(x):
obj.x = Ch(x)
return obj.dr_wrt(obj.x).ravel()
def errfunc(x):
obj.x = Ch(x)
return obj.r
def ch(a_city, d_city, date):
return Ch.get_ch(a_city, d_city, date)
