'Construct an efficient incremental generator.'

def _create_generator(self, input_batch, global_condition_batch):

    init_ops = []
    push_ops = []
    outputs = []
    current_layer = input_batch
    q = tf.FIFOQueue(1, dtypes=tf.float32, shapes=(self.batch_size, self.quantization_channels))
    init = q.enqueue_many(tf.zeros((1, self.batch_size, self.quantization_channels)))
    current_state = q.dequeue()
    push = q.enqueue([current_layer])
    init_ops.append(init)
    push_ops.append(push)
    current_layer = self._generator_causal_layer(current_layer, current_state)
    with tf.name_scope('dilated_stack'):
        for (layer_index, dilation) in enumerate(self.dilations):
            with tf.name_scope('layer{}'.format(layer_index)):
                q = tf.FIFOQueue(dilation, dtypes=tf.float32, shapes=(self.batch_size, self.residual_channels))
                init = q.enqueue_many(tf.zeros((dilation, self.batch_size, self.residual_channels)))
                current_state = q.dequeue()
                push = q.enqueue([current_layer])
                init_ops.append(init)
                push_ops.append(push)
                (output, current_layer) = self._generator_dilation_layer(current_layer, current_state, layer_index, dilation, global_condition_batch)
                outputs.append(output)
    self.init_ops = init_ops
    self.push_ops = push_ops
    with tf.name_scope('postprocessing'):
        variables = self.variables['postprocessing']
        w1 = variables['postprocess1']
        w2 = variables['postprocess2']
        if self.use_biases:
            b1 = variables['postprocess1_bias']
            b2 = variables['postprocess2_bias']
        total = sum(outputs)
        transformed1 = tf.nn.relu(total)
        conv1 = tf.matmul(transformed1, w1[0, :, :])
        if self.use_biases:
            conv1 = (conv1 + b1)
        transformed2 = tf.nn.relu(conv1)
        conv2 = tf.matmul(transformed2, w2[0, :, :])
        if self.use_biases:
            conv2 = (conv2 + b2)
    return conv2
