yapf

    return R

class AlphaShares(Layer):

def AlphaShare(**kwargs):

  """

  This method should be used when constructing AlphaShare layers from Sluice Networks

  References:

  Sluice networks: Learning what to share between loosely related tasks

  https://arxiv.org/abs/1705.08142

  """

  output_layers = []

  alpha_share = AlphaShareLayer(**kwargs)

  num_outputs = len(kwargs['in_layers'])

  for num_layer in range(0, num_outputs):

    output_layers.append(

        LayerSplitter(in_layers=alpha_share, output_num=num_layer))

  return output_layers

class AlphaShareLayer(Layer):

  """

    Part of a sluice network. Adds alpha parameters to control

    sharing between the main and auxillary tasks

    """

  def __init__(self, **kwargs):

        super(AlphaShares, self).__init__(**kwargs)

    super(AlphaShareLayer, self).__init__(**kwargs)

  def create_tensor(self, in_layers=None, set_tensors=True, **kwargs):

    inputs = self._get_input_tensors(in_layers)

    subspaces = tf.reshape(tf.stack(subspaces), [n_alphas, -1])

    # create the alpha learnable parameters

        alphas = tf.Variable(tf.random_normal(

            [n_alphas, n_alphas]), name='alphas')

    alphas = tf.Variable(tf.random_normal([n_alphas, n_alphas]), name='alphas')

    subspaces = tf.matmul(alphas, subspaces)

    out_tensor = []

    tmp_tensor = []

    for row in range(n_alphas):

            tmp_tensor.append(tf.reshape(

                subspaces[row, ], [-1, subspace_size]))

      tmp_tensor.append(tf.reshape(subspaces[row,], [-1, subspace_size]))

      count += 1

      if (count == 2):

        out_tensor.append(tf.concat(tmp_tensor, 1))

  def set_tensors(self, tensor):

    self.num_outputs, self.out_tensor, self.alphas = tensor

def AlphaShare(**kwargs):

  output_layers = []

  alpha_share = AlphaShares(**kwargs)

  num_outputs = len(kwargs['in_layers'])

  for num_layer in range(0, num_outputs):

    output_layers.append(LayerSplitter(in_layers = alpha_share, output_num=num_layer))

  return output_layers

class LayerSplitter(Layer):

  """

    Returns the nth output of a layer

    Assumes out_tensor has shape [x, :] where x is the total number of intended output tensors

    """

  def __init__(self, output_num, **kwargs):