#include "case.h"

#include "ccv_case.h"

#include "ccv_nnc_case.h"

#include <ccv.h>

#include <nnc/ccv_nnc.h>

#include <nnc/ccv_nnc_easy.h>

#include <3rdparty/dsfmt/dSFMT.h>

TEST_SETUP()

{

  ccv_nnc_init();

}

static int weight_dim(int bidirectional, int num_layers, int input_size, int hidden_size, int proj_size, int bias)

{

  const int D = !!bidirectional + 1;

  if (hidden_size == proj_size)

    return (num_layers * (bias ? 8 : 
00
) + (num_layers - 1) * (hidden_size * 4 * D + hidden_size * 4) + input_size * 4 + hidden_size * 4) * D;

  else

    return (num_layers * (bias ? 8 : 
00
) + (num_layers - 1) * (proj_size * 4 * D + proj_size * 4) + (proj_size * 4 + input_size * 4) + num_layers * proj_size) * D;

}

static int r_dim(int bidirectional, int dropout, int batch_count, int num_layers, int max_seq_count, int hidden_size, int proj_size)

{

  const int D = !!bidirectional + 1;

  if (hidden_size == proj_size)

    // 5: i, f, g, o, tanh(c)

    // 2: c, h

    return D * batch_count * ((5 + !!dropout) * num_layers * max_seq_count + 2 * num_layers * (max_seq_count - 1));

  else

    // 6: i, f, g, o, tanh(c), h

    // 1: c, h_proj

    return D * batch_count * ((6 + !!dropout) * num_layers * max_seq_count + 2 * num_layers * (max_seq_count - 1));

}

TEST_CASE("LSTM forward")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 24, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int r_d = r_dim(0, 0, 1, 6, 5, 24, 24);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 12; 
i++36
)

    hx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 24; 
i++72
)

    cx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++28.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, hx, cx, w), TENSOR_LIST(gx, ghx, gcx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, ghx, gcx, gw), TENSOR_LIST(gy, ghy, gcy, gr), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, ghy, gcy, gr), TENSOR_LIST(y, hy, cy, r), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(ghx);

  ccv_nnc_tensor_free(gcx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(ghy);

  ccv_nnc_tensor_free(gcy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(hx);

  ccv_nnc_tensor_free(cx);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(hy);

  ccv_nnc_tensor_free(cy);

  ccv_nnc_tensor_free(r);

}

TEST_CASE("LSTM forward without hx, cx, hy, cy")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 24, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  const int r_d = r_dim(0, 0, 1, 6, 5, 24, 24);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++28.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, w), TENSOR_LIST(gx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, 0, 0, gw), TENSOR_LIST(gy, 0, 0, gr), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, gr), TENSOR_LIST(y, r), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(r);

}

TEST_CASE("LSTM forward with dropout")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 24, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int r_d = r_dim(0, 1, 1, 6, 5, 24, 24);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 12; 
i++36
)

    hx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 24; 
i++72
)

    cx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++28.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, hx, cx, w), TENSOR_LIST(gx, ghx, gcx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 0, 6, 1, 0, 0, 0.5, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, ghx, gcx, gw), TENSOR_LIST(gy, ghy, gcy, gr), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, ghy, gcy, gr), TENSOR_LIST(y, hy, cy, r), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(ghx);

  ccv_nnc_tensor_free(gcx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(ghy);

  ccv_nnc_tensor_free(gcy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(hx);

  ccv_nnc_tensor_free(cx);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(hy);

  ccv_nnc_tensor_free(cy);

  ccv_nnc_tensor_free(r);

}

TEST_CASE("LSTM forward with projection")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 12), 0);

  ccv_nnc_tensor_t* const cx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 12, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 12), 0);

  ccv_nnc_tensor_t* const hy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 12), 0);

  ccv_nnc_tensor_t* const cy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int r_d = r_dim(0, 1, 1, 6, 5, 24, 12);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 12; 
i++36
)

    hx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 24; 
i++72
)

    cx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++17.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 12), 0);

  ccv_nnc_tensor_t* const gcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, hx, cx, w), TENSOR_LIST(gx, ghx, gcx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 12), 0);

  ccv_nnc_tensor_t* const ghy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 12), 0);

  ccv_nnc_tensor_t* const gcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 12, 6, 1, 0, 0, 0.5, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, ghx, gcx, gw), TENSOR_LIST(gy, ghy, gcy, gr), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, ghy, gcy, gr), TENSOR_LIST(y, hy, cy, r), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(ghx);

  ccv_nnc_tensor_free(gcx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(ghy);

  ccv_nnc_tensor_free(gcy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(hx);

  ccv_nnc_tensor_free(cx);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(hy);

  ccv_nnc_tensor_free(cy);

  ccv_nnc_tensor_free(r);

}

TEST_CASE("LSTM forward with projection, bidirectional")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 12, 1, 12), 0);

  ccv_nnc_tensor_t* const cx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 12, 1, 24), 0);

  const int weight_d = weight_dim(1, 6, 24, 24, 12, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 12, 1, 12), 0);

  ccv_nnc_tensor_t* const cy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 12, 1, 24), 0);

  const int r_d = r_dim(1, 1, 1, 6, 5, 24, 12);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 12; 
i++36
)

    hx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 3 * 24; 
i++72
)

    cx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++47.2k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 12, 1, 12), 0);

  ccv_nnc_tensor_t* const gcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 12, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, hx, cx, w), TENSOR_LIST(gx, ghx, gcx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 12, 1, 12), 0);

  ccv_nnc_tensor_t* const gcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 12, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 12, 6, 1, 0, 1, 0.5, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, ghx, gcx, gw), TENSOR_LIST(gy, ghy, gcy, gr), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, ghy, gcy, gr), TENSOR_LIST(y, hy, cy, r), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(ghx);

  ccv_nnc_tensor_free(gcx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(ghy);

  ccv_nnc_tensor_free(gcy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(hx);

  ccv_nnc_tensor_free(cx);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(hy);

  ccv_nnc_tensor_free(cy);

  ccv_nnc_tensor_free(r);

}

TEST_CASE("LSTM backward")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN) &&

    ccv_nnc_cmd_ok(CCV_NNC_LSTM_BACKWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 24, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int r_d = r_dim(0, 0, 1, 6, 5, 24, 24);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 6 * 24; 
i++144
)

    hx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 6 * 24; 
i++144
)

    cx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++28.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, hx, cx, w), TENSOR_LIST(gx, ghx, gcx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, ghx, gcx, gw), TENSOR_LIST(gy, ghy, gcy, gr), 0);

  ccv_nnc_tensor_t* const dy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const dhy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const dcy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  for (i = 0; i < 5 * 24; 
i++120
)

    dy->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 6 * 24; 
i++144
)

    dhy->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 6 * 24; 
i++144
)

    dcy->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gdy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gdhy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gdcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(dy, dhy, dcy), TENSOR_LIST(gdy, gdhy, gdcy), 0);

  ccv_nnc_tensor_t* const gdx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gdhx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gdcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gdw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_BACKWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gdy, gdhy, gdcy, 0, gx, 0, ghx, gcx, gw, gy, ghy, gcy, gr), TENSOR_LIST(gdx, 0, gdhx, gdcx, gdw), 0);

  ccv_nnc_tensor_t* const dx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const dhx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const dcx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const dw = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, ghy, gcy, gr, gdx, gdhx, gdcx, gdw), TENSOR_LIST(y, hy, cy, r, dx, dhx, dcx, dw), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(ghx);

  ccv_nnc_tensor_free(gcx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(ghy);

  ccv_nnc_tensor_free(gcy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(gdy);

  ccv_nnc_tensor_free(gdhy);

  ccv_nnc_tensor_free(gdcy);

  ccv_nnc_tensor_free(gdx);

  ccv_nnc_tensor_free(gdhx);

  ccv_nnc_tensor_free(gdcx);

  ccv_nnc_tensor_free(gdw);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(hx);

  ccv_nnc_tensor_free(cx);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(hy);

  ccv_nnc_tensor_free(cy);

  ccv_nnc_tensor_free(r);

  ccv_nnc_tensor_free(dy);

  ccv_nnc_tensor_free(dhy);

  ccv_nnc_tensor_free(dcy);

  ccv_nnc_tensor_free(dx);

  ccv_nnc_tensor_free(dhx);

  ccv_nnc_tensor_free(dcx);

  ccv_nnc_tensor_free(dw);

}

TEST_CASE("LSTM backward without dhy, dcy, dhx, dcx")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN) &&

    ccv_nnc_cmd_ok(CCV_NNC_LSTM_BACKWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 24, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const hy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const cy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 6, 1, 24), 0);

  const int r_d = r_dim(0, 0, 1, 6, 5, 24, 24);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 6 * 24; 
i++144
)

    hx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 6 * 24; 
i++144
)

    cx->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++28.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, hx, cx, w), TENSOR_LIST(gx, ghx, gcx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const ghy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gcy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 6, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, ghx, gcx, gw), TENSOR_LIST(gy, ghy, gcy, gr), 0);

  ccv_nnc_tensor_t* const dy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  for (i = 0; i < 5 * 24; 
i++120
)

    dy->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gdy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(dy), TENSOR_LIST(gdy), 0);

  ccv_nnc_tensor_t* const gdx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gdw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_BACKWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gdy, 0, 0, 0, gx, 0, ghx, gcx, gw, gy, ghy, gcy, gr), TENSOR_LIST(gdx, 0, 0, 0, gdw), 0);

  ccv_nnc_tensor_t* const dx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const dw = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, ghy, gcy, gr, gdx, gdw), TENSOR_LIST(y, hy, cy, r, dx, dw), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(ghx);

  ccv_nnc_tensor_free(gcx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(ghy);

  ccv_nnc_tensor_free(gcy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(gdy);

  ccv_nnc_tensor_free(gdx);

  ccv_nnc_tensor_free(gdw);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(hx);

  ccv_nnc_tensor_free(cx);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(hy);

  ccv_nnc_tensor_free(cy);

  ccv_nnc_tensor_free(r);

  ccv_nnc_tensor_free(dy);

  ccv_nnc_tensor_free(dx);

  ccv_nnc_tensor_free(dw);

}

TEST_CASE("LSTM backward without hx, cx, hy, cy, dhy, dcy, dhx, dcx")

{

  GUARD_ELSE_RETURN(ccv_nnc_cmd_ok(CCV_NNC_LSTM_FORWARD, CCV_NNC_BACKEND_GPU_CUDNN) &&

    ccv_nnc_cmd_ok(CCV_NNC_LSTM_BACKWARD, CCV_NNC_BACKEND_GPU_CUDNN));

  ccv_nnc_tensor_t* const x = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  const int weight_d = weight_dim(0, 6, 24, 24, 24, 1);

  ccv_nnc_tensor_t* const w = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_tensor_t* const y = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  const int r_d = r_dim(0, 0, 1, 6, 5, 24, 24);

  ccv_nnc_tensor_t* const r = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, r_d, 24), 0);

  dsfmt_t dsfmt;

  dsfmt_init_gen_rand(&dsfmt, 0);

  int i;

  for (i = 0; i < 5 * 24; 
i++120
)

    x->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  for (i = 0; i < 24 * weight_d; 
i++28.8k
)

    w->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(x, w), TENSOR_LIST(gx, gw), 0);

  ccv_nnc_tensor_t* const gy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gr = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, r_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_FORWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gx, 0, 0, 0, gw), TENSOR_LIST(gy, 0, 0, gr), 0);

  ccv_nnc_tensor_t* const dy = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  for (i = 0; i < 5 * 24; 
i++120
)

    dy->data.f32[i] = dsfmt_genrand_open_close(&dsfmt);

  ccv_nnc_tensor_t* const gdy = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(dy), TENSOR_LIST(gdy), 0);

  ccv_nnc_tensor_t* const gdx = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const gdw = ccv_nnc_tensor_new(0, GPU_TENSOR_NHWC(000, 32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_LSTM_BACKWARD(24, 0, 6, 1, 0, 0, 0, 0), ccv_nnc_no_hint, 0, TENSOR_LIST(gdy, 0, 0, 0, gx, 0, 0, 0, gw, gy, 0, 0, gr), TENSOR_LIST(gdx, 0, 0, 0, gdw), 0);

  ccv_nnc_tensor_t* const dx = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, 5, 1, 24), 0);

  ccv_nnc_tensor_t* const dw = ccv_nnc_tensor_new(0, CPU_TENSOR_NHWC(32F, weight_d, 24), 0);

  ccv_nnc_cmd_exec(CMD_DATA_TRANSFER_FORWARD(), ccv_nnc_no_hint, 0, TENSOR_LIST(gy, gr, gdx, gdw), TENSOR_LIST(y, r, dx, dw), 0);

  ccv_nnc_tensor_free(gx);

  ccv_nnc_tensor_free(gw);

  ccv_nnc_tensor_free(gy);

  ccv_nnc_tensor_free(gr);

  ccv_nnc_tensor_free(gdy);

  ccv_nnc_tensor_free(gdx);

  ccv_nnc_tensor_free(gdw);

  ccv_nnc_tensor_free(x);

  ccv_nnc_tensor_free(w);

  ccv_nnc_tensor_free(y);

  ccv_nnc_tensor_free(r);

  ccv_nnc_tensor_free(dy);

  ccv_nnc_tensor_free(dx);

  ccv_nnc_tensor_free(dw);

}

#include "case_main.h"