Wstęp

Support Vector Machine to jeden z najpopularniejszych algorytmów uczenia maszynowego. Jest używany nie tylko do klasyfikacji, ale także do problemów regresji. Ale przede wszystkim jego użycie zaobserwowano w problemach klasyfikacji w obszarze uczenia maszynowego. Wiele osób preferuje maszynę wektora nośnego, ponieważ zapewnia ona znaczną dokładność przy mniejszym zużyciu mocy obliczeniowej. Maszyna Wektorów Wsparcia segreguje dane za pomocą hiperpłaszczyzny, a nowy punkt danych jest umieszczany w najlepiej dopasowanej kategorii. To jest podstawowy cel Maszyny Wektorów Wsparcia. Ta hiperpłaszczyzna jest również nazywana granicą decyzyjną maszyny wektorów nośnych. Istnieje wiele różnych hiperpłaszczyzn, których można użyć do podzielenia dwóch klas punktów danych. Znalezienie płaszczyzny z największym marginesem — tj.

Przykład

Jeśli chcemy mieć model, który potrafi prawidłowo odróżnić kota od psa, powiedzmy, że obserwujemy niezwykłego kota, który również przypomina psa. Możemy zbudować taki model, wykorzystując algorytm SVM. Przed przetestowaniem go z tym dziwnym zwierzęciem najpierw przeszkolimy naszego modela kilkoma fotografiami kotów i psów, aby mógł zapoznać się z różnymi cechami kotów i psów. Kiedy wynik, skrajne przypadki kotów i psów zostaną zauważone przez wektor wsparcia, który wyznacza granicę oceny między tymi dwoma zestawami danych (kot i pies). Wektory wsparcia zostaną użyte do sklasyfikowania go jako kota.

Rodzaje SVM

Liniowa SVM : Termin „dane separowalne liniowo” odnosi się do danych, które można podzielić na dwie grupy za pomocą tylko jednej linii prostej. Liniowy SVM służy do klasyfikowania takich danych, a używany klasyfikator jest znany jako liniowy klasyfikator SVM.

N on-linear SVM : Non-linear SVM jest używany do danych rozdzielonych nieliniowo, co oznacza, że ​​jeśli zbioru danych nie można sklasyfikować za pomocą linii prostej, wówczas takie dane są określane jako dane nieliniowe, a używany klasyfikator nazywany jest Non -liniowy klasyfikator SVM.

Pracujący

SVM kategoryzuje punkty danych, nawet jeśli nie można ich liniowo rozdzielić, mapując dane do wielowymiarowej przestrzeni cech. Po zidentyfikowaniu separatora między kategoriami dane są konwertowane, aby umożliwić hiperpłaszczyznową reprezentację separatora. Dzięki charakterystyce nowych danych można następnie przewidzieć, do której grupy powinien należeć nowy rekord.

Aktualizacje funkcji kosztów i gradientów

Celem metody SVM jest zwiększenie odległości między punktami danych a hiperpłaszczyzną. Strata na zawiasach to funkcja straty, która pomaga w maksymalizacji marży.

Jeśli wartość przewidywana i rzeczywista mają ten sam znak, nie ma kosztów. Jeśli nie, ustalamy następnie wartość straty. Funkcja kosztu otrzymuje od nas również parametr regularyzacji. Celem parametru regularyzacji jest znalezienie równowagi między maksymalizacją depozytu zabezpieczającego a stratą. Funkcje kosztów pojawiają się w następujący sposób po dodaniu parametru regularyzacji.

Teraz, gdy mamy funkcję straty, możemy znaleźć gradienty, biorąc pochodne cząstkowe w odniesieniu do wag. Możemy modyfikować nasze wagi za pomocą gradientów.

Musimy zaktualizować gradient z parametru regularyzacji tylko wtedy, gdy nie ma błędnej klasyfikacji, to znaczy, gdy nasz model poprawnie przewiduje klasę naszego punktu danych.

Aby przeprowadzić aktualizację gradientu w przypadku błędnej klasyfikacji lub gdy nasz model nieprawidłowo przewiduje klasę punktu danych, uwzględniamy utratę wraz z parametrem regularyzacji.

Przykładowy fragment programu

Importowanie bibliotek

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split

class SVM:
    def __init__(self, learning_rate=0.0001, lambda_param=0.001, n_iters=10000):
        self.weights = None
        self.bias =  None
        self.lr = learning_rate
        self.lambda_param = lambda_param
        self.n_iters = n_iters
    def fit(self,X,y):
        n_samples, n_features = X.shape
        
        y1 = np.where(y <= 0, -1, 1)
        
        self.weights = np.zeros(n_features)
        self.bias = 0
        for i in range(self.n_iters):
            for idx, x_i in enumerate(X):
                condition = y1[idx] * (np.dot(x_i, self.weights) - self.bias) >= 1
                if condition:
                    self.weights -= self.lr * (2 * self.lambda_param * self.weights)
                else:
                    self.weights -= self.lr * (2 * self.lambda_param * self.weights - np.dot(x_i, y1[idx]))
                    self.bias -= self.lr * y1[idx]
        
    def predict(self, X):
        approx = np.dot(X, self.weights) - self.bias
        return np.sign(approx)

def accuracy(y_true,y_pred):
    acc = np.sum(y_true == y_pred)/len(y_true)
    return acc
X, y =  datasets.make_blobs(n_samples=10, n_features=2, centers=2, cluster_std=1.05, random_state=40)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=42)
y = np.where(y == 0, -1, 1)
clf = SVM()
clf.fit(X_train,y_train)
predict = clf.predict(X_test)
svm_acc = accuracy(y_test,predict)
print('Accuracy:',svm_acc)
print(f'''
     Final Weight:{clf.weights}
     Final Bias:{clf.bias}
     ''')

Waga końcowa: [0,34494241 0,1443094] Odchylenie
końcowe: -0,012899999999999977

Wyobrażanie sobie

def visualize_svm():
    def get_hyperplane_value(x, w, b, offset):
        return (-w[0] * x + b + offset) / w[1]
    fig = plt.figure()
    ax = fig.add_subplot(1,1,1)
    plt.scatter(X[:,0], X[:,1], marker='x',c=y)

    x0_1 = np.amin(X[:,0])
    x0_2 = np.amax(X[:,0])

    x1_1 = get_hyperplane_value(x0_1, clf.weights, clf.bias, 0)
    x1_2 = get_hyperplane_value(x0_2, clf.weights, clf.bias, 0)

    x1_1_m = get_hyperplane_value(x0_1, clf.weights, clf.bias, -1)
    x1_2_m = get_hyperplane_value(x0_2, clf.weights, clf.bias, -1)

    x1_1_p = get_hyperplane_value(x0_1, clf.weights, clf.bias, 1)
    x1_2_p = get_hyperplane_value(x0_2, clf.weights, clf.bias, 1)

    ax.plot([x0_1, x0_2],[x1_1, x1_2], 'b--')
    ax.plot([x0_1, x0_2],[x1_1_m, x1_2_m], 'k')
    ax.plot([x0_1, x0_2],[x1_1_p, x1_2_p], 'k')

    x1_min = np.amin(X[:,1])
    x1_max = np.amax(X[:,1])
    ax.set_ylim([x1_min-3,x1_max+3])

    plt.show()

visualize_svm()

      
                

                    
                    
                
            

Wykrywanie twarzy — SVMc klasyfikuje części obrazu jako twarz i niebędące twarzą oraz tworzy kwadratową granicę wokół twarzy.

Kategoryzacja tekstu i hipertekstu — maszyny SVM obsługują zarówno modele indukcyjne, jak i transdukcyjne do klasyfikacji tekstu i hipertekstu. Aby sklasyfikować artykuły w odrębne grupy, wymagają one danych szkoleniowych. Klasyfikuje na podstawie uzyskanego wyniku, a następnie porównuje z wartością progową.
Klasyfikacja obrazów — maszyny SVM poprawiają dokładność wyszukiwania w celu klasyfikacji obrazów. W porównaniu z konwencjonalnymi strategiami wyszukiwania opartymi na zapytaniach zapewnia większą dokładność.
Klasyfikacja białek i klasyfikacja nowotworów to dwa przykłady bioinformatyki. SVM służy do klasyfikowania genów, pacjentów według ich genów i innych kwestii biologicznych.
Zastosuj algorytmy SVM do zdalnego wykrywania homologii białek i wykrywania fałdów białek.

Wniosek

Support Vector Machine to potężny algorytm klasyfikacji w uczeniu maszynowym. Chociaż może być również używany do problemów z regresją, sugerujemy używanie go głównie do celów klasyfikacyjnych. Może być używany do danych liniowych lub nieliniowych i działa dobrze. Jest to jednak algorytm uczenia nadzorowanego, więc potrzebuje oznaczonych danych. Działa najlepiej na mniejszych zestawach danych, a nie na złożonych.

Bibliografia

Maszyna wektorów nośnych

Zadanie domowe dotyczące wnioskowania statystycznego (SI) autorstwa studentów sztucznej inteligencji i nauki o danych (AI&DS), Vishwakarma Institute of Technology, Pune.

Przygotowane przez:-

1. Ajinkya Mahajan
2. Aditya Bodhankar
3. Riya Dhakalkar
4. Diksha Prasad
5. Shivani Mahajan