क्या सोलर/लुसीन में कोसाइन समानता मॉडल करना संभव है?

Question

मैं सोलर का उपयोग कर कोसाइन समानता एल्गोरिदम मॉडल करने के संभावित तरीकों में रूचि रखता हूं। मेरे पास वेक्टर हैं जिन्हें वेक्टर असाइन किया गया है, उदाहरण के लिए:

items = [ 
    { id: 1, vector: [0,0,0,2,3,0,0] }, 
    { id: 2, vector: [0,1,0,1,5,0,0] }, 
    { id: 3, vector: [2,3,0,0,0,1,0] }, 
    { id: 4, vector: [1,2,4,6,5,0,0] } 
] 

और एक खोज वेक्टर जिस पर दूसरों को रैंक करने की आवश्यकता है।

वर्तमान में, मैं सभी वस्तुओं पर चलकर और उन्हें इनपुट वेक्टर के खिलाफ रैंक असाइन करके रूबी में मॉडलिंग कर रहा हूं। यहाँ मैं उपयोग कर रहा हूँ कोज्या समानता के कार्यान्वयन है:

module SimilarityCalculator 

    def self.get_similarity(vector1, vector2) 
    dp = dot_product(vector1, vector2) 
    nm = normalize(vector1) * normalize(vector2) 
    dp/nm 
    end 

    private 

    def self.dot_product(vector1, vector2) 
    sum = 0.0 
    vector1.each_with_index { |val, i| sum += val * vector2[i] } 
    sum 
    end 

    def self.normalize(vector) 
    Math.sqrt(vector.inject(0.0) { |m,o| m += o**2 }) 
    end 

end 

फिर, एक स्थान पर रहीं सूची मैं की तरह कुछ करना होगा प्राप्त करने के लिए निम्नलिखित:

ranked = [] 
search_vector = [1,0,0,3,5,0,0] 
items.each do |item| 
    rank = SimilarityCalculator.get_similarity(search_vector, item.vector) 
    { id: item.id, rank: rank } 
end 

मैं के बारे में पता करने के लिए Solr पर्याप्त जानकारी नहीं है यह कैसे मॉडलिंग किया जाएगा या यहां तक ​​कि अगर यह कर सकता है, लेकिन मैंने सोचा कि मैं इसे बाहर फेंक दूंगा।

Answer 1

लुसीन पहले से ही कोसाइन समानता मॉडल का उपयोग करता है, इसलिए असली सवाल यह है: क्या आप अपने वैक्टर को लुसीन के वैक्टर में मैप कर सकते हैं? और क्या आप मानदंड आदि को हटा सकते हैं जो लुसीन करता है जिसे आप नहीं चाहते हैं?

आप हमेशा अपना स्कोरिंग और विश्लेषण कार्य लिख सकते हैं, इसलिए यदि आप कुछ कोडिंग करने के इच्छुक हैं, तो उत्तर स्पष्ट "हाँ" है। यद्यपि आप चाहते हैं कि इससे अधिक काम की आवश्यकता हो सकती है।

एक विकल्प के लिए जो आपको रास्ते का हिस्सा ले सकता है लेकिन किसी भी कोडिंग की आवश्यकता नहीं है: प्रत्येक आयाम को "dim_n" शब्द में अनुवाद करें और इसे दोहराएं (या इसे बढ़ावा दें) हालांकि कई बार उस आयाम में वेक्टर की परिमाण है । उदाहरण के लिए:

[1,2,0,1] ==> "dim_1 dim_2 dim_2 dim_4" 

अपने वैक्टर लगभग एक ही आकार के सभी और समान रूप से आयाम भर में वितरित कर रहे हैं, यह एक बहुत अच्छा सन्निकटन हो सकता है।

यदि आप हमें समस्या के बारे में और बताते हैं (उदाहरण के लिए आपको वास्तव में इनपुट के रूप में लुसीन वैक्टर देना होगा या आप इसे पाठ दे सकते हैं?) हम बेहतर समाधान ढूंढ पाएंगे।