/* ****************************************************************************** * * * This program and the accompanying materials are made available under the * terms of the Apache License, Version 2.0 which is available at * https://www.apache.org/licenses/LICENSE-2.0. * * See the NOTICE file distributed with this work for additional * information regarding copyright ownership. * 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. * * SPDX-License-Identifier: Apache-2.0 ******************************************************************************/ // // @author raver119@gmail.com // #ifndef LIBND4J_RANDOM_OPS_H #define LIBND4J_RANDOM_OPS_H #ifdef __CUDACC__ #define random_def __device__ __host__ inline static #else #define random_def inline static #endif // since we can't inherit/overwrite static methods - we just define default impls #define method_idx random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator* rng, T *extraParams) { return -1.0f; } #define method_X random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator* rng, T *extraParams) { return -2.0f; } #define method_XY random_def T op(T valueX, T valueY, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator* rng, T *extraParams) { return -3.0f; } #define no_exec_special static const bool requiresSpecial = false; static inline void specialOp(Nd4jPointer state, const T *x, const Nd4jLong *xShapeBuffer, const T *y, const Nd4jLong *yShapeBuffer, T *z, const Nd4jLong *zShapeBuffer, T *extraArguments) { } #ifdef __CUDACC__ #define no_exec_special_cuda __device__ static inline void specialOpCuda(Nd4jPointer state, T const* x, Nd4jLong const* xShapeBuffer, T const* y, Nd4jLong const* yShapeBuffer, T *z, Nd4jLong const* zShapeBuffer, T *extraArguments) { } #else #define no_exec_special_cuda #endif #include #include #include namespace randomOps { /** * This Op merges two arrays per-element, if probability meets threshold */ template class ProbablisticMerge { public: no_exec_special no_exec_special_cuda method_idx method_X random_def T op(T valueX, T valueY, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T threshold = extraParams[0]; T randVal = helper->relativeT(idx); return randVal <= threshold ? valueY : valueX; } }; /** * This Op produces random values within specified boundaries. Disribution is uniform */ template class UniformDistribution { public: no_exec_special no_exec_special_cuda method_XY method_X random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { return helper->relativeT(idx, extraParams[0], extraParams[1]); } }; /** * This op produces single bernoulli trial */ template class BernoulliDistribution { public: no_exec_special no_exec_special_cuda method_XY random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { return extraParams[0] >= helper->relativeT(idx) ? (T) 1.0f : (T) 0.0f; } random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { return valueX >= helper->relativeT(idx) ? (T) 1.0f : (T) 0.0f; } }; /** * This op produces single bernoulli trial */ template class ExponentialDistribution { public: no_exec_special no_exec_special_cuda method_XY random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T lambda = extraParams[0]; T x = helper->relativeT(idx, sd::DataTypeUtils::min(), T(1.f) - sd::DataTypeUtils::template min()); // x from (0, 1) without bounds T xVal = -sd::math::nd4j_log(x); return xVal <= (T)0.f ? (T)0.f : xVal / lambda; //pow((T) M_E, -(lambda * x)); } random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T lambda = extraParams[0]; return valueX <= (T)0.f ? (T)0.f : (T)(valueX/lambda); //1.f - sd::math::nd4j_exp(-lambda * valueX); //pow((T) M_E, -(lambda * valueX)); } }; template class PoissonDistribution { public: no_exec_special no_exec_special_cuda method_XY random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T lambda = extraParams[0]; T x = helper->relativeT(idx, -sd::DataTypeUtils::template max() / 10 , sd::DataTypeUtils::template max() / 10); return x <= (T)0.f ? (T)0.f : sd::math::nd4j_igammac(sd::math::nd4j_floor(x), lambda); } random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T lambda = extraParams[0]; return valueX <= (T)0.f ? (T)0.f : (T)sd::math::nd4j_igammac(sd::math::nd4j_floor(valueX), lambda); } }; template class GammaDistribution { public: no_exec_special no_exec_special_cuda method_XY random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T alpha = extraParams[0]; T beta = extraParams[1]; T x = helper->relativeT(idx, -sd::DataTypeUtils::template max() / 10 , sd::DataTypeUtils::template max() / 10); return x <= (T)0.f ? (T)0.f : sd::math::nd4j_igamma(alpha, x * beta); } random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T alpha = extraParams[0]; T beta = extraParams[1]; return valueX <= (T)0.f ? (T)0.f : sd::math::nd4j_igamma(alpha, beta * valueX); } }; /** * Basic DropOut/DropConnect Op */ template class DropOut { public: no_exec_special no_exec_special_cuda method_idx method_XY // please note: prob is chance to retain original value random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T randVal = helper->relativeT(idx); return randVal >= extraParams[0] ? (T) 0.0f : valueX; } }; template class AlphaDropOut { public: no_exec_special no_exec_special_cuda method_idx method_XY // please note: prob is chance to retain original value random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T randVal = helper->relativeT(idx); // extraParams[0] == p // [1] = a // [2] = b // [3] = alphaPrime return randVal >= extraParams[0] ? (T) extraParams[1] * extraParams[3] + extraParams[2] : extraParams[1] * valueX + extraParams[2]; } }; /** * Inverted DropOut implementation, used in DL4j */ template class DropOutInverted { public: no_exec_special no_exec_special_cuda method_idx method_XY // please note: prob is chance to retain original value random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T prob = extraParams[0]; T randVal = helper->relativeT(idx); return randVal >= prob ? (T) 0.0f : valueX / prob; } }; template class Linspace { public: no_exec_special no_exec_special_cuda method_X method_XY random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T from = extraParams[0]; T to = extraParams[1]; T step = extraParams[2]; if (step == static_cast(0.0f)) { step = (T) idx / ((T)length - (T) 1.0f); return from * ((T) 1.0f - step) + step * to; } return from + (idx * step); } }; template class ExponentialDistributionInv { // inverse exponential distribution public: no_exec_special no_exec_special_cuda method_XY random_def T op(Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T lambda = extraParams[0]; T x = helper->relativeT(idx, sd::DataTypeUtils::template min(), (T)1.f - sd::DataTypeUtils::template min()); return -sd::math::nd4j_log((T)1.f - x) / lambda; } random_def T op(T valueX, Nd4jLong idx, Nd4jLong length, sd::graph::RandomGenerator *helper, T *extraParams) { T lambda = extraParams[0]; return -sd::math::nd4j_log((T)1.f - valueX) / lambda; // valueX must be within (0, 1] } }; } #endif //LIBND4J_RANDOM_OPS_H