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_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_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 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_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_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_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_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))