"新神经 "是MetaTrader 5平台的一个开源神经网络引擎项目。 - 页 16

新评论
 

我没有办法理解这个项目的本质。例如，什么是神经网络引擎？而为什么不同类型的网络必须是相同的呢？一些网络以一种方式有效地 "移动"，另一些则以另一种方式。对网络结构的描述也可能相应不同。对于一个简单的例子，以解决线性方程为例。当然，用一种方法解决所有类型的线性系统是可能的--高斯。但如果我们知道系数矩阵的结构，就有更有效的解决方法。这也是训练网络的 问题。前向传播网络是通过反向误差传播法训练的，回声网络是通过MNC训练的，等等。为什么不是一个引擎，而是创建几个引擎？为什么我们需要一个由程序员组成的团队来做同一件事，同时试图达成共识？在这种情况下，一致意见妨碍了创造性。让不同的程序员以库的形式编写不同网络的代码，可以从指标和顾问那里调用。在这种情况下，该项目与现有的由程序员发送他们的代码到图书馆代码库的系统没有什么不同，伴随着文章的是对网络的详细描述，它是如何工作的以及它的使用实例。如果几个程序员独立创建同一网络的代码，这没有什么问题。训练直接传播网络的变体有几十种。有了这种方法，与其浪费大量时间来讨论如何正确描述一个网络，人们已经开始创建这些网络的代码了。例如，我非常有兴趣阅读TheXpert关于回声网络的文章。但显然，这在很长一段时间内不会发生。

 
gpwr:

我无法理解项目的本质。例如，什么是神经网络引擎？而且为什么不同类型的网络应该是一样的呢？

我们要的是多功能性。内脏和装配当然会有所不同。为了可能的可视化和合并成委员会，需要进行统一。

gpwr:

例如，我非常有兴趣阅读TheXpert关于回声网络的文章。但这可能需要很长的时间。

好吧，你可以把它看成是OPS部队的一部分 :) 。

规模的代表。


 

这就是全部 :)

介绍一下网络。


 

样品 层模板。

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

共同的缓冲区。因此，缓冲区的变化对图层对象和突触都会立即可见。

输出突触也以同样的方式通过输出缓冲区连接。

 

突触。

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

突触中的错误也是存在的。

神经元的错误是为了学习阈值，突触的错误是为了学习突触。

而实际的权重矩阵（这里缺少的是一个好的权重可用性矩阵，可以手动设置）和缓冲区，用于与各层的通信。

 

网。

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

这大概是网络的样子。

 

在最简单的测试中建立和使用。

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%的潜在用户来说却完全无法使用。

如果我们必须向市场提供一个新的交易工具，它应该针对每个人，包括那些刚刚打开终端的人，那些多年来一直使用手轮的人，那些拥有两个更高学位的人和那些拥有更高计算机的人。

界面和产品本身应该像乐高积木一样简单易懂。

 
米切克。

如果任务是向受众提供一个新的工具，那么它最好是针对每个人，嗯，几乎每个人，包括那些第一次打开终端的人和那些迷恋多年的人，以及那些拥有两个大学学位的人和拥有Tspsh的人。

我认为最好是有能力的人，但不是程序员。
 
纸杯。
在贸易商中进行调查。它们能解决哪些交易任务？获得大多数人需要的东西。
交易员们自己上来写点东西，是不是太麻烦了？
1...91011121314151617181920212223...100
新评论