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)
