class_docstr: Variational Autoencoder for Collaborative Filtering.
  
  Parameters
  ----------
  k: int, optional, default: 10
      The dimension of the stochastic user factors ``z''.
  
  autoencoder_structure: list, default: [20]
      The number of neurons of encoder/decoder layer for VAE.
      For example, autoencoder_structure = [200], the VAE structure will be [num_items, 200, k, 200, num_items].
  
  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 the observations.
      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: 100
      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 as in beta-VAE.
  
  name: string, optional, default: 'VAECF'
      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.
  
  References
  ----------
  * Liang, Dawen, Rahul G. Krishnan, Matthew D. Hoffman, and Tony Jebara. "Variational autoencoders for collaborative filtering."     In Proceedings of the 2018 World Wide Web Conference on World Wide Web, pp. 689-698.
code: def __init__(
      self,
      name="VAECF",
      k=10,
      autoencoder_structure=[20],
      act_fn="tanh",
      likelihood="mult",
      n_epochs=100,
      batch_size=100,
      learning_rate=0.001,
      beta=1.0,
      trainable=True,
      verbose=False,
      seed=None,
      use_gpu=False,
  ):
      Recommender.__init__(
          self, name=name, trainable=trainable, verbose=verbose
      )
      self.k = k
      self.autoencoder_structure = autoencoder_structure
      self.act_fn = act_fn
      self.likelihood = likelihood
      self.batch_size = batch_size
      self.n_epochs = n_epochs
      self.learning_rate = learning_rate
      self.beta = beta
      self.seed = seed
      self.use_gpu = use_gpu
  
file_path: cornac/cornac/models/vaecf/recom_vaecf.py
imports: import numpy
  from ..recommender import Recommender
  from ...exception import ScoreException
label_desc: Use image node_id 1 to create a new VAECF object from inherited base classes: Recommender with example: obj = VAECF(name, k, autoencoder_structure, act_fn, likelihood, n_epochs, batch_size, learning_rate, beta, trainable, verbose, seed, use_gpu)