class_docstr: Collaborative Context Poisson Factorization.
  
  Parameters
  ----------
  k: int, optional, default: 100
      The dimension of the latent factors.
  
  max_iter: int, optional, default: 100
      Maximum number of iterations for variational C2PF.
  
  variant: string, optional, default: 'c2pf'
      C2pf's variant: c2pf: 'c2pf', 'tc2pf' (tied-c2pf) or 'rc2pf' (reduced-c2pf).         Please refer to the original paper for details.
  
  name: string, optional, default: None
      The name of the recommender model. If None,         then "variant" is used as the default name of the model.
  
  trainable: boolean, optional, default: True
      When False, the model is not trained and Cornac assumes that the model already         pre-trained (Theta, Beta and Xi are not None).
  
  Item_context: See "cornac/examples/c2pf_example.py" in the GitHub repo for an example of how to use         cornac's graph modality to load and provide "item context" for C2PF.
  
  init_params: dict, optional, default: None
      List of initial parameters, e.g., init_params = {'G_s':G_s, 'G_r':G_r, 'L_s':L_s, 'L_r':L_r, 'L2_s':L2_s, 'L2_r':L2_r, 'L3_s':L3_s, 'L3_r': L3_r}
  
      Theta: ndarray, shape (n_users, k)
          The expected user latent factors.
  
      Beta: ndarray, shape (n_items, k)
          The expected item latent factors.
  
      Xi: ndarray, shape (n_items, k)
          The expected context item latent factors multiplied by context effects Kappa.
          
      G_s: ndarray, shape (n_users, k)
          Represent the "shape" parameters of Gamma distribution over Theta.
          
      G_r: ndarray, shape (n_users, k)
          Represent the "rate" parameters of Gamma distribution over Theta. 
      
      L_s: ndarray, shape (n_items, k)
          Represent the "shape" parameters of Gamma distribution over Beta.
          
      L_r: ndarray, shape (n_items, k)
          Represent the "rate" parameters of Gamma distribution over Beta. 
      
      L2_s: ndarray, shape (n_items, k)
          Represent the "shape" parameters of Gamma distribution over Xi.
          
      L2_r: ndarray, shape (n_items, k)
          Represent the "rate" parameters of Gamma distribution over Xi.
           
      L3_s: ndarray
          Represent the "shape" parameters of Gamma distribution over Kappa.
          
      L3_r: ndarray 
          Represent the "rate" parameters of Gamma distribution over Kappa.
  
  References
  ----------
  * Salah, Aghiles, and Hady W. Lauw. A Bayesian Latent Variable Model of User Preferences with Item Context.     In IJCAI, pp. 2667-2674. 2018.
docstr: Fit the model to observations.
  
  Parameters
  ----------
  train_set: :obj:`cornac.data.Dataset`, required
      User-Item preference data as well as additional modalities.
  
  val_set: :obj:`cornac.data.Dataset`, optional, default: None
      User-Item preference data for model selection purposes (e.g., early stopping).
  
  Returns
  -------
  self : object
docstr_tok: ["Fit","the","model","to","observations",".","Parameters","--","--","--","--","--","train_set",":",":","obj",":","`","cornac.data.Dataset","`",",","required","User-Item","preference","data","as","well","as","additional","modalities",".","val_set",":",":","obj",":","`","cornac.data.Dataset","`",",","optional",",","default",":","None","User-Item","preference","data","for","model","selection","purposes","(","e.g.",",","early","stopping",")",".","Returns","--","--","--","-","self",":","object"]
code: def fit(self, train_set, val_set=None):
      """Fit the model to observations.
  
      Parameters
      ----------
      train_set: :obj:`cornac.data.Dataset`, required
          User-Item preference data as well as additional modalities.
  
      val_set: :obj:`cornac.data.Dataset`, optional, default: None
          User-Item preference data for model selection purposes (e.g., early stopping).
  
      Returns
      -------
      self : object
      """
      Recommender.fit(self, train_set, val_set)
  
      X = train_set.csr_matrix
  
      # recover the striplet sparse format from csc sparse matrix X (needed to feed c++)
      (rid, cid, val) = sp.find(X)
      val = np.array(val, dtype="float32")
      rid = np.array(rid, dtype="int32")
      cid = np.array(cid, dtype="int32")
      tX = np.concatenate(
          (
              np.concatenate(([rid], [cid]), axis=0).T,
              val.reshape((len(val), 1)),
          ),
          axis=1,
      )
      del rid, cid, val
  
      if self.trainable:
          # use pre-trained params if exists, otherwise from constructor
          init_params = {
              "G_s": self.Gs,
              "G_r": self.Gr,
              "L_s": self.Ls,
              "L_r": self.Lr,
              "L2_s": self.L2s,
              "L2_r": self.L2r,
              "L3_s": self.L3s,
              "L3_r": self.L3r,
          }
  
          train_item_indices = set(train_set.uir_tuple[1])
          (rid, cid, val) = train_set.item_graph.get_train_triplet(
              train_item_indices, train_item_indices
          )
          context_info = np.hstack(
              (
                  rid.reshape(-1, 1),
                  cid.reshape(-1, 1),
                  val.reshape(-1, 1),
              )
          )
  
          if self.variant == "c2pf":
              res = c2pf.c2pf(
                  tX,
                  X.shape[0],
                  X.shape[1],
                  context_info,
                  X.shape[1],
                  X.shape[1],
                  self.k,
                  self.max_iter,
                  init_params,
              )
          elif self.variant == "tc2pf":
              res = c2pf.t_c2pf(
                  tX,
                  X.shape[0],
                  X.shape[1],
                  context_info,
                  X.shape[1],
                  X.shape[1],
                  self.k,
                  self.max_iter,
                  init_params,
              )
          elif self.variant == "rc2pf":
              res = c2pf.r_c2pf(
                  tX,
                  X.shape[0],
                  X.shape[1],
                  context_info,
                  X.shape[1],
                  X.shape[1],
                  self.k,
                  self.max_iter,
                  init_params,
              )
          else:
              res = c2pf.c2pf(
                  tX,
                  X.shape[0],
                  X.shape[1],
                  context_info,
                  X.shape[1],
                  X.shape[1],
                  self.k,
                  self.max_iter,
                  init_params,
              )
  
          self.Theta = sp.csc_matrix(res["Z"]).todense()
          self.Beta = sp.csc_matrix(res["W"]).todense()
          self.Xi = sp.csc_matrix(res["Q"]).todense()
  
          # overwrite init_params for future fine-tuning
          self.Gs = np.asarray(res["G_s"])
          self.Gr = np.asarray(res["G_r"])
          self.Ls = np.asarray(res["L_s"])
          self.Lr = np.asarray(res["L_r"])
          self.L2s = np.asarray(res["L2_s"])
          self.L2r = np.asarray(res["L2_r"])
          self.L3s = np.asarray(res["L3_s"])
          self.L3r = np.asarray(res["L3_r"])
  
      elif self.verbose:
          print(
              "%s is trained already (trainable = False)" % (self.name)
          )
  
      return self
  
file_path: cornac/cornac/models/c2pf/recom_c2pf.py
imports: import numpy
  import scipy.sparse
  from cornac.models.c2pf import c2pf
  from ..recommender import Recommender
  from ..recommender import ANNMixin, MEASURE_DOT
label_desc: Use image node_id 2 for calling the C2PF obj's underlying member method code with example usage: obj.fit(train_set, val_set) and returns: self