gru_compute.cu 7.6 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
G
guosheng 已提交
2 3 4 5 6 7 8 9 10 11
Licensed 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. */

Y
Yu Yang 已提交
12
#include <paddle/fluid/platform/device_context.h>
Y
Yu Yang 已提交
13
#include "paddle/fluid/operators/math/blas.h"
Y
Yi Wang 已提交
14 15 16
#include "paddle/fluid/operators/math/detail/gru_gpu_kernel.h"
#include "paddle/fluid/operators/math/detail/gru_kernel.h"
#include "paddle/fluid/operators/math/gru_compute.h"
G
guosheng 已提交
17 18 19 20 21 22

namespace paddle {
namespace operators {
namespace math {

template <typename T>
Q
QI JUN 已提交
23 24
struct GRUUnitFunctor<platform::CUDADeviceContext, T> {
  static void compute(const platform::CUDADeviceContext &context,
25
                      GRUMetaValue<T> value, int frame_size, int batch_size,
26 27
                      const detail::ActivationType active_node,
                      const detail::ActivationType active_gate) {
Q
QI JUN 已提交
28
    auto stream = context.stream();
G
guosheng 已提交
29 30
    dim3 threads;
    dim3 grid;
G
guosheng 已提交
31 32 33 34 35
    if (batch_size == 1) {
      int frame_per_block = frame_size <= 1024 ? frame_size : 1024;
      int frame_blocks = (frame_size + 1024 - 1) / 1024;
      threads = dim3(frame_per_block, 1);
      grid = dim3(frame_blocks, 1);
G
guosheng 已提交
36 37
    } else {
      threads = dim3(32, 32);
G
guosheng 已提交
38
      grid = dim3((frame_size + 32 - 1) / 32, (batch_size + 32 - 1) / 32);
G
guosheng 已提交
39
    }
Y
Yu Yang 已提交
40
    auto blas = math::GetBlas<platform::CUDADeviceContext, T>(context);
G
guosheng 已提交
41
    if (value.prev_out_value) {
Y
Yu Yang 已提交
42 43 44
      blas.GEMM(false, false, batch_size, frame_size * 2, frame_size, 1,
                value.prev_out_value, frame_size, value.gate_weight,
                frame_size * 2, 1, value.gate_value, frame_size * 3);
G
guosheng 已提交
45 46
    }

G
guosheng 已提交
47
    if (batch_size == 1) {
G
guosheng 已提交
48
      detail::KeGruForwardResetOutput<detail::forward::gru_resetOutput<T>,
G
guosheng 已提交
49
                                      /* is_batch= */ false,
G
guosheng 已提交
50
                                      T><<<grid, threads, 0, stream>>>(
G
guosheng 已提交
51 52 53
          detail::forward::gru_resetOutput<T>(), value.gate_value,
          value.reset_output_value, value.prev_out_value, frame_size,
          batch_size, active_gate);
G
guosheng 已提交
54 55
    } else {
      detail::KeGruForwardResetOutput<detail::forward::gru_resetOutput<T>,
G
guosheng 已提交
56
                                      /* is_batch= */ true,
G
guosheng 已提交
57
                                      T><<<grid, threads, 0, stream>>>(
G
guosheng 已提交
58 59 60
          detail::forward::gru_resetOutput<T>(), value.gate_value,
          value.reset_output_value, value.prev_out_value, frame_size,
          batch_size, active_gate);
G
guosheng 已提交
61 62
    }

G
guosheng 已提交
63
    if (value.prev_out_value) {
Y
Yu Yang 已提交
64 65 66 67
      blas.GEMM(false, false, batch_size, frame_size, frame_size, 1,
                value.reset_output_value, frame_size, value.state_weight,
                frame_size, 1, value.gate_value + frame_size * 2,
                frame_size * 3);
G
guosheng 已提交
68 69
    }

G
guosheng 已提交
70
    if (batch_size == 1) {
G
guosheng 已提交
71
      detail::KeGruForwardFinalOutput<detail::forward::gru_finalOutput<T>,
G
guosheng 已提交
72
                                      /* is_batch= */ false,
G
guosheng 已提交
73
                                      T><<<grid, threads, 0, stream>>>(
G
guosheng 已提交
74 75
          detail::forward::gru_finalOutput<T>(), value.gate_value,
          value.prev_out_value, value.output_value, frame_size, batch_size,
G
guosheng 已提交
76 77 78
          active_node);
    } else {
      detail::KeGruForwardFinalOutput<detail::forward::gru_finalOutput<T>,
G
guosheng 已提交
79
                                      /* is_batch= */ true,
G
guosheng 已提交
80
                                      T><<<grid, threads, 0, stream>>>(
G
guosheng 已提交
81 82
          detail::forward::gru_finalOutput<T>(), value.gate_value,
          value.prev_out_value, value.output_value, frame_size, batch_size,
G
guosheng 已提交
83 84 85 86 87 88
          active_node);
    }
  }
};

template <typename T>
Q
QI JUN 已提交
89 90
struct GRUUnitGradFunctor<platform::CUDADeviceContext, T> {
  static void compute(const platform::CUDADeviceContext &context,
91
                      GRUMetaValue<T> value, GRUMetaGrad<T> grad,
G
guosheng 已提交
92
                      int frame_size, int batch_size,
93 94
                      const detail::ActivationType active_node,
                      const detail::ActivationType active_gate) {
Q
QI JUN 已提交
95
    auto stream = context.stream();
G
guosheng 已提交
96 97
    dim3 threads;
    dim3 grid;
G
guosheng 已提交
98 99 100 101 102
    if (batch_size == 1) {
      int frame_per_block = frame_size <= 1024 ? frame_size : 1024;
      int frame_blocks = (frame_size + 1024 - 1) / 1024;
      threads = dim3(frame_per_block, 1);
      grid = dim3(frame_blocks, 1);
G
guosheng 已提交
103 104
    } else {
      threads = dim3(32, 32);
G
guosheng 已提交
105
      grid = dim3((frame_size + 32 - 1) / 32, (batch_size + 32 - 1) / 32);
G
guosheng 已提交
106 107
    }

G
guosheng 已提交
108
    if (batch_size == 1) {
G
guosheng 已提交
109 110
      detail::KeGruBackwardStateGrad<
          detail::backward::gru_stateGrad<T>,
G
guosheng 已提交
111 112 113 114
          /* is_batch= */ false><<<grid, threads, 0, stream>>>(
          detail::backward::gru_stateGrad<T>(), value.gate_value,
          grad.gate_grad, value.prev_out_value, grad.prev_out_grad,
          grad.output_grad, frame_size, batch_size, active_node);
G
guosheng 已提交
115 116 117
    } else {
      detail::KeGruBackwardStateGrad<
          detail::backward::gru_stateGrad<T>,
G
guosheng 已提交
118 119 120 121
          /* is_batch= */ true><<<grid, threads, 0, stream>>>(
          detail::backward::gru_stateGrad<T>(), value.gate_value,
          grad.gate_grad, value.prev_out_value, grad.prev_out_grad,
          grad.output_grad, frame_size, batch_size, active_node);
G
guosheng 已提交
122 123
    }

Y
Yu Yang 已提交
124 125
    auto blas = math::GetBlas<platform::CUDADeviceContext, T>(context);

G
guosheng 已提交
126
    if (value.prev_out_value && grad.prev_out_grad) {
Y
Yu Yang 已提交
127 128 129 130
      blas.GEMM(false, true, batch_size, frame_size, frame_size, 1,
                grad.gate_grad + frame_size * 2, frame_size * 3,
                value.state_weight, frame_size, 0, grad.reset_output_grad,
                frame_size);
G
guosheng 已提交
131

G
guosheng 已提交
132
      if (grad.state_weight_grad) {
Y
Yu Yang 已提交
133 134 135 136
        blas.GEMM(true, false, frame_size, frame_size, batch_size, 1,
                  value.reset_output_value, frame_size,
                  grad.gate_grad + frame_size * 2, frame_size * 3, 1,
                  grad.state_weight_grad, frame_size);
G
guosheng 已提交
137 138 139
      }
    }

G
guosheng 已提交
140
    if (batch_size == 1) {
G
guosheng 已提交
141 142
      detail::KeGruBackwardResetGrad<
          detail::backward::gru_resetGrad<T>,
G
guosheng 已提交
143 144 145 146
          /* is_batch= */ false><<<grid, threads, 0, stream>>>(
          detail::backward::gru_resetGrad<T>(), value.gate_value,
          grad.gate_grad, value.prev_out_value, grad.prev_out_grad,
          grad.reset_output_grad, frame_size, batch_size, active_gate);
G
guosheng 已提交
147 148 149
    } else {
      detail::KeGruBackwardResetGrad<
          detail::backward::gru_resetGrad<T>,
G
guosheng 已提交
150 151 152 153
          /* is_batch= */ true><<<grid, threads, 0, stream>>>(
          detail::backward::gru_resetGrad<T>(), value.gate_value,
          grad.gate_grad, value.prev_out_value, grad.prev_out_grad,
          grad.reset_output_grad, frame_size, batch_size, active_gate);
G
guosheng 已提交
154 155
    }

G
guosheng 已提交
156
    if (grad.prev_out_grad && value.prev_out_value) {
Y
Yu Yang 已提交
157 158 159
      blas.GEMM(false, true, batch_size, frame_size, frame_size * 2, 1,
                grad.gate_grad, frame_size * 3, value.gate_weight,
                frame_size * 2, 1, grad.prev_out_grad, frame_size);
G
guosheng 已提交
160

G
guosheng 已提交
161
      if (grad.gate_weight_grad) {
Y
Yu Yang 已提交
162 163 164
        blas.GEMM(true, false, frame_size, frame_size * 2, batch_size, 1,
                  value.prev_out_value, frame_size, grad.gate_grad,
                  frame_size * 3, 1, grad.gate_weight_grad, frame_size * 2);
G
guosheng 已提交
165 166 167 168 169
      }
    }
  }
};

Q
QI JUN 已提交
170 171 172 173
template struct GRUUnitFunctor<platform::CUDADeviceContext, float>;
template struct GRUUnitFunctor<platform::CUDADeviceContext, double>;
template struct GRUUnitGradFunctor<platform::CUDADeviceContext, float>;
template struct GRUUnitGradFunctor<platform::CUDADeviceContext, double>;
G
guosheng 已提交
174 175 176

}  // namespace math
}  // namespace operators
G
guosheng 已提交
177
}  // namespace paddle