class_docstr: Conditional Variational Autoencoder for Collaborative Filtering.
  
  Parameters
  ----------
  z_dim: int, optional, default: 20
      The dimension of the stochastic user factors ``z'' representing the preference information.
  
  h_dim: int, optional, default: 20
      The dimension of the stochastic user factors ``h'' representing the auxiliary data.
  
  autoencoder_structure: list, default: [20]
      The number of neurons of encoder/decoder hidden layer for CVAE.
      For example, when autoencoder_structure = [20],
      the CVAE encoder structures will be [y_dim, 20, z_dim] and [x_dim, 20, h_dim],
      the decoder structure will be [z_dim + h_dim, 20, y_dim], where y and x are respectively the preference and         auxiliary data.
  
  act_fn: str, default: 'tanh'
      Name of the activation function used between hidden layers of the auto-encoder.
      Supported functions: ['sigmoid', 'tanh', 'elu', 'relu', 'relu6']
  
  likelihood: str, default: 'mult'
      Name of the likelihood function used for modeling user preferences.
      Supported choices:
  
      mult: Multinomial likelihood
      bern: Bernoulli likelihood
      gaus: Gaussian likelihood
      pois: Poisson likelihood
  
  n_epochs: int, optional, default: 100
      The number of epochs for SGD.
  
  batch_size: int, optional, default: 128
      The batch size.
  
  learning_rate: float, optional, default: 0.001
      The learning rate for Adam.
  
  beta: float, optional, default: 1.0
      The weight of the KL term KL(q(z|y)||p(z)) as in beta-VAE.
  
  alpha_1: float, optional, default: 1.0
      The weight of the KL term KL(q(h|x)||p(h|x)).
  
  alpha_2: float, optional, default: 1.0
      The weight of the KL term KL(q(h|x)||q(h|y)).
  
  name: string, optional, default: 'CVAECF'
      The name of the recommender model.
  
  trainable: boolean, optional, default: True
      When False, the model is not trained, and Cornac assumes that the model is already         pre-trained.
  
  verbose: boolean, optional, default: False
      When True, some running logs are displayed.
  
  seed: int, optional, default: None
      Random seed for parameters initialization.
  
  use_gpu: boolean, optional, default: False
      If True and your system supports CUDA then training is performed on GPUs.
  
  user auxiliary data : See "cornac/examples/cvaecf_filmtrust.py" for an example of how to use         cornac's graph modality to load and provide the ``user network'' for CVAECF.
  
  References
  ----------
  * Lee, Wonsung, Kyungwoo Song, and Il-Chul Moon. "Augmented variational autoencoders for collaborative filtering      with auxiliary information." Proceedings of ACM CIKM. 2017.
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)
  
      import torch
      from .cvaecf import CVAE, learn
  
      self.device = (
          torch.device("cuda:0")
          if (self.use_gpu and torch.cuda.is_available())
          else torch.device("cpu")
      )
  
      self.r_mat = train_set.matrix
      self.u_adj_mat = train_set.user_graph.matrix
  
      if self.trainable:
          if self.seed is not None:
              torch.manual_seed(self.seed)
              torch.cuda.manual_seed(self.seed)
  
          if not hasattr(self, "cvae"):
              n_items = self.r_mat.shape[1]
              n_users = self.r_mat.shape[0]
              self.cvae = CVAE(
                  self.z_dim,
                  self.h_dim,
                  [n_items] + self.autoencoder_structure,
                  [n_users] + self.autoencoder_structure,
                  self.act_fn,
                  self.likelihood,
              ).to(self.device)
  
          learn(
              self.cvae,
              train_set,
              n_epochs=self.n_epochs,
              batch_size=self.batch_size,
              learn_rate=self.learning_rate,
              beta=self.beta,
              alpha_1=self.alpha_1,
              alpha_2=self.alpha_2,
              verbose=self.verbose,
              device=self.device,
          )
  
      elif self.verbose:
          print(
              "%s is trained already (trainable = False)" % (self.name)
          )
  
      return self
  
file_path: cornac/cornac/models/cvaecf/recom_cvaecf.py
imports: import numpy
  from ..recommender import Recommender
  from ...exception import ScoreException
label_desc: Use image node_id 2 for calling the CVAECF obj's underlying member method code with example usage: obj.fit(train_set, val_set) and returns: self