Thuật toán nào để áp dụng cho việc chọn đúng điểm

Hình dưới đây cho thấy 7 điểm xung quanh nguồn gốc. Một trong số chúng đã được chọn bởi một người dựa trên các quy tắc và kinh nghiệm và được tô màu đỏ (một trong góc phần tư phía dưới bên trái).

Bây giờ chúng ta có hơn 1000 bộ điểm này và với mỗi bộ, một con người đã chọn một điểm duy nhất. Những điều kiện này áp dụng cho tất cả các bộ:

• Mỗi bộ có khoảng 3 - 10 điểm
• Không có ngoại lệ
• Điểm có thể có giá trị dương và âm
• Không có sai lầm khi chọn một điểm

Câu hỏi của tôi là: Có tồn tại thuật toán học máy để học từ các bộ này và các lựa chọn do con người tạo ra để nó có thể tự động quyết định chọn điểm nào khi đưa ra một điểm mới không? Bộ mới này đáp ứng 3 điều kiện đầu tiên ở trên.

2 nhận xét cuối cùng:

• Ví dụ tôi đưa ra chỉ là một ví dụ được xây dựng ngẫu nhiên bởi tôi để hỗ trợ ý tưởng về các điểm trong mặt phẳng xung quanh gốc tọa độ với điểm được chọn. Trong cuộc sống thực có thể có nhiều cấu trúc hơn nhưng bây giờ tôi tò mò và muốn biết những gì có thể cho trường hợp này.
• Các biến thể sẽ có thể? Giả sử đó là khoảng 2 điểm được chọn hoặc bạn có các vòng tròn có bán kính cho trước thay vì các điểm.

Đây là một vấn đề hấp dẫn! Hai điều làm cho nó đặc biệt thách thức:

• Làm thế nào chúng ta nên so sánh hai bộ điểm? Các vấn đề kinh điển trong Machine Learning có số lượng thuộc tính cố định và các thuộc tính này không thể thay thế cho nhau: Ví dụ: tôi có thể có dữ liệu về những người khác nhau có thuộc tính agevà height(tính bằng centimet). Mỗi mẫu có một mục nhập cho mỗi mục, và tất nhiên (age, height) = (22, 180)không giống như (age, height) = (180, 22). Không phải là sự thật trong vấn đề của bạn. Một tập hợp điểm có từ 3 đến 10 điểm và thứ tự chúng tôi nhập vào các điểm sẽ không tạo ra sự khác biệt khi so sánh hai tập hợp điểm.
• Làm thế nào để chúng ta đưa ra một dự đoán? Giả sử chúng tôi đã tìm ra cách chọn tập hợp điểm từ tập huấn luyện của chúng tôi tương tự như tập điểm của bạn ở trên. Chúng tôi phải đối mặt với vấn đề rằng dự đoán của chúng tôi phải là một trong 7 điểm trong bức tranh của bạn; nhưng không có điểm nào trong số này có thể được chứa trong các tập hợp điểm tương tự.

Hãy để tôi phác thảo một thuật toán liên quan đến cả hai thách thức. Độ chính xác dự đoán không tốt lắm; nhưng có lẽ bạn thấy một cách làm thế nào nó có thể được cải thiện. Và ít nhất nó dự đoán một cái gì đó , phải không?

1. Mô phỏng mẫu

Để có thể kiểm tra thuật toán, tôi đã viết các hàm tạo mẫu và nhãn.

Tạo mẫu: Mỗi mẫu chứa từ 3 đến 10 điểm. Số lượng điểm là ngẫu nhiên, được rút ra từ một phân phối thống nhất. Mỗi điểm là của hình thức (x_coordinate, y_coordinate). Các tọa độ một lần nữa là ngẫu nhiên, được rút ra từ một phân phối bình thường.

import numpy as np
from random import randint

def create_samples(number_samples, min_points, max_points):

    def create_single_sample(min_points, max_points):
        n = randint(min_points, max_points)
        return np.array([np.random.normal(size=2) for _ in range(n)]) 

    return np.array([create_single_sample(min_points, max_points) for _ in range(number_samples)])

Tạo nhãn: Như một ví dụ về đồ chơi, chúng ta hãy giả sử rằng quy tắc chọn điểm là: Luôn chọn điểm gần nhất (0, 0), trong đó 'gần nhất' nên được hiểu theo tiêu chuẩn Euclide.

def decision_function_minnorm(sample):
    norms = np.apply_along_axis(np.linalg.norm, axis=1, arr=sample)
    return sample[norms.argmin()]

def create_labels(samples, decision_function):
    return np.array([decision_function(sample) for sample in samples])

Bây giờ chúng ta có thể tạo các bộ thử nghiệm và xe lửa của mình:

n_train, n_test = 1000, 100
dec_fun = decision_function_minnorm

X_train = create_samples(number_samples=n_train, min_points=3, max_points=10)
X_test = create_samples(number_samples=n_test, min_points=3, max_points=10)
y_train = create_labels(X_train, dec_fun)
y_test = create_labels(X_test, dec_fun)

2. So sánh các tập hợp điểm qua khoảng cách Hausdorff

Hãy để chúng tôi giải quyết vấn đề đầu tiên: Làm thế nào chúng ta nên so sánh các tập hợp điểm khác nhau? Số lượng điểm trong bộ điểm là khác nhau. Cũng nên nhớ rằng thứ tự chúng tôi ghi lại các điểm không quan trọng: So sánh với tập hợp điểm [(0,0), (1,1), (2,2)]sẽ mang lại kết quả tương tự như so với tập hợp điểm [(2,2), (0,0), (1,1)]. Cách tiếp cận của tôi là so sánh các tập hợp điểm thông qua khoảng cách Hausdorff của chúng :

def hausdorff(A, B):

    def dist_point_to_set(x, A):
        return min(np.linalg.norm(x - a) for a in A)

    def dist_set_to_set(A, B):
        return max(dist_point_set(a, B) for a in A)

    return max(dist_set_to_set(A, B), dist_set_to_set(B, A))

3. Dự đoán qua hàng xóm k gần nhất và tính trung bình

Bây giờ chúng ta có một khái niệm về khoảng cách giữa các bộ điểm. Điều này cho phép sử dụng phân loại hàng xóm gần nhất k: Với tập hợp điểm kiểm tra, chúng tôi tìm thấy các ktập hợp điểm trong mẫu đào tạo của chúng tôi có khoảng cách Hausdorff nhỏ nhất so với tập hợp điểm kiểm tra và lấy nhãn của chúng. Bây giờ đến vấn đề thứ hai: Làm thế nào để chúng ta biến các knhãn này thành một dự đoán cho tập hợp điểm kiểm tra? Tôi đã sử dụng cách tiếp cận đơn giản nhất: lấy trung bình các nhãn và dự đoán điểm trong tập hợp điểm kiểm tra gần nhất với mức trung bình.

def predict(x, num_neighbors):
    # Find num_neighbors closest points in X_train.
    distances_to_train = np.array([hausdorff(x, x_train) for x_train in X_train])
    neighbors_idx = np.argpartition(distances_to_train, -num_neighbors)[-num_neighbors:]

    # Get labels of the neighbors and calculate the average.
    targets_neighbors = y_train[neighbors_idx]
    targets_mean = sum(targets_neighbors) / num_neighbors

    # Find point in x that is closest to targets_mean and use it as prediction.
    distances_to_mean = np.array([np.linalg.norm(p - targets_mean) for p in x])
    closest_point = x[distances_to_mean.argmin()]

    return closest_point

4. Kiểm tra

Tất cả mọi thứ là ở chỗ để kiểm tra hiệu suất của thuật toán của chúng tôi.

num_neighbors = 70
successes = 0
for i, x in enumerate(X_test):
    print('%d/%d' % (i+1, n_test))
    prediction = predict(x, num_neighbors)
    successes += np.array_equal(prediction, y_test[i])

Đối với hàm quyết định đã cho và num_neighbors = 70, chúng tôi có độ chính xác dự đoán là 84%. Điều này không phải là quá tốt, và tất nhiên nó là cụ thể cho chức năng quyết định của chúng tôi, điều này có vẻ khá dễ dự đoán.

Để thấy điều này, hãy xác định một hàm quyết định khác:

decision_function_maxaverage(sample):
    avgs = (sample[:, 0] + sample[:, 1]) / 2
    return sample[norms.argmin()]

Sử dụng chức năng này thông qua dec_fun = decision_function_maxaveragegiảm độ chính xác dự đoán xuống 45%. Điều này cho thấy tầm quan trọng của việc suy nghĩ về các quy tắc quyết định tạo nhãn của bạn. Nếu bạn có một ý tưởng tại sao mọi người chọn một số điểm nhất định, điều này sẽ giúp bạn tìm ra thuật toán tốt nhất.

Một số cách để cải thiện thuật toán này: (1) Sử dụng hàm khoảng cách khác thay vì khoảng cách Hausdorff, (2) sử dụng thứ gì đó tinh vi hơn so với hàng xóm gần nhất k, (3) cải thiện cách các nhãn đào tạo được chọn được biến thành dự đoán.

Dưới đây là một số cách bạn có thể sử dụng mạng thần kinh để giải quyết vấn đề này:

Với một mạng lưới thần kinh Feedforward đơn giản:

• Chia tỷ lệ dữ liệu của bạn để khớp với hình vuông xung quanh gốc từ (-1, -1) đến (1,1)
• $k$
• Thêm một đầu vào chỉ báo thứ ba cho mỗi điểm, cho biết điểm đó có mặt không
• Chọn số lượng và kích thước của các lớp ẩn
• Sử dụng lớp softmax cỡ 10 ở đầu ra

$k$$k$

Với một mạng lưới thần kinh chuyển đổi:

• $n$$n$$n$$n$$k$$k$$i,j$$0$$1$$0$
• $n*n$

CNN có thể hoạt động tốt hơn vì dữ liệu của bạn vốn là không gian. Tuy nhiên, bạn phải quyết định phải làm gì nếu hai hoặc nhiều điểm trùng nhau. Giải pháp đơn giản nhất là chọn ngẫu nhiên, có thể ổn tùy theo nhiệm vụ cụ thể của bạn.

Với mạng thần kinh tái phát:

• Nạp theo chuỗi độ dài thay đổi của các điểm được chia tỷ lệ (x, y) và đưa ra ước tính kích thước 10 softmax

Vâng, nó dễ dàng như vậy với RNNs! Họ xử lý tốt các đầu vào có độ dài thay đổi, nhưng họ vẫn thiếu các lợi thế của CNN để xử lý dữ liệu không gian.

Hãy cẩn thận:

Nếu sử dụng FNN hoặc RNN, vấn đề là bạn đặt hàng dữ liệu đầu vào như thế nào. Nếu không có thứ tự vốn có trong dữ liệu thực của bạn, thì chúng tôi không muốn mạng của chúng tôi đưa ra các dự đoán khác nhau cho cùng một dữ liệu được mã hóa theo các đơn hàng khác nhau. Một cách để xử lý vấn đề này là tăng dữ liệu : sao chép mỗi ví dụ đào tạo một vài lần với các thứ tự đầu vào khác nhau, vì vậy hy vọng mạng của bạn có thể tìm hiểu các đối xứng phù hợp.

Nếu bạn chỉ có thời gian để thử một cách tiếp cận, tôi sẽ chọn CNN. CNN được thiết kế để làm tốt với dữ liệu không gian và không có vấn đề gì với thứ tự đầu vào.