def testSaveParams(self): try: import sklearn except ImportError as error: return svm = LibSVM() svm.setC(10.5) svm.setEpsilon(12.1) svm.setErrorCost(1.8) svm.setSvmType("Epsilon_SVR") svm.setTermination(0.12) svm.setKernel("gaussian", 0.43) outputDir = PathDefaults.getOutputDir() fileName = outputDir + "test/testSvmParams" svm.saveParams(fileName) svm2 = LibSVM() svm2.loadParams(fileName) self.assertEquals(svm.getC(), 10.5) self.assertEquals(svm.getEpsilon(), 12.1) self.assertEqual(svm.getErrorCost(), 1.8) self.assertEqual(svm.getSvmType(), "Epsilon_SVR") self.assertEqual(svm.getTermination(), 0.12) self.assertEqual(svm.getKernel(), "gaussian") self.assertEqual(svm.getKernelParams(), 0.43)
def testStr(self): try: import sklearn except ImportError as error: return svm = LibSVM()
def testSetErrorCost(self): try: import sklearn except ImportError as error: return numExamples = 1000 numFeatures = 100 eg = ExamplesGenerator() X, y = eg.generateBinaryExamples(numExamples, numFeatures) svm = LibSVM() C = 0.1 kernel = "linear" kernelParam = 0 svm.setKernel(kernel, kernelParam) svm.setC(C) svm.setErrorCost(0.1) svm.learnModel(X, y) predY = svm.classify(X) e1 = Evaluator.binaryErrorP(y, predY) svm.setErrorCost(0.9) svm.learnModel(X, y) predY = svm.classify(X) e2 = Evaluator.binaryErrorP(y, predY) self.assertTrue(e1 > e2)
def testComputeTestError(self): C = 10.0 gamma = 0.5 numTrainExamples = self.X.shape[0] * 0.5 trainX, trainY = self.X[ 0:numTrainExamples, :], self.y[0:numTrainExamples] testX, testY = self.X[numTrainExamples:, :], self.y[numTrainExamples:] svm = LibSVM('gaussian', gamma, C) args = (trainX, trainY, testX, testY, svm) error = computeTestError(args) svm = LibSVM('gaussian', gamma, C) svm.learnModel(trainX, trainY) predY = svm.predict(testX) self.assertEquals(Evaluator.binaryError(predY, testY), error)
def testGetWeights(self): try: import sklearn except ImportError as error: return numExamples = 6 X = numpy.array([[-3], [-2], [-1], [1], [2], [3]], numpy.float64) #X = numpy.random.rand(numExamples, 10) y = numpy.array([[-1], [-1], [-1], [1], [1], [1]]) svm = LibSVM() svm.learnModel(X, y.ravel()) weights, b = svm.getWeights() #Let's see if we can compute the decision values y, decisions = svm.predict(X, True) decisions2 = numpy.zeros(numExamples) decisions2 = numpy.dot(X, weights) - b self.assertTrue((decisions == decisions2).all()) predY = numpy.sign(decisions2) self.assertTrue((y.ravel() == predY).all()) #Do the same test on a random datasets numExamples = 50 numFeatures = 10 X = numpy.random.rand(numExamples, numFeatures) y = numpy.sign(numpy.random.rand(numExamples) - 0.5) svm = LibSVM() svm.learnModel(X, y.ravel()) weights, b = svm.getWeights() #Let's see if we can compute the decision values y, decisions = svm.predict(X, True) decisions2 = numpy.dot(X, weights) + b tol = 10**-6 self.assertTrue(numpy.linalg.norm(decisions - decisions2) < tol) predY = numpy.sign(decisions2) self.assertTrue((y.ravel() == predY).all())
def testComputeBootstrapError(self): C = 10.0 gamma = 0.5 numTrainExamples = self.X.shape[0] * 0.5 trainX, trainY = self.X[ 0:numTrainExamples, :], self.y[0:numTrainExamples] testX, testY = self.X[numTrainExamples:, :], self.y[numTrainExamples:] svm = LibSVM('gaussian', gamma, C) args = (trainX, trainY, testX, testY, svm) error = computeBootstrapError(args)
def testGetModel(self): try: import sklearn except ImportError as error: return numExamples = 50 numFeatures = 3 eg = ExamplesGenerator() X, y = eg.generateBinaryExamples(numExamples, numFeatures) svm = LibSVM() svm.learnModel(X, y) weights, b = svm.getWeights()
def profileModelSelect(self): learner = LibSVM() numExamples = 10000 numFeatures = 10 X = numpy.random.rand(numExamples, numFeatures) Y = numpy.array(numpy.random.rand(numExamples) < 0.1, numpy.int) * 2 - 1 def run(): for i in range(5): print("Iteration " + str(i)) idx = Sampling.crossValidation(self.folds, numExamples) learner.parallelModelSelect(X, Y, idx, self.paramDict) ProfileUtils.profile('run()', globals(), locals())
def testPredict(self): try: import sklearn except ImportError as error: return numExamples = 100 numFeatures = 10 X = numpy.random.randn(numExamples, numFeatures) c = numpy.random.randn(numFeatures) y = numpy.dot(X, numpy.array([c]).T).ravel() y = numpy.array(y > 0, numpy.int32) * 2 - 1 svm = LibSVM() svm.learnModel(X, y) y2, d = svm.predict(X, True)
def profileParallelPen(self): learner = LibSVM(processes=8) learner.setChunkSize(2) numExamples = 10000 numFeatures = 10 X = numpy.random.rand(numExamples, numFeatures) Y = numpy.array(numpy.random.rand(numExamples) < 0.1, numpy.int) * 2 - 1 Cvs = [self.folds - 1] def run(): for i in range(2): print("Iteration " + str(i)) idx = Sampling.crossValidation(self.folds, numExamples) learner.parallelPen(X, Y, idx, self.paramDict, Cvs) ProfileUtils.profile('run()', globals(), locals())
def testSetSvmType(self): try: import sklearn except ImportError as error: return numExamples = 100 numFeatures = 10 X = numpy.random.randn(numExamples, numFeatures) X = Standardiser().standardiseArray(X) c = numpy.random.randn(numFeatures) y = numpy.dot(X, numpy.array([c]).T).ravel() + 1 y2 = numpy.array(y > 0, numpy.int32) * 2 - 1 svm = LibSVM() svm.setSvmType("Epsilon_SVR") self.assertEquals(svm.getType(), "Epsilon_SVR") #Try to get a good error Cs = 2**numpy.arange(-6, 4, dtype=numpy.float) epsilons = 2**numpy.arange(-6, 4, dtype=numpy.float) bestError = 10 for C in Cs: for epsilon in epsilons: svm.setEpsilon(epsilon) svm.setC(C) svm.learnModel(X, y) yp = svm.predict(X) if Evaluator.rootMeanSqError(y, yp) < bestError: bestError = Evaluator.rootMeanSqError(y, yp) self.assertTrue( bestError < Evaluator.rootMeanSqError(y, numpy.zeros(y.shape[0]))) svm.setSvmType("C_SVC") svm.learnModel(X, y2) yp2 = svm.predict(X) self.assertTrue(0 <= Evaluator.binaryError(y2, yp2) <= 1)
def setUp(self): try: import sklearn except ImportError as error: logging.debug(error) return numpy.random.seed(21) numExamples = 100 numFeatures = 10 eg = ExamplesGenerator() self.X, self.y = eg.generateBinaryExamples(numExamples, numFeatures) self.svm = LibSVM() self.svm.Cs = 2.0**numpy.arange(-2, 2, dtype=numpy.float) self.svm.gammas = 2.0**numpy.arange(-3, 1, dtype=numpy.float) self.svm.epsilons = 2.0**numpy.arange(-2, 0, dtype=numpy.float) numpy.set_printoptions(linewidth=150, suppress=True, precision=3) logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
def testLearnModel(self): try: import sklearn except ImportError as error: return self.svm.learnModel(self.X, self.y) predY = self.svm.classify(self.X) y = self.y e = Evaluator.binaryError(y, predY) #Test for wrong labels numExamples = 6 X = numpy.array([[-3], [-2], [-1], [1], [2], [3]], numpy.float) y = numpy.array([[-1], [-1], [-1], [1], [1], [5]]) self.assertRaises(ValueError, self.svm.learnModel, X, y) #Try the regression SVM svm = LibSVM(type="Epsilon_SVR") y = numpy.random.rand(self.X.shape[0]) svm.learnModel(self.X, self.y)
def testSetEpsilon(self): """ Test out the parameter for the regressive SVM, vary epsilon and look at number of support vectors. """ try: import sklearn except ImportError as error: return svm = LibSVM() svm.setC(10.0) svm.setEpsilon(0.1) svm.setSvmType("Epsilon_SVR") numExamples = 100 numFeatures = 10 X = numpy.random.randn(numExamples, numFeatures) c = numpy.random.randn(numFeatures) y = numpy.dot(X, numpy.array([c]).T).ravel() + numpy.random.randn(100) svm.setEpsilon(1.0) svm.learnModel(X, y) numSV = svm.getModel().support_.shape svm.setEpsilon(0.5) svm.learnModel(X, y) numSV2 = svm.getModel().support_.shape svm.setEpsilon(0.01) svm.learnModel(X, y) numSV3 = svm.getModel().support_.shape #There should be fewer SVs as epsilon increases self.assertTrue(numSV < numSV2) self.assertTrue(numSV2 < numSV3)
def testComputeIdealPenalty(self): C = 10.0 gamma = 0.5 svm = LibSVM("gaussian", gamma, C) args = (self.X, self.y, self.X, self.y, svm) error = computeIdealPenalty(args)
def testGetC(self): svm = LibSVM() svm.setC(10.0) C = svm.getC() self.assertTrue(C == 10.0)
def testGetGamma(self): svm = LibSVM() svm.setKernel("gaussian", 12.0) gamma = svm.getKernelParams() self.assertTrue(gamma == 12.0)