Gets the elapsed time, in milliseconds.

Performs all reduce of the tensors after fusing them in a buffer. Args: tensor(List of Tensors): a list of tensors to be all-

Platform-independent sign mask. \param arg integer value in two's complement \retval -1 if \a arg negative \retval 0 if \a arg positive

Hyperbolic tangent. This function is exact to rounding for all rounding modes. See also:** Documentation for [std::tanh](https://en.cppreference.com/

Set the model in evaluation mode. Args: mode(bool): when mode is True, this model will enter training mode

TODO(wangwei) add a copypatch function for improve the efficiency on GPU.

Returns the current time in milliseconds.

Return memory size (i.e., Bytes)

Removes any redundant separators that might be in the pathname. For example, "bar///foo" becomes "bar/foo". Does not eliminate other redundancies that

Parses a string for a bool flag, in the form of either "--flag=value" or "--flag". In the former case, the value is taken as true as long as it does

shallow copy. Returns: a new Tensor which shares the underlying data memory (shallow copy).

Reset the internal time point to the current time

Change the data type. Args: dtype: accepts 'int', 'float', 'singa.kFloat32', 'singa.kInt' Returns: new tenso

64-bit division. \param x upper 32 bit of dividend \param y divisor \param s variable to store sticky bit for rounding \return (\a x << 32) / \a y

Sets the model in evaluation mode.

:param arch: architecture to be scored :param device: cpu or GPU :param space_name: search space name :param batch_da

Fixed point binary exponential. This uses the BKM algorithm in E-mode. \param m exponent in [0,1) as Q0.31 \param n number of iterations (at most 32)

64-bit multiplication. \param x first factor \param y second factor \return upper 32 bit of \a x * \a y rounded to nearest

:param cand: candidate id :param epoch_per_model: epoch for each model :return:

Resize the image to make the smaller side be at the given size

To transpose the tensor Args: t: input tensor axes: axes to transpose Returns: the transposed tensor

Reads and returns the Boolean environment variable corresponding to the given flag; if it's not set, returns default_value. The value is considered t

Divide row 'v' by each row of matrix M; write results into 'out'

Converts the buffer in a stringstream to an std::string, converting NUL bytes to "\\0" along the way.

Iterates over a vector of TestCases, keeping a running sum of the results of calling a given int-returning method on each. Returns the sum.

Performs a single optimization step. Args: param_name(String): the name of the param param_value(Tensor): par

Compile and initialize the model This function will automatically derive the shape of parameters in each sublayer based on the shape

Generate a value for each element following a Gaussian distribution. Args: mean (float): mean of the distribution std

This is slow, in filtering phase, we could enable caching here.

Returns the current OS stack trace getter if it is not NULL; otherwise, creates an OsStackTraceGetter, makes it the current getter, and returns it.

=============Matrix operations============================================

Chops off the n lowest bits from a bit pattern. Returns the n lowest bits. As a side effect, the original bit pattern will be shifted to the right b

Formats a source file path and a line number as they would appear in an error message from the compiler used to compile this code.

Helper function used by ValidateRegex() to format error messages.

Returns true iff ch appears anywhere in str (excluding the terminating '\0' character).

Returns whether the given character is a valid path separator.

Parses a string for a string flag, in the form of "--flag=value". On success, stores the value of the flag in *value, and returns true. On failure,

If *pstr starts with the given prefix, modifies *pstr to be right past the prefix and returns true; otherwise leaves *pstr unchanged and returns false

get the operator type from a given operator Args: op: a given operator Returns: operator type

Fill the tensor with values sampled from a distribution. With `distribution="normal"`, samples are drawn from a normal distribution centered

Check and signal for any NaN. \param x first half-precision value to check \param y second half-precision value to check \retval true if either \a x o