Sơ đồ ranh giới quyết định cho một tri giác

Tôi đang cố gắng vạch ra ranh giới quyết định của thuật toán perceptron và tôi thực sự bối rối về một vài điều. Các thể hiện đầu vào của tôi ở dạng , về cơ bản là một thể hiện đầu vào 2D ( và ) và giá trị đích của lớp nhị phân ( ) [1 hoặc 0].$[(x_{1},x_{2}), y]$$x_{1}$$x_{2}$$y$

Do đó, vectơ trọng lượng của tôi có dạng: .$[w_{1}, w_{2}]$

Bây giờ tôi phải kết hợp một tham số thiên vị bổ sung và do đó vectơ trọng lượng của tôi trở thành vectơ ? nó có phải là vectơ không? Tôi nghĩ rằng nó phải là vì một vectơ chỉ có 1 hàng và n cột.$w_{0}$$3 \times 1$$1 \times 3$$1 \times 3$

Bây giờ hãy nói rằng tôi khởi tạo thành các giá trị ngẫu nhiên, làm thế nào để tôi vẽ ranh giới quyết định cho điều này? Có nghĩa là gì biểu thị ở đây? Là khoảng cách của vùng quyết định từ gốc? Nếu vậy, làm thế nào để tôi nắm bắt được điều này và vẽ nó trong Python bằng matplotlib.pyplot hoặc tương đương Matlab của nó?$[w_{0}, w_{1}, w_{2}]$$w_{0}$$w_{0}/norm(w)$

Tôi thực sự sẽ đánh giá cao thậm chí một chút giúp đỡ về vấn đề này.

Cách thức perceptionron dự đoán đầu ra trong mỗi lần lặp là theo phương trình:

$$y_{j} = f[{\bf{w}}^{T} {\bf{x}}] = f[\vec{w}\cdot \vec{x}] = f[w_{0} + w_{1}x_{1} + w_{2}x_{2} + ... + w_{n}x_{n}]$$

Như bạn đã nói, trọng lượng của bạn chứa một thuật ngữ thiên vị . Do đó, bạn cần bao gồm trong đầu vào để duy trì kích thước trong sản phẩm chấm.$\vec{w}$$w_{0}$$1$

Bạn thường bắt đầu với một vectơ cột cho các trọng số, nghĩa là một vectơ . Theo định nghĩa, sản phẩm chấm yêu cầu bạn hoán chuyển vectơ này để có vectơ trọng lượng và để bổ sung cho sản phẩm chấm đó, bạn cần một vectơ đầu vào . Đó là lý do tại sao một sự nhấn mạnh sự thay đổi giữa ký hiệu ma trận và ký hiệu vectơ trong phương trình trên, vì vậy bạn có thể thấy cách ký hiệu gợi ý cho bạn các kích thước phù hợp.$n \times 1$$1 \times n$$n \times 1$

Hãy nhớ rằng, điều này được thực hiện cho mỗi đầu vào bạn có trong tập huấn luyện. Sau đó, cập nhật vectơ trọng số để sửa lỗi giữa đầu ra dự đoán và đầu ra thực.

Đối với ranh giới quyết định, đây là một sửa đổi của mã tìm hiểu scikit tôi tìm thấy ở đây :

import numpy as np
from sklearn.linear_model import Perceptron
import matplotlib.pyplot as plt

X = np.array([[2,1],[3,4],[4,2],[3,1]])
Y = np.array([0,0,1,1])
h = .02  # step size in the mesh


# we create an instance of SVM and fit our data. We do not scale our
# data since we want to plot the support vectors

clf = Perceptron(n_iter=100).fit(X, Y)

# create a mesh to plot in
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))

# Plot the decision boundary. For that, we will assign a color to each
# point in the mesh [x_min, m_max]x[y_min, y_max].
fig, ax = plt.subplots()
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

# Put the result into a color plot
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=plt.cm.Paired)
ax.axis('off')

# Plot also the training points
ax.scatter(X[:, 0], X[:, 1], c=Y, cmap=plt.cm.Paired)

ax.set_title('Perceptron')

tạo ra cốt truyện sau:

Về cơ bản, ý tưởng là dự đoán một giá trị cho mỗi điểm trong một lưới bao gồm mọi điểm và vẽ từng dự đoán với một màu thích hợp bằng cách sử dụng contourf.

Gần đây tôi đã cố gắng thực hiện điều tương tự, nhưng quá bối rối làm thế nào để vẽ sơ đồ ranh giới quyết định với ba trọng số . Và dựa trên giải pháp khác, tôi đã viết mã matplotlib python để vẽ đường biên phân loại hai lớp.$w_0,w_1,w_2$

def plot_data(self,inputs,targets,weights):
    # fig config
    plt.figure(figsize=(10,6))
    plt.grid(True)

    #plot input samples(2D data points) and i have two classes. 
    #one is +1 and second one is -1, so it red color for +1 and blue color for -1
    for input,target in zip(inputs,targets):
        plt.plot(input[0],input[1],'ro' if (target == 1.0) else 'bo')

    # Here i am calculating slope and intercept with given three weights
    for i in np.linspace(np.amin(inputs[:,:1]),np.amax(inputs[:,:1])):
        slope = -(weights[0]/weights[2])/(weights[0]/weights[1])  
        intercept = -weights[0]/weights[2]

        #y =mx+c, m is slope and c is intercept
        y = (slope*i) + intercept
        plt.plot(i, y,'ko')