Brtdku

Currently I'm trying to implement a probabilistic SVM, but I've run into issues, this is my code:

import numpy as np

import random

from sklearn.svm import SVC

import math

from scipy.optimize import minimize

import matplotlib.pyplot as plt

from sklearn import decomposition

from sklearn import svm

from sklearn.model_selection import GridSearchCV

from sklearn.model_selection import train_test_split

import warnings

warnings.filterwarnings("ignore")



def training_banana(name):

    inputs = 

    file = open(name, "r")

    for line in file:

        vector = line.split()

        coordinate = 

        for i in range(len(vector)):

            coordinate.append(float(vector[i]))

        inputs.append(coordinate)

    file.close()



    return np.array(inputs)





def define_inputs(name, name_targets):

    inputs = training_banana(name)

    targets_array = training_banana(name_targets)

    N = targets_array.shape[0]

    targets = np.zeros(N)

    for i in range(N):

        targets[i] = targets_array[i][0]

    return inputs, targets, N



#training set

inputs_train, targets_train, N = define_inputs('banana_train_data_10.asc', 'banana_train_labels_10.asc') # banana_train, banana_train_label

permute = list(range(N))

random.shuffle(permute)

inputs_train = inputs_train[permute, :]

targets_train = targets_train[permute]



#test set

inputs_test, targets_test, N = define_inputs('banana_test_data_10.asc', 'banana_test_labels_10.asc') #banana_test.txt, banana_test_label

permute = list(range(N))

random.shuffle(permute)

inputs_test = inputs_test[permute, :]

targets_test = targets_test[permute]



#print(inputs_train[0])





def plotting():

    param_C = [2048]

    param_grid = {'C': param_C, 'kernel': ['rbf'], 'gamma': [0.5]}

    clf = GridSearchCV(svm.SVC(), param_grid)

    clf.fit(inputs_train, targets_train)

    clf = SVC(C=clf.best_params_['C'], cache_size=200, class_weight=None, coef0=0.0,

              decision_function_shape='ovr', degree=5, gamma=clf.best_params_['gamma'],

              kernel=clf.best_params_['kernel'],

              max_iter=-1, probability=True, random_state=None, shrinking=True,

              tol=0.001, verbose=False)

    clf.fit(inputs_train, targets_train)

    index = clf.support_vectors_

    print(len(index))

    list_to_compare = 

    for i in range(inputs_test.shape[0]):

        if clf.predict([inputs_test[i]]) == targets_test[i]:

            list_to_compare.append(1)

    return_value = np.sum(list_to_compare)/inputs_test.shape[0]

    print(return_value)



















    #print(predicting_classes_pos_inputs)

    #print(inputs_test)

    #print(predicting_classes_pos_targets)

    #print(inputs_test.shape[0])









    #print(predicting_classes)

    #colors = [int(i % 23) for i in xy[0]]

    #for i in range(inputs_test.shape[0]):

    #    if clf.predict([targets_test[i]]) == 1:

    #        predict_pos_inputs.append(inputs_test[i])

    #print(predict_pos_inputs)

    #plt.scatter(inputs_test[:, 0], predictions[:, 0], s=30, cmap=plt.cm.Paired)

    #plt.show()



    #print(inputs_test.shape[0])





#support_vectors = get_supp_vec()

#print(support_vectors[:,0])

plotting()

My problem is that I seem to get the same number of support vectors no matter if I choose the probabilistic version or the "standard" SVM. By the probabilistic version, I mean Platt's implementation of it. As you see, I'm using:

index = clf.support_vectors_

    print(len(index))

After running it on 10 datasets, I get approximately 84.7 support vectors, if I instead try using:

index2 = clf.n_support

    print(len(index2))

I get only two support vectors. From what I've understood, probabilstic SVM is supposed to be more sparse than the regular, but when I use the second variant (index2), it doesn't really matter how I change gamma or C (the slack), I still get the same result, that is, complete insensitivty to the parameters, which also seems wrong.

Can someone tell me, what is the correct way of plotting the support vectors for a probabilistic SVM using the sklearn package? Thanks