Giới thiệu

Support Vector Machine là một trong những thuật toán học máy phổ biến nhất. Nó không chỉ được sử dụng để phân loại mà còn cho các bài toán hồi quy. Nhưng chủ yếu, việc sử dụng nó đã được quan sát thấy trong các vấn đề Phân loại trong lĩnh vực học máy. Nhiều người ủng hộ máy vectơ hỗ trợ vì nó mang lại độ chính xác đáng chú ý trong khi sử dụng ít sức mạnh xử lý hơn. Support Vector Machine phân tách dữ liệu thông qua một siêu phẳng và điểm dữ liệu mới được đưa vào danh mục phù hợp nhất. Đây là mục đích cơ bản của Support Vector Machine. Siêu phẳng này còn được gọi là ranh giới quyết định của Support Vector Machine. Có nhiều loại siêu phẳng khác nhau có thể được sử dụng để phân chia hai loại điểm dữ liệu. Tìm một mặt phẳng có lề lớn nhất - nghĩa là,

Ví dụ

Nếu chúng ta muốn một mô hình có thể phân biệt chính xác giữa mèo và chó, giả sử chúng ta quan sát thấy một con mèo khác thường cũng giống một con chó. Chúng ta có thể xây dựng một mô hình như vậy bằng cách sử dụng thuật toán SVM. Trước khi thử nghiệm với con vật kỳ lạ này, trước tiên chúng ta sẽ huấn luyện mô hình của mình bằng một số bức ảnh chụp chó và mèo để nó có thể làm quen với các thuộc tính khác nhau của chó và mèo. Kết quả là, các trường hợp cực đoan của mèo và chó sẽ được nhìn thấy bởi vectơ hỗ trợ khi nó vẽ ra một ranh giới phán đoán giữa hai bộ dữ liệu này (mèo và chó). Các vectơ hỗ trợ sẽ được sử dụng để phân loại nó là một con mèo.

Các loại SVM

L inear SVM : Thuật ngữ “dữ liệu có thể phân tách tuyến tính” đề cập đến dữ liệu có thể được chia thành hai nhóm chỉ bằng một đường thẳng duy nhất. SVM tuyến tính được sử dụng để phân loại dữ liệu đó và trình phân loại được sử dụng được gọi là trình phân loại SVM tuyến tính.

N SVM trực tuyến : SVM phi tuyến tính được sử dụng cho dữ liệu được phân tách phi tuyến tính, có nghĩa là nếu một tập dữ liệu không thể được phân loại bằng cách sử dụng một đường thẳng, thì dữ liệu đó được gọi là dữ liệu phi tuyến tính và trình phân loại được sử dụng được gọi là Không -phân loại SVM tuyến tính.

Đang làm việc

SVM phân loại các điểm dữ liệu ngay cả khi chúng không thể phân tách tuyến tính bằng cách ánh xạ dữ liệu sang không gian đặc trưng nhiều chiều. Sau khi dấu phân cách giữa các danh mục được xác định, dữ liệu được chuyển đổi để cho phép biểu diễn siêu phẳng của dấu phân cách. Sau đó, nhóm mà một bản ghi mới sẽ thuộc về có thể được dự đoán bằng cách sử dụng các đặc điểm của dữ liệu mới.

Cập nhật hàm chi phí và độ dốc

Mục tiêu của phương pháp SVM là tăng khoảng cách giữa các điểm dữ liệu và siêu phẳng. Tổn thất bản lề là hàm tổn thất hỗ trợ trong việc tối đa hóa lợi nhuận.

Nếu giá trị dự kiến ​​và giá trị thực tế có cùng một dấu hiệu, không có chi phí. Nếu không, tiếp theo chúng ta xác định giá trị tổn thất. Hàm chi phí cũng nhận được tham số chính quy hóa từ chúng tôi. Mục tiêu của tham số chính quy hóa là đạt được sự cân bằng giữa tối đa hóa lợi nhuận và tổn thất. Các hàm chi phí xuất hiện như sau sau khi tham số chuẩn hóa đã được thêm vào.

Bây giờ chúng ta có hàm mất mát, chúng ta có thể tìm gradient bằng cách lấy đạo hàm riêng theo trọng số. Chúng tôi có thể sửa đổi trọng số của mình bằng cách sử dụng độ dốc.

Chúng tôi chỉ cần cập nhật độ dốc từ tham số chuẩn hóa khi không có phân loại sai, nghĩa là khi mô hình của chúng tôi dự đoán chính xác loại điểm dữ liệu của chúng tôi.

Để thực hiện cập nhật độ dốc khi có phân loại sai hoặc khi mô hình của chúng tôi dự đoán sai loại của một điểm dữ liệu, chúng tôi bao gồm tổn thất cùng với tham số chuẩn hóa.

Đoạn chương trình mẫu

Nhập thư viện

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}
     ''')

Trọng lượng cuối cùng:[0,34494241 0,1443094 ]
Độ lệch cuối cùng:-0,012899999999999977

Hình dung

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()

      
                

                    
                    
                
            

Phát hiện khuôn mặt — SVMc phân loại các phần của hình ảnh thành khuôn mặt và không phải khuôn mặt, đồng thời tạo đường viền hình vuông xung quanh khuôn mặt.

Phân loại văn bản và siêu văn bản — SVM hỗ trợ cả mô hình quy nạp và chuyển đổi để phân loại văn bản và siêu văn bản. Để phân loại các bài báo thành các nhóm riêng biệt, chúng yêu cầu dữ liệu huấn luyện. Nó phân loại dựa trên điểm thu được và sau đó đối chiếu với giá trị ngưỡng.
Phân loại hình ảnh — SVM cải thiện độ chính xác của tìm kiếm đối với việc phân loại hình ảnh. So với các chiến lược tìm kiếm dựa trên truy vấn thông thường, nó mang lại độ chính xác cao hơn.
Phân loại protein và phân loại ung thư là hai ví dụ về tin sinh học. SVM được sử dụng để phân loại gen, bệnh nhân theo gen của họ và các vấn đề sinh học khác.
Áp dụng thuật toán SVM để phát hiện tương đồng từ xa protein và phát hiện nếp gấp protein.

Phần kết luận

Support Vector Machine là một thuật toán mạnh mẽ để phân loại trong Machine learning. Mặc dù nó cũng có thể được sử dụng cho các bài toán hồi quy, nhưng chúng tôi khuyên bạn nên sử dụng nó chủ yếu cho mục đích phân loại. Nó có thể được sử dụng cho dữ liệu tuyến tính hoặc phi tuyến tính và nó hoạt động tốt. Tuy nhiên, nó là một thuật toán học có giám sát nên nó cần dữ liệu được gắn nhãn. Nó hoạt động tốt nhất trên các bộ dữ liệu nhỏ hơn là các bộ dữ liệu phức tạp.

Người giới thiệu

Máy véc tơ hỗ trợ

Bài tập tại nhà về suy luận thống kê (SI) của sinh viên Khoa học dữ liệu và trí tuệ nhân tạo (AI&DS), Viện Công nghệ Vishwakarma, Pune.

Được soạn bởi:-

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