"New Neural "は、MetaTrader 5プラットフォーム用のオープンソース・ニューラルネットワークエンジンプロジェクトです。 - ページ 16

[Vladimir]

本質を理解する術がない。例えば、ニューラルネットワークエンジンとは何でしょうか？また、なぜネットワークの種類によって同じでなければならないのでしょうか？あるネットワークはある方法で、あるネットワークは別の方法で、効果的に「動く」のです。それに伴い、ネットワークの構造に関する記述も異なる場合があります。簡単な例として、連立方程式の解法を考えてみよう。もちろん、ガウスという1つの手法であらゆる種類の連立方程式を解くことは可能である。しかし、係数行列の構造が分かれば、より効率的な解法がある。ネットワークの学習も 同じような問題です。前方伝搬ネットワークは後方誤差伝搬法で、エコーネットワークはMNCで学習させる、など。なぜ、1つのエンジンではなく、複数のエンジンを作るのか？なぜ、プログラマーのチームが合意形成を図りながら同じことをする必要があるのでしょうか？この場合の全会一致は、創造性を妨げる。異なるプログラマーに、指標やアドバイザーから呼び出せるライブラリーの形で、異なるネットワークのコードを書かせる。この場合、プログラマーが自分のコードをライブラリーのコードベースに送り、ネットワークの詳細な説明や仕組み、使用例などを記事に添えて送るという既存のシステムと何ら変わりはありません。同じネットワークのコードを複数のプログラマーが独立して作成しても、何ら問題はない。直接伝搬型ネットワークの学習には、何十種類ものバリエーションがある。このアプローチでは、ネットワークをどう記述するかという議論に多くの時間を費やす代わりに、人々はすでにそのネットワークのコードを作り始めているのです。TheXpertのエコーネットワークに関する記事など、とても興味深く読ませていただきました。しかし、どうやら長い間実現しないようだ。

[TheXpert]

gpwr

本質を理解できない。例えば、ニューラルネットワークエンジンとは何でしょうか？また、なぜネットワークの種類が違っても同じでなければならないのでしょうか？

私たちは汎用性を求めています。ガットや組み立てはもちろん別物になります。可視化や委員会への統合を可能にするために、統一が必要である。

gpwr

例えば、TheXpertのエコーネットワークに関する記事を読んで、とても興味を持ちました。でも、きっと長い時間がかかるでしょう。

まあ、オプソースの一部として読んでもいいんですけどね :) .

スケールの表現。

[TheXpert]

以上です :)

ネットワークを紹介します。

[TheXpert]

サンプルレイヤーのテンプレート です。

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;
};

これはMLPの実装の近似値であり，そのほとんどはユニバーサルインターフェースに適合しています．

m_vInSynapses

レイヤーを構成するシナプスのベクトル。これらのシナプスと層そのものは

m_pInputs

コモンバッファーしたがって、バッファの変化はレイヤーオブジェクトとシナプスの両方に即座に表示される。

出力シナプスも出力バッファを介して同じようにリンクされている。

[TheXpert]

シナプス

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;
};

シナプスのエラーもある。

ニューロンのエラーは閾値の学習のため、シナプスのエラーはシナプスの学習のためです。

そして、実際の重みの行列（ここに欠けているのは、重みの可用性の良い行列で、手動で設定することができる）と層との通信のためのバッファである。

[TheXpert]

ネットのことです。

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;
};

ネットワークはだいたいこんな感じです。

[TheXpert]

最も簡単なテストで構築し、使用することができます。

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);
}

さらに、代表的な構成のテンプレートを作成することができます。

[михаил потапыч]

TheXpert です。

それはうまくいきません :) 少なくとも、何を取り、何を教え、どう評価するかは知っておかなければなりません。そして、これらは自分の手で整理しなければならない。

その通り、そして私は知らない。そればかりか、まったく組み合わせが難しいセットもあります。神経細胞は道具に過ぎない。巧みな手腕で（例えばレオニード）、とてもパワフルです。

アドバイスしてくれないかなあ。

結局、機能面ではニーズを十分に満たしていても、99％の潜在的なユーザーには全く使えない製品を作ってしまうリスクは避けなければなりません。

新しい取引ツールを市場に提供するとしたら、端末を開いたばかりの人、何年も手書きで使っている人、2つ上の学位を持っている人、上位のコンピューターを持っている人など、すべての人を対象にしたものでなければならないのです。

インターフェースや製品そのものは、レゴのセットのようにシンプルでわかりやすいものであるべきです。

[TheXpert]

ミシェック

新しいツールを提供するという課題であれば、初めて端末を開いた人と何年もハマっている人、2大卒の人とTspshを持っている人など、すべての人、いや、ほぼすべての人に向けたものが理想的です。

実力はあってもプログラマーではない人が望ましいと思います。

[Mykola Demko]

papaklass
トレーダーへのアンケートを実施する。どのような取引業務を解決するのか？多くの人が必要とするものを手に入れる。

トレーダー本人が出てきてここに何か書くのは面倒なのでしょうか？