सही बिंदु चुनने के लिए कौन सा एल्गोरिदम लागू करना है

Question

नीचे दी गई तस्वीर मूल के आसपास के 7 बिंदुओं को दिखाती है। उनमें से एक को नियमों और अनुभव के आधार पर एक मानव द्वारा चुना गया है और लाल रंग का है (निचले बाएं वृत्त का चतुर्थ भाग में से एक)।

अब हमारे पास इन अंकों के 1000 से अधिक सेट हैं और प्रत्येक सेट के लिए एक मानव ने एक बिंदु का चयन किया है। ये शर्तें सभी सेटों पर लागू होती हैं:

• प्रत्येक सेट में लगभग 3 - 10 अंक होते हैं
• कोई आउटलेयर नहीं हैं
• अंक में सकारात्मक और नकारात्मक मूल्य हो सकते हैं
• एक बिंदु का चयन करते समय कोई गलती नहीं की गई थी

मेरा सवाल यह है कि क्या इन सेटों और मानव निर्मित चयनों से सीखने के लिए मशीन लर्निंग एल्गोरिदम मौजूद है ताकि यह स्वचालित रूप से तय कर सके कि नए सेट के अंकों का चयन कब किया जाए? यह नया सेट पाठ्यक्रम के ऊपर से पहली 3 स्थितियों को संतुष्ट करता है।

2 अंतिम टिप्पणी:

• मैंने जो उदाहरण दिया, वह मेरे द्वारा मूल रूप से एक चयनित विमान के साथ एक विमान में बिंदुओं के बारे में विचार का समर्थन करने के लिए एक यादृच्छिक रूप से निर्मित उदाहरण है। वास्तविक जीवन में अधिक संरचना हो सकती है लेकिन अभी के लिए मैं उत्सुक हूं और जानना चाहूंगा कि इस मामले के लिए क्या संभव है।
• क्या बदलाव संभव होगा? यह कहें कि यह 2 चयनित बिंदुओं के बारे में है या आपके पास बिंदुओं के बजाय किसी दिए गए त्रिज्या वाले वृत्त हैं।

Comments

बस जोर से सोच, कर्नेल चाल शायद मदद? चयनित बिंदु अन्य बिंदुओं के बहुत करीब बैठा हुआ दिखता है, जबकि अन्य स्थान (जैसे उच्च आयाम) में अलग होने की संभावना है, फिर वहां आप वर्गीकरण करते हैं! मैं कहूंगा कि यह सोचने लायक है।

— ट्विनपेंग्जिन

@MajidMortazavi अच्छा लगता है। सच कहूं, तो मशीन लर्निंग मेरे लिए एक नया क्षेत्र है। केवल एक चीज जो मुझे पता है कि वहाँ बहुत संभव है लेकिन मैं कैसे और क्या के बारे में संघर्ष कर रहा हूं। आपके कर्नेल सुझाव के बारे में पढ़ने की कोशिश करेंगे।

— Elmex80s

यदि आप प्रत्येक बिंदु में सुविधाओं को जोड़ते हैं जैसे कि अन्य बिंदुओं से दूरी, अन्य बिंदुओं की संख्या आदि, तो आप शायद कुछ सरल उपयोग कर सकते हैं जैसे कि के-नेस्ट पड़ोसी से यह निर्धारित करने के लिए कि आपने किस ऐतिहासिक बिंदु को प्रशिक्षित किया है वह सबसे समान है आपका नया बिंदु (ओं), और उस वर्गीकरण का उपयोग करें। इस तरह के गैर-रैखिक सीमा के लिए निर्णय पेड़ या तंत्रिका जाल एक बेहतर फिट हो सकते हैं।

— डैन कार्टर

@ DanCarter की टिप्पणी को बंद करने के लिए, एमएल एल्गोरिथ्म का उपयोग करने के लिए पूछना गलत सवाल है। उन सुविधाओं के बारे में सोचें जो आप इंजीनियर कर सकते हैं, और यह निर्धारित करने दें कि किन विधियों का उपयोग करना है (बहुवचन यहाँ आवश्यक है; आपको कभी भी एक विधि का प्रयास नहीं करना चाहिए, जब तक कि समस्या बहुत अच्छी तरह से समझ में न आ जाए)। कोशिश करने के लिए कुछ अन्य संभावित विशेषताएं: सेंटीरोइड से दूरी (दोनों पूर्ण और सापेक्ष बिंदु-औसत दूरी सेंट्रोइड दूरी), मूल से दूरी, कोण से मूल-वेक्टर एक अक्ष के साथ बनाता है।

— पॉल

क्या दो या दो से अधिक अंक एक-दूसरे के करीब हो सकते हैं?

— इमरान

Answer 1

यह एक आकर्षक समस्या है! दो चीजें इसे विशेष रूप से चुनौतीपूर्ण बनाती हैं:

• हमें दो बिंदु सेट की तुलना कैसे करनी चाहिए? मशीन लर्निंग में शास्त्रीय समस्याओं की एक निश्चित संख्या के गुण होते हैं, और ये विशेषताएँ विनिमेय नहीं होती हैं: उदाहरण के लिए, मेरे पास अलग-अलग व्यक्तियों के गुण ageऔर height(सेंटीमीटर में) डेटा हो सकता है । प्रत्येक नमूने में प्रत्येक के लिए एक प्रविष्टि है, और निश्चित (age, height) = (22, 180)रूप से समान नहीं है (age, height) = (180, 22)। न तो आपकी समस्या में सच है। एक बिंदु सेट में 3 और 10 बिंदु होते हैं, और जिस क्रम में हम बिंदुओं में प्रवेश करते हैं, उसे दो बिंदु सेटों की तुलना करते समय फर्क नहीं करना चाहिए।
• हम एक भविष्यवाणी कैसे करते हैं? मान लीजिए कि हमने अपने प्रशिक्षण सेट से पॉइंट सेट लेने का एक तरीका खोज लिया है जो आपके पॉइंट सेट के समान है। हम इस समस्या का सामना करते हैं कि हमारी भविष्यवाणी आपकी तस्वीर के 7 बिंदुओं में से एक होनी चाहिए; लेकिन इनमें से कोई भी बिंदु समान बिंदु सेट में शामिल नहीं हो सकता है।

मुझे एक एल्गोरिथ्म को रेखांकित करने दो जो दोनों चुनौतियों से निपटता है। भविष्यवाणी सटीकता बहुत अच्छी नहीं है; लेकिन हो सकता है कि आपको एक रास्ता दिखाई दे कि इसमें कैसे सुधार किया जा सकता है। और कम से कम यह कुछ भविष्यवाणी करता है , है ना?

1. नमूने का अनुकरण

एल्गोरिथ्म का परीक्षण करने में सक्षम होने के लिए, मैंने ऐसे कार्य लिखे जो नमूने और लेबल उत्पन्न करते हैं।

नमूने उत्पन्न करना: प्रत्येक नमूने में 3 और 10 अंक होते हैं। अंकों की संख्या यादृच्छिक है, एक समान वितरण से तैयार की गई है। प्रत्येक बिंदु रूप का है (x_coordinate, y_coordinate)। निर्देशांक फिर से यादृच्छिक हैं, एक सामान्य वितरण से खींचा गया है।

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

जनरेटिंग लेबल: एक खिलौना उदाहरण के रूप में, मान लेते हैं कि एक बिंदु चुनने का नियम है: हमेशा उस बिंदु को चुनें जो सबसे नज़दीकी हो (0, 0), जहाँ 'निकटतम' को यूक्लिडियन मानदंड के रूप में समझा जाना चाहिए।

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

अब हम अपनी ट्रेन और परीक्षण सेट बना सकते हैं:

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. हॉसडॉर्फ दूरी के माध्यम से तुलना बिंदु सेट

आइए हम पहली समस्या से निपटें: हमें विभिन्न बिंदुओं की तुलना कैसे करनी चाहिए? पॉइंट सेट में अंकों की संख्या अलग-अलग होती है। यह भी याद रखें कि जिस क्रम में हम अंक लिखते हैं, उससे कोई फर्क नहीं पड़ता: बिंदु सेट की [(0,0), (1,1), (2,2)]तुलना बिंदु बिंदु की तुलना के समान परिणाम प्राप्त करना चाहिए [(2,2), (0,0), (1,1)]। मेरा दृष्टिकोण उनके होडॉर्फ दूरी के माध्यम से बिंदु सेट की तुलना करना है :

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. k- निकटतम पड़ोसियों और औसत के माध्यम से भविष्यवाणी करना

अब हमारे पास बिंदु सेट के बीच की दूरी की धारणा है। यह k- निकटतम पड़ोसियों के वर्गीकरण का उपयोग करना संभव बनाता है: एक परीक्षण बिंदु सेट को देखते हुए, हम kअपने प्रशिक्षण नमूने में बिंदु सेट पाते हैं जो परीक्षण बिंदु सेट के सापेक्ष सबसे छोटा हॉसडॉर्फ दूरी रखते हैं, और उनके लेबल प्राप्त करते हैं। अब दूसरी समस्या आती है: हम इन kबिंदुओं को परीक्षण बिंदु सेट के लिए एक भविष्यवाणी में कैसे बदल देते हैं ? मैंने सबसे सरल दृष्टिकोण लिया: लेबल को औसत करें और परीक्षण बिंदु सेट में उस बिंदु की भविष्यवाणी करें जो औसत से निकटतम है।

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. परीक्षण

हमारे एल्गोरिथ्म के प्रदर्शन का परीक्षण करने के लिए सब कुछ है।

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

दिए गए निर्णय समारोह के लिए और num_neighbors = 70, हम 84% की एक भविष्यवाणी सटीकता प्राप्त करते हैं। यह बहुत अच्छा नहीं है, और यह निश्चित रूप से हमारे निर्णय समारोह के लिए विशिष्ट है, जो भविष्यवाणी करना काफी आसान लगता है।

इसे देखने के लिए, एक अलग निर्णय फ़ंक्शन को परिभाषित करें:

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

इस फ़ंक्शन का उपयोग करके dec_fun = decision_function_maxaverageभविष्यवाणी सटीकता को 45% तक नीचे लाया जाता है। इससे पता चलता है कि आपके लेबल बनाने वाले निर्णय नियमों के बारे में सोचना कितना महत्वपूर्ण है। यदि आपके पास एक विचार है कि लोग कुछ बिंदुओं का चयन क्यों करते हैं, तो यह आपको सबसे अच्छा एल्गोरिथ्म खोजने में मदद करेगा।

इस एल्गोरिथ्म को बेहतर बनाने के कुछ तरीके: (1) हॉसडॉर्फ दूरी के बजाय एक अलग दूरी फ़ंक्शन का उपयोग करें, (2) के-निकटतम पड़ोसियों की तुलना में अधिक परिष्कृत कुछ का उपयोग करें, (3) सुधार कैसे चयनित प्रशिक्षण लेबल एक भविष्यवाणी में बदल जाते हैं।

Answer 2

इस समस्या को हल करने के लिए आप कुछ तरीकों का उपयोग कर सकते हैं:

एक सादे फीडफॉर्वर्ड न्यूरल नेटवर्क के साथ:

• मूल (-1, -1) से (1,1) के आसपास के वर्ग में फिट होने के लिए अपने डेटा को स्केल करें
• प्रत्येक बिंदु को उसके एक्स और वाई निर्देशांक के अनुरूप दो इनपुट के साथ, या 0,0 यदि $k$वें बिंदु मौजूद नहीं है
• प्रत्येक बिंदु के लिए एक तीसरा संकेतक इनपुट जोड़ें, यह दर्शाता है कि क्या वह बिंदु मौजूद है
• छिपी हुई परतों की संख्या और आकार चुनें
• आउटपुट पर आकार 10 की सॉफ्टमैक्स परत का उपयोग करें

तो हर इनपुट उदाहरण लंबाई 30 की एक वेक्टर होगा, जहां पिछले 3 * (10-$k$) मान शून्य हैं जब वहाँ हैं $k$ सेट में मौजूद बिंदु, और आउटपुट लंबाई 10 वेक्टर से 1 तक है, चाहे सबसे बड़ा मूल्य अनुमानित बिंदु (जिसकी स्थिति इनपुट में उस स्थिति से मेल खाती है) से मेल खाती है।

एक संवादात्मक तंत्रिका नेटवर्क के साथ:

• अपने विमान को ग्रिड में विभाजित करें $n$ एक्स $n$ वर्गों, और एक के रूप में अपने इनपुट का प्रतिनिधित्व करते हैं $n$ एक्स $n$ मैट्रिक्स है कि $k$ अगर वहाँ $k$ वर्ग में अंक ($i,j$) तथा $0$अन्यथा। उम्मीद है कि अंक ओवरलैप नहीं होंगे, इसलिए आपके पास एक मैट्रिक्स है$1$रेत $0$रों।
• अपने इनपुट मैट्रिसेस पर एक CNN ट्रेन करें। आपका आउटपुट आकार आकार का सॉफ्टमैक्स होना चाहिए$n*n$, जो इनपुट आकार से मेल खाती है चपटा। इसी आउटपुट निर्देशांक पर उच्चतम मूल्य के साथ बिंदु चुनें।

सीएनएन बेहतर प्रदर्शन कर सकता है क्योंकि आपका डेटा स्वाभाविक रूप से स्थानिक है। हालांकि आपको यह तय करना होगा कि दो या दो से अधिक अंक ओवरलैप होने पर क्या करें। सबसे सरल समाधान एक यादृच्छिक रूप से चुनना है, जो आपके विशिष्ट कार्य के आधार पर ठीक हो सकता है।

एक आवर्तक तंत्रिका नेटवर्क के साथ:

• स्केल (x, y) अंक की चर लंबाई अनुक्रम में फ़ीड और एक आकार 10 सॉफ्टमैक्स अनुमान

हाँ, यह RNN के साथ उतना ही आसान है! वे चर लंबाई के इनपुट को अच्छी तरह से संभालते हैं, लेकिन उन्हें अभी भी स्थानिक डेटा को संभालने के लिए सीएनएन के फायदे की कमी है।

चेतावनियां:

यदि FNN या RNN का उपयोग करते हैं, तो यह भी बात है कि आप अपने इनपुट डेटा को कैसे ऑर्डर करते हैं। यदि आपके वास्तविक डेटा में कोई अंतर्निहित आदेश नहीं है, तो हम नहीं चाहते हैं कि हमारा नेटवर्क एक ही डेटा के लिए अलग-अलग भविष्यवाणियों को अलग-अलग क्रम में एन्कोड किया गया हो। इसे संभालने का एक तरीका डेटा वृद्धि के साथ है : प्रत्येक प्रशिक्षण उदाहरण को अलग-अलग इनपुट आदेशों के साथ कुछ बार दोहराएं, इसलिए उम्मीद है कि आपका नेटवर्क उचित समरूपता सीख सकता है।

यदि आपके पास केवल एक दृष्टिकोण का प्रयास करने का समय है, तो मैं सीएनएन चुनूंगा। सीएनएन को स्थानिक डेटा के साथ अच्छा करने के लिए डिज़ाइन किया गया है, और इनपुट आदेशों के साथ कोई समस्या नहीं है।

Comments

इसके साथ समस्या यह है कि भविष्यवाणी आदेश-निर्भर है। एल्गोरिथ्म को एक बिंदु सेट (0,0), (1,1), (2,2)को खिलाने से एक बिंदु सेट को खिलाने की तुलना में एक अलग प्रभाव पड़ेगा (1,1), (2,2), (0,0)।

— एलियास स्ट्रील

अच्छी बात एलियास - मैं इसे कम करने के लिए एक सुझाव दूंगा।

— इमरान

यह अच्छा है @EliasStrehle इसका उल्लेख करता है, इस समस्या के लिए आदेश अप्रासंगिक है। हमारे पास अंकों का एक सेट (सभी अद्वितीय, कोई आदेश नहीं) है।

— Elmex80s