using tf.losses.hinge_loss

class Hingeloss(Layer):

  def __init__(self, in_layers=None, weights, batch_size, labels, reg,

               **kwargs):

    """

      Inputs have dimension D, there are C classes, and we operate on minibatches

      of N examples.

      Inputs:

      Weigths: A numpy array of shape (D, C) containing weights.

      batch_size: A numpy array of shape (N, D) containing a minibatch of data.

      labels: A numpy array of shape (N,)

      reg: (float) regularization strength

    """

  def __init__(self, in_layers=None, labels, logits, **kwargs):

    self.weights = weights

    self.batch_size = batch_size

    self.labels = labels

    self.reg = reg

    self.logits = logits

    super(Hingeloss, self).__init__(in_layers, **kwargs)

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

    inputs = self.get_input_tensors(in_layers)

    weights, batch_size, labels, reg = inputs[0], inputs[1], inputs[2], inputs[

        3]

    scores = tf.matmul(batch_size, weights)

    labels_i = scores[np.arange(scores.shape[0]), labels]

    loss_i = tf.maximum(0, scores - tf.transpose(labels_i) + 1)

    loss = tf.reduce_mean(tf.sum(loss_i), axis=1)

    loss = loss + 0.5 * reg * tf.sum(weights * weights)

    out_tensor = loss

    labels, logits = inputs[0], inputs[1]

    out_tensor = tf.losses.hinge_loss(labels, logits)

    if set_tensors:

      self.out_tensor = out_tensor

    return out_tensor

from deepchem.models.tensorgraph.layers import Gather

from deepchem.models.tensorgraph.layers import GraphConv

from deepchem.models.tensorgraph.layers import GraphGather

from deepchem.models.tensorgraph.layers import Hingeloss

from deepchem.models.tensorgraph.layers import Input

from deepchem.models.tensorgraph.layers import InputFifoQueue

from deepchem.models.tensorgraph.layers import InteratomicL2Distances

  def test_hingeloss(self):

    batch_size = 10

    reg = 0.00001

    labels = np.array([0, 1])

    weights = tf.Variable(10)

    input_tensor = np.random.rand(weights, batch_size, labels, reg)

    labels = 2

    logits = 0.0001

    input_tensor = np.random.uniform(labels, logits, [1, 1])

    with self.test_session() as sess:

      input_tensor = tf.convert_to_tensor(input_tensor, dtype=tf.float32)

      out_tensor = Hingeloss()(input_tensor)

      out_tensor = out_tensor.eval()

      assert out_tensor.shape == (batch_size,)

      assert type(out_tensor) is FloatType