"New Neural", MetaTrader 5 platformu için bir sinir ağı motorunun Açık Kaynak projesidir. - sayfa 16

Yeni yorum
 

Projenin özünü anlayamıyorum. Örneğin, bir sinir ağı motoru nedir? Ve neden farklı ağ türleri için aynı olsun? Bazı ağlar bir şekilde etkili bir şekilde "hareket eder", diğerleri ise başka bir şekilde. Sırasıyla ağ yapısının açıklaması da farklı olabilir. Basit bir örnek için lineer denklemlerin çözümünü alın. Tabii ki, tüm lineer sistem türleri tek bir yöntemle çözülebilir - Gauss. Ancak, katsayılar matrisinin yapısını biliyorsak, o zaman çözmek için daha etkili yöntemler vardır. Aynı şey eğitim ağlarının görevidir. İleri yayılma ağları geri yayılma ile eğitilir, yankı ağları en küçük kareler ile eğitilir, vb. Neden bir motor yerine birkaç tane yaratalım? Neden aynı şey üzerinde çalışan ve aynı zamanda bir fikir birliğine varmaya çalışan bir programcı ekibine ihtiyacımız var? Bu durumda oybirliği yaratıcılığı engeller. Farklı programcıların, göstergelerden ve danışmanlardan arama imkanı ile bir kütüphane şeklinde farklı ağların kodlarını yazmasına izin verin. Bu durumda proje, programcılara kodlarını ağın, nasıl çalıştığının ve kullanım örneklerinin ayrıntılarını içeren bir makalenin eşlik ettiği kütüphane kod tabanına gönderen mevcut sistemden farklı değildir. Birkaç programcının aynı ağı bağımsız olarak kodlaması sorun değil. Doğrudan yayılma ağlarını eğitmek için düzinelerce seçenek vardır. Bu yaklaşımla, ağın nasıl doğru bir şekilde tanımlanacağını tartışmak için çok zaman harcamak yerine, insanlar bu ağlar için kodlar oluşturmaya çoktan başlayacaktı. Örneğin, TheXpert'in yankı ağları hakkındaki makalesini okumakla çok ilgileniyorum. Ama görünüşe göre yakında olmayacak.

 
gpwr :

Projenin özünü anlayamıyorum. Örneğin, bir sinir ağı motoru nedir? Ve neden farklı ağ türleri için aynı olsun?

Çok yönlülük istiyoruz. İç ve montaj elbette değişecektir. Olası görselleştirme ve komitelerle ilişkilendirme için birleştirme gereklidir.

gpwr :

Örneğin, TheXpert'in yankı ağları hakkındaki makalesini okumakla çok ilgileniyorum. Ama görünüşe göre yakında olmayacak.

Eh, açık kaynak çerçevesinde, muhtemelen okuyabilirsiniz :).

Ölçek gösterimi:


 

Aslında hepsi bu :)

Ağ temsili:


 

Örnek katman şablonu :

 class LayerFunctional
{
        typedef boost::shared_ptr<Synapse> SynapsePtr;
        typedef std::vector<SynapsePtr> SynapseVector;
        typedef SynapseVector::iterator SynapseIterator;

public :
        typedef boost::shared_ptr<Vector> VectorPtr;
        typedef boost::shared_ptr<IPatternCollection> PatternsPtr;

public :
        LayerFunctional
                (         bool bAdaptiveStep
                        , double step
                        , size_t newSize
                        , bool bTUsed
                );

         void Init( const Initializer& initializer);

         void AddInputSynapse(boost::shared_ptr<Synapse> pSynapse);
         void RemoveInputSynapse(boost::shared_ptr<Synapse> pSynapse);

         void AddOutputSynapse(boost::shared_ptr<Synapse> pSynapse);
         void RemoveOutputSynapse(boost::shared_ptr<Synapse> pSynapse);

         void FwdPropagate();
         void BackPropagate();

         void ClearInputs();
         void ClearErrors();

         const size_t Size() const ;

         void SetSize(size_t newSize);

         const bool ThresholdsUsed() const ;
         void SetThresholdsUsed( bool used = false );

         const bool AdaptiveStepUsed() const ;
         void SetAdaptiveStepUsed( bool used = false );
         const double GetStep() const ;

         const VectorPtr GetInputs() const ;
         const VectorPtr GetOutputs() const ;
         const Vector& GetErrors() const ;
         const Vector& GetThresholds() const ;

         const PatternsPtr GetInputCollection() const ;
         const PatternsPtr GetOutputCollection() const ;


         void SetInputCollection(PatternsPtr patterns);
         void SetOutputCollection(PatternsPtr patterns);

         void FeedInputs(size_t patternIndex);
         void CompareOutputs(size_t patternIndex);

         void DoF(Vector& data);
         void DodF(Vector& data);

         void Learn();

         double CountAlpha();

        template< class Archive>
         void save(Archive & ar, const unsigned int version ) const
        {
        }

        template< class Archive>
         void load(Archive & ar, const unsigned int version )
        {
        }

private :
         bool m_bAdaptiveStep;

         double m_Step;

        size_t m_Size;
         bool m_bTAreUsed;

        Vector m_vT;
        Vector m_vErrors;
        VectorPtr m_pInputs;
        VectorPtr m_pOutputs;

        SynapseVector m_vInSynapses;
        SynapseVector m_vOutSynapses;

        PatternsPtr m_pInputCollection;
        PatternsPtr m_pOutputCollection;
};

Bu, MLP'nin uygulanması için bir tahmindir, çoğu genel arayüze uyar. 

m_vInSynapses

Katmana dahil edilen sinaps vektörü. Bu sinapslar ve katmanın kendisi, 

m_pInputs

paylaşılan tampon Bu nedenle, arabellekteki bir değişiklik hem katman nesnesi hem de sinapslar tarafından hemen görülebilir.

Çıkış sinapsları, çıkış arabelleği aracılığıyla aynı şekilde bağlanır.

 

Sinapslar:

 class Synapse
{
        Synapse()
        {
        }

public :
        typedef boost::shared_ptr<Vector> VectorPtr;

public :
        Synapse(boost::shared_ptr<Vector> inputVector, boost::shared_ptr<Vector> outputVector);
        
         void AssignInput(boost::shared_ptr<Vector> inputVector);
         void AssignOutput(boost::shared_ptr<Vector> outputVector);

         void FwdPropagate();
         void BackPropagate(LayerFunctional* outLayer);

         double operator ()(size_t inIdx, size_t outIdx) const ;

         const Detail::Slice FromInput(size_t inIdx) const ;
         const Detail::Slice ToOutput(size_t outIdx) const ;

        size_t GetOutSize() const ;
        size_t GetInSize() const ;

         const Vector& GetErrors() const ;
         void ZeroErrors();

         void Init( const Initializer& initializer);
         void Learn(LayerFunctional* outLayer, const double & step);

         const VectorPtr GetInputs() const ;
         const VectorPtr GetOutputs() const ;

         void SetValues( const Synapse& other);

private :
        size_t m_InSize;
        size_t m_OutSize;

        Matrix m_vSynapses;
        Vector m_vErrors;

        VectorPtr m_pInBuffer;
        VectorPtr m_pOutBuffer;
};

Sinapslarda da hatalar vardır.

Nöron hataları eşik öğrenme içindir, sinaps hataları sinaps öğrenme içindir.

Peki, gerçek ağırlık matrisi (manuel olarak ayarlanabilen ağırlıkların varlığının matrisi hala iyi bir şekilde yeterli değil) ve katmanlarla iletişim için tamponlar.

 

Ağ:

 class Net
{
        typedef boost::shared_ptr<LayerFunctional> LayerPtr;
        typedef boost::shared_ptr<Synapse> SynapsePtr;
        
        typedef std::vector<LayerPtr> LayersVector;
        typedef std::vector<SynapsePtr> SynapsesVector;

public :
        Net();

         void AddLayer(size_t size, bool bTUsed)
         void AddLayer( const LayerPtr& pLayer);

        LayerPtr GetLayer(size_t index) const ;
        SynapsePtr GetSynapse(size_t index) const ;

         void ConnectLayers(LayerPtr& inLayer, LayerPtr& outLayer);
        size_t GetLayersCount() const ;

        size_t GetSynapsesCount() const ;

         void Init( const Initializer& initializer);

         void FeedInputs(size_t patternIndex);
         void FwdPropagate();
         void BackPropagate();
         void CountErrors(size_t patternIndex);
         void Learn();

        size_t GetLayerID( const LayerPtr& pLayer) const ;

         void save(Archive & ar, const unsigned int version ) const
         void load(Archive & ar, const unsigned int version )

private :
         struct Link;

        typedef std::vector<Link> LinksVector;

private :
        size_t m_LayersCount;
        size_t m_SynapsesCount;

        LayersVector m_vLayers;
        SynapsesVector m_vSynapses;
        LinksVector m_vLinks;
};

Ağın görünüşü bu.

 

En basit testte yapı ve kullanım:

 void XORTest()
{
        Net net;

        LayerPtr inLayer( new Layer<Functions::LinearFunction>( false , 0.2 , 2 , false ));
        LayerPtr hiddenLayer( new Layer<Functions::BiSigmoidFunction>( false , 0.2 , 3 , false ));
        LayerPtr outLayer( new Layer<Functions::LinearFunction>( false , 0.2 , 1 , false ));

        net.AddLayer(inLayer);
        net.AddLayer(hiddenLayer);
        net.AddLayer(outLayer);

        net.ConnectLayers(inLayer, hiddenLayer);
        net.ConnectLayers(hiddenLayer, outLayer);

        PatternsPtr inPattern( new PatternCollection<>( 2 ));
         // filling patterns

        PatternsPtr outPattern( new PatternCollection<>( 1 ));
         // filling patterns

        inLayer->SetInputCollection(inPattern);
        outLayer->SetOutputCollection(outPattern);

        Initializer initer( 0.1 );
        net.Init(initer);

        size_t count = 0 ;
         double Es = 0.0 ;

         do 
        {
                Es = 0.0 ;
                 for (size_t i = 0 ; i < 4 ; ++i)
                {
                        net.FeedInputs(i);
                        net.FwdPropagate();
                        net.CountErrors(i);
                        net.BackPropagate();
                        net.Learn();

                        Vector v(outLayer->Size());
                        v = outLayer->GetErrors();
                        v *= v;

                        Es += v.sum()/ 2.0 ;
                }

                ++count;
        } while (Es > 0.0001 && count < 10000 );
}

Ayrıca, tipik konfigürasyonlar için şablonlar oluşturabilirsiniz.

 
TheXpert :

Bu şekilde olmaz :) En azından neyi nasıl alacağınızı, neyi öğreteceğinizi ve nasıl değerlendireceğinizi bilmeniz gerekiyor. Ve bu şeylerin tutamaçlarla düzenlenmesi gerekiyor.

Aynen öyle. Ve bilmiyorum. Ayrıca, genellikle birleştirilmesi çok zor olan takımlar da vardır. Nöronlar sadece bir araçtır. Becerikli ellerde (en azından Leonid'i alın)) çok güçlü.

Merak ediyorum, danışmak istiyor mu?

Burada bir boşluk varken küçük bir IMHO.Sonuçta, işlevsellik açısından ihtiyaçlarınızı tam olarak karşılayan, ancak potansiyel kullanıcıların diğer %99'u için tamamen uygun olmayan bir ürün oluşturma riskinden kaçınmanız gerekir.

Görev, izleyiciye yeni bir araç sağlamaksa, o zaman ideal olarak, hem terminali ilk kez açanlar hem de Quick'te yıllardır oturanlar ve hemen hemen herkes için ideal olarak tasarlanmalıdır. iki tane daha yüksek olanlar ve çay kaşığı olanlar.

Arayüz ve ürünün kendisi bir Lego seti gibi basit ve anlaşılır olmalıdır.

 
yanlış :

Görev, izleyiciye yeni bir araç sağlamaksa, o zaman ideal olarak, hem terminali ilk kez açanlar hem de Quick'te yıllardır oturanlar ve hemen hemen herkes için ideal olarak tasarlanmalıdır. iki tane daha yüksek olanlar ve çay kaşığı olanlar.

Bunun için yetkin birinin olması arzu edilir, ancak bir programcı değil.
 
papaklas :
Tüccarlar arasında bir anket yapın. Ticarette hangi görevleri çözüyorlar? Çoğunluğun ihtiyacı olanı alın.
Ve tüccarlar kendilerini yakalamak ve buraya bir şeyler yazmak için vlom?
1...91011121314151617181920212223...100
Yeni yorum