class_docstr: SSE-PT Model
  
  :Citation:
  
  Wu L., Li S., Hsieh C-J., Sharpnack J., SSE-PT: Sequential Recommendation
  Via Personalized Transformer, RecSys, 2020.
  TF 1.x codebase: https://github.com/SSE-PT/SSE-PT
  TF 2.x codebase (SASREc): https://github.com/nnkkmto/SASRec-tf2
docstr: Model prediction for candidate (negative) items
docstr_tok: ["Model","prediction","for","candidate","(","negative",")","items"]
code: def predict(self, inputs):
      """
      Model prediction for candidate (negative) items
  
      """
      training = False
      user = inputs["user"]
      input_seq = inputs["input_seq"]
      candidate = inputs["candidate"]
  
      mask = tf.expand_dims(
          tf.cast(tf.not_equal(input_seq, 0), tf.float32), -1
      )
      seq_embeddings, positional_embeddings = self.embedding(
          input_seq
      )  # (1, s, h)
  
      u0_latent = self.user_embedding_layer(user)
      u0_latent = u0_latent * (
          self.user_embedding_dim**0.5
      )  # (1, 1, h)
      u0_latent = tf.squeeze(u0_latent, axis=0)  # (1, h)
      test_user_emb = tf.tile(
          u0_latent, [1 + self.num_neg_test, 1]
      )  # (101, h)
  
      u_latent = self.user_embedding_layer(user)
      u_latent = u_latent * (
          self.user_embedding_dim**0.5
      )  # (b, 1, h)
      u_latent = tf.tile(
          u_latent, [1, tf.shape(input_seq)[1], 1]
      )  # (b, s, h)
  
      seq_embeddings = tf.reshape(
          tf.concat([seq_embeddings, u_latent], 2),
          [tf.shape(input_seq)[0], -1, self.hidden_units],
      )
      seq_embeddings += positional_embeddings  # (b, s, h1 + h2)
  
      seq_embeddings *= mask
      seq_attention = seq_embeddings
      seq_attention = self.encoder(seq_attention, training, mask)
      seq_attention = self.layer_normalization(
          seq_attention
      )  # (b, s, h1+h2)
      seq_emb = tf.reshape(
          seq_attention,
          [
              tf.shape(input_seq)[0] * self.seq_max_len,
              self.hidden_units,
          ],
      )  # (b*s1, h1+h2)
  
      candidate_emb = self.item_embedding_layer(
          candidate
      )  # (b, s2, h2)
      candidate_emb = tf.squeeze(candidate_emb, axis=0)  # (s2, h2)
      candidate_emb = tf.reshape(
          tf.concat([candidate_emb, test_user_emb], 1),
          [-1, self.hidden_units],
      )  # (b*s2, h1+h2)
  
      candidate_emb = tf.transpose(
          candidate_emb, perm=[1, 0]
      )  # (h1+h2, b*s2)
      test_logits = tf.matmul(seq_emb, candidate_emb)  # (b*s1, b*s2)
  
      test_logits = tf.reshape(
          test_logits,
          [
              tf.shape(input_seq)[0],
              self.seq_max_len,
              1 + self.num_neg_test,
          ],
      )  # (1, s, 101)
      test_logits = test_logits[:, -1, :]  # (1, 101)
      return test_logits
  
file_path: recommenders/recommenders/models/sasrec/ssept.py
imports: import tensorflow
  from recommenders.models.sasrec.model import SASREC, Encoder, LayerNormalization
label_desc: Use image node_id 3 for calling the SSEPT obj's underlying member method code with example usage: obj.predict(inputs) and returns: test_logits