# API

Defines

`DISABLE_COPY_AND_ASSIGN`(classname)

Enums

enum `SparseValueType`

  Values:

  `SPARSE_NON_VALUE` = 0
  `SPARSE_VALUE` = 1

enum `SparseFormatType`

  Values:

  `SPARSE_CSR` = 0
  `SPARSE_CSC` = 1

enum `GradientMatchineCreateMode`

  Values:

  `CREATE_MODE_NORMAL` = 0
  `CREATE_MODE_TESTING` = 4

Functions

void `initPaddle`(int argc, char **argv)

  Initialize paddle.

  In python, this method should be invoked as

      import sys
      import paddle
      paddle.initPaddle(sys.argv)
      or you can change arguments as any list of str.

bool `isGpuVersion`()

  Return true if this py_paddle is compiled in GPU Version.

Variables

const size_t `NO_SPARSE_ID`

  In Python, -1UL is hard to write. So define a const value used by python side.

class `IOError`
  #include <PaddleAPI.h>

  The Error of IO Operation. Such as file not found, etc.

class `RangeError`
  #include <PaddleAPI.h>

  Out of range error.

class `UnsupportError`
  #include <PaddleAPI.h>

  Not support Error, such as access GPU memory directly, etc.

struct `FloatArray`
  #include <PaddleAPI.h>

  This type will map to python’s list of float.

  Public Functions

  `FloatArray`(const float *b, const size_t l)

  Public Members

  const float *`buf`
  const size_t `length`
  bool `needFree`

struct `IntArray`
  #include <PaddleAPI.h>

  This type will map to python’s list of int.

  Public Functions

  `IntArray`(const int *b, const size_t l, bool f = false)

  Public Members

  const int *`buf`
  const size_t `length`
  bool `needFree`

struct `IntWithFloatArray`
  #include <PaddleAPI.h>

  This type will map to python’s list of (int, float)

  Public Functions

  `IntWithFloatArray`(const float *v, const int *i, size_t l, bool f = false)

  Public Members

  const float *`valBuf`
  const int *`idxBuf`
  const size_t `length`
  bool `needFree`

class `Matrix`

  Public Functions

  `~Matrix`()
  void `toNumpyMatInplace`(float **view_data, int *dim1, int *dim2)

    Cast to numpy matrix.

    Example:

        import paddle
        m = paddle.Matrix.createZero(10,2)
        numpy_mat = m.toNumpyMat()

    Note

      This method take no parameter in python.

      This method in python will return a numpy matrix, not void.

      Only CpuDenseMatrix is supported.

  void `copyToNumpyMat`(float **view_m_data, int *dim1, int *dim2)

    Copy To numpy mat.

  void `copyFromNumpyMat`(float *data, int dim1, int dim2)

    Copy From Numpy Mat.

  bool `isSparse`() const

    return true if this matrix is sparse.

  SparseValueType `getSparseValueType`() const
  SparseFormatType `getSparseFormat`() const
  IntArray `getSparseRowCols`(size_t i) const
  IntWithFloatArray `getSparseRowColsVal`(size_t i) const
  size_t `getHeight`() const
  size_t `getWidth`() const
  float `get`(size_t x, size_t y) const
  void `set`(size_t x, size_t y, float val)
  FloatArray `getData`() const

    return type is list of float

  void `sparseCopyFrom`(const std::vector<int> &rows, const std::vector<int> &cols, const std::vector<float> &values = std::vector< float >())

    Copy from rows, cols, values.

    if sparse_nonvalue, the values should be []

  bool `isGpu`() const

  Public Static Functions

  Matrix *`createZero`(size_t height, size_t width, bool useGpu = false)

    Create A Matrix with height,width, which is filled by zero.

  Matrix *`createSparse`(size_t height, size_t width, size_t nnz, bool isNonVal = true, bool trans = false, bool useGpu = false)

    Create Sparse Matrix.

    After create sparse, sparseCopyFrom can be used to fill matrix.

    Note
      the default sparse type is SPARSE_CSR.
    Parameters
      - `nnz`: Number of non zero values.
  Matrix *`createDense`(const std::vector<float> &data, size_t height, size_t width, bool useGpu = false)

    Create Dense Matrix.

    Note
      the value will be copy into a new matrix.
    Parameters
      - `data`: list of float should be passed in python.
  Matrix *`createCpuDenseFromNumpy`(float *data, int dim1, int dim2, bool copy = false)

    Create Cpu Dense Matrix from numpy matrix, dtype=float32

    Parameters
      - `data`: a numpy matrix.
      - `dim1`: dimension of data.
      - `dim2`: dimension of data.
      - `copy`: true if copy into a new matrix, false will create matrix inplace.
  Matrix *`createGpuDenseFromNumpy`(float *data, int dim1, int dim2)

    Create Gpu Dense Matrix from numpy matrix, dtype=float32.

  Private Functions

  `Matrix`()
  `DISABLE_COPY_AND_ASSIGN`( Matrix )
  void *`getSharedPtr`() const

  Private Members

  MatrixPrivate *`m`

  Private Static Functions

  Matrix *`createByPaddleMatrixPtr`(void *sharedPtr)

  Friends

  friend `Trainer`
  friend `GradientMachine`
  friend `Arguments`

class `Vector`

  Public Functions

  `~Vector`()
  void `toNumpyArrayInplace`(float **view_data, int *dim1)

    Cast to numpy array inplace.

  void `copyToNumpyArray`(float **view_m_data, int *dim1)

    Copy to numpy array.

  void `copyFromNumpyArray`(float *data, int dim)

    Copy from numpy array.

  float `get`(const size_t idx) const

    getitem in python

  void `set`(const size_t idx, float val)

    setitem in python

  bool `isGpu`() const

    Return is GPU vector or not.

  size_t `getSize`() const

    len in python

  Public Static Functions

  Vector *`createZero`(size_t sz, bool useGpu = false)

    Create Vector filled with zero.

  Vector *`create`(const std::vector<float> &data, bool useGpu = false)

    Create Vector from list of float.

    It will create a new vector, and copy data into it.

  Vector *`createCpuVectorFromNumpy`(float *data, int dim, bool copy = false)

    Create Cpu Vector from numpy array, which dtype=float32

    If copy is false, it will create vector inplace.

  Vector *`createGpuVectorFromNumpy`(float *data, int dim)

    Create Gpu Vector from numpy array, which dtype=float32.

  Private Functions

  `DISABLE_COPY_AND_ASSIGN`( Vector )
  `Vector`()
  void *`getSharedPtr`()

  Private Members

  VectorPrivate *`m`

  Private Static Functions

  Vector *`createByPaddleVectorPtr`(void *ptr)

  Friends

  friend `Parameter`
  friend `ParameterOptimizer`
  friend `ParameterTraverseCallbackPrivate`

class `IVector`

  Public Functions

  void `toNumpyArrayInplace`(int **view_data, int *dim1)

    Cast to numpy array inplace.

  void `copyToNumpyArray`(int **view_m_data, int *dim1)

    Copy to numpy array.

  void `copyFromNumpyArray`(int *data, int dim)

    Copy from numpy array.

  `~IVector`()
  IntArray `getData`() const

    Return a list of int, the memory is alloced and copied.

  int &`operator[]`(const size_t idx)

    This method will map to python [] method.

  const int &`operator[]`(const size_t idx) const
  int `get`(const size_t idx) const
  void `set`(const size_t idx, int val)
  bool `isGpu`() const

    Return true if it is gpu vector.

  size_t `getSize`() const

    This method will map to python len();.

  Public Static Functions

  IVector *`createZero`(size_t sz, bool useGpu = false)

    Create IVector filled with zero.

  IVector *`create`(const std::vector<int> &data, bool useGpu = false)

    Create IVector from list of int. It will create a new vector, and copy data into it.

  IVector *`createCpuVectorFromNumpy`(int *data, int dim, bool copy = false)

    Create Cpu IVector from numpy array, which dtype=int32

    If copy is false, it will create vector inplace

  IVector *`createGpuVectorFromNumy`(int *data, int dim)

    Create Gpu IVector from numpy array, which dtype=int32

  Private Functions

  `IVector`()
  `DISABLE_COPY_AND_ASSIGN`( IVector )
  void *`getSharedPtr`() const

  Private Members

  IVectorPrivate *`m`

  Private Static Functions

  IVector *`createByPaddleVectorPtr`(void *ptr)

  Friends

  friend `Arguments`

class `Arguments`
  #include <PaddleAPI.h>

  The Arguments is actual a std::vector<paddle::Argument> in paddle.

  Public Functions

  void `resize`(size_t slotNum)
  `~Arguments`()
  size_t `getSlotNum`() const

    Return the slot number that aguments contains.

    It is actually the vector’s size

  Matrix *`getSlotValue`(size_t idx) const

    The get functions of Arguments

    the param idx is the slot id

  IVector *`getSlotIds`(size_t idx) const
  Matrix *`getSlotIn`(size_t idx) const
  IVector *`getSlotSequenceStartPositions`(size_t idx) const
  IVector *`getSlotSubSequenceStartPositions`(size_t idx) const
  IVector *`getSlotSequenceDim`(size_t idx) const
  int64_t `getBatchSize`(size_t idx = 0) const
  void `setSlotValue`(size_t idx, Matrix *mat)

    The set functions of Arguments.

    The param idx is the slot id. The other param is the input Matrix or vector.

  void `setSlotIn`(size_t idx, Matrix *mat)
  void `setSlotIds`(size_t idx, IVector *vec)
  void `setSlotSequenceStartPositions`(size_t idx, IVector *vec)
  void `setSlotSubSequenceStartPositions`(size_t idx, IVector *vec)
  void `setSlotSequenceDim`(size_t idx, IVector *vec)

  Public Static Functions

  Arguments *`createArguments`(size_t slotNum)

    Create a arguments with size. Note that it can be zero.

  Private Functions

  `Arguments`()
  `DISABLE_COPY_AND_ASSIGN`( Arguments )
  void *`getInternalArgumentsPtr`() const

  Private Members

  ArgumentsPrivate *`m`

  Private Static Functions

  Arguments *`createByPaddleArgumentVector`(void *ptr)

  Friends

  friend `Trainer`
  friend `GradientMachine`
  friend `SequenceGenerator`

class `ParameterConfig`

  Public Functions

  `~ParameterConfig`()
  std::string `toProtoString`() const

    return proto buf string.

  Private Functions

  `DISABLE_COPY_AND_ASSIGN`( ParameterConfig )
  `ParameterConfig`()
  void *`getRawPtr`()

  Private Members

  ParameterConfigPrivate *`m`

  Private Static Functions

  ParameterConfig *`createParameterConfigFromParameterSharedPtr`(void *ptr)

    Internal methods

  ParameterConfig *`createParameterConfigFromParameterPtr`(void *ptr)

  Friends

  friend `Parameter`
  friend `ParameterOptimizer`
  friend `ParameterTraverseCallbackPrivate`

class `OptimizationConfig`

  Public Functions

  `~OptimizationConfig`()
  std::string `toProtoString`()

    return protobuf string.

  Public Static Functions

  OptimizationConfig *`createFromProtoString`(const std::string &str)

  Private Functions

  `DISABLE_COPY_AND_ASSIGN`( OptimizationConfig )
  `OptimizationConfig`()

  Private Members

  OptimizationConfigPrivate *`m`

  Friends

  friend `TrainerConfig`
  friend `ParameterOptimizer`
  friend `Trainer`

class `Parameter`

  Public Functions

  `~Parameter`()
  std::string `getName`() const

    get parameter name

  Vector *`getBuf`(ParameterType type)

    get buf in Parameter

  size_t `getID`() const

    get id

  ParameterConfig *`getConfig`()

  Private Functions

  `Parameter`()
  `DISABLE_COPY_AND_ASSIGN`( Parameter )

  Private Members

  ParameterPrivate *`m`

  Private Static Functions

  Parameter *`createFromRawPtr`(void *ptr)
  Parameter *`createFromSharedPtr`(void *ptr)

  Friends

  friend `UpdateCallbackWrapper`
  friend `GradientMachine`

class `ModelConfig`
  #include <PaddleAPI.h>

  You can only get model config from TrainerConfig.

  It is used by GradientMachine.

  Public Functions

  `~ModelConfig`()

  Private Functions

  `ModelConfig`()
  `DISABLE_COPY_AND_ASSIGN`( ModelConfig )

  Private Members

  ModelConfigPrivate *`m`

  Friends

  friend `TrainerConfig`
  friend `TrainerConfigPrivate`
  friend `GradientMachine`

class `TrainerConfig`
  #include <PaddleAPI.h>

  To get TrainerConfig from file.

  It is used by GradientMachine.

  Public Functions

  `~TrainerConfig`()
  ModelConfig *`getModelConfig`() const
  OptimizationConfig *`getOptimizationConfig`() const

  Public Static Functions

  TrainerConfig *`createFromTrainerConfigFile`(const std::string &configPath)
  TrainerConfig *`createFromProtoString`(const std::string &str)

  Private Functions

  `TrainerConfig`()
  `DISABLE_COPY_AND_ASSIGN`( TrainerConfig )

  Private Members

  TrainerConfigPrivate *`m`

  Friends

  friend `Trainer`

class `UpdateCallback`
  #include <PaddleAPI.h>

  The callback in backword.

  You can inherit this class in python.

      class UpdateCallbackInPython(paddle.UpdateCallback):
        def __init__(self):
          paddle.UpdateCallback.__init__(self)

        def apply(self, param):
          assert isinstance(param, paddle.Parameter)

  Subclassed by SwigDirector_UpdateCallback

  Public Functions

  `~UpdateCallback`()
  void `apply`( Parameter *p)

class `ParameterTraverseCallback`

  Public Functions

  `~ParameterTraverseCallback`()
  void `apply`(const std::vector<Vector *> &vecs, const ParameterConfig &config, size_t sparseId)

  Private Functions

  `DISABLE_COPY_AND_ASSIGN`( ParameterTraverseCallback )
  `ParameterTraverseCallback`()

  Private Members

  ParameterTraverseCallbackPrivate *`m`

  Friends

  friend `ParameterOptimizer`

class `ParameterOptimizer`

  Public Functions

  `~ParameterOptimizer`()
  void `init`(size_t numRows, const ParameterConfig *config)
  void `startPass`()
  void `finishPass`()
  void `startBatch`(size_t numSamplesProcessed)
  void `finishBatch`()
  void `update`(const std::vector<Vector *> &vecs, const ParameterConfig &conf, size_t sparseId = NO_SPARSE_ID)
  std::vector<int> `getParameterTypes`() const
  ParameterTraverseCallback *`needSpecialTraversal`(const ParameterConfig &config) const

  Public Static Functions

  ParameterOptimizer *`create`( OptimizationConfig *config)

  Private Functions

  `DISABLE_COPY_AND_ASSIGN`( ParameterOptimizer )
  `ParameterOptimizer`()

  Private Members

  ParameterOptimizerPrivate *`m`

class `GradientMachine`

  Public Functions

  `~GradientMachine`()
  void `forward`(const Arguments &inArgs, Arguments *outArgs, PassType passType)

    The forward stage of GradientMachine.

    Note

      the outArgs could be zero length arguemnts.

      THIS METHOD IS VERY USEFULL FOR PREDICT FROM TRAINED MODEL.

  void `backward`(const UpdateCallback &callback = UpdateCallback ())

    The backward stage of GradientMachine.

    Note
      Currently the ParameterUpdater is not wrapped in SWIG, so backward cannot actually train a network. But you can write a update callback to change the parameter or implement a ParameterUpdater in python side.
  void `forwardBackward`(const Arguments &inArgs, Arguments *outArgs, PassType passType, const UpdateCallback &callback = UpdateCallback ())

    Combine forward/backward

  void `loadParameters`(const std::string &path)
  size_t `getParameterSize`() const
  Parameter *`getParameter`(size_t i)
  void `randParameters`()
  Matrix *`getLayerOutput`(const std::string &layerName) const
  SequenceGenerator *`asSequenceGenerator`(const std::vector<std::string> &dict = std::vector< std::string >(), size_t begin_id = 0UL, size_t end_id = 0UL, size_t max_length = 100UL, size_t beam_size = -1UL)

    Create a sequence generator.

    Note
      It just like a paddle_gen_sequence.

  Public Static Functions

  GradientMachine *`createByConfigProtoStr`(const std::string &protoStr, GradientMatchineCreateMode mode = CREATE_MODE_NORMAL, const std::vector<int> &parameterTypes = defaultParamTypes)

    Create By ProtoStr.

    The ProtoStr can be generate by python’s protobuf code.

  GradientMachine *`createByModelConfig`( ModelConfig *conf, GradientMatchineCreateMode mode = CREATE_MODE_NORMAL, const std::vector<int> &parameterTypes = defaultParamTypes)

    Create by ModelConfig object.

    To get ModelConfig, you can get TrainerConfig from config file, then get model config by TrainerConfig

  Private Functions

  `GradientMachine`()
  `DISABLE_COPY_AND_ASSIGN`( GradientMachine )

  Private Members

  GradientMachinePrivate *`m`

  Private Static Functions

  GradientMachine *`createFromPaddleModelPtr`(const void *confPtr, GradientMatchineCreateMode mode, const std::vector<int> &types)

  Private Static Attributes

  std::vector<int> `defaultParamTypes`

  Friends

  friend `Trainer`

class `Trainer`

  Public Functions

  `~Trainer`()
  void `startTrain`()

    Start training.

  void `finishTrain`()

    Finish training.

  void `startTrainPass`()

    Start a pass.

  void `finishTrainPass`()

    Finish a pass.

  bool `trainOneBatch`(size_t batchSize)

    Train one batch,

    Return
      true if all batch finished.
  void `trainOneDataBatch`(size_t batchSize, const Arguments &args)
  void `startTestPeriod`()
  void `testOneDataBatch`(size_t batchSize, const Arguments &args)
  void `finishTestPeriod`()
  void `forwardOneBatch`(size_t batchSize)
  Arguments *`getForwardOutput`()
  Matrix *`getLayerOutput`(const std::string &layerName)

  Public Static Functions

  Trainer *`createByCommandLine`()

    Create A Trainer By TrainerConfig. using paddle command line.

  Trainer *`create`( TrainerConfig *optConfig, GradientMachine *gm)

  Private Functions

  `Trainer`()
  `Trainer`( TrainerConfig *optConfig, GradientMachine *gm)
  `DISABLE_COPY_AND_ASSIGN`( Trainer )

  Private Members

  TrainerPrivate *`m`

class `ISequenceResults`
  #include <PaddleAPI.h>

  the N-Best results generated from one input sequence.

  Subclassed by PathSequenceResults

  Public Functions

  `~ISequenceResults`()
  virtual size_t `getSize`() const = 0

    Number of result.

  virtual std::string `getSentence`(size_t id, bool split = false) const = 0

    Get sentence from dictionary.

    Parameters
      - `id`: the index of result.
      - `split`: if true, the return sentence will be splited with ‘ ‘ by each word. Default is false.
  virtual std::vector<int> `getSequence`(size_t id) const = 0
  virtual float `getScore`(size_t id) const = 0

class `SequenceGenerator`

  Public Functions

  `~SequenceGenerator`()
  ISequenceResults *`generateSequence`(const Arguments &inArgs) const

    Generate Sequence by input.

    Note

      The inArgs is just one sequence of data.

      The return will get a N-best generate result by inArgs. Sort by score.

  void `setDict`(const std::vector<std::string> &dict)
  void `setBos`(size_t bos)
  void `setEos`(size_t eos)
  void `setMaxLength`(size_t maxlength)
  void `setBeamSize`(size_t beamSize)

  Private Functions

  `DISABLE_COPY_AND_ASSIGN`( SequenceGenerator )
  `SequenceGenerator`()

  Private Members

  SequenceGeneratorPrivate *`m`

  Private Static Functions

  SequenceGenerator *`createByGradientMachineSharedPtr`(void *ptr)

  Friends

  friend `GradientMachine`

Functions

template <typename T1, typename T2>
void `staticCastVector`(std::vector<T2> *dest, const std::vector<T1> &src)