Merge pull request #783 from proteneer/WIP3

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

class L1Loss(Layer):

  def __init__(self, **kwargs):

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

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

    inputs = self._get_input_tensors(in_layers, True)

    guess, label = inputs[0], inputs[1]

    out_tensor = tf.reduce_mean(

        tf.abs(guess - label), axis=list(range(1, len(label.shape))))

    if set_tensors:

      self.out_tensor = out_tensor

    return out_tensor

class L2Loss(Layer):

  def __init__(self, **kwargs):

    self.transform_y = transform_y

    self.transform_w = transform_w

    self.compute_graph = self.build()

    self.sess = tf.Session(graph=self.compute_graph)

    self.transform_batch_size = 128

    assert self.transform_X

    assert not self.transform_y

    assert not self.transform_w

  def transform_array(self, X, y, w):

    if self.transform_X:

      n_samples = X.shape[0]

      batches = np.linspace(0, n_samples, int(n_samples / 100) + 1).astype(int)

      X_out = []

      sess = tf.Session(graph=self.compute_graph)

      num_transformed = 0

      for i, start in enumerate(batches):

        if start == batches[-1]:

          X_batch = X[start:]

        else:

          X_batch = X[start:batches[i + 1]]

        output = sess.run([self.outputs], feed_dict={self.inputs: X_batch})[0]

      start = 0

      batch_size = self.transform_batch_size

      while True:

        end = min((start + 1) * batch_size, X.shape[0])

        X_batch = X[(start * batch_size):end]

        output = self.sess.run(

            [self.outputs], feed_dict={self.inputs: X_batch})[0]

        X_out.append(output)

        num_transformed = num_transformed + X_batch.shape[0]

        print('%i samples transformed' % num_transformed)

        start += 1

        if end >= len(X):

          break

      X_new = np.concatenate(X_out, axis=0)

      assert X_new.shape[0] == X.shape[0]