def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
assert_equal(type(vals), np.int_)
vals = nan_to_num(1, nan=10, posinf=20, neginf=30)
assert_all(vals == 1)
assert_equal(type(vals), np.int_)
def test_float(self):
vals = nan_to_num(1.0)
assert_all(vals == 1.0)
assert_equal(type(vals), np.float_)
vals = nan_to_num(1.1, nan=10, posinf=20, neginf=30)
assert_all(vals == 1.1)
assert_equal(type(vals), np.float_)
def test_array(self):
vals = nan_to_num([1])
assert_array_equal(vals, np.array([1], int))
assert_equal(type(vals), np.ndarray)
vals = nan_to_num([1], nan=10, posinf=20, neginf=30)
assert_array_equal(vals, np.array([1], int))
assert_equal(type(vals), np.ndarray)
def test_complex_good(self):
vals = nan_to_num(1+1j)
assert_all(vals == 1+1j)
assert_equal(type(vals), np.complex_)
vals = nan_to_num(1+1j, nan=10, posinf=20, neginf=30)
assert_all(vals == 1+1j)
assert_equal(type(vals), np.complex_)
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
assert_equal(type(vals), np.int_)
vals = nan_to_num(1, nan=10, posinf=20, neginf=30)
assert_all(vals == 1)
assert_equal(type(vals), np.int_)
def test_float(self):
vals = nan_to_num(1.0)
assert_all(vals == 1.0)
assert_equal(type(vals), np.float_)
vals = nan_to_num(1.1, nan=10, posinf=20, neginf=30)
assert_all(vals == 1.1)
assert_equal(type(vals), np.float_)
def test_complex_good(self):
vals = nan_to_num(1 + 1j)
assert_all(vals == 1 + 1j)
assert_equal(type(vals), np.complex_)
vals = nan_to_num(1 + 1j, nan=10, posinf=20, neginf=30)
assert_all(vals == 1 + 1j)
assert_equal(type(vals), np.complex_)
def test_array(self):
vals = nan_to_num([1])
assert_array_equal(vals, np.array([1], int))
assert_equal(type(vals), np.ndarray)
vals = nan_to_num([1], nan=10, posinf=20, neginf=30)
assert_array_equal(vals, np.array([1], int))
assert_equal(type(vals), np.ndarray)
def test_generic(self):
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0.)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
# perform the same test but in-place
with np.errstate(divide='ignore', invalid='ignore'):
vals = np.array((-1., 0, 1))/0.
result = nan_to_num(vals, copy=False)
assert_(result is vals)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
def test_complex_bad(self):
with np.errstate(divide='ignore', invalid='ignore'):
v = 1 + 1j
v += np.array(0+1.j)/0.
vals = nan_to_num(v)
# !! This is actually (unexpectedly) zero
assert_all(np.isfinite(vals))
def calcN(classKernels, trainLabels):
N = zeros((len(trainLabels), len(trainLabels)))
for i, l in enumerate(unique(trainLabels)):
numExamplesWithLabel = len(where(trainLabels == l)[0])
Idiff = identity(numExamplesWithLabel, Float64) - (1.0 / numExamplesWithLabel) * ones(numExamplesWithLabel, Float64)
firstDot = dot(classKernels[i], Idiff)
labelTerm = dot(firstDot, transpose(classKernels[i]))
N += labelTerm
N = nan_to_num(N)
#make N more numerically stable
#if I had more time, I would train this parameter, but I don't
additionToN = ((mean(diag(N)) + 1) / 100.0) * identity(N.shape[0], Float64)
N += additionToN
#make sure N is invertable
for i in range(1000):
try:
inv(N)
except LinAlgError:
#doing this to make sure the maxtrix is invertable
#large value supported by section titled
#"numerical issues and regularization" in the paper
N += additionToN
return N
def test_generic(self):
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1)) / 0.)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
# perform the same test but in-place
with np.errstate(divide='ignore', invalid='ignore'):
vals = np.array((-1., 0, 1)) / 0.
result = nan_to_num(vals, copy=False)
assert_(result is vals)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
def test_complex_bad2(self):
with np.errstate(divide='ignore', invalid='ignore'):
v = 1 + 1j
v += np.array(-1 + 1.j) / 0.
vals = nan_to_num(v)
assert_all(np.isfinite(vals))
assert_equal(type(vals), np.complex_)
def test_complex_bad2(self):
with np.errstate(divide='ignore', invalid='ignore'):
v = 1 + 1j
v += np.array(-1+1.j)/0.
vals = nan_to_num(v)
assert_all(np.isfinite(vals))
assert_equal(type(vals), np.complex_)
def test_complex_bad(self):
with np.errstate(divide='ignore', invalid='ignore'):
v = 1 + 1j
v += np.array(0 + 1.j) / 0.
vals = nan_to_num(v)
# !! This is actually (unexpectedly) zero
assert_all(np.isfinite(vals))
def test_complex_bad(self):
with np.errstate(divide="ignore", invalid="ignore"):
v = 1 + 1j
v += np.array(0 + 1.0j) / 0.0
vals = nan_to_num(v)
# !! This is actually (unexpectedly) zero
assert_all(np.isfinite(vals))
assert_equal(type(vals), np.complex_)
def test_do_not_rewrite_previous_keyword(self):
# This is done to test that when, for instance, nan=np.inf then these
# values are not rewritten by posinf keyword to the posinf value.
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0., nan=np.inf, posinf=999)
assert_all(np.isfinite(vals[[0, 2]]))
assert_all(vals[0] < -1e10)
assert_equal(vals[[1, 2]], [np.inf, 999])
assert_equal(type(vals), np.ndarray)
def test_do_not_rewrite_previous_keyword(self):
# This is done to test that when, for instance, nan=np.inf then these
# values are not rewritten by posinf keyword to the posinf value.
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0., nan=np.inf, posinf=999)
assert_all(np.isfinite(vals[[0, 2]]))
assert_all(vals[0] < -1e10)
assert_equal(vals[[1, 2]], [np.inf, 999])
assert_equal(type(vals), np.ndarray)
def trainKFD(trainKernel, trainLabels):
classKernels = getClassKernels(trainKernel, trainLabels)
M = calcM(classKernels, trainLabels)
N = calcN(classKernels, trainLabels)
'''
print "train kernel:",trainKernel
print "Class kernels:", classKernels
print "M",M
print "N",N
'''
try:
solutionMatrix = dot(inv(N), M)
except LinAlgError:
#if we get a singular matrix here, there isn't much we can do about it
#just skip this configuration
solutionMatrix = identity(N.shape[0], Float64)
solutionMatrix = nan_to_num(solutionMatrix)
eVals, eVects = eig(solutionMatrix)
#find the 'leading' term i.e. find the eigenvector with the highest eigenvalue
alphaVect = eVects[:, absolute(eVals).argmax()].real.astype(Float64)
trainProjections = dot(trainKernel, alphaVect)
'''
print 'alpha = ', alphaVect
print 'train kernel = ', trainKernel
print 'train projction = ', trainProjections
'''
#train sigmoid based on evaluation accuracy
#accuracyError = lambda x: 100.0 - evaluations(trainLabels, classifyKFDValues(trainProjections, *list(x)))[0]
accuracyError = lambda x: 100.0 - evaluations(trainLabels, classifyKFDValues(trainProjections, *x))[0]
#get an initial guess by brute force
#ranges = ((-100, 100, 1), (-100, 100, 1))
#x0 = brute(accuracyError, ranges)
#popt = minimize(accuracyError, x0.tolist(), method="Powell").x
rc = LSFAIL
niter = 0
i = 0
while rc in (LSFAIL, INFEASIBLE, CONSTANT, NOPROGRESS, USERABORT, MAXFUN) or niter <= 1:
if i == 10:
break
#get a 'smarter' x0
#ranges = ((-1000, 1000, 100), (-1000, 1000, 100))
ranges = ((-10**(i + 1), 10**(i + 1), 10**i),) * 2
x0 = brute(accuracyError, ranges)
(popt, niter, rc) = fmin_tnc(accuracyError, x0, approx_grad=True)
#popt = fmin_tnc(accuracyError, x0.tolist(), approx_grad=True)[0]
i += 1
return (alphaVect, popt)
def test_generic(self):
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1)) / 0.)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
assert_equal(type(vals), np.ndarray)
# perform the same tests but with nan, posinf and neginf keywords
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1)) / 0.,
nan=10,
posinf=20,
neginf=30)
assert_equal(vals, [30, 10, 20])
assert_all(np.isfinite(vals[[0, 2]]))
assert_equal(type(vals), np.ndarray)
# perform the same test but in-place
with np.errstate(divide='ignore', invalid='ignore'):
vals = np.array((-1., 0, 1)) / 0.
result = nan_to_num(vals, copy=False)
assert_(result is vals)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
assert_equal(type(vals), np.ndarray)
# perform the same test but in-place
with np.errstate(divide='ignore', invalid='ignore'):
vals = np.array((-1., 0, 1)) / 0.
result = nan_to_num(vals, copy=False, nan=10, posinf=20, neginf=30)
assert_(result is vals)
assert_equal(vals, [30, 10, 20])
assert_all(np.isfinite(vals[[0, 2]]))
assert_equal(type(vals), np.ndarray)
def test_generic(self):
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0.)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
assert_equal(type(vals), np.ndarray)
# perform the same tests but with nan, posinf and neginf keywords
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0.,
nan=10, posinf=20, neginf=30)
assert_equal(vals, [30, 10, 20])
assert_all(np.isfinite(vals[[0, 2]]))
assert_equal(type(vals), np.ndarray)
# perform the same test but in-place
with np.errstate(divide='ignore', invalid='ignore'):
vals = np.array((-1., 0, 1))/0.
result = nan_to_num(vals, copy=False)
assert_(result is vals)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
assert_equal(type(vals), np.ndarray)
# perform the same test but in-place
with np.errstate(divide='ignore', invalid='ignore'):
vals = np.array((-1., 0, 1))/0.
result = nan_to_num(vals, copy=False, nan=10, posinf=20, neginf=30)
assert_(result is vals)
assert_equal(vals, [30, 10, 20])
assert_all(np.isfinite(vals[[0, 2]]))
assert_equal(type(vals), np.ndarray)
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
vals = nan_to_num([1])
assert_array_equal(vals, np.array([1], np.int))
def test_float(self):
vals = nan_to_num(1.0)
assert_all(vals == 1.0)
assert_equal(type(vals), np.float_)
def test_generic(self):
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0.)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
vals = nan_to_num([1])
assert_array_equal(vals, np.array([1], np.int))
def test_complex_good(self):
vals = nan_to_num(1 + 1j)
assert_all(vals == 1 + 1j)
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
assert_equal(type(vals), np.int_)
def test_generic(self):
with np.errstate(divide='ignore', invalid='ignore'):
vals = nan_to_num(np.array((-1., 0, 1))/0.)
assert_all(vals[0] < -1e10) and assert_all(np.isfinite(vals[0]))
assert_(vals[1] == 0)
assert_all(vals[2] > 1e10) and assert_all(np.isfinite(vals[2]))
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
def polyKernel(x,y, gamma, coef, degree):
if gamma == 0:
gamma = .01
ret = (gamma * dot(x, transpose(y)) + coef) ** degree
ret = nan_to_num(ret)
return ret
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
assert_equal(type(vals), np.int_)
def test_array(self):
vals = nan_to_num([1])
assert_array_equal(vals, np.array([1], int))
assert_equal(type(vals), np.ndarray)
def test_complex_good(self):
vals = nan_to_num(1+1j)
assert_all(vals == 1+1j)
assert_equal(type(vals), np.complex_)
def test_complex_good(self):
vals = nan_to_num(1 + 1j)
assert_all(vals == 1 + 1j)
assert_equal(type(vals), np.complex_)
def test_float(self):
vals = nan_to_num(1.0)
assert_all(vals == 1.0)
assert_equal(type(vals), np.float_)
def test_complex_good(self):
vals = nan_to_num(1+1j)
assert_all(vals == 1+1j)
def test_complex_bad2(self):
with np.errstate(divide="ignore", invalid="ignore"):
v = 1 + 1j
v += np.array(-1 + 1.0j) / 0.0
vals = nan_to_num(v)
assert_all(np.isfinite(vals))
def test_integer(self):
vals = nan_to_num(1)
assert_all(vals == 1)
def test_array(self):
vals = nan_to_num([1])
assert_array_equal(vals, np.array([1], int))
assert_equal(type(vals), np.ndarray)
