न्यूरोफ तंत्रिका नेटवर्क

Question

के साथ मेरी स्नातक शोध के लिए मैं एक तंत्रिका नेटवर्क बना रहा हूं जो छवियों को पहचानने के लिए ट्रेन करता है। मैं सिर्फ आरजीबी मूल्यों, डाउनसमलिंग, और नेटवर्क के इनपुट में भेजने के बजाय बहुत अधिक जटिल जा रहा हूं, जैसे कई उदाहरण करते हैं। मैं वास्तव में 100 से अधिक स्वतंत्र रूप से प्रशिक्षित तंत्रिका नेटवर्क का उपयोग करता हूं जो विशेषताओं का पता लगाते हैं, जैसे रेखाएं, छायांकन पैटर्न इत्यादि। मानव आंख की तरह, और यह वास्तव में अब तक बहुत अच्छा काम करता है! समस्या यह है कि मेरे पास प्रशिक्षण डेटा का थोड़ा सा हिस्सा है। मैं इसे 100 से अधिक उदाहरण दिखाता हूं कि एक कार कैसा दिखती है। फिर एक व्यक्ति जैसा दिखता है उसके 100 उदाहरण। फिर 100 से अधिक कुत्ते कैसा दिखता है, आदि। यह प्रशिक्षण डेटा का थोड़ा सा है! वर्तमान में मैं नेटवर्क को प्रशिक्षित करने के लिए लगभग एक सप्ताह में दौड़ रहा हूं। यह मेरी प्रगति को मारने की तरह है, क्योंकि मुझे समायोजन और रोकथाम की आवश्यकता है।

मैं निम्न स्तर के तंत्रिका नेटवर्क एपीआई के रूप में Neuroph का उपयोग कर रहा हूं। मैं एक दोहरी-क्वाडकोर मशीन चला रहा हूं (हाइपरथ्रेडिंग के साथ 16 कोर), इसलिए यह तेज़ होना चाहिए। मेरा प्रोसेसर प्रतिशत केवल 5% है। क्या न्यूरोफ प्रदर्शन पर कोई चाल है? या सामान्य रूप से जावा प्रदर्शन? सुझाव? मैं एक संज्ञानात्मक मनोचिकित्सक छात्र हूं, और मैं एक प्रोग्रामर के रूप में सभ्य हूं, लेकिन प्रदर्शन प्रोग्रामिंग के बारे में बहुत कुछ नहीं जानता।

Answer 1

हाँ मैं कुछ महीने पहले उस सड़क पर गया था। एक विश्वविद्यालय परियोजना के लिए भी। पहली समस्या न्यूरोफ है। इसकी घातक धीमी गति से। न्यूरोफ ने प्रमुख वास्तुकला और प्रदर्शन के मुद्दों को अच्छी तरह से जानते हैं, कोड प्रोजेक्ट पर पिछले सप्ताह के बारे में सिर्फ एक लेख था।

http://www.codeproject.com/KB/recipes/benchmark-neuroph-encog.aspx

मैं इस लेख के लेखक के रूप में वही रास्ता पीछा किया। न्यूरोफ से एनकॉग तक स्विच करना एक वास्तविक आसान बंदरगाह है। उपर्युक्त आलेख के लेखक में एक और है जो एनकॉग, जोन और न्यूरोफ के वाक्यविन्यास की तुलना करता है, ताकि आप इसकी तुलना कर सकें। Encog बारे में अधिक जानकारी के लिए,

http://www.heatonresearch.com/encog

Encog भी अपने कोर के अधिक लाभ उठाएंगे। बस उपरोक्त आलेख में चार्ट देखें।

शुभकामनाएं! आपका शोध वास्तव में कमाल लगता है, मुझे परिणाम देखना अच्छा लगेगा।

Answer 2

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

पुनरावृत्तियों को तेज करना अच्छा है। लेकिन प्रशिक्षण पुनरावृत्ति के साथ और अधिक करना अक्सर बेहतर होता है। और दोनों को सबसे अच्छा करना है।

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

मैं भी सहमत हूं, आपका शोध वास्तव में दिलचस्प लगता है।

Answer 3

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

जेफ तरह का सुझाव दिया है (धन्यवाद जेफ) अपने नेटवर्क से स्वतंत्र हैं यदि आप कुछ इस तरह कर सकता है:

for(int index = 0; index < numberThreads ; index++) {  
    MultiLayerPerceptron mlp = new MultiLayerPerceptron(inputSize, hiddenLayerSize,outputSize);  
    SupervisedLearning learningRule = (SupervisedLearning)mlp.getLearningRule(); 
    learningRule.setMaxError(maxError); 
    learningRule.setMaxIterations(maxIterations); // make sure we can end. 
    learningRule.addObserver(this); // user observer to tell when individual networks are done and launch new networks. 
    this.mlpVector.add(mlp); 
    mlp.learnInNewThread(trainingSet); 
} 

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

Answer 4

आप एक हल्के (< 50kb) की तलाश में हैं जावा में तंत्रिका नेटवर्क कार्यान्वयन, आप भी एक नज़र Nen Beta पर लग सकता है - मैं नहीं जानता कि यह कैसे Neuroph या Encog की तुलना लेकिन एक performance- and speed-comparison against LibSVM काफी होनहार लग रहा है।

Answer 5

शायद बहुत देर हो चुकी है, लेकिन मैं भी न्यूरोफ का उपयोग करता हूं। मैं अपने एसएसडी और 4 कोर सीपीयू के साथ रात भर 100 से अधिक नेटवर्क बना देता हूं। जब आप जावा 8 का उपयोग कर रहे हैं, तो आप महान कोडर-कौशल के बिना मल्टीथ्रेडिंग कर सकते हैं। बस जावा 8 के नए "निष्पादक" पर एक नज़र डालें। मैं इसे अपनी कक्षा में उपयोग करता हूं। "मोंकी" ऑब्जेक्ट पर एक नज़र डालें। और कृपया खराब कोडिंग शैली को ध्यान में रखें। मुझे यहां जल्दी होने की जरूरत है ...

package de.sauer.dispe; 

import java.io.File; 
import java.io.FileWriter; 
import java.io.IOException; 
import java.time.Instant; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.TimeUnit; 

import org.neuroph.core.NeuralNetwork; 
import org.neuroph.core.data.DataSet; 
import org.neuroph.nnet.MultiLayerPerceptron; 
import org.neuroph.nnet.learning.BackPropagation; 
import org.neuroph.util.TransferFunctionType; 

import de.sauer.dispe.model.Director; 
import de.sauer.dispe.model.Specialist; 

@SuppressWarnings("rawtypes") 
public class DirBreeder_old { 

    private static final int MAX_ITER = 40; 
    public static final double GG_EPS = 0.49; 
    private static final double[] ERROR_RANGE = {0.02, 0.05, 0.47}; 
    private static final double[] LEARNING_RANGE = {0.1, 0.1, 0.3}; 
    private static final int[] LAYER_RANGE = {25, 5, 50}; 

    private static final TransferFunctionType[] TF_TYPES = { 
      TransferFunctionType.GAUSSIAN, 
      TransferFunctionType.LOG 
     }; 

    private static final String DIRECTOR_FOLDER = SpecAnalyser.SPEC_PATH+"\\director\\"; 
    private static final String OUTPUT_SUMMARY_FILE = DIRECTOR_FOLDER+"\\summary.csv"; 
    private static final String DATASET_FILE = TeamBuilder.TEAM_PATH+"\\1918_train.csv"; 
    private static ExecutorService MONKEY; 

    public static void main(String[] args) throws IOException { 
     doStuff(); 
    } 

    public static void doStuff() throws IOException { 
     System.out.println("Starting at: "+Instant.now()); 
     int counter = 0; 

     MONKEY = Executors.newFixedThreadPool(4); 
     FileWriter output = new FileWriter(new File(OUTPUT_SUMMARY_FILE), true); 

     DataSet ds = DataSet.createFromFile(DATASET_FILE, 11, 1, ";"); 

     for(int firstLayer=LAYER_RANGE[0];firstLayer<=LAYER_RANGE[2];firstLayer+=LAYER_RANGE[1]) { 
      for(int secondLayer=LAYER_RANGE[0];secondLayer<=LAYER_RANGE[2];secondLayer+=LAYER_RANGE[1]) { 
       for(int thirdLayer=LAYER_RANGE[0];thirdLayer<=LAYER_RANGE[2];thirdLayer+=LAYER_RANGE[1]) { 
        for(int forthLayer=LAYER_RANGE[0];forthLayer<=LAYER_RANGE[2];forthLayer+=LAYER_RANGE[1]) { 
         for(double maxError=ERROR_RANGE[0];maxError<=ERROR_RANGE[2];maxError+=ERROR_RANGE[1]) { 
          for(double learnRate=LEARNING_RANGE[0];learnRate<=LEARNING_RANGE[2];learnRate+=LEARNING_RANGE[1]) { 
           for(TransferFunctionType tft: TF_TYPES) { 

            Specialist trainee = new Director(
              buildAnn(tft, firstLayer, secondLayer, thirdLayer, forthLayer), 
              tft, 
              maxError, 
              ds, 
              MAX_ITER, 
              GG_EPS, 
              learnRate); 

            MONKEY.execute(new Trainer(trainee, output, counter++)); 
           } 
          } 
         } 
        } 
       } 
      } 
     } 
     System.out.println("Building "+counter); 
     MONKEY.shutdown(); 
     try { 
      MONKEY.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS); 
     } catch (InterruptedException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 

     output.flush(); 
     output.close(); 
    } 

    @SuppressWarnings("unchecked") 
    private static NeuralNetwork<BackPropagation> buildAnn(TransferFunctionType tft, int layer1, int layer2, int layer3, int layer4) { 
     NeuralNetwork nn = new MultiLayerPerceptron(tft, 11, layer1, layer2, layer3, layer4, 1); 
     nn.randomizeWeights(); 
     return nn; 
    } 

}