सी ++

Question

में क्षमता एक पेड़ स्थापित करने की कोशिश कर रहा हूं (अंततः "तंत्रिका नेटवर्क" में उपयोग के लिए और जितना संभव हो सके सेटअप को यथासंभव कुशल बनाने की कोशिश कर रहा है। दुर्भाग्यवश, पेड़ को स्थापित करने में लगभग 3 मिनट लगते हैं और मैं पता लगा सकते हैं नहीं इसके बारे में क्या यह इतना अक्षम कर रही है। मैं संकेत जहां भी संभव हो उपयोग करने के लिए लोड को कम करने का प्रयास किया, लेकिन यह अभी भी हमेशा के लिए ले जा रहा है। क्या मैं गलत कर रहा हूँ?

पी एस। इस के लिए अंत में है एक टिक टैक पैर की अंगुली एआई (हाँ मुझे पता है कि इसे बेवकूफ खेल को देखकर हल किया जा सकता है, लेकिन मैं इसे खुद को सिखाने के लिए एक साधारण एआई के रूप में करना चाहता था।

पेड़ की प्रत्येक शाखा में 9 नोड होंगे, प्रत्येक नोड एक और बनाने के लिए बाहर शाखाओं के साथ 9। यह शाखाओं का अंतिम सेट लगभग 400 मिलियन नोड्स देता है। क्या इस कोड को और अधिक कुशलता से करने का कोई तरीका है?

#include <iostream> 
#include <vector> 


using namespace std; 

class Node; 
class Set; 


class Node { 
    public: 
     Node(double, Set*); 
     Node(); 
     double value; 
     Set * nextSet; 
}; 
class Set { 
    public: 
     Set(vector<Node *>); 
     Set(); 
     vector<Node *> nodes; 
}; 
class NeuralNet { 
    public: 
     Set * firstSet; 
}; 
Node::Node(double val, Set * newSet){ 
    value = val; 
    nextSet = newSet; 
} 
Set::Set(vector<Node *> input){ 
    nodes = input; 
} 
Node::Node(){ 
    Set temp; 
    nextSet = &temp; 
} 
Set::Set(){ 
    vector<Node *> temp; 
    nodes = temp; 
} 
void setUpNeuralNetRecursive(Set * curSet, int curDepth){ 
    if(curDepth<9){ 
     for(int i=0;i<9;i++){ 
      Set newSet; 
      Node newNode(1,&newSet); 
      (*curSet).nodes.push_back(&newNode); 
      setUpNeuralNetRecursive(&newSet, curDepth+1); 
     } 
    } 
} 
void setUpNeuralNet(NeuralNet net){ 
    Set newSet; 
    net.firstSet=&newSet; 
    setUpNeuralNetRecursive(&newSet, 0); 
} 
int main() 
{ 
    cout << "Setting up neural network. This may take up to 3 minutes." << endl; 
    NeuralNet net; 
    setUpNeuralNet(net); 
    cout << "Setup ended." << endl; 

    return 0; 
} 

Answer 1

आपके पास पूरी तरह संतुलित, 9-आरी पेड़ है? प्रत्येक तत्व के लिए नोड आवंटित न करें! इसके बजाय, आप नोड्स के लिए एक सरणी का आवंटन और संगणना का उपयोग कर पेड़ से नेविगेट:

• अपनी मूल करने के लिए नोड i से नेविगेट करने के लिए आप की गणना होगी (i - 1)/9
• सबसे बाईं ओर बच्चे आप की गणना होगी i * 9 + 1
जानने के लिए

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

उसने कहा, मुझे संदेह है कि आप वास्तव में इस तरह का पेड़ चाहते हैं: प्रत्येक चाल के साथ विकल्पों की संख्या कम हो जाती है और आप शायद कुछ शाखाओं को पूरी तरह से मारना चाहते हैं। पेड़ के लिए तकनीक अभी भी उपयोगी हो सकती है, हालांकि।