Example #1
0
    def test_dnc_optimization(self):
        batch_size = 7
        time_steps = 15
        input_size = 30
        controller_config = {
            "hidden_size": 64,
        }
        memory_config = {
            'read_heads_num': 10,
            'word_size': 9,
            'words_num': 27,
        }
        output_size = 36

        dnc = DNC(controller_config,
                  memory_config,
                  output_size,
                  classic_dnc_output=False)
        dnc_initial_state = dnc.initial_state(batch_size)
        inputs = tf.random_normal([time_steps, batch_size, input_size])
        dnc_output_op, _ = rnn.dynamic_rnn(cell=dnc,
                                           inputs=inputs,
                                           initial_state=dnc_initial_state,
                                           time_major=True)

        targets = np.random.rand(time_steps, batch_size, output_size)
        loss = tf.reduce_mean(tf.square(dnc_output_op - targets))
        optimizier_op = tf.train.GradientDescentOptimizer(5).minimize(loss)
        init_op = tf.global_variables_initializer()

        with self.test_session():
            init_op.run()
            optimizier_op.run()
Example #2
0
    def test_dnc_output_shape(self):
        batch_size = 3
        controller_config = {
            "hidden_size": 64,
        }
        memory_config = {
            'read_heads_num': 7,
            'word_size': 5,
            'words_num': 16,
        }
        output_size = 10

        for input_size in [10, 17, 49]:
            dnc = DNC(controller_config,
                      memory_config,
                      output_size,
                      classic_dnc_output=False)
            initial_state = dnc.initial_state(batch_size)
            input_shape = dnc._W * dnc._R + input_size
            test_input = np.random.uniform(
                -3, 3, (batch_size, input_shape)).astype(np.float32)
            example_output_op, _ = dnc(
                tf.convert_to_tensor(test_input),
                initial_state,
            )
            init = tf.global_variables_initializer()

            with self.test_session() as sess:
                init.run()
                example_output = sess.run(example_output_op)
            self.assertEqual(example_output.shape, (batch_size, output_size))