SYMBOL INDEX (413 symbols across 73 files)

FILE: benchmarks/benchmark_gru.cc
  function TimeLoop (line 49) | float TimeLoop(std::function<void()> fn, int iterations) {
  function CudnnInference (line 65) | float CudnnInference(
  function CudnnTrain (line 144) | float CudnnTrain(
  function HasteInference (line 281) | float HasteInference(
  function HasteTrain (line 333) | float HasteTrain(
  function usage (line 462) | void usage(const char* name) {
  function main (line 473) | int main(int argc, char* const* argv) {

FILE: benchmarks/benchmark_lstm.cc
  function TimeLoop (line 49) | float TimeLoop(std::function<void()> fn, int iterations) {
  function CudnnInference (line 65) | float CudnnInference(
  function CudnnTrain (line 143) | float CudnnTrain(
  function HasteInference (line 280) | float HasteInference(
  function HasteTrain (line 331) | float HasteTrain(
  function usage (line 469) | void usage(const char* name) {
  function main (line 480) | int main(int argc, char* const* argv) {

FILE: benchmarks/cudnn_wrappers.h
  function float (line 26) | struct CudnnDataType<float> {
  function double (line 31) | struct CudnnDataType<double> {

FILE: benchmarks/report.py
  function extract (line 22) | def extract(x, predicate):
  function main (line 26) | def main(args):

FILE: build/setup.pytorch.py
  class BuildHaste (line 26) | class BuildHaste(cpp_extension.BuildExtension):
    method run (line 27) | def run(self):

FILE: build/setup.tf.py
  class BinaryDistribution (line 24) | class BinaryDistribution(Distribution):
    method has_ext_modules (line 26) | def has_ext_modules(self):
  class BuildHaste (line 30) | class BuildHaste(_build):
    method run (line 31) | def run(self):

FILE: examples/device_ptr.h
  function device_ptr (line 26) | static device_ptr<T> NewByteSized(size_t bytes) {
  function explicit (line 30) | explicit device_ptr(size_t size_)
  function explicit (line 37) | explicit device_ptr(const T& elem)
  function ToDevice (line 63) | void ToDevice(const T& src) {
  function ToHost (line 68) | void ToHost(T& target) const {
  function zero (line 77) | void zero() {

FILE: examples/gru.cc
  class ScopeTimer (line 47) | class ScopeTimer {
    method ScopeTimer (line 49) | ScopeTimer(const string& msg) : msg_(msg) {
  function GruInference (line 71) | void GruInference(
  function GruTrain (line 119) | void GruTrain(
  function main (line 209) | int main() {

FILE: examples/lstm.cc
  class ScopeTimer (line 47) | class ScopeTimer {
    method ScopeTimer (line 49) | ScopeTimer(const string& msg) : msg_(msg) {
  function LstmInference (line 71) | void LstmInference(const Tensor2& W, const Tensor2& R, const Tensor1& b,...
  function LstmTrain (line 114) | void LstmTrain(const Tensor2& W, const Tensor2& R, const Tensor1& b, con...
  function LstmTrainIterative (line 219) | void LstmTrainIterative(const Tensor2& W, const Tensor2& R, const Tensor...
  function main (line 332) | int main() {

FILE: frameworks/pytorch/base_rnn.py
  class BaseRNN (line 25) | class BaseRNN(nn.Module):
    method __init__ (line 26) | def __init__(
    method _permute (line 40) | def _permute(self, x):
    method _get_state (line 45) | def _get_state(self, input, state, state_shape):
    method _get_final_state (line 52) | def _get_final_state(self, state, lengths):
    method _get_zoneout_mask (line 64) | def _get_zoneout_mask(self, input):
    method _is_cuda (line 72) | def _is_cuda(self):
  function _validate_state (line 79) | def _validate_state(state, state_shape):
  function _zero_state (line 108) | def _zero_state(input, state_shape):

FILE: frameworks/pytorch/gru.cc
  function gru_forward (line 31) | std::vector<Tensor> gru_forward(
  function gru_backward (line 91) | std::vector<Tensor> gru_backward(
  function gru_init (line 162) | void gru_init(py::module& m) {

FILE: frameworks/pytorch/gru.py
  function GRUScript (line 33) | def GRUScript(
  class GRUFunction (line 69) | class GRUFunction(torch.autograd.Function):
    method forward (line 71) | def forward(ctx, training, zoneout_prob, *inputs):
    method backward (line 79) | def backward(ctx, grad_h):
  class GRU (line 91) | class GRU(BaseRNN):
    method __init__ (line 110) | def __init__(self,
    method to_native_weights (line 161) | def to_native_weights(self):
    method from_native_weights (line 186) | def from_native_weights(self, weight_ih_l0, weight_hh_l0, bias_ih_l0, ...
    method reset_parameters (line 210) | def reset_parameters(self):
    method forward (line 219) | def forward(self, input, state=None, lengths=None):
    method _impl (line 249) | def _impl(self, input, state, zoneout_mask):

FILE: frameworks/pytorch/indrnn.cc
  function Tensor (line 31) | Tensor indrnn_forward(
  function indrnn_backward (line 84) | std::vector<Tensor> indrnn_backward(
  function indrnn_init (line 145) | void indrnn_init(py::module& m) {

FILE: frameworks/pytorch/indrnn.py
  function IndRNNScript (line 33) | def IndRNNScript(
  class IndRNNFunction (line 57) | class IndRNNFunction(torch.autograd.Function):
    method forward (line 59) | def forward(ctx, training, zoneout_prob, *inputs):
    method backward (line 66) | def backward(ctx, grad_h):
  class IndRNN (line 76) | class IndRNN(BaseRNN):
    method __init__ (line 86) | def __init__(
    method reset_parameters (line 134) | def reset_parameters(self):
    method forward (line 139) | def forward(self, input, state=None, lengths=None):
    method _impl (line 171) | def _impl(self, input, state, zoneout_mask):

FILE: frameworks/pytorch/layer_norm_gru.cc
  function layer_norm_gru_forward (line 31) | std::vector<Tensor> layer_norm_gru_forward(
  function layer_norm_gru_backward (line 117) | std::vector<Tensor> layer_norm_gru_backward(
  function layer_norm_gru_init (line 224) | void layer_norm_gru_init(py::module& m) {

FILE: frameworks/pytorch/layer_norm_gru.py
  function LayerNormGRUScript (line 33) | def LayerNormGRUScript(
  class LayerNormGRUFunction (line 70) | class LayerNormGRUFunction(torch.autograd.Function):
    method forward (line 72) | def forward(ctx, training, zoneout_prob, *inputs):
    method backward (line 80) | def backward(ctx, grad_h):
  class LayerNormGRU (line 92) | class LayerNormGRU(BaseRNN):
    method __init__ (line 109) | def __init__(self,
    method reset_parameters (line 164) | def reset_parameters(self):
    method forward (line 174) | def forward(self, input, state=None, lengths=None):
    method _impl (line 206) | def _impl(self, input, state, zoneout_mask):

FILE: frameworks/pytorch/layer_norm_indrnn.cc
  function layer_norm_indrnn_forward (line 31) | std::vector<Tensor> layer_norm_indrnn_forward(
  function layer_norm_indrnn_backward (line 99) | std::vector<Tensor> layer_norm_indrnn_backward(
  function layer_norm_indrnn_init (line 179) | void layer_norm_indrnn_init(py::module& m) {

FILE: frameworks/pytorch/layer_norm_indrnn.py
  function LayerNormIndRNNScript (line 33) | def LayerNormIndRNNScript(
  class LayerNormIndRNNFunction (line 59) | class LayerNormIndRNNFunction(torch.autograd.Function):
    method forward (line 61) | def forward(ctx, training, zoneout_prob, *inputs):
    method backward (line 68) | def backward(ctx, grad_h):
  class LayerNormIndRNN (line 79) | class LayerNormIndRNN(BaseRNN):
    method __init__ (line 91) | def __init__(
    method reset_parameters (line 143) | def reset_parameters(self):
    method forward (line 150) | def forward(self, input, state=None, lengths=None):
    method _impl (line 182) | def _impl(self, input, state, zoneout_mask):

FILE: frameworks/pytorch/layer_norm_lstm.cc
  function layer_norm_lstm_forward (line 31) | std::vector<Tensor> layer_norm_lstm_forward(
  function layer_norm_lstm_backward (line 141) | std::vector<Tensor> layer_norm_lstm_backward(
  function layer_norm_lstm_init (line 272) | void layer_norm_lstm_init(py::module& m) {

FILE: frameworks/pytorch/layer_norm_lstm.py
  function LayerNormLSTMScript (line 33) | def LayerNormLSTMScript(
  class LayerNormLSTMFunction (line 72) | class LayerNormLSTMFunction(torch.autograd.Function):
    method forward (line 74) | def forward(ctx, training, zoneout_prob, *inputs):
    method backward (line 82) | def backward(ctx, grad_h, grad_c):
  class LayerNormLSTM (line 94) | class LayerNormLSTM(BaseRNN):
    method __init__ (line 109) | def __init__(self,
    method reset_parameters (line 172) | def reset_parameters(self):
    method forward (line 184) | def forward(self, input, state=None, lengths=None):
    method _impl (line 215) | def _impl(self, input, state, zoneout_mask):

FILE: frameworks/pytorch/lstm.cc
  function lstm_forward (line 31) | std::vector<Tensor> lstm_forward(
  function lstm_backward (line 91) | std::vector<Tensor> lstm_backward(
  function lstm_init (line 161) | void lstm_init(py::module& m) {

FILE: frameworks/pytorch/lstm.py
  function LSTMScript (line 33) | def LSTMScript(
  class LSTMFunction (line 69) | class LSTMFunction(torch.autograd.Function):
    method forward (line 71) | def forward(ctx, training, zoneout_prob, *inputs):
    method backward (line 79) | def backward(ctx, grad_h, grad_c):
  class LSTM (line 91) | class LSTM(BaseRNN):
    method __init__ (line 106) | def __init__(self,
    method to_native_weights (line 159) | def to_native_weights(self):
    method from_native_weights (line 182) | def from_native_weights(self, weight_ih_l0, weight_hh_l0, bias_ih_l0, ...
    method reset_parameters (line 203) | def reset_parameters(self):
    method forward (line 212) | def forward(self, input, state=None, lengths=None):
    method _impl (line 243) | def _impl(self, input, state, zoneout_mask):

FILE: frameworks/pytorch/support.cc
  function PYBIND11_MODULE (line 25) | PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {

FILE: frameworks/pytorch/support.h
  function Half (line 30) | struct native_type<c10::Half> {

FILE: frameworks/tf/arena.h
  function T (line 42) | T* data() {
  type Entry (line 66) | struct Entry {
  type Entry (line 88) | struct Entry {

FILE: frameworks/tf/base_rnn.py
  function reverse_sequence (line 29) | def reverse_sequence(sequence, sequence_length):
  function transpose (line 40) | def transpose(tensor_or_tuple, perm):
  class BaseRNN (line 47) | class BaseRNN(tf.Module):
    method __init__ (line 48) | def __init__(self, rnn_class, num_units, direction, default_name, **kw...
    method build (line 63) | def build(self, shape):
    method output_size (line 81) | def output_size(self):
    method state_size (line 87) | def state_size(self):
    method __call__ (line 92) | def __call__(self, inputs, training, sequence_length=None, time_major=...
    method bidirectional (line 129) | def bidirectional(self):

FILE: frameworks/tf/gru.cc
  type HasteGruOp (line 78) | struct HasteGruOp : public OpKernel {
    method HasteGruOp (line 79) | explicit HasteGruOp(OpKernelConstruction* context) : OpKernel(context) {
    method Compute (line 87) | void Compute(OpKernelContext* context) override {
  type HasteGruGradOp (line 206) | struct HasteGruGradOp : public OpKernel {
    method HasteGruGradOp (line 207) | explicit HasteGruGradOp(OpKernelConstruction* context) : OpKernel(cont...
    method Compute (line 209) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/gru.py
  function gru_gradient (line 36) | def gru_gradient(op, *grads):
  class GRULayer (line 62) | class GRULayer(tf.Module):
    method __init__ (line 63) | def __init__(self,
    method build (line 97) | def build(self, shape):
    method get_weights (line 122) | def get_weights(self):
    method __call__ (line 133) | def __call__(self, inputs, sequence_length, training):
  class GRU (line 175) | class GRU(BaseRNN):
    method __init__ (line 190) | def __init__(self, num_units, direction='unidirectional', **kwargs):

FILE: frameworks/tf/gru_cell.py
  class GRUCell (line 25) | class GRUCell(rnn_cell.RNNCell):
    method __init__ (line 33) | def __init__(self, num_units, name=None, **kwargs):
    method state_size (line 41) | def state_size(self):
    method output_size (line 45) | def output_size(self):
    method build (line 48) | def build(self, shape):
    method __call__ (line 68) | def __call__(self, inputs, state, scope=None):

FILE: frameworks/tf/indrnn.cc
  type HasteIndrnnOp (line 71) | struct HasteIndrnnOp : public OpKernel {
    method HasteIndrnnOp (line 72) | explicit HasteIndrnnOp(OpKernelConstruction* context) : OpKernel(conte...
    method Compute (line 77) | void Compute(OpKernelContext* context) override {
  type HasteIndrnnGradOp (line 171) | struct HasteIndrnnGradOp : public OpKernel {
    method HasteIndrnnGradOp (line 172) | explicit HasteIndrnnGradOp(OpKernelConstruction* context) : OpKernel(c...
    method Compute (line 174) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/indrnn.py
  function indrnn_gradient (line 38) | def indrnn_gradient(op, *grads):
  function _get_initializer (line 60) | def _get_initializer(initializer):
  class IndRNNLayer (line 72) | class IndRNNLayer(tf.Module):
    method __init__ (line 73) | def __init__(self,
    method build (line 105) | def build(self, shape):
    method get_weights (line 127) | def get_weights(self):
    method __call__ (line 134) | def __call__(self, inputs, sequence_length, training):
  class IndRNN (line 171) | class IndRNN(BaseRNN):
    method __init__ (line 179) | def __init__(self, num_units, direction='unidirectional', **kwargs):

FILE: frameworks/tf/layer_norm.cc
  type HasteLayerNormOp (line 55) | struct HasteLayerNormOp : public OpKernel {
    method HasteLayerNormOp (line 56) | explicit HasteLayerNormOp(OpKernelConstruction* context) : OpKernel(co...
    method Compute (line 58) | void Compute(OpKernelContext* context) override {
  type HasteLayerNormGradOp (line 116) | struct HasteLayerNormGradOp : public OpKernel {
    method HasteLayerNormGradOp (line 117) | explicit HasteLayerNormGradOp(OpKernelConstruction* context) : OpKerne...
    method Compute (line 119) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/layer_norm.py
  function layer_norm_gradient (line 34) | def layer_norm_gradient(op, *grads):
  class LayerNorm (line 43) | class LayerNorm(tf.Module):
    method __init__ (line 51) | def __init__(self, name=None):
    method build (line 64) | def build(self, shape):
    method __call__ (line 82) | def __call__(self, x):

FILE: frameworks/tf/layer_norm_gru.cc
  type HasteLayerNormGruOp (line 81) | struct HasteLayerNormGruOp : public OpKernel {
    method HasteLayerNormGruOp (line 82) | explicit HasteLayerNormGruOp(OpKernelConstruction* context) : OpKernel...
    method Compute (line 90) | void Compute(OpKernelContext* context) override {
  type HasteLayerNormGruGradOp (line 246) | struct HasteLayerNormGruGradOp : public OpKernel {
    method HasteLayerNormGruGradOp (line 247) | explicit HasteLayerNormGruGradOp(OpKernelConstruction* context) : OpKe...
    method Compute (line 249) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/layer_norm_gru.py
  function layer_norm_gru_gradient (line 36) | def layer_norm_gru_gradient(op, *grads):
  class LayerNormGRULayer (line 63) | class LayerNormGRULayer(tf.Module):
    method __init__ (line 64) | def __init__(self,
    method build (line 98) | def build(self, shape):
    method get_weights (line 124) | def get_weights(self):
    method __call__ (line 136) | def __call__(self, inputs, sequence_length, training):
  class LayerNormGRU (line 179) | class LayerNormGRU(BaseRNN):
    method __init__ (line 194) | def __init__(self, num_units, direction='unidirectional', **kwargs):

FILE: frameworks/tf/layer_norm_gru_cell.py
  class LayerNormGRUCell (line 30) | class LayerNormGRUCell(rnn_cell.RNNCell):
    method __init__ (line 39) | def __init__(self,
    method state_size (line 60) | def state_size(self):
    method output_size (line 64) | def output_size(self):
    method build (line 67) | def build(self, shape):
    method __call__ (line 88) | def __call__(self, inputs, state, training=False, scope=None):
    method _layer_norm (line 106) | def _layer_norm(self, x, gamma):

FILE: frameworks/tf/layer_norm_indrnn.cc
  type HasteLayerNormIndrnnOp (line 78) | struct HasteLayerNormIndrnnOp : public OpKernel {
    method HasteLayerNormIndrnnOp (line 79) | explicit HasteLayerNormIndrnnOp(OpKernelConstruction* context) : OpKer...
    method Compute (line 84) | void Compute(OpKernelContext* context) override {
  type HasteLayerNormIndrnnGradOp (line 208) | struct HasteLayerNormIndrnnGradOp : public OpKernel {
    method HasteLayerNormIndrnnGradOp (line 209) | explicit HasteLayerNormIndrnnGradOp(OpKernelConstruction* context) : O...
    method Compute (line 211) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/layer_norm_indrnn.py
  function layer_norm_indrnn_gradient (line 38) | def layer_norm_indrnn_gradient(op, *grads):
  function _get_initializer (line 62) | def _get_initializer(initializer):
  class LayerNormIndRNNLayer (line 74) | class LayerNormIndRNNLayer(tf.Module):
    method __init__ (line 75) | def __init__(self,
    method build (line 108) | def build(self, shape):
    method get_weights (line 130) | def get_weights(self):
    method __call__ (line 138) | def __call__(self, inputs, sequence_length, training):
  class LayerNormIndRNN (line 176) | class LayerNormIndRNN(BaseRNN):
    method __init__ (line 186) | def __init__(self, num_units, direction='unidirectional', **kwargs):

FILE: frameworks/tf/layer_norm_lstm.cc
  type HasteLayerNormLstmOp (line 86) | struct HasteLayerNormLstmOp : public OpKernel {
    method HasteLayerNormLstmOp (line 87) | explicit HasteLayerNormLstmOp(OpKernelConstruction* context) : OpKerne...
    method Compute (line 95) | void Compute(OpKernelContext* context) override {
  type HasteLayerNormLstmGradOp (line 281) | struct HasteLayerNormLstmGradOp : public OpKernel {
    method HasteLayerNormLstmGradOp (line 282) | explicit HasteLayerNormLstmGradOp(OpKernelConstruction* context) : OpK...
    method Compute (line 284) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/layer_norm_lstm.py
  function lstm_gradient (line 37) | def lstm_gradient(op, *grads):
  class LayerNormLSTMLayer (line 78) | class LayerNormLSTMLayer(tf.Module):
    method __init__ (line 79) | def __init__(self,
    method build (line 116) | def build(self, shape):
    method get_weights (line 149) | def get_weights(self):
    method state_size (line 162) | def state_size(self):
    method output_size (line 166) | def output_size(self):
    method __call__ (line 169) | def __call__(self, x, sequence_length, training):
  class LayerNormLSTM (line 212) | class LayerNormLSTM(BaseRNN):
    method __init__ (line 225) | def __init__(self, num_units, direction='unidirectional', **kwargs):

FILE: frameworks/tf/layer_norm_lstm_cell.py
  class LayerNormLSTMCell (line 30) | class LayerNormLSTMCell(rnn_cell.RNNCell):
    method __init__ (line 39) | def __init__(self,
    method state_size (line 61) | def state_size(self):
    method output_size (line 65) | def output_size(self):
    method build (line 68) | def build(self, shape):
    method __call__ (line 84) | def __call__(self, inputs, state, training=False, scope=None):
    method _layer_norm (line 106) | def _layer_norm(self, x, gamma, beta):

FILE: frameworks/tf/lstm.cc
  type HasteLstmOp (line 77) | struct HasteLstmOp : public OpKernel {
    method HasteLstmOp (line 78) | explicit HasteLstmOp(OpKernelConstruction* context) : OpKernel(context) {
    method Compute (line 86) | void Compute(OpKernelContext* context) override {
  type HasteLstmGradOp (line 215) | struct HasteLstmGradOp : public OpKernel {
    method HasteLstmGradOp (line 216) | explicit HasteLstmGradOp(OpKernelConstruction* context) : OpKernel(con...
    method Compute (line 218) | void Compute(OpKernelContext* context) override {

FILE: frameworks/tf/lstm.py
  function lstm_gradient (line 38) | def lstm_gradient(op, *grads):
  class LSTMLayer (line 63) | class LSTMLayer(tf.Module):
    method __init__ (line 64) | def __init__(self,
    method build (line 102) | def build(self, shape):
    method get_weights (line 146) | def get_weights(self):
    method state_size (line 183) | def state_size(self):
    method output_size (line 187) | def output_size(self):
    method __call__ (line 190) | def __call__(self, x, sequence_length, training):
  class LSTM (line 230) | class LSTM(BaseRNN):
    method __init__ (line 245) | def __init__(self, num_units, direction='unidirectional', **kwargs):

FILE: frameworks/tf/support.cc
  type std (line 29) | namespace std {
    type hash<Key> (line 32) | struct hash<Key> {
  function cublasHandle_t (line 43) | cublasHandle_t GetCublasHandle(tensorflow::OpKernelContext* context) {
  function cudaStream_t (line 64) | const cudaStream_t& GetCudaStream(tensorflow::OpKernelContext* context) {

FILE: frameworks/tf/support.h
  function namespace (line 21) | namespace tensorflow {

FILE: frameworks/tf/weight_config.py
  class WeightConfig (line 17) | class WeightConfig:
    method __init__ (line 20) | def __init__(self, initializer=None, constraint=None, transform=None):
    method override (line 25) | def override(self, initializer, constraint, transform):

FILE: frameworks/tf/zoneout_wrapper.py
  class ZoneoutWrapper (line 29) | class ZoneoutWrapper(rnn_cell.RNNCell):
    method __init__ (line 38) | def __init__(self, cell, rate, training):
    method state_size (line 56) | def state_size(self):
    method output_size (line 60) | def output_size(self):
    method __call__ (line 63) | def __call__(self, inputs, state, scope=None):
    method _apply_zoneout (line 92) | def _apply_zoneout(self, new_tensor, old_tensor):
    method _build_mask (line 100) | def _build_mask(self, shape):

FILE: lib/blas.h
  function set_pointer_mode (line 22) | struct set_pointer_mode {
  function enable_tensor_cores (line 34) | struct enable_tensor_cores {
  function __half (line 49) | struct blas<__half> {
  function float (line 54) | struct blas<float> {
  function double (line 59) | struct blas<double> {

FILE: lib/gru_backward_gpu.cu.cc
  function __global__ (line 27) | __global__
  function __global__ (line 100) | __global__
  type haste (line 118) | namespace haste {
    type v0 (line 119) | namespace v0 {
      type gru (line 120) | namespace gru {
        type BackwardPass<T>::private_data (line 123) | struct BackwardPass<T>::private_data {
        type BackwardPass<half> (line 411) | struct BackwardPass<half>
        type BackwardPass<float> (line 412) | struct BackwardPass<float>
        type BackwardPass<double> (line 413) | struct BackwardPass<double>

FILE: lib/gru_forward_gpu.cu.cc
  function __global__ (line 28) | __global__
  function __global__ (line 89) | __global__
  type haste (line 107) | namespace haste {
    type v0 (line 108) | namespace v0 {
      type gru (line 109) | namespace gru {
        type ForwardPass<T>::private_data (line 112) | struct ForwardPass<T>::private_data {
        type ForwardPass<half> (line 373) | struct ForwardPass<half>
        type ForwardPass<float> (line 374) | struct ForwardPass<float>
        type ForwardPass<double> (line 375) | struct ForwardPass<double>

FILE: lib/haste/gru.h
  function namespace (line 21) | namespace haste {

FILE: lib/haste/indrnn.h
  function namespace (line 21) | namespace haste {

FILE: lib/haste/layer_norm.h
  function namespace (line 20) | namespace haste {

FILE: lib/haste/layer_norm_gru.h
  function namespace (line 21) | namespace haste {

FILE: lib/haste/layer_norm_indrnn.h
  function namespace (line 21) | namespace haste {

FILE: lib/haste/layer_norm_lstm.h
  function namespace (line 21) | namespace haste {

FILE: lib/haste/lstm.h
  function namespace (line 21) | namespace haste {

FILE: lib/indrnn_backward_gpu.cu.cc
  function __global__ (line 26) | __global__
  type haste (line 78) | namespace haste {
    type v0 (line 79) | namespace v0 {
      type indrnn (line 80) | namespace indrnn {
        type BackwardPass<T>::private_data (line 83) | struct BackwardPass<T>::private_data {
        class BackwardPass<float> (line 209) | class BackwardPass<float>
        class BackwardPass<double> (line 210) | class BackwardPass<double>

FILE: lib/indrnn_forward_gpu.cu.cc
  function __global__ (line 26) | __global__
  type haste (line 67) | namespace haste {
    type v0 (line 68) | namespace v0 {
      type indrnn (line 69) | namespace indrnn {
        type ForwardPass<T>::private_data (line 72) | struct ForwardPass<T>::private_data {
        class ForwardPass<float> (line 212) | class ForwardPass<float>
        class ForwardPass<double> (line 213) | class ForwardPass<double>

FILE: lib/inline_ops.h
  function atomicAdd (line 47) | double atomicAdd(double* address, double val) {

FILE: lib/layer_norm_backward_gpu.cu.cc
  function __global__ (line 24) | __global__
  type haste (line 97) | namespace haste {
    type v0 (line 98) | namespace v0 {
      type layer_norm (line 99) | namespace layer_norm {
        class BackwardPass<float> (line 167) | class BackwardPass<float>
        class BackwardPass<double> (line 168) | class BackwardPass<double>

FILE: lib/layer_norm_forward_gpu.cu.cc
  function __global__ (line 23) | __global__
  type haste (line 92) | namespace haste {
    type v0 (line 93) | namespace v0 {
      type layer_norm (line 94) | namespace layer_norm {
        class ForwardPass<float> (line 152) | class ForwardPass<float>
        class ForwardPass<double> (line 153) | class ForwardPass<double>

FILE: lib/layer_norm_gru_backward_gpu.cu.cc
  function __global__ (line 26) | __global__
  type haste (line 99) | namespace haste {
    type v0 (line 100) | namespace v0 {
      type layer_norm_gru (line 101) | namespace layer_norm_gru {
        type BackwardPass<T>::private_data (line 104) | struct BackwardPass<T>::private_data {
        type BackwardPass<float> (line 312) | struct BackwardPass<float>
        type BackwardPass<double> (line 313) | struct BackwardPass<double>

FILE: lib/layer_norm_gru_forward_gpu.cu.cc
  function __global__ (line 26) | __global__
  type haste (line 87) | namespace haste {
    type v0 (line 88) | namespace v0 {
      type layer_norm_gru (line 89) | namespace layer_norm_gru {
        type ForwardPass<T>::private_data (line 92) | struct ForwardPass<T>::private_data {
        type ForwardPass<float> (line 307) | struct ForwardPass<float>
        type ForwardPass<double> (line 308) | struct ForwardPass<double>

FILE: lib/layer_norm_indrnn_backward_gpu.cu.cc
  function __global__ (line 26) | __global__
  type haste (line 78) | namespace haste {
    type v0 (line 79) | namespace v0 {
      type layer_norm_indrnn (line 80) | namespace layer_norm_indrnn {
        type BackwardPass<T>::private_data (line 83) | struct BackwardPass<T>::private_data {
        class BackwardPass<float> (line 211) | class BackwardPass<float>
        class BackwardPass<double> (line 212) | class BackwardPass<double>

FILE: lib/layer_norm_indrnn_forward_gpu.cu.cc
  function __global__ (line 26) | __global__
  type haste (line 67) | namespace haste {
    type v0 (line 68) | namespace v0 {
      type layer_norm_indrnn (line 69) | namespace layer_norm_indrnn {
        type ForwardPass<T>::private_data (line 72) | struct ForwardPass<T>::private_data {
        class ForwardPass<float> (line 215) | class ForwardPass<float>
        class ForwardPass<double> (line 216) | class ForwardPass<double>

FILE: lib/layer_norm_lstm_backward_gpu.cu.cc
  function __global__ (line 28) | __global__
  function __global__ (line 68) | __global__
  type haste (line 122) | namespace haste {
    type v0 (line 123) | namespace v0 {
      type layer_norm_lstm (line 124) | namespace layer_norm_lstm {
        type BackwardPass<T>::private_data (line 127) | struct BackwardPass<T>::private_data {
        type BackwardPass<float> (line 354) | struct BackwardPass<float>
        type BackwardPass<double> (line 355) | struct BackwardPass<double>

FILE: lib/layer_norm_lstm_forward_gpu.cu.cc
  function __global__ (line 27) | __global__
  function __global__ (line 76) | __global__
  type haste (line 113) | namespace haste {
    type v0 (line 114) | namespace v0 {
      type layer_norm_lstm (line 115) | namespace layer_norm_lstm {
        type ForwardPass<T>::private_data (line 118) | struct ForwardPass<T>::private_data {
        type ForwardPass<float> (line 342) | struct ForwardPass<float>
        type ForwardPass<double> (line 343) | struct ForwardPass<double>

FILE: lib/lstm_backward_gpu.cu.cc
  function __global__ (line 28) | __global__
  type haste (line 100) | namespace haste {
    type v0 (line 101) | namespace v0 {
      type lstm (line 102) | namespace lstm {
        type BackwardPass<T>::private_data (line 105) | struct BackwardPass<T>::private_data {
        type BackwardPass<float> (line 407) | struct BackwardPass<float>
        type BackwardPass<double> (line 408) | struct BackwardPass<double>

FILE: lib/lstm_forward_gpu.cu.cc
  function __global__ (line 28) | __global__
  type haste (line 91) | namespace haste {
    type v0 (line 92) | namespace v0 {
      type lstm (line 93) | namespace lstm {
        type ForwardPass<T>::private_data (line 96) | struct ForwardPass<T>::private_data {
        type ForwardPass<float> (line 368) | struct ForwardPass<float>
        type ForwardPass<double> (line 369) | struct ForwardPass<double>

FILE: validation/pytorch.py
  function self_consistency (line 42) | def self_consistency(rnn, x):
  function native_consistency (line 65) | def native_consistency(haste_rnn, pytorch_rnn, x):
  function _run_rnn (line 92) | def _run_rnn(rnn_type, x, **kwargs):
  function run_rnn (line 100) | def run_rnn(rnn_type, x):
  function main (line 105) | def main(args):

FILE: validation/tf.py
  function stfu (line 21) | def stfu():
  function NativeGRUBuilder (line 27) | def NativeGRUBuilder(hidden_size):
  function NativeLSTMBuilder (line 37) | def NativeLSTMBuilder(hidden_size):
  function NativeGRUWeights (line 47) | def NativeGRUWeights(native_gru, haste_gru):
  function NativeLSTMWeights (line 54) | def NativeLSTMWeights(native_lstm, haste_lstm):
  function native_consistency (line 89) | def native_consistency(haste_rnn, native_rnn, x):
  function run_rnn (line 107) | def run_rnn(rnn_type, x):
  function main (line 114) | def main(args):

FILE: validation/tf_pytorch.py
  function stfu (line 25) | def stfu():
  function copy_weights_gru (line 31) | def copy_weights_gru(rnn_tf, rnn_pt):
  function copy_weights_indrnn (line 44) | def copy_weights_indrnn(rnn_tf, rnn_pt):
  function copy_weights_layer_norm_gru (line 55) | def copy_weights_layer_norm_gru(rnn_tf, rnn_pt):
  function copy_weights_layer_norm_indrnn (line 70) | def copy_weights_layer_norm_indrnn(rnn_tf, rnn_pt):
  function copy_weights_layer_norm_lstm (line 83) | def copy_weights_layer_norm_lstm(rnn_tf, rnn_pt):
  function copy_weights_lstm (line 100) | def copy_weights_lstm(rnn_tf, rnn_pt):
  function run_rnn (line 144) | def run_rnn(rnn_type, x):
  function main (line 166) | def main(args):