• https://docs.microsoft.com/en-us/cognitive-toolkit/setup-windows-python?tabs=cntkpy22 airsim支持两种控制,一种是通过USB接入控制手柄控制(之前安装博客说的就是这个)另一种就是...先安装微软的CNTK We...

    https://docs.microsoft.com/en-us/cognitive-toolkit/setup-windows-python?tabs=cntkpy22

    airsim支持两种控制,一种是通过USB接入控制手柄控制(之前安装博客说的就是这个)另一种就是通过API调用控制,API可以写代码进行策略修改以及计算机视觉的任务。

    现在进行API控制的学习

    先安装微软的CNTK

    We offer three ways to install CNTK for Python:

    1. PyPI installation
    2. Wheel (.whl) files for each release
    3. Nightly builds                  

    有三种安装方式

    我装了anaconda所以,选第二个方法

    如何查看anaconda的版本

    https://jingyan.baidu.com/article/86fae34613d1c43c49121aca.html

    python是3.6.5

    我选择CPU-only

    如果要升级,Upgrade an existing CNTK installation

    python -c "import cntk; print(cntk.__version__)"测试一下是否安装成功

    因为:

    For CNTK 2.5+, we recommend you simply install through PyPI instead.

    所以就安装了默认的2.2

    显示了版本号。

    Installing Samples and Tutorials

    安装案例

    这将下载示例/教程,安装所需的Python包,并将示例复制到当前工作目录下名为CNTK- samples -VERSION(版本将被实际的CNTK版本替换)的目录中。

    在setting.json文件中选mode是car即可,打开后,能成功控制小车。

    至此,新手教程全部完毕,

    这个山地图只适合飞无人机,车不好控制,但是城市地图要钱啊,这可咋整,难不成要自己推一个虚拟城市地图出来么。。。

    焦虑。。。。。。。。。。。。。。

     

     

    展开全文
  • 但EvalDLL目前为C++的实现,本文将仿照CNTK中EvalWrapper工程,将EvalDLL封装为Python可以调用的Python模块。目标根据EvalWrapper工程,具体需要封装的其实只有2个全局的方法(分别对应float和double)以及1个接口。

    前言

    CNTK中网络模型的使用是通过EvalDLL进行的。但EvalDLL目前为C++的实现,本文将仿照CNTK中EvalWrapper工程,将EvalDLL封装为Python可以调用的Python模块。

    目标

    根据EvalWrapper工程,具体需要封装的其实只有2个全局的方法(分别对应float和double)以及1个接口。

    enum NodeGroup
    {
        nodeInput,  // an input node
        nodeOutput, // an output node
        nodeSpecified
    };
    
    // IEvaluateModel - interface used by decoders and other components that need just evaluator functionality in DLL form
    template <class ElemType>
    class IEvaluateModel // Evaluate Model Interface
    {
    public:
        virtual void Init(const std::string& config) = 0;
        virtual void Destroy() = 0;
    
        virtual void CreateNetwork(const std::string& networkDescription) = 0;
        virtual void GetNodeDimensions(std::map<std::wstring, size_t>& dimensions, NodeGroup nodeGroup) = 0;
        virtual void StartEvaluateMinibatchLoop(const std::wstring& outputNodeName) = 0;
        virtual void Evaluate(std::map<std::wstring, std::vector<ElemType>*>& inputs, std::map<std::wstring, std::vector<ElemType>*>& outputs) = 0;
        virtual void Evaluate(std::map<std::wstring, std::vector<ElemType>*>& outputs) = 0;
        virtual void ResetState() = 0;
    };
    
    // GetEval - get a evaluator type from the DLL
    // since we have 2 evaluator types based on template parameters, exposes 2 exports
    // could be done directly with the templated name, but that requires mangled C++ names
    template <class ElemType>
    void EVAL_API GetEval(IEvaluateModel<ElemType>** peval);
    extern "C" EVAL_API void GetEvalF(IEvaluateModel<float>** peval);
    extern "C" EVAL_API void GetEvalD(IEvaluateModel<double>** peval);

    上述声明中的GetEvalF以及GetEvalD方法分别对应获取float或者是double类型的IEvaluateModel。之后通过IEvaluateModel即可调用已经训练完成的网络模型。

    实现

    封装的思路

    通过Python调用C++的方法有很多,这里计划使用Boost.Python来封装,原因主要是因为CNTK工程中已经引入的Boost库,所以继续使用Boost.Python可以不增加负担,并且目前为Boost.Python的封装的软件也有好多,包括py++等。使用Boost.Python对C++进行封装也是比较成熟的方法。所以笔者目前决定使用Boost.Python来对EvalDLL进行针对Python调用的封装。

    具体针对Boost.Python的介绍可以参考如下链接:

    http://www.boost.org/doc/libs/1_60_0/libs/python/doc/html/index.html

    另外介绍一点,其实Apache的thrift也是在备选范围内的一种,Thrift的本质目的就是提供一种异步架构的互操作机制。但是如果要使用Thrift,则需要提供一个service的进程来提供服务。相比于直接利用C++中本身Boost库提供的机制来讲,Boost.Python在封装上相比较thrift比较麻烦,但是提供给最终用户的调用很方便。

    具体针对Thrift的介绍可以参考如下链接:

    https://thrift.apache.org/

    创建及配置工程

    为保持CNTK的整体Project的结构风格,笔者将在CNTK工程中的Extensibility目录创建一个子工程,命名为CNTKPythonWrapper,目标目录选择CNTK\Source\Extensibility\

    这里写图片描述

    之后就是配置工程,配置工程不建议用Visual Studio的界面去配置,因为目前已经存在EvalWrapper工程,并且我们的工程配置信息应该同这个类似,所以我建议复制EvalWrapper.vcxproj的内容,来修改我们的配置。

    具体需要做的事情就是:
    1. 将EvalWrapper.vcxproj拷贝至CNTKPythonWrapper工程目录,然后改名为CNTKPythonWrapper.vcxproj覆盖原油的.vcxproj文件。(这步骤主要是方便直接创建了x64以及Debug和Debuy_CPUonly等编译相关的配置管理)
    2. 删除.vcxproj中对原有.cpp文件的引用,就是删掉下面的内容,

    ```
      <ItemGroup>
        <ClCompile Include="EvalWrapper.cpp" />
      </ItemGroup>
    ```
    

    3. 去掉clr编译选项

    这里写图片描述
    4. 添加Boost相关的Header文件以及Lib文件引用

    这里写图片描述
    这里写图片描述
    5. Post-build时的文件拷贝(主要是boost库的一些dll)

    这里写图片描述

    1. 重要的一点是Python加载的模块的拓展名为.pyd,我们修改输出文件为.pyd文件

    这里写图片描述

    根据上述步骤,我们即完成了工程的创建以及配置工作。由于是该工程是用于封装,所以不必复杂,我们简单的添加一个PythonWrapper.cpp文件在工程中,所有实现都写在这个文件里即可(不用使用头文件,python调用不需要关心这些的)。

    Boost.Python简单的介绍

    这里简单介绍下Boost.Python的使用,首先是Header文件的引用,

    #include <boost/python.hpp>

    对于Boost.Python,是通过BOOST_PYTHON_MODULE来创建一个Python的模块,模块名字写在其后面的括号中,具体形式如下:

    BOOST_PYTHON_MODULE(TestForPython)
    {
        using namespace boost::python;
        class_<hello>("hello", init<std::string>())
            // Add a regular member function.
            .def("greet", &hello::greet)
            // Add invite() as a member of hello!
            .def("invite", invite);
    
        // Also add invite() as a regular function to the module.
        def("invite", invite);
    }

    上述代码中则实现了一个TestForPython的Python模块的封装,其中,定义了一个hello的类型,hello类型中,包括了一个传入std::string的构造函数,以及greet方法。

    而invite方法,被定义了两次,第一次是定义于hello类型中,默认这种定义要求的是可以接受一个hello类型作为传入参数的方法。而后面单独的def("invite", invite);则是定义invite为一个全局方法。

    def函数后面可能根据需要还需要添加针对参数以及返回值的修饰说明,例如下面情况,

    def("getHello", getHello, return_value_policy<reference_existing_object>());

    这里定义的getHello方法将返回值作为引用类型返回,这种情况下getHello的原型可能为:

    hello& getHello()

    还有就是一些传入的数组等,Boost.Python中,提供了boost::python::list类型供使用。所以一般c++同Python交互的时候使用该类型,然后再在c++这端将其解开在赋值。

    封装IEvaluateModel

    笔者对Boost.Python并不是很熟悉,研究了一下午,简单的封装了下IEvalueteModel方法,重点其实涉及到的主要是加载DLL以及找到函数的入口并进行调用。

    首先是定义一下GetEval方法的原型,也就是之前在EvalDLL中暴露出来的C方法。

     // Used for retrieving the model appropriate for the element type (float / double)
     template<typename ElemType>
     using GetEvalProc = void(*)(IEvaluateModel<ElemType>**);

    可以根据下面的方法,首先先加载evaldll.dll,然后再该dll中找到具体的获取IEvaluateModel对象的方法(GetEvalF或者是GetEvalD)。

    auto hModule = LoadLibraryA("evaldll.dll");
    if (hModule == nullptr)
    {
        throw std::runtime_error("Cannot find library: evaldll.dll");
    }           
    
    auto procAddress = GetProcAddress(hModule, funcName.c_str());
    auto getEvalProc = (GetEvalProc<ElemType>)procAddress;
    getEvalProc(&m_eval);
    if (m_eval == nullptr)
    {
        throw std::runtime_error("Cannot get IEvaluateModel.");
    }

    最后就是针对于相关接口的封装,其中用到了Boost.Python的一些对象,包括boost::python::dict以及boost::python::list等。笔者将最后的封装完成的代码粘贴如下:

     // Used for retrieving the model appropriate for the element type (float / double)
     template<typename ElemType>
     using GetEvalProc = void(*)(IEvaluateModel<ElemType>**);
    
     /// Managed wrapper for the native evaluation model
     template<typename ElemType>
     class IPythonEvaluateModel
     {
         typedef std::pair<std::wstring, std::vector<ElemType>*> MapEntry;
    
     public:
         /// <summary>Initializes a new instance of the <see cref="IPythonEvaluateModel"> class.</summary>
         /// <param name="funcName">Factory function name for retrieving the native model from the dll.</param>
         IPythonEvaluateModel(const std::string& funcName)
         {
             auto hModule = LoadLibraryA("evaldll.dll");
             if (hModule == nullptr)
             {
                 throw std::runtime_error("Cannot find library: evaldll.dll");
             }           
    
             auto procAddress = GetProcAddress(hModule, funcName.c_str());
             auto getEvalProc = (GetEvalProc<ElemType>)procAddress;
             getEvalProc(&m_eval);
             if (m_eval == nullptr)
             {
                 throw std::runtime_error("Cannot get IEvaluateModel.");
             }
    
         }
    
         /// <summary>Initializes the model evaluation library with a CNTK configuration</summary>
         /// <param name="config">Model configuration entries</param>
         void Init(const std::string& config)
         {
             if (m_eval == nullptr)
             {
                 throw std::runtime_error("Object has been disposed.");
             }
    
             m_eval->Init(config);
         }
    
         /// <summary>Creates a network based from the network description in the configuration</summary>
         /// <param name="networkDescription">The configuration file containing the network description</param>
         void CreateNetwork(const std::string& networkDescription)
         {
             if (m_eval == nullptr)
             {
                 throw std::runtime_error("Object has been disposed.");
             }
    
             m_eval->CreateNetwork(networkDescription);
         }
    
         /// <summary>Evaluates the model using a single forward feed pass and retrieves the output layer data</summary>
         /// <param name="outputKey"></param>
         /// <param name="outputSize"></param>
         /// <returns>Results for specified layer</returns>
         boost::python::list Evaluate(const std::wstring& outputKey, int outputSize)
         {
             if (m_eval == nullptr)
             {
                 throw std::runtime_error("Object has been disposed.");
             }
    
             std::map<std::wstring, std::vector<ElemType>* > stdOutputs;
    
             std::shared_ptr<std::vector<ElemType> > pOutputVector(new std::vector<ElemType>());
    
             pOutputVector->resize(outputSize);
    
             stdOutputs[outputKey]=pOutputVector.get();
    
             m_eval->Evaluate(stdOutputs);
    
             boost::python::list ret;
    
             for (std::vector<ElemType>::iterator itr = pOutputVector->begin(); itr != pOutputVector->end(); ++itr)
             {
                 ret.append(*itr);
             }
    
             return ret;
    
         }
    
    
    
         /// <summary>Evaluates the model against input data and retrieves the output layer data</summary>
         /// <param name="inputs"></param>
         /// <param name="outputKey"></param>
         /// <param name="outputSize"></param>
         /// <returns>Results for specified layer</returns>
         boost::python::list Evaluate2(const boost::python::dict& inputs, const std::wstring& outputKey, int outputSize)
         {
             if (m_eval == nullptr)
             {
                 throw std::runtime_error("Object has been disposed.");
             }
    
             std::map<std::wstring, std::vector<ElemType>* > stdInputs;
             std::vector<std::shared_ptr<std::vector<ElemType> >> resourceManagement;
             for (int i = 0; i < boost::python::len(inputs); ++i)
             {
                 std::shared_ptr<std::vector<ElemType> > pInputVector(new std::vector<ElemType>());
                 resourceManagement.push_back(pInputVector);
                 boost::python::list theValues = boost::python::extract<boost::python::list>(inputs.values()[i]);
                 for (int j = 0; j < boost::python::len(theValues); ++j)
                 {
                     pInputVector->push_back(boost::python::extract<ElemType>(theValues[j]));
                 }
    
                 std::wstring key = boost::python::extract<std::wstring>(inputs.keys()[i]);
                 stdInputs[key] = pInputVector.get();
             }
    
    
             std::map<std::wstring, std::vector<ElemType>* > stdOutputs;
    
             std::shared_ptr<std::vector<ElemType> > pOutputVector(new std::vector<ElemType>());
    
             pOutputVector->resize(outputSize);
    
             stdOutputs[outputKey]=pOutputVector.get();
    
             m_eval->Evaluate(stdInputs, stdOutputs);
    
             boost::python::list ret;
    
             for (std::vector<ElemType>::iterator itr = pOutputVector->begin(); itr != pOutputVector->end(); ++itr)
             {
                 ret.append(*itr);
             }
    
             return ret;
         }
    
         std::string TEST()
         {
             return "TEST";
         }
    
    #if 0 //Not IMPLEMENT
    
         /// <summary>Evaluates the model against input data and retrieves the output layer data</summary>
         /// <param name="inputs"></param>
         /// <param name="outputs"></param>
         void Evaluate3(const boost::python::dict& inputs, boost::python::dict& outputs)
         {
             if (m_eval == nullptr)
             {
                 throw std::runtime_error("Object has been disposed.");
             }
    
             throw std::runtime_error("Not implemented.");
         }
    #endif
    
         ~IPythonEvaluateModel()
         {
             if (m_eval != nullptr)
             {
                 m_eval->Destroy();
                 m_eval = nullptr;
             }
         }
    
     private:
         // Native model evaluation instance
         IEvaluateModel<ElemType> *m_eval;
    
     };
    

    上述封装的内容为base类,根据不同的类型(float或者是double),派生出来2个其他类型,IPythonEvaluateModelF以及IPythonEvaluateModelD,这两个类型将在python中直接使用。

     class IPythonEvaluateModelF : public IPythonEvaluateModel<float>
     {
     public:
         IPythonEvaluateModelF()
             : IPythonEvaluateModel("GetEvalF")
         {
         }
     };
    
     class IPythonEvaluateModelD : public IPythonEvaluateModel<double>
     {
     public:
         IPythonEvaluateModelD()
             : IPythonEvaluateModel("GetEvalD")
         {
         }
     };

    封装Python模块

    上述内容只是将IEvaluateModel给暴露出来,但是并没有暴露到具体的Python模块。下面的代码将根据Boost.Python将其封装成模块。

    BOOST_PYTHON_MODULE(CNTKPythonWrapper)
    {
        using namespace boost::python;
        using namespace Microsoft::MSR::CNTK::Extensibility::Managed;
    
        class_<IPythonEvaluateModelD>("IPythonEvaluateModelD", init<>())
            .def("Init", &IPythonEvaluateModelD::Init)
            .def("CreateNetwork", &IPythonEvaluateModelD::CreateNetwork)
            .def("Evaluate", &IPythonEvaluateModelD::Evaluate)
            .def("Evaluate2", &IPythonEvaluateModelD::Evaluate2)
            .def("TEST", &IPythonEvaluateModelD::TEST);
    
        class_<IPythonEvaluateModelF>("IPythonEvaluateModelF", init<>())
            .def("Init", &IPythonEvaluateModelF::Init)
            .def("CreateNetwork", &IPythonEvaluateModelF::CreateNetwork)
            .def("Evaluate", &IPythonEvaluateModelF::Evaluate)
            .def("Evaluate2", &IPythonEvaluateModelF::Evaluate2)
            .def("TEST", &IPythonEvaluateModelF::TEST);
    
    }

    这里Python模块的名称为CNTKPythonWrapper,包含两个类型IPythonEvaluateModelD以及IPythonEvaluateModelF,并提供若干方法。
    完成上述操作后,即完成了针对Python的封装。可以在Python中进行调用。

    在Python中尝试调用

    首先,我们需要将工程生成的pyd文件拷贝至python环境的dlls目录中。(否则会提示找不到指定名称的模块)。
    这里写图片描述

    之后,即可的执行Python代码,调用我们封装的CNTK的EvalDLL。

    # -*- coding: utf-8 -*-
    """
    Created on Sun Apr 17 00:42:52 2016
    
    @author: LiuXz
    """
    
    
    from CNTKPythonWrapper import *
    
    model=IPythonEvaluateModelF();
    config="C:\\Users\\liuxz\\Git\\CNTK\\Examples\\Image\\MNIST\\Config\\01_OneHidden.cntk";
    model.Init(config);
    networkConfig="deviceId=-1\nmodelPath=\"C:\\Users\\liuxz\\Git\\CNTK\\Examples\\Image\\MNIST\\Output\\Models\\01_OneHidden\""
    model.CreateNetwork(networkConfig)
    values=[232,250,164,3,193,222,83,195,98,157,206,105,56,246,6,227,213,181,110,99,66,121,35,70,77,62,193,10,144,163,180,229,101,77,109,195,23,71,189,82,122,253,194,235,73,156,239,183,8,172,185,142,207,236,125,111,214,93,180,131,28,72,50,189,232,231,4,234,137,66,204,141,247,28,231,68,181,55,252,176,77,10,2,226,233,37,21,119,206,252,235,185,145,57,53,49,203,4,2,96,152,5,46,196,223,43,149,179,5,57,185,158,96,3,54,18,70,78,211,194,209,139,27,139,85,18,250,189,229,181,119,176,53,155,24,72,218,60,3,189,143,97,114,149,67,76,88,141,3,34,234,124,48,62,142,12,233,161,110,205,47,214,205,78,192,8,105,195,234,236,54,10,75,21,51,112,25,132,72,9,184,108,186,194,202,250,128,245,13,11,94,57,204,52,142,183,147,36,211,58,226,147,162,21,235,223,49,26,11,30,242,100,88,101,20,193,28,10,130,197,134,115,182,222,142,252,61,22,134,123,219,243,176,14,38,36,201,164,214,234,200,101,233,237,24,248,223,102,32,203,155,136,160,14,178,110,220,194,134,237,162,26,147,143,65,253,179,74,63,238,247,118,50,151,251,33,136,199,198,148,28,213,244,185,223,83,83,161,90,182,71,7,30,231,72,174,208,90,172,25,69,149,38,49,211,36,85,9,17,145,229,20,250,240,208,203,36,217,175,236,170,17,239,136,166,240,88,74,78,77,79,46,27,173,79,134,174,195,229,186,252,73,144,200,207,51,11,45,22,123,137,246,169,191,110,52,164,157,137,226,203,11,185,195,66,183,248,77,160,74,28,96,242,243,239,97,128,39,183,114,229,42,51,210,194,87,131,90,62,27,224,17,57,3,238,240,142,203,133,24,58,188,139,203,94,40,3,181,206,12,179,125,228,23,252,160,215,230,0,233,51,157,15,133,104,11,39,239,5,253,209,179,160,158,55,40,158,102,115,154,83,205,139,49,103,98,43,34,6,77,25,167,202,155,228,156,173,5,99,83,1,19,176,208,58,254,220,70,222,211,2,113,114,101,150,101,17,220,30,5,222,4,233,182,228,42,231,5,185,154,122,152,3,32,152,64,28,186,246,103,133,228,66,49,75,166,52,101,4,126,138,207,229,93,115,251,40,248,234,15,22,215,139,67,88,104,110,81,203,86,72,86,228,182,127,249,192,183,107,61,244,130,0,59,15,169,178,164,172,155,23,35,206,230,80,172,89,253,216,225,56,226,152,173,53,51,234,47,221,121,58,111,141,172,26,147,215,80,52,173,181,201,164,47,62,37,135,252,101,209,160,193,222,136,5,18,232,81,5,218,190,130,197,51,97,166,148,34,204,188,212,8,201,43,44,110,62,105,111,16,171,236,201,11,215,119,144,5,166,8,170,133,74,88,238,50,3,112,205,150,143,101,48,167,251,151,247,179,91,150,211,127,225,244,47,208,184,185,90,232,22,143,122,195,18,79,188,113,59,248,106,204,154,215,128,70,187,33,15,64,127,220,168,16,52,42,162,85,41,29,121,72,22,228,128,254,234,107,149,172,217,134,119,98,43,6,227,10,115,232,21,150,170,26,104,57,229,105,143,230,171,102,72,30,126,34,181,181,87,128,91,79,139,98,101,248,100,70,228,45,69,152,224,63,7,226,156,251,123,70,25,128,219,173,0,114,61,88,226,8,79,46,178,242,141,196,10,72,179,111,211,159,132,98,160,19,133,8,22,154,132,185,57,16]
    inputs={"features":values}
    outputs=model.Evaluate2(inputs, "ol.z", 10)
    
    print outputs

    最后,上述的Python代码使用的是MNIST样例中的网络模型,通过输入一个指定的样本(图像灰度数组,共784维,28*28的图像),最后将返回输出节点输出的数据(10维度对应0-9十个数字的字母)。
    这里写图片描述

    总结

    本文中首先讨论了针对EvalDLL中重要的接口,之后是提出了将CNTK拓展的本质接口。最后针对CNTK的接口针对Python环境进行封装。希望能够对大家的使用有所帮助。

    笔者对Python以及Python与C++的互操作并非很熟悉,所以如果本文中有错误请及时指正。

    展开全文
  • 本次考虑用CNTK实现一个最简单的前馈网络,所使用的数据集为OpenML上一个one_hundred_plants_shape,原数据集为arff格式,本人已转换为csv格式上传到了百度网盘中。数据集为1600*65,前64列为特征值,最后一列为分类...

    本次考虑用CNTK实现一个最简单的前馈网络,所使用的数据集为OpenML上一个one_hundred_plants_shape,原数据集为arff格式,本人已转换为csv格式上传到了百度网盘中。数据集为1600*65,前64列为特征值,最后一列为分类号,从1至100,每一类16组数据。cntk版本为beta 5。主要用到的模块为cntk.learner、cntk.trainer、cntk.ops、cntk.utils。learner模块主要包含了一些随机优化算法如sgd()、momentum_sgd()等。trainer模块主要在训练模型时使用,常用的函数为train_minibatch()和test_minibatch()。ops模块中包含了各种运算函数,也有计算模型优度的函数cross_entropy_with_softmax()、classification_error()。

    一般而言,训练神经网络需要以下几个步骤:

    1. 读取数据并对数据进行处理;
    2. 建立神经网络模型;
    3. 初始化学习器learner与训练器;
    4. 训练模型;
    5. 对模型进行测试。

    读取数据并进行处理

    在python中读取数据可以使用numpy的genfromtxt(),用delimiter设置分隔符。此外在CNTK中,目标向量需要转换为张量才能进行处理,因此需要预处理。假设目标的分类向量为[1,2,3],那么在CNTK中就需要转换为[[1,0,0],[0,1,0],[0,0,1]]。而在本数据集中,总共有100种分类,因此需要将每一个分类值转换为一个100维的向量,转换之后的分类张量为1600*100,由toTensor()函数完成。
    代码如下:
    dataset=np.genfromtxt('one-hundred-plants-shape.csv',skip_header=1,delimiter=',')
    features_data=dataset[:,0:63]
    targets_data=np.reshape(dataset[:,-1],[1600,1])
    
    def toTensor(li):
        class_ind=[li== i for i in range(int(np.unique(li).shape[0]))]
        li= np.asarray(np.hstack(class_ind), dtype=np.float32)
        return li
    
    targets_data=toTensor(targets_data)

    建立神经网络模型

    建立神经网络模型所需要用到的主要为Sequential()和Laystack()函数。Sequential()可以将各种神经层叠加在一起,其参数为一个多个神经层组成的向量。在cntk中提供的神经层有10种,对于简单前馈网络 而言,只需要使用其中的Dense()层就可以了。代码中的features和targets类似于一个容器,用于盛放输入和目标数据,,需要使用input_variable()函数,传递的参数为数据的维度。
    代码如下:
    input_dim=63
    output_dim=100
    features=input_variable(input_dim,np.float32)
    targets=input_variable(output_dim,np.float32)
    
    model=Sequential([
            Dense(200,activation=sigmoid),
            Dense(150,activation=sigmoid),
            Dense(120,activation=relu),
            Dense(output_dim)
        ])(features)
    cs=cross_entropy_with_softmax(model,targets)
    ce=classification_error(model,targets)
    Dense()的参数为输出的维度和激活函数,一般有sigmoid、relu等。在用Sequential()时有两点需要注意的地方,一是最后一层的输出维度必须与分类张量的维度一致,在本例中就为100维。二是在模型之后需要添加用input_variable()创建的输入数据容器,如本例中sequential后跟的features,否则在定义trainer时,会出现未知维度的错误。

    初始化学习器learner与训练器trainer

    这一步主要用到Trainer()构造器和lenrner模型中的随机优化函数。max_epoch为最大的epoch次数,一个epoch为向网络传递所有的样本数据,50 epoch就会像网络传递50次所有样本的数据。而batch_size为每一个epoch中,每一次向网络传递多少样本。一般使用小的epoch可以提高精度。
    向Trainer()传递的参数为模型、loss function、evaluation function以及学习器,loss function为优化的目标函数,学习器就是所使用的优化算法,本例中为cross_entroy_with_softmax()。evaluation function为判断模型拟合优度的函数。学习中主要定义学习率的变化情况,一般在各个模型中是通用的。
    代码如下:evaluation function
    max_epoch=50
    sample_size=1600
    batch_size=10
    
    lr_per_sample=[0.001]*10+[0.005]*10+[0.001]
    lr_schedule=learning_rate_schedule(lr_per_sample,UnitType.sample,max_epoch)
    mm_time_constant=[0]*5+[1024]
    mm_schedule=momentum_as_time_constant_schedule(mm_time_constant,max_epoch)
    
    learner=momentum_sgd(model.parameters,lr_schedule,mm_schedule)
    trainer=Trainer(model,cs,ce,learner)
    progress_printer=ProgressPrinter(tag='Training')
    代码中的ProgressPrinter()用于打印每一个epoch的结果。

    对模型进行测试主要用到test_minibatch函数,过程与训练模型类似,本次不讨论这个问题。
    以上代码的实际运行结果如下:
    Finished Epoch [44]: [Training] loss = 4.603901 * 1600, metric = 99.0% * 1600 0.441s (3626.3 samples per second)
    Finished Epoch [45]: [Training] loss = 4.603828 * 1600, metric = 99.0% * 1600 0.454s (3526.2 samples per second)
    Finished Epoch [46]: [Training] loss = 4.603758 * 1600, metric = 99.0% * 1600 0.473s (3384.3 samples per second)
    Finished Epoch [47]: [Training] loss = 4.603689 * 1600, metric = 99.0% * 1600 0.444s (3605.8 samples per second)
    Finished Epoch [48]: [Training] loss = 4.603622 * 1600, metric = 99.0% * 1600 0.498s (3210.8 samples per second)
    Finished Epoch [49]: [Training] loss = 4.603556 * 1600, metric = 99.0% * 1600 0.450s (3553.7 samples per second)
    Finished Epoch [50]: [Training] loss = 4.603492 * 1600, metric = 99.0% * 1600 0.481s (3327.8 samples per second)

    其中的metric为模型的错误率,可以看到为99%,非常不理想,不过本次仅作为一个例子,重在实现过程。

    展开全文
  • cntk深度网络——从入门到转行一开始关于cntk的编译和安装,请参见相关文档。此文档用于cntk 2.0版的python。用于c++接口的有需求再整理资料。如果你还没安装Cntk的运行环境工具包,那么可以先择使用预选安装cntk...

    cntk深度网络——从入门到转行一

    开始

    关于cntk的编译和安装,请参见相关文档。此文档用于cntk 2.0版的python。用于c++接口的有需求再整理资料。

    如果你还没安装Cntk的运行环境工具包,那么可以先择使用预选安装cntk运行在Azure Notebook的托管环境。

    如果你在你的机器上安装了cntk,在完成安装后你可以立即从Python 开始使用cntk(不要忘记激活你的python环境)。

      >>> import cntk
        >>> cntk.__version__
        '2.0rc2+'
    
        >>> cntk.minus([1, 2, 3], [4, 5, 6]).eval()
        array([-3., -3., -3.], dtype=float32)

    以上代码使用了带有两个数组常量的cntk节点。每个操作符都有一个eval()方法,该方法可以调用,该方法使用它的输入为该节点运行向前传递,并返回向前传递的结果。使用输入变量。更常见的例子是这样的:

      >>> import numpy as np
        >>> x = cntk.input_variable(2)
        >>> y = cntk.input_variable(2)
        >>> x0 = np.asarray([[2., 1.]], dtype=np.float32)
        >>> y0 = np.asarray([[4., 6.]], dtype=np.float32)
        >>> cntk.squared_error(x, y).eval({x:x0, y:y0})
        array([ 29.], dtype=float32)

    在上面的例子中,我们首先设置了两个带有形状(1、2)的输入变量,然后我们设置了一个带有这两个变量作为输入的squarederror节点。在eval()方法中,我们可以为这两个变量设置数据的输入映射。在本例中,我们传入两个numpy数组。平方误差当然是(2-4)2+(1-6)2=29。

    大多数的数据容器,比如参数、常量、值等等,都实现了asarray()方法,该方法返回一个NumPy接口。

    >>> import cntk as C
        >>> c = C.constant(3, shape=(2,3))
        >>> c.asarray()
        array([[ 3.,  3.,  3.],
               [ 3.,  3.,  3.]], dtype=float32)
        >>> np.ones_like(c.asarray())
        array([[ 1.,  1.,  1.],
               [ 1.,  1.,  1.]], dtype=float32)

    对于具有序列轴的值,asarray()不能工作,它要求形状是矩形的,并且大多数时间的序列都有不同的长度。在这种情况下,as序列(var)返回一个NumPy数组列表,其中每个NumPy数组都具有var的静态轴的形状。

    展开全文
  • Python语言有超过12万个第三方库,覆盖信息技术几乎所有领域。下面简单介绍网络爬虫、自动化、数据分析与可视化、WEB开发、机器学习和其他常用的一些第三方库,如果有你感兴趣的库,不妨去试试它的功能吧。 1、...

    Python语言有超过12万个第三方库,覆盖信息技术几乎所有领域。下面简单介绍下网络爬虫、自动化、数据分析与可视化、WEB开发、机器学习和其他常用的一些第三方库,如果有你感兴趣的库,不妨去试试它的功能吧。
    1、网络爬虫
    •requests-对HTTP协议进行高度封装,支持非常丰富的链接访问功能。
    •PySpider-一个国人编写的强大的网络爬虫系统并带有强大的WebUI。
    •bs4-beautifulsoup4库,用于解析和处理HTML和XML。
    •Scrapy-很强大的爬虫框架,用于抓取网站并从其页面中提取结构化数据。可用于从数据挖掘到监控和自动化测试的各种用途
    •Crawley-高速爬取对应网站的内容,支持关系和非关系数据库,数据可以导出为JSON、XML等
    •Portia-可视化爬取网页内容
    •cola-分布式爬虫框架
    •newspaper-提取新闻、文章以及内容分析
    •lxml-lxml是python的一个解析库,这个库支持HTML和xml的解析,支持XPath的解析方式

    2、自动化
    •XlsxWriter-操作Excel工作表的文字,数字,公式,图表等
    •win32com-有关Windows系统操作、Office(Word、Excel等)文件读写等的综合应用库
    •pymysql-操作MySQL数据库
    •pymongo-把数据写入MongoDB
    •smtplib-发送电子邮件模块
    •selenium-一个调用浏览器的driver,通过这个库可以直接调用浏览器完成某些操作,比如输入验证码,常用来进行浏览器的自动化工作。
    •pdfminer-一个可以从PDF文档中提取各类信息的第三方库。与其他PDF相关的工具不同,它能够完全获取并分析 P D F 的文本数据
    •PyPDF2-一个能够分割、合并和转换PDF页面的库。
    •openpyxl- 一个处理Microsoft Excel文档的Python第三方库,它支持读写Excel的xls、xlsx、xlsm、xltx、xltm。
    •python-docx-一个处理Microsoft Word文档的Python第三方库,它支持读取、查询以及修改doc、docx等格式文件,并能够对Word常见样式进行编程设置。

    3、数据分析及可视化
    •matplotlib-Matplotlib 是一个 Python 2D 绘图库,可以生成各种可用于出版品质的硬拷贝格式和跨平台交互式环境数据。Matplotlib 可用于 Python 脚本,Python 和 IPython shell(例如 MATLAB 或 Mathematica),Web 应用程序服务器和各种图形用户界面工具包。”
    •numpy-NumPy 是使用 Python 进行科学计算所需的基础包。用来存储和处理大型矩阵,如矩阵运算、矢量处理、N维数据变换等。
    •pyecharts-用于生成 Echarts 图表的类库
    •pandas-一个强大的分析结构化数据的工具集,基于numpy扩展而来,提供了一批标准的数据模型和大量便捷处理数据的函数和方法。
    •Scipy: 基于Python的matlab实现,旨在实现matlab的所有功能,在numpy库的基础上增加了众多的数学、科学以及工程计算中常用的库函数。
    •Plotly-Plotly提供的图形库可以进行在线WEB交互,并提供具有出版品质的图形,支持线图、散点图、区域图、条形图、误差条、框图、直方图、热图、子图、多轴、极坐标图、气泡图、玫瑰图、热力图、漏斗图等众多图形
    •wordcloud-词云生成器
    •jieba-中文分词模块

    4、WEB开发
    •Django-一个开放源代码的Web应用框架,由Python写成。是Python生态中最流行的开源Web应用框架,Django采用模型、模板和视图的编写模式,称为MTV模式。
    •Pyramid是一个通用、开源的Python Web应用程序开发框架。它主要的目的是让Python开发者更简单的创建Web应用,相比Django,Pyramid是一个相对小巧、快速、灵活的开源Python Web框架。
    •Tornado-一种 Web 服务器软件的开源版本。Tornado和现在的主流Web服务器框架(包括大多数Python的框架)有着明显的区别:它是非阻塞式服务器,而且速度相当快
    •Flask是轻量级Web应用框架,相比Django和Pyramid,它也被称为微框架。使用Flask开发Web应用十分方便,甚至几行代码即可建立一个小型网站。Flask核心十分简单,并不直接包含诸如数据库访问等的抽象访问层,而是通过扩展模块形式来支持。

    5、机器学习
    •NLTK-一个自然语言处理的第三方库,NLP领域中常用,可建立词袋模型(单词计数),支持词频分析(单词出现次数)、模式识别、关联分析、情感分析(词频分析+度量指标)、可视化(+matploylib做分析图)等。
    •TensorFlow-谷歌的第二代机器学习系统,是一个使用数据流图进行数值计算的开源软件库。
    •Keras -是一个高级神经网络 API,用 Python 编写,能够在 TensorFlow,CNTK 或 Theano 之上运行。它旨在实现快速实验,能够以最小的延迟把想法变成结果,这是进行研究的关键。
    •Caffe-一个深度学习框架,主要用于计算机视觉,它对图像识别的分类具有很好的应用效果。
    •theano-深度学习库。它与Numpy紧密集成,支持GPU计算、单元测试和自我验证,为执行深度学习中大规模神经网络算法的运算而设计,擅长处理多维数组。
    •Scikit-learn-是一个简单且高效的数据挖掘和数据分析工具,它基于NumPy、SciPy和matplotlib构建。Scikit-learn的基本功能主要包括6个部分:分类,回归,聚类,数据降维,模型选择和数据预处理。Scikit-learn也被称为sklearn。

    6、其他常用
    •IPython-一个基于Python 的交互式shell,比默认的Python shell 好用得多,支持变量自动补全、自动缩进、交互式帮助、魔法命令、系统命令等,内置了许多很有用的功能和函数
    •PTVS-Visual Studio 的 Python 工具
    •pydub-支持多种格式声音文件,可进行多种信号处理、信号生成、音效注册、静音处理等
    •TimeSide-能够进行音频分析、成像、转码、流媒体和标签处理的Python框架
    •dnspython-DNS工具包
    •pygame-专为电子游戏设计的一个模块
    •PyQt5-pyqt5是Qt5应用框架的Python第三方库,编写Python脚本的应用界面
    •PIL(Pillow)-PIL库是Python语言在图像处理方面的重要第三方库,支持图像存储、显示和处理,它能够处理几乎所有图片格式,可以完成对图像的缩放、剪裁、叠加以及向图像添加线条、图像和文字等操作。
    •OpenCV-图像和视频工作库
    •Py2exe: 将python脚本转换为windows上可以独立运行的可执行程序。
    •WeRoBot 是一个微信公众号开发框架,也称为的微信机器人框架。WeRoBot可以解析微信服务器发来的消息,并将消息转换成成Message或者Event类型。

    展开全文
  • CNTK是微软开发的一个开源深度学习平台,最大的特点是高效率,据微软的测试,CNTK的性能要远超Theano、Tensorflow、Caffe等等这些平台。配置CNTK既可以自己编译,也可以用已经编译好的文件,推荐使用已经编译好的,...
  • Python Tutorial Python教程

    2019-11-13 14:45:04
    Python教程 Python是最流行的编程语言之一。在过去的几年中,由于对数据科学,深度学习,机器学习和人工智能的兴趣日益浓厚,它已经获得了很大的普及。 只需查看Google趋势图即可了解对Python编程语言的兴趣...
  • Python的灵活性和易用性不仅体现在大家都知道的语法优雅简洁上,还因为它拥有非常庞大且强大的库。这些库可以用于数据清理、数据操作、可视化、构建模型甚至模型部署,所以这也是为什么Python在开发者中这么受欢迎的...
  • 本文讲解了从零开始学习Python数据科学的全过程,涵盖各种工具和方法 你将会学习到如何使用python做基本的数据分析 你还可以了解机器学习算法的原理和使用 说明 先说一段题外话。我是一名数据工程师,在用SAS做...
  • CNTK是用C++写的深层神经网络工具集,就目前的趋势来看,google类库虽然人气众多,但是不重视抢占windows市场,估计以后windows平台下面,还是微软的cntk做老大的地位。 CNTK虽然支持C++,c#的调用,但是仍然离不开...
  • 点击“简说Python”,选择“置顶/星标公众号”福利干货,第一时间送达!图片来自:https://unsplash.com/本文授权转载自王的机器禁二次转载作者:王圣元0引言...Keras 可以以两种方法运行:以TensorFlow,CNTK, 或者T...
  • 这篇教程展示了CNTK中一些比较高级的特性,目标读者是完成了之前教程或者是使用过其他机器学习组件的人。如果你是完完全全的新手,请先看我们之前的十多期教程。欢迎来到CNTK。深度神经网络正在重新定义计算机编程。...
  • 本文从程序员的角度对CNTK和TensorFlow做高层次的对比。本文也不属于性能分析,而是编程模型分析。文中会夹杂着大量的代码。 原标题:当TensorFlow遇见CNTKCNTK是微软用于搭建深度神经网络的计算网络工具包,此项目...
  • 本文讲解了从零开始学习Python数据科学的全过程,涵盖各种工具和方法 你将会学习到如何使用python做基本的数据分析 你还可以了解机器学习算法的原理和使用 说明 先说一段题外话。我是一名数据工程师,在用SAS做分析...
  • 配套的CNTK代码版本下载路径: http://pan.baidu.com/s/1slS3JHj 视频: http://i.youku.com/lijin6249
  • CNTK2.0由微软正式发布,全名Cognitive Toolkit/CNTK,是一个可帮助...其他新特性包括Python示例和教程、Layers library的诸多改进、自动安装、Docker Hub中包括Docker 图像等等,部署了数百个新特性、性能提升和修复。
  • 深度学习研究的热潮持续高涨,各种开源深度学习框架也层出不穷,其中包括TensorFlow、Caffe8、Keras9、CNTK10、Torch711、MXNet12、Leaf13、Theano14、DeepLearning415、Lasagne16、Neon17,等等。然而TensorFlow却...
  • Pytorch是Facebook的AI研究团队发布了一个Python工具包,专门针对GPU加速的深度神经网络(DNN)编程.Torch是一个经典的对多维矩阵数据进行操作的张量(tensor)库,在机器学习和其他数学密集型应用有广泛应用。...
  • 使用教程https://blog.csdn.net/cvfbgh/article/details/53446910安装时,运行命令出现如下错误: 是因为使用了电脑的命令提示符进行安装的。 2.虽然powershell和cmd很类似,但还有很多不同点。cmd只能运行系统...
  • Python Deep Learning Packages State of open source deep learning frameworks keras[11] Well known for being minimalistic, the Keras neural network library (with a supporting interface of Python) suppo...
1 2 3 4 5 ... 20
收藏数 946
精华内容 378