Data Science: Creating a Stochastic Solution with Support Vector Machine in Python
Support Vector Machine (SVM) machinelearning algorithms are a fantastic tool for a data scientist to use with Python. Of course, even the best solutions have problems. For example, you might think that the SVM has too many parameters in the SVM. Certainly, the parameters are a nuisance, especially when you have to test so many combinations of them, which can take a lot of CPU time.
However, the key problem is the time necessary for training the SVM. You may have noticed that the examples use small datasets with a limited number of variables, and performing some extensive grid searches still takes a lot of time. Realworld datasets are much bigger. Sometimes it may seem to take forever to train and optimize your SVM on your computer.
A possible solution when you have too many cases (a suggested limit is 10,000 examples) is found inside the same SVM module, the LinearSVC class. This algorithm works only with the linear kernel and its focus is to classify (sorry, no regression) large numbers of examples and variables at a higher speed than the standard SVC. Such characteristics make the LinearSVC a good candidate for textualbased classification. LinearSVC has fewer and slightly different parameters to fix than the usual SVM (it’s similar to a regression class):

C: The penalty parameter. Small values imply more regularization (simpler models with attenuated or set to zero coefficients).

loss: A value of l1 (just as in SVM) or l2 (errors weight more, so it strives harder to fit misclassified examples).

penalty: A value of l2 (attenuation of less important parameters) or l1 (unimportant parameters are set to zero).

dual: A value of true or false. It refers to the type of optimization problem solved and, though it won’t change the obtained scoring much, setting the parameter to false results in faster computations than when it is set to true.
The loss, penalty, and dual parameters are also bound by reciprocal constraints, so please refer below to plan which combination to use in advance.
penalty  loss  dual 

l1  l2  False 
l2  l1  True 
l2  l2  True; False 
The algorithm doesn’t support the combination of penalty=‘l1’ and loss=‘l1’. However, the combination of penalty=‘l2’ and loss=‘l1’ perfectly replicates the SVC optimization approach.
LinearSVC is quite fast, and a speed test against SVC demonstrates the level of improvement to expect in choosing this algorithm.
from sklearn.datasets import make_classification X,y = make_classification(n_samples=10**4, n_features=15, n_informative=10, random_state=101) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=101) from sklearn.svm import SVC, LinearSVC slow_SVM = SVC(kernel=“linear”, random_state=101) fast_SVM = LinearSVC(random_state=101, penalty=‘l2’, loss=‘l1’) slow_SVM.fit(X_train, y_train) fast_SVM.fit(X_train, y_train) print ‘SVC test accuracy score: %0.3f’ % slow_SVM.score(X_test, y_test) print ‘LinearSVC test accuracy score: %0.3f’ % fast_SVM.score(X_test, y_test) SVC test accuracy score: 0.808 LinearSVC test accuracy score: 0.808
After you create an artificial dataset using make_classfication, the code obtains confirmation of how the two algorithms arrive at identical results. At this point, the code tests the speed of the two solutions on the synthetic dataset in order to understand how they scale to using more data.
import timeit X,y = make_classification(n_samples=10**4, n_features=15, n_informative=10, random_state=101) print ‘avg secs for SVC, best of 3: %0.1f’
% np.mean(timeit.timeit(“slow_SVM.fit(X, y)”, “from __main__ import slow_SVM, X, y”, number=1)) print ‘avg secs for LinearSVC, best of 3: %0.1f’ % np.mean( timeit.timeit(“fast_SVM.fit(X, y)”, “from __main__ import fast_SVM,
X, y”, number=1))
The example system shows the following result:
avg secs for SVC, best of 3: 15.9 avg secs for LinearSVC, best of 3: 0.4
Clearly, given the same data quantity, LinearSVC is much faster than SVC. You can calculate its performance ratio as 15.9 / 0.4 = 39.75 times faster than SVC. But what if you grow the sample size from 10**4 to 10**5?
avg secs for SVC, best of 3: 3831.6 avg secs for LinearSVC, best of 3: 10.0
The results are quite impressive. LinearSVC is 383.16 times faster than SVC. Even if LinearSVC is quite fast at performing tasks, you may need to classify or regress with examples in the range of millions. You need to know whether LinearSVC is still a better choice.
You previously saw how the SGD class, using SGDClassifier and SGDRegressor, helps you implement an SVMtype algorithm in situations with millions of data rows without investing too much computational power. All you have to do is to set their loss to ‘hinge’ for SGDClassifier and to ‘epsilon_insensitive’ for SGDRegressor.
Another performance and speed test makes the advantages and limitations of using LinearSVC or SGDClassifier clear:
from sklearn.linear_model import SGDClassifier X,y = make_classification(n_samples=10**6, n_features=15, n_informative=10, random_state=101) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=101)
The sample is quite big — 1 million cases. If you have enough memory and a lot of time, you may even want to increase the number of trained cases or the number of features and more extensively test how the two algorithms scale with big data.
fast_SVM = LinearSVC(random_state=101) fast_SVM.fit(X_train, y_train) print ‘LinearSVC test accuracy score: %0.3f’ % fast_SVM.score(X_test, y_test) print ‘avg secs for LinearSVC, best of 3: %0.1f’ % np.mean( timeit.timeit(“fast_SVM.fit(X_train, y_train)”, “from __main__ import fast_SVM, X_train, y_train”, number=1)) LinearSVC test accuracy score: 0.806 avg secs for LinearSVC, best of 3: 311.2
On the test computer, LinearSVC completed its computations on 1 million rows in about five minutes. SGDClassifier instead took about a second for processing the same data and obtaining an inferior, but comparable, score.
stochastic_SVM = SGDClassifier(loss=‘hinge’, n_iter=5, shuffle=True, random_state=101) stochastic_SVM.fit(X_train, y_train) print ‘SGDClassifier test accuracy score: %0.3f’ % stochastic_SVM.score(X_test, y_test) print ‘avg secs for SGDClassifier, best of 3: %0.1f’ % np.mean( timeit.timeit(“stochastic_SVM.fit(X_train, y_train)”, “from __main__ import stochastic_SVM, X_train, y_train”, number=1)) SGDClassifier test accuracy score: 0.799 avg secs for SGDClassifier, best of 3: 0.8
Increasing the n_iter parameter can improve the performance, but it proportionally increases the computation time. Increasing the number of iterations up to a certain value increases the performance. However, after that value, performance starts to decrease because of overfitting.