symbol.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you 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.
 */
 
#ifndef MXNET_CPP_SYMBOL_H_
#define MXNET_CPP_SYMBOL_H_
 
#include <map>
#include <string>
#include <vector>
#include "mxnet-cpp/base.h"
#include "mxnet-cpp/ndarray.h"
#include "mxnet-cpp/op_map.h"
 
namespace mxnet {
namespace cpp {
 
class Executor;
 
struct SymBlob {
 public:
  SymBlob() : handle_(nullptr) {}
  explicit SymBlob(SymbolHandle handle) : handle_(handle) {}
  ~SymBlob() {
    MXSymbolFree(handle_);
  }
  SymbolHandle handle_;
 
 private:
  SymBlob(const SymBlob&);
  SymBlob& operator=(const SymBlob&);
};
 
class Symbol {
 public:
  Symbol() {}
  explicit Symbol(SymbolHandle handle);
  explicit Symbol(const char* name);
  explicit Symbol(const std::string& name);
  Symbol operator+(const Symbol& rhs) const;
  Symbol operator-(const Symbol& rhs) const;
  Symbol operator*(const Symbol& rhs) const;
  Symbol operator/(const Symbol& rhs) const;
  Symbol operator%(const Symbol& rhs) const;
 
  Symbol operator+(mx_float scalar) const;
  Symbol operator-(mx_float scalar) const;
  Symbol operator*(mx_float scalar) const;
  Symbol operator/(mx_float scalar) const;
  Symbol operator%(mx_float scalar) const;
  Symbol Copy() const;
  static Symbol Variable(const std::string& name = "");
  Symbol operator[](int index);
  Symbol operator[](const std::string& index);
  static Symbol Group(const std::vector<Symbol>& symbols);
  static Symbol Load(const std::string& file_name);
  static Symbol LoadJSON(const std::string& json_str);
  void Save(const std::string& file_name) const;
  std::string ToJSON() const;
  Symbol GetInternals() const;
  SymbolHandle GetHandle() const {
    return (blob_ptr_) ? blob_ptr_->handle_ : nullptr;
  }
  Symbol(const std::string& operator_name,
         const std::string& name,
         std::vector<const char*> input_keys,
         std::vector<SymbolHandle> input_values,
         std::vector<const char*> config_keys,
         std::vector<const char*> config_values);
  void InferShape(const std::map<std::string, std::vector<mx_uint> >& arg_shapes,
                  std::vector<std::vector<mx_uint> >* in_shape,
                  std::vector<std::vector<mx_uint> >* aux_shape,
                  std::vector<std::vector<mx_uint> >* out_shape) const;
  std::vector<std::string> ListArguments() const;
  std::vector<std::string> ListInputs() const;
  std::vector<std::string> ListOutputs() const;
  std::vector<std::string> ListAuxiliaryStates() const;
  std::map<std::string, std::string> ListAttributes() const;
  void SetAttribute(const std::string& key, const std::string& value);
  void SetAttributes(const std::map<std::string, std::string>& attrs);
  mx_uint GetNumOutputs() const;
  mxnet::cpp::Symbol GetBackendSymbol(const std::string& backendName) const;
  std::string GetName() const;
  void InferExecutorArrays(
      const Context& context,
      std::vector<NDArray>* arg_arrays,
      std::vector<NDArray>* grad_arrays,
      std::vector<OpReqType>* grad_reqs,
      std::vector<NDArray>* aux_arrays,
      const std::map<std::string, NDArray>& args_map,
      const std::map<std::string, NDArray>& arg_grad_store  = std::map<std::string, NDArray>(),
      const std::map<std::string, OpReqType>& grad_req_type = std::map<std::string, OpReqType>(),
      const std::map<std::string, NDArray>& aux_map = std::map<std::string, NDArray>()) const;
  void InferArgsMap(const Context& context,
                    std::map<std::string, NDArray>* args_map,
                    const std::map<std::string, NDArray>& known_args) const;
  Executor* SimpleBind(
      const Context& context,
      const std::map<std::string, NDArray>& args_map,
      const std::map<std::string, NDArray>& arg_grad_store  = std::map<std::string, NDArray>(),
      const std::map<std::string, OpReqType>& grad_req_type = std::map<std::string, OpReqType>(),
      const std::map<std::string, NDArray>& aux_map         = std::map<std::string, NDArray>());
  Executor* Bind(
      const Context& context,
      const std::vector<NDArray>& arg_arrays,
      const std::vector<NDArray>& grad_arrays,
      const std::vector<OpReqType>& grad_reqs,
      const std::vector<NDArray>& aux_arrays,
      const std::map<std::string, Context>& group_to_ctx = std::map<std::string, Context>(),
      Executor* shared_exec                              = nullptr);
 
 private:
  std::shared_ptr<SymBlob> blob_ptr_;
  static OpMap*& op_map();
};
Symbol operator+(mx_float lhs, const Symbol& rhs);
Symbol operator-(mx_float lhs, const Symbol& rhs);
Symbol operator*(mx_float lhs, const Symbol& rhs);
Symbol operator/(mx_float lhs, const Symbol& rhs);
Symbol operator%(mx_float lhs, const Symbol& rhs);
}  // namespace cpp
}  // namespace mxnet
#endif  // MXNET_CPP_SYMBOL_H_