def synthesize(self, in_tensor, out_tensor, mask):
        # All sequences in a minibatch are the same length for convenience
        seq_len = np.random.randint(1, self.seq_len_max + 1)
        repeat_count = np.random.randint(1, self.repeat_count_max + 1)
        time_steps = self.time_steps_func(seq_len, repeat_count)

        # Get the minibatch specific numpy buffers
        inputs, outputs = super(RepeatCopyTask, self).fetch_io(time_steps)

        # Set the start bit
        inputs[-2, :self.be.bsz] = 1

        # Generate the sequence to be copied
        seq = np.random.randint(2,
                                size=(self.vec_size,
                                      seq_len * self.be.bsz))

        # Set the repeat count
        # TODO: should we normalize repeat count?
        stop_loc = self.be.bsz * (seq_len + 1)
        inputs[-1, stop_loc:stop_loc + self.be.bsz] = repeat_count

        # Place the actual sequence to copy in inputs
        inputs[:self.vec_size, self.be.bsz:stop_loc] = seq

        # Now place that same sequence repeat_copy times in outputs
        for i in range(repeat_count):
            start = self.be.bsz * ((i + 1) * seq_len + 2)
            stop = start + seq_len * self.be.bsz
            outputs[:-1, start:stop] = seq

        # Place the output finish bit
        outputs[-1, -self.be.bsz:] = 1

        # Fill the device minibatch buffers
        super(RepeatCopyTask, self).fill_buffers(time_steps, inputs, outputs,
                                                 in_tensor, out_tensor, mask)
Test to make sure we can set the monitor timeout value
dataset/ETHPy150Open NervanaSystems/neon/neon/data/ticker.py/RepeatCopyTask.synthesize--crossover with--dataset/ETHPy150Open saltstack/salt/tests/unit/modules/win_powercfg_test.py/PowerCfgTestCase.test_set_monitor_timeout