Huawei_Technology
/
MindSpore-AKG
Not watched
1
0
Fork 0
Code
Releases 1 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: efe42ee8fe
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'efe42ee8fe'
${ noResults }
MindSpore-AKG/tests/common/test_run/lstm_rnn_run.py

223 lines
12 kB
Raw Blame History 

  1. # Copyright 2019 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. 

  15. import numpy as np

  16. from tests.common.tensorio import compare_tensor

  17. from akg.utils import kernel_exec as utils

  18. from tests.common.test_op import lstm_rnn

  19. from tests.common.gen_random import random_gaussian

  20. 

  21. def sigmoid(x):

  22.     return 1 / (1 + np.exp(-x))

  23. 

  24. 

  25. def lstmcell_run(shape, dtype, kernel_name="lstmcell", attrs={}):

  26.     # shape: batch_size, input_size, hidden_size

  27.     batch_size = shape[0]

  28.     input_size = shape[1]

  29.     hidden_size = shape[2]

  30.     W_ih_shape = (4 * hidden_size, input_size,)

  31.     W_hh_shape = (4 * hidden_size, hidden_size,)

  32.     b_shape = (4 * hidden_size,)

  33.     c_prev_shape = (batch_size, hidden_size,)

  34.     h_prev_shape = (batch_size, hidden_size,)

  35.     x_shape = (batch_size, input_size,)

  36. 

  37.     print("lstmcell - ")

  38.     op_attrs = []

  39. 

  40.     if 'tuning' in attrs.keys():

  41.         t = attrs.get("tuning", False)

  42.         kernel_name = attrs.get("kernel_name", False)

  43.         mod = utils.op_build_test(lstm_rnn.lstmcell,

  44.                                   [x_shape, h_prev_shape, c_prev_shape, W_ih_shape, W_hh_shape, b_shape, b_shape, ],

  45.                                   [dtype, dtype, dtype, dtype, dtype, dtype, dtype],

  46.                                   op_attrs=op_attrs, kernel_name=kernel_name, attrs=attrs, tuning=t)

  47.         if t:

  48.             W_hh, W_ih, b_hh, b_ih, c, c_prev, expect_c, expect_h, h, h_prev, x = gen_lstmcell_data(W_hh_shape,

  49.                                                                                                     W_ih_shape,

  50.                                                                                                     b_shape,

  51.                                                                                                     c_prev_shape,

  52.                                                                                                     dtype, h_prev_shape,

  53.                                                                                                     hidden_size,

  54.                                                                                                     x_shape)

  55.             return mod, (expect_c, expect_h), {"args": (x, h_prev, c_prev, W_ih, W_hh, b_ih, b_hh, h, c), 'outputs': (-2, -1), 'tuning': False}

  56.         else:

  57.             return mod

  58.     else:

  59.         mod = utils.op_build_test(lstm_rnn.lstmcell,

  60.                                   [x_shape, h_prev_shape, c_prev_shape, W_ih_shape, W_hh_shape, b_shape, b_shape, ],

  61.                                   [dtype, dtype, dtype, dtype, dtype, dtype, dtype],

  62.                                   op_attrs=op_attrs, kernel_name=kernel_name, attrs=attrs)

  63.         W_hh, W_ih, b_hh, b_ih, c, c_prev, expect_c, expect_h, h, h_prev, x = gen_lstmcell_data(W_hh_shape, W_ih_shape,

  64.                                                                                                 b_shape, c_prev_shape,

  65.                                                                                                 dtype, h_prev_shape,

  66.                                                                                                 hidden_size, x_shape)

  67.         h, c = utils.mod_launch(mod, (x, h_prev, c_prev, W_ih, W_hh, b_ih, b_hh, h, c), outputs=(-2, -1),

  68.                                 expect=(expect_h, expect_c))

  69. 

  70.         assert_res = True

  71.         assert_res &= compare_tensor(h, expect_h, rtol=5e-02, atol=5e-02, equal_nan=True)

  72.         print("act_h_output = ", h)

  73.         print("expect_h_output = ", expect_h)

  74.         print("LSTM_cell assert_res_h = ", assert_res)

  75.         assert_res &= compare_tensor(c, expect_c, rtol=5e-02, atol=5e-02, equal_nan=True)

  76.         print("act_c_output = ", c)

  77.         print("expect_c_output = ", expect_c)

  78.         print("LSTM_cell assert_res = ", assert_res)

  79.         # input("Press ENTER...")

  80. 

  81.         return (x, h_prev, c_prev, W_ih, W_hh, b_ih, b_hh), (h, c), (expect_h, expect_c), assert_res

  82. 

  83. 

  84. def gen_lstmcell_data(W_hh_shape, W_ih_shape, b_shape, c_prev_shape, dtype, h_prev_shape, hidden_size, x_shape):

  85.     W_ih = random_gaussian(W_ih_shape, miu=0.1, sigma=0.1).astype(dtype)

  86.     W_hh = random_gaussian(W_hh_shape, miu=0.1, sigma=0.1).astype(dtype)

  87.     b_ih = random_gaussian(b_shape, miu=0.1, sigma=0.1).astype(dtype)

  88.     b_hh = random_gaussian(b_shape, miu=0.1, sigma=0.1).astype(dtype)

  89.     c_prev = random_gaussian(c_prev_shape, miu=0.1, sigma=0.1).astype(dtype)

  90.     h_prev = random_gaussian(h_prev_shape, miu=0.1, sigma=0.1).astype(dtype)

  91.     x = random_gaussian(x_shape, miu=0.1, sigma=0.1).astype(dtype)

  92.     np_hx = np.concatenate((x, h_prev), axis=1)

  93.     np_wx = np.concatenate((W_ih, W_hh), axis=1)

  94.     np_t = np.dot(np_hx, np_wx.transpose(1, 0)) + b_ih + b_hh

  95.     np_i = sigmoid(np_t[:, 0: hidden_size])

  96.     np_f = sigmoid(np_t[:, hidden_size: 2 * hidden_size])

  97.     np_c_ = np.tanh(np_t[:, 2 * hidden_size: 3 * hidden_size])

  98.     np_o = sigmoid(np_t[:, 3 * hidden_size: 4 * hidden_size])

  99.     expect_c = np.add(np.multiply(np_f, c_prev), np.multiply(np_i, np_c_))

  100.     expect_h = np.multiply(np_o, np.tanh(expect_c))

  101.     h = np.full(h_prev.shape, np.nan, dtype)

  102.     c = np.full(c_prev.shape, np.nan, dtype)

  103.     return W_hh, W_ih, b_hh, b_ih, c, c_prev, expect_c, expect_h, h, h_prev, x

  104. 

  105. 

  106. def rnn_tanh_cell_run(shape, dtype, kernel_name="rnn_tanh_cell", attrs={}):

  107.     # shape: batch_size, input_size, hidden_size

  108.     batch_size = shape[0]

  109.     input_size = shape[1]

  110.     hidden_size = shape[2]

  111.     W_ih_shape = (hidden_size, input_size,)

  112.     W_hh_shape = (hidden_size, hidden_size,)

  113.     b_shape = (hidden_size,)

  114.     h_prev_shape = (batch_size, hidden_size,)

  115.     x_shape = (batch_size, input_size,)

  116. 

  117.     print("rnn_tanh_cell - ")

  118.     op_attrs = []

  119. 

  120.     if 'tuning' in attrs.keys():

  121.         t = attrs.get("tuning", False)

  122.         kernel_name = attrs.get("kernel_name", False)

  123.         mod = utils.op_build_test(lstm_rnn.rnn_tanh_cell,

  124.                                   [x_shape, h_prev_shape, W_ih_shape, W_hh_shape, b_shape, b_shape, ],

  125.                                   [dtype, dtype, dtype, dtype, dtype, dtype],

  126.                                   op_attrs=op_attrs, kernel_name=kernel_name, attrs=attrs, tuning=t)

  127.         if t:

  128.             W_hh, W_ih, b_hh, b_ih, expect, h, h_prev, x = gen_rnn_tanh_cell_data(W_hh_shape, W_ih_shape, b_shape,

  129.                                                                                   dtype, h_prev_shape, x_shape)

  130.             return mod, expect, (x, h_prev, W_ih, W_hh, b_ih, b_hh, h)

  131.         else:

  132.             return mod

  133.     else:

  134.         mod = utils.op_build_test(lstm_rnn.rnn_tanh_cell,

  135.                                   [x_shape, h_prev_shape, W_ih_shape, W_hh_shape, b_shape, b_shape, ],

  136.                                   [dtype, dtype, dtype, dtype, dtype, dtype],

  137.                                   op_attrs=op_attrs, kernel_name=kernel_name, attrs=attrs)

  138.         W_hh, W_ih, b_hh, b_ih, expect, h, h_prev, x = gen_rnn_tanh_cell_data(W_hh_shape, W_ih_shape, b_shape, dtype,

  139.                                                                               h_prev_shape, x_shape)

  140.         h = utils.mod_launch(mod, (x, h_prev, W_ih, W_hh, b_ih, b_hh, h))

  141.         assert_res = compare_tensor(h, expect, rtol=5e-02, atol=5e-02, equal_nan=True)

  142.         # print("act_h_output = ", h)

  143.         # print("expect_h_output = ", expect)

  144.         print("RNN_tanh_cell assert_res = ", assert_res)

  145. 

  146.         return (x, h_prev, W_ih, W_hh, b_ih, b_hh), h, expect, assert_res

  147. 

  148. 

  149. def gen_rnn_tanh_cell_data(W_hh_shape, W_ih_shape, b_shape, dtype, h_prev_shape, x_shape):

  150.     x = random_gaussian(x_shape, miu=0.1, sigma=0.1).astype(dtype)

  151.     h_prev = random_gaussian(h_prev_shape, miu=0.1, sigma=0.1).astype(dtype)

  152.     W_ih = random_gaussian(W_ih_shape, miu=0.1, sigma=0.1).astype(dtype)

  153.     W_hh = random_gaussian(W_hh_shape, miu=0.1, sigma=0.1).astype(dtype)

  154.     b_ih = random_gaussian(b_shape, miu=0.1, sigma=0.1).astype(dtype)

  155.     b_hh = random_gaussian(b_shape, miu=0.1, sigma=0.1).astype(dtype)

  156.     np_igates = np.dot(x, W_ih.transpose(1, 0)) + b_ih

  157.     np_hgates = np.dot(h_prev, W_hh.transpose(1, 0)) + b_hh

  158.     expect = np.tanh(np_igates + np_hgates)

  159.     h = np.full(h_prev.shape, np.nan, dtype)

  160.     return W_hh, W_ih, b_hh, b_ih, expect, h, h_prev, x

  161. 

  162. 

  163. def rnn_relu_cell_run(shape, dtype, kernel_name="rnn_relu_cell", attrs={}):

  164.     # shape: batch_size, input_size, hidden_size

  165.     batch_size = shape[0]

  166.     input_size = shape[1]

  167.     hidden_size = shape[2]

  168.     W_ih_shape = (hidden_size, input_size,)

  169.     W_hh_shape = (hidden_size, hidden_size,)

  170.     b_shape = (hidden_size,)

  171.     h_prev_shape = (batch_size, hidden_size,)

  172.     x_shape = (batch_size, input_size,)

  173. 

  174.     print("rnn_relu6_cell - ")

  175.     op_attrs = []

  176. 

  177.     if 'tuning' in attrs.keys():

  178.         t = attrs.get("tuning", False)

  179.         kernel_name = attrs.get("kernel_name", False)

  180.         mod = utils.op_build_test(lstm_rnn.rnn_relu_cell,

  181.                                   [x_shape, h_prev_shape, W_ih_shape, W_hh_shape, b_shape, b_shape, ],

  182.                                   [dtype, dtype, dtype, dtype, dtype, dtype],

  183.                                   op_attrs=op_attrs, kernel_name=kernel_name, attrs=attrs, tuning=t)

  184.         if t:

  185.             W_hh, W_ih, b_hh, b_ih, expect, h, h_prev, x = gen_rnn_relu_cell_data(W_hh_shape, W_ih_shape, b_shape,

  186.                                                                                   dtype, h_prev_shape, x_shape)

  187.             return mod, expect, (x, h_prev, W_ih, W_hh, b_ih, b_hh, h)

  188.         else:

  189.             return mod

  190.     else:

  191.         mod = utils.op_build_test(lstm_rnn.rnn_relu_cell,

  192.                                   [x_shape, h_prev_shape, W_ih_shape, W_hh_shape, b_shape, b_shape, ],

  193.                                   [dtype, dtype, dtype, dtype, dtype, dtype],

  194.                                   op_attrs=op_attrs, kernel_name=kernel_name, attrs=attrs)

  195.         W_hh, W_ih, b_hh, b_ih, expect, h, h_prev, x = gen_rnn_relu_cell_data(W_hh_shape, W_ih_shape, b_shape, dtype,

  196.                                                                               h_prev_shape, x_shape)

  197.         h = utils.mod_launch(mod, (x, h_prev, W_ih, W_hh, b_ih, b_hh, h))

  198.         assert_res = compare_tensor(h, expect, rtol=5e-02, atol=5e-02, equal_nan=True)

  199.         # print("act_h_output = ", h)

  200.         # print("expect_h_output = ", expect)

  201.         print("RNN_relu6_cell assert_res = ", assert_res)

  202. 

  203.         return (x, h_prev, W_ih, W_hh, b_ih, b_hh), h, expect, assert_res

  204. 

  205. 

  206. def gen_rnn_relu_cell_data(W_hh_shape, W_ih_shape, b_shape, dtype, h_prev_shape, x_shape):

  207.     x = random_gaussian(x_shape, miu=0.1, sigma=0.1).astype(dtype)

  208.     h_prev = random_gaussian(h_prev_shape, miu=0.1, sigma=0.1).astype(dtype)

  209.     W_ih = random_gaussian(W_ih_shape, miu=0.1, sigma=0.1).astype(dtype)

  210.     W_hh = random_gaussian(W_hh_shape, miu=0.1, sigma=0.1).astype(dtype)

  211.     b_ih = random_gaussian(b_shape, miu=0.1, sigma=0.1).astype(dtype)

  212.     b_hh = random_gaussian(b_shape, miu=0.1, sigma=0.1).astype(dtype)

  213.     np_igates = np.dot(x, W_ih.transpose(1, 0)) + b_ih

  214.     np_hgates = np.dot(h_prev, W_hh.transpose(1, 0)) + b_hh

  215.     np_t = np_igates + np_hgates

  216.     # relu6

  217.     zero = np.full(np_t.shape, 0, dtype)

  218.     six = np.full(np_t.shape, 6, dtype)

  219.     max = np.maximum(np_t, zero)

  220.     expect = np.minimum(max, six)

  221.     h = np.full(h_prev.shape, np.nan, dtype)

  222.     return W_hh, W_ih, b_hh, b_ih, expect, h, h_prev, x