diff --git a/nnvm/LICENSE b/nnvm/LICENSE index 8dada3edaf50..3908a9e0dbed 100644 --- a/nnvm/LICENSE +++ b/nnvm/LICENSE @@ -1,201 +1,13 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ +Copyright (c) 2016 by Contributors - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at - 1. Definitions. + http://www.apache.org/licenses/LICENSE-2.0 - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. diff --git a/nnvm/README.md b/nnvm/README.md index 75e7a81c5f6e..a20f40d95fb0 100644 --- a/nnvm/README.md +++ b/nnvm/README.md @@ -1,9 +1,40 @@ -# mxnngraph -Prototype of graph optimizer and construction API for next generation core engine in MXNet and beyond +# NNVM: Build deep learning system by parts -## Goal -- Construct graph easily -- Pluggable inference, optimization algorithms -- Can be used as input graph execution in various settings, specifically be able to support mxnet's symbolic execution API +NNVM is not a deep learning library. It is a modular, lightweight library to +help build deep learning libraries efficiently. +## What is it +While most deep learning systems offer end to end solutions, +it is interesting to ask if we can actually assemble a deep learning system by parts. +The goal is to enable hackers can customize optimizations, target platforms and set of operators they care about. +We believe that the modular system is an interesting direction. +The hope is that effective parts can be assembled together just like you assemble your own desktops. +So the customized deep learning solution can be minimax, minimum in terms of dependencies, +while maxiziming the users' need. + +NNVM offers one such part, it provides a generic to do generic +computation graph optimization such as memory reduction, device allocation, +operator fusion while being agnostic to the operator +interface defintion and how operators are executed. +NNVM is inspired by LLVM, aiming to be an intermediate representation library +for neural nets and computation graphs in general. + +## Deep learning system by parts + +This is one way to divide the deep learning system into common parts. +Each can be isolated to a modular part. + +- Computation graph definition, manipulation. +- Computation graph intermediate optimization. +- Computation graph execution. +- Operator kernel libraries. +- Imperative task scheduling and parallel task coordination. + +We hope that there will be more modular parts in the future, +so system building can be fun and rewarding. + +## Links + +[MXNet](https://github.com/dmlc/mxnet) will be using NNVM as its intermediate +representation layer for symbolic graphs. diff --git a/nnvm/include/nngraph/base.h b/nnvm/include/nnvm/base.h similarity index 83% rename from nnvm/include/nngraph/base.h rename to nnvm/include/nnvm/base.h index 155f688165c4..92175cf17a8f 100644 --- a/nnvm/include/nngraph/base.h +++ b/nnvm/include/nnvm/base.h @@ -1,10 +1,10 @@ /*! * Copyright (c) 2016 by Contributors * \file base.h - * \brief Configuation of nngraph as well as basic data structure. + * \brief Configuation of nnvm as well as basic data structure. */ -#ifndef NNGRAPH_BASE_H_ -#define NNGRAPH_BASE_H_ +#ifndef NNVM_BASE_H_ +#define NNVM_BASE_H_ #include #include @@ -12,7 +12,7 @@ #include #include -namespace nngraph { +namespace nnvm { /*! \brief any type */ using any = dmlc::any; @@ -47,6 +47,6 @@ inline const T& get(const any& src) { return dmlc::get(src); } -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_BASE_H_ +#endif // NNVM_BASE_H_ diff --git a/nnvm/include/nngraph/graph.h b/nnvm/include/nnvm/graph.h similarity index 94% rename from nnvm/include/nngraph/graph.h rename to nnvm/include/nnvm/graph.h index 2650ca2ee0f6..296f62bf839d 100644 --- a/nnvm/include/nngraph/graph.h +++ b/nnvm/include/nnvm/graph.h @@ -1,10 +1,10 @@ /*! * Copyright (c) 2016 by Contributors * \file graph.h - * \brief Configuation of nngraph as well as basic data structure. + * \brief Configuation of nnvm as well as basic data structure. */ -#ifndef NNGRAPH_GRAPH_H_ -#define NNGRAPH_GRAPH_H_ +#ifndef NNVM_GRAPH_H_ +#define NNVM_GRAPH_H_ #include #include @@ -15,7 +15,7 @@ #include "./base.h" #include "./node.h" -namespace nngraph { +namespace nnvm { /*! * \brief Symbolic computation graph. @@ -98,6 +98,6 @@ inline void Graph::DFSVisit(FVisit fvisit) const { }); } -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_GRAPH_H_ +#endif // NNVM_GRAPH_H_ diff --git a/nnvm/include/nngraph/graph_attr_types.h b/nnvm/include/nnvm/graph_attr_types.h similarity index 88% rename from nnvm/include/nngraph/graph_attr_types.h rename to nnvm/include/nnvm/graph_attr_types.h index f856ecf9c1f2..ab14185724f1 100644 --- a/nnvm/include/nngraph/graph_attr_types.h +++ b/nnvm/include/nnvm/graph_attr_types.h @@ -3,14 +3,14 @@ * \file graph_attr_types.h * \brief Data structures that can appear in graph attributes. */ -#ifndef NNGRAPH_GRAPH_ATTR_TYPES_H_ -#define NNGRAPH_GRAPH_ATTR_TYPES_H_ +#ifndef NNVM_GRAPH_ATTR_TYPES_H_ +#define NNVM_GRAPH_ATTR_TYPES_H_ #include #include #include "./graph.h" -namespace nngraph { +namespace nnvm { /*! * \brief Auxililary data structure to index a graph. @@ -39,7 +39,7 @@ struct IndexedGraph { /*! \brief Node data structure in IndexedGraph */ struct Node { /*! \brief pointer to the source node */ - const nngraph::Node* source; + const nnvm::Node* source; /*! \brief inputs to the node */ array_view inputs; /*! \brief control flow dependencies to the node */ @@ -68,7 +68,7 @@ struct IndexedGraph { * \param e The entry to query for index. * \return the unique index. */ - inline uint32_t entry_id(const nngraph::NodeEntry& e) const { + inline uint32_t entry_id(const nnvm::NodeEntry& e) const { return entry_rptr_[node_id(e.node.get())] + e.index; } /*! @@ -76,7 +76,7 @@ struct IndexedGraph { * \param node The Node to query for index. * \return the node index. */ - inline uint32_t node_id(const nngraph::Node* node) const { + inline uint32_t node_id(const nnvm::Node* node) const { return node2index_.at(node); } /*! @@ -92,7 +92,7 @@ struct IndexedGraph { * \param node The pointer to the Node structure * \return const reference to the corresponding IndexedGraph::Node */ - inline const Node& operator[](const nngraph::Node* node) const { + inline const Node& operator[](const nnvm::Node* node) const { return nodes_[node_id(node)]; } /*! \return list of argument nodes */ @@ -113,7 +113,7 @@ struct IndexedGraph { // index to argument nodes std::vector arg_nodes_; // mapping from node to index. - std::unordered_map node2index_; + std::unordered_map node2index_; // CSR pointer of node entries std::vector entry_rptr_; // space to store input entries of each @@ -122,6 +122,6 @@ struct IndexedGraph { std::vector control_deps_; }; -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_GRAPH_ATTR_TYPES_H_ +#endif // NNVM_GRAPH_ATTR_TYPES_H_ diff --git a/nnvm/include/nngraph/node.h b/nnvm/include/nnvm/node.h similarity index 94% rename from nnvm/include/nngraph/node.h rename to nnvm/include/nnvm/node.h index 2caeb2f5a293..d6eb5817abc7 100644 --- a/nnvm/include/nngraph/node.h +++ b/nnvm/include/nnvm/node.h @@ -1,10 +1,10 @@ /*! * Copyright (c) 2016 by Contributors - * \file base.h + * \file node.h * \brief Graph node data structure. */ -#ifndef NNGRAPH_NODE_H_ -#define NNGRAPH_NODE_H_ +#ifndef NNVM_NODE_H_ +#define NNVM_NODE_H_ #include #include @@ -13,7 +13,7 @@ #include "./base.h" #include "./op.h" -namespace nngraph { +namespace nnvm { // Forward declare node. class Node; @@ -93,6 +93,6 @@ inline uint32_t Node::num_outputs() const { } } -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_NODE_H_ +#endif // NNVM_NODE_H_ diff --git a/nnvm/include/nngraph/op.h b/nnvm/include/nnvm/op.h similarity index 91% rename from nnvm/include/nngraph/op.h rename to nnvm/include/nnvm/op.h index 1f768d95e9a0..a3467c5a6bcf 100644 --- a/nnvm/include/nngraph/op.h +++ b/nnvm/include/nnvm/op.h @@ -3,8 +3,8 @@ * \file op.h * \brief Operator information structor. */ -#ifndef NNGRAPH_OP_H_ -#define NNGRAPH_OP_H_ +#ifndef NNVM_OP_H_ +#define NNVM_OP_H_ #include #include @@ -13,7 +13,7 @@ #include #include "./base.h" -namespace nngraph { +namespace nnvm { // forward declarations class Node; @@ -38,18 +38,18 @@ static const int kVarg = -1; * // registeration of oeprators * // NOTE that the attr function can register any * // additional attributes to the operator - * NNGRAPH_REGISTER_OP(add) + * NNVM_REGISTER_OP(add) * .describe("add two inputs together") * .set_num_inputs(2) * .attr("gpu_kernel", AddKernel); * - * NNGRAPH_REGISTER_OP(sub) + * NNVM_REGISTER_OP(sub) * .describe("substract one tensor from another") * .set_num_inputs(2); * * // Can call regster multiple times in different files * // to register different part of information - * NNGRAPH_REGISTER_OP(sub) + * NNVM_REGISTER_OP(sub) * .attr("gpu_kernel", SubKernel); * * // get operators from registry. @@ -124,7 +124,7 @@ class Op { * const std::vector& ishapes) { * // we can use the parsed version of param * // without repeatively parsing the parameter - * const SumParam& param = nngraph::get(attrs.parsed); + * const SumParam& param = nnvm::get(attrs.parsed); * } * \endcode */ @@ -234,36 +234,36 @@ class OpMap { }; // internal macros to make -#define NNGRAPH_STR_CONCAT_(__x, __y) __x##__y -#define NNGRAPH_STR_CONCAT(__x, __y) NNGRAPH_STR_CONCAT_(__x, __y) -#define NNGRAPH_REGISTER_VAR_DEF(OpName) \ - static ::nngraph::Op & __make_ ## NNGraphOp ## _ ## OpName +#define NNVM_STR_CONCAT_(__x, __y) __x##__y +#define NNVM_STR_CONCAT(__x, __y) NNVM_STR_CONCAT_(__x, __y) +#define NNVM_REGISTER_VAR_DEF(OpName) \ + static ::nnvm::Op & __make_ ## NnvmOp ## _ ## OpName /*! - * \def NNGRAPH_REGISTER_OP + * \def NNVM_REGISTER_OP * \brief Register * This macro must be used under namespace dmlc, and only used once in cc file. * \param OpName The name of registry * * \code * - * NNGRAPH_REGISTER_OP(add) + * NNVM_REGISTER_OP(add) * .describe("add two inputs together") * .set_num_inputs(2) * .attr("gpu_kernel", AddKernel); * * \endcode */ -#define NNGRAPH_REGISTER_OP(OpName) \ - NNGRAPH_STR_CONCAT(NNGRAPH_REGISTER_VAR_DEF(OpName), __COUNTER__) = \ - ::dmlc::Registry<::nngraph::Op>::Get()->__REGISTER_OR_GET__(#OpName) +#define NNVM_REGISTER_OP(OpName) \ + NNVM_STR_CONCAT(NNVM_REGISTER_VAR_DEF(OpName), __COUNTER__) = \ + ::dmlc::Registry<::nnvm::Op>::Get()->__REGISTER_OR_GET__(#OpName) // implementations of template functions after this. // member function of Op template inline const OpMap& Op::GetAttr(const std::string& key) { const any& ref = GetAttrMap(key); - return nngraph::get >(ref); + return nnvm::get >(ref); } template @@ -282,7 +282,7 @@ inline Op& Op::attr( // NOLINT(*) << " previously " << pmap->type().name() << " current " << typeid(OpMap).name(); std::vector >& vec = - nngraph::get >(*pmap).data_; + nnvm::get >(*pmap).data_; // resize the value type. vec.resize(index_ + 1, std::make_pair(ValueType(), 0)); @@ -338,6 +338,6 @@ inline const ValueType& OpMap::operator[](const Op* op) const { return data_[idx].first; } -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_OP_H_ +#endif // NNVM_OP_H_ diff --git a/nnvm/include/nngraph/pass.h b/nnvm/include/nnvm/pass.h similarity index 90% rename from nnvm/include/nngraph/pass.h rename to nnvm/include/nnvm/pass.h index 48a16f7d9320..c1936941b331 100644 --- a/nnvm/include/nngraph/pass.h +++ b/nnvm/include/nnvm/pass.h @@ -3,15 +3,15 @@ * \file pass.h * \brief Pass that can be applied to a graph. */ -#ifndef NNGRAPH_PASS_H_ -#define NNGRAPH_PASS_H_ +#ifndef NNVM_PASS_H_ +#define NNVM_PASS_H_ #include #include #include "./base.h" #include "./graph.h" -namespace nngraph { +namespace nnvm { /*! * \brief A PassFunction is a basic "Operator on Graph" @@ -90,12 +90,12 @@ struct PassFunctionReg }; /*! - * \def NNGRAPH_REGISTER_PASS + * \def NNVM_REGISTER_PASS * \brief Macro to register pass fuctions. * * \code * // example of registering a shape inference pass - * NNGRAPH_REGISTER_PASS(InferShape) + * NNVM_REGISTER_PASS(InferShape) * .describe("Shape Inference function, generate graph attributes") * .provide_graph_attr("data_shape") * .depend_graph_attr("indexed_graph") @@ -105,9 +105,9 @@ struct PassFunctionReg * }); * \endcode */ -#define NNGRAPH_REGISTER_PASS(name) \ - DMLC_REGISTRY_REGISTER(::nngraph::PassFunctionReg, PassFunctionReg, name) +#define NNVM_REGISTER_PASS(name) \ + DMLC_REGISTRY_REGISTER(::nnvm::PassFunctionReg, PassFunctionReg, name) -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_PASS_H_ +#endif // NNVM_PASS_H_ diff --git a/nnvm/include/nngraph/tuple.h b/nnvm/include/nnvm/tuple.h similarity index 98% rename from nnvm/include/nngraph/tuple.h rename to nnvm/include/nnvm/tuple.h index f3e541b7a8ba..8898fc054ca7 100644 --- a/nnvm/include/nngraph/tuple.h +++ b/nnvm/include/nnvm/tuple.h @@ -3,15 +3,15 @@ * \file tuple.h * \brief Data structure Tuple and TShape to store dynamic sized shapes. */ -#ifndef NNGRAPH_TUPLE_H_ -#define NNGRAPH_TUPLE_H_ +#ifndef NNVM_TUPLE_H_ +#define NNVM_TUPLE_H_ #include #include #include #include -namespace nngraph { +namespace nnvm { /*! \brief data type to store array index */ typedef uint32_t index_t; @@ -329,6 +329,6 @@ class TShape : public Tuple { } }; -} // namespace nngraph +} // namespace nnvm -#endif // NNGRAPH_TUPLE_H_ +#endif // NNVM_TUPLE_H_ diff --git a/nnvm/src/core/graph_attr_types.cc b/nnvm/src/core/graph_attr_types.cc index ee01ed5c74cd..43351f544835 100644 --- a/nnvm/src/core/graph_attr_types.cc +++ b/nnvm/src/core/graph_attr_types.cc @@ -3,10 +3,10 @@ * \file graph_attr_types.cc * \brief Graph node data structure. */ -#include +#include #include -namespace nngraph { +namespace nnvm { // implement constructor from graph IndexedGraph::IndexedGraph(const Graph &g) { @@ -14,7 +14,7 @@ IndexedGraph::IndexedGraph(const Graph &g) { std::vector inputs_rptr{0}, control_rptr{0}; g.DFSVisit([this, &inputs_rptr, &control_rptr] - (const std::shared_ptr& n) { + (const std::shared_ptr& n) { CHECK_LT(nodes_.size(), std::numeric_limits::max()); uint32_t nid = static_cast(nodes_.size()); // nodes_ @@ -59,4 +59,4 @@ IndexedGraph::IndexedGraph(const Graph &g) { } } -} // namespace nngraph +} // namespace nnvm diff --git a/nnvm/src/core/node.cc b/nnvm/src/core/node.cc index 5051c1eb3259..72cea0479ddf 100644 --- a/nnvm/src/core/node.cc +++ b/nnvm/src/core/node.cc @@ -3,9 +3,9 @@ * \file node.cc * \brief Graph node data structure. */ -#include +#include -namespace nngraph { +namespace nnvm { Node::~Node() { if (inputs.size() != 0) { @@ -42,4 +42,4 @@ std::shared_ptr Node::Create() { return std::make_shared(); } -} // namespace nngraph +} // namespace nnvm diff --git a/nnvm/src/core/op.cc b/nnvm/src/core/op.cc index 9705f57b1034..57514aa7fbcb 100644 --- a/nnvm/src/core/op.cc +++ b/nnvm/src/core/op.cc @@ -3,18 +3,18 @@ * \file op.cc * \brief Support for operator registry. */ -#include -#include +#include +#include #include #include namespace dmlc { // enable registry -DMLC_REGISTRY_ENABLE(nngraph::Op); +DMLC_REGISTRY_ENABLE(nnvm::Op); } // namespace dmlc -namespace nngraph { +namespace nnvm { // single manager of operator information. struct OpManager { @@ -66,4 +66,4 @@ void Op::UpdateAttrMap(const std::string& key, updater(&value); } -} // namespace nngraph +} // namespace nnvm diff --git a/nnvm/src/core/pass.cc b/nnvm/src/core/pass.cc index 06a5dbcdf864..f94acf50c8d3 100644 --- a/nnvm/src/core/pass.cc +++ b/nnvm/src/core/pass.cc @@ -3,15 +3,15 @@ * \file pass.cc * \brief Support for pass registry. */ -#include +#include #include namespace dmlc { // enable registry -DMLC_REGISTRY_ENABLE(nngraph::PassFunctionReg); +DMLC_REGISTRY_ENABLE(nnvm::PassFunctionReg); } // namespace dmlc -namespace nngraph { +namespace nnvm { const PassFunctionReg* FindPassDep(const std::string&attr_name) { for (auto* r : dmlc::Registry::List()) { @@ -54,4 +54,4 @@ Graph ApplyPass(const Graph& src, return g; } -} // namespace nngraph +} // namespace nnvm diff --git a/nnvm/src/example/operator.cc b/nnvm/src/example/operator.cc index a33307e59c80..8152b117c2cb 100644 --- a/nnvm/src/example/operator.cc +++ b/nnvm/src/example/operator.cc @@ -1,14 +1,14 @@ // Copyright (c) 2016 by Contributors -// This is an example on how we can register operator information to NNGRAPH +// This is an example on how we can register operator information to NNVM -#include +#include #include -NNGRAPH_REGISTER_OP(add) +NNVM_REGISTER_OP(add) .describe("add two data together") .set_num_inputs(2) .attr("inplace_pair", std::make_pair(0, 0)); -NNGRAPH_REGISTER_OP(add) +NNVM_REGISTER_OP(add) .attr("nick_name", "plus"); diff --git a/nnvm/src/test_main.cc b/nnvm/src/test_main.cc index 377519f9f386..6a6946171b38 100644 --- a/nnvm/src/test_main.cc +++ b/nnvm/src/test_main.cc @@ -1,20 +1,20 @@ // Copyright (c) 2016 by Contributors -#include -#include -#include -#include +#include +#include +#include +#include #include void test_op() { - using namespace nngraph; + using namespace nnvm; auto add = Op::Get("add"); auto nick = Op::GetAttr("nick_name"); LOG(INFO) << "nick=" << nick[add]; } void test_tuple() { - using nngraph::Tuple; - using nngraph::TShape; + using nnvm::Tuple; + using nnvm::TShape; Tuple x{1, 2, 3}; Tuple y{1, 2, 3, 5, 6}; x = std::move(y); @@ -27,7 +27,7 @@ void test_tuple() { std::istringstream is(os.str()); is >> y; CHECK_EQ(x, y); - Tuple ss{1, 2, 3}; + Tuple ss{1, 2, 3}; TShape s = ss; s = std::move(ss); CHECK((s == TShape{1, 2, 3})); @@ -35,8 +35,8 @@ void test_tuple() { void test_graph() { - nngraph::Graph g; - g.DFSVisit([](const std::shared_ptr& n){ + nnvm::Graph g; + g.DFSVisit([](const std::shared_ptr& n){ }); } int main() {