parameters: (self, item_users, show_progress=True)
docstring: Factorizes the item_users matrix.
  
          After calling this method, the members 'user_factors' and 'item_factors' will be
          initialized with a latent factor model of the input data.
  
          The item_users matrix does double duty here. It defines which items are liked by which
          users (P_iu in the original paper), as well as how much confidence we have that the user
          liked the item (C_iu).
  
          The negative items are implicitly defined: This code assumes that non-zero items in the
          item_users matrix means that the user liked the item. The negatives are left unset in this
          sparse matrix: the library will assume that means Piu = 0 and Ciu = 1 for all these items.
      
          Parameters
          ----------
          item_users: csr_matrix
              Matrix of confidences for the liked items. This matrix should be a csr_matrix where
              the rows of the matrix are the item, the columns are the users that liked that item,
              and the value is the confidence that the user liked the item.
          show_progress : bool, optional
              Whether to show a progress bar during fitting
docstring_summary: Factorizes the item_users matrix.
docstring_tokens: Factorizes the item_users matrix .
function: def fit(self, item_users, show_progress=True):
          """ Factorizes the item_users matrix.
  
          After calling this method, the members 'user_factors' and 'item_factors' will be
          initialized with a latent factor model of the input data.
  
          The item_users matrix does double duty here. It defines which items are liked by which
          users (P_iu in the original paper), as well as how much confidence we have that the user
          liked the item (C_iu).
  
          The negative items are implicitly defined: This code assumes that non-zero items in the
          item_users matrix means that the user liked the item. The negatives are left unset in this
          sparse matrix: the library will assume that means Piu = 0 and Ciu = 1 for all these items.
      
          Parameters
          ----------
          item_users: csr_matrix
              Matrix of confidences for the liked items. This matrix should be a csr_matrix where
              the rows of the matrix are the item, the columns are the users that liked that item,
              and the value is the confidence that the user liked the item.
          show_progress : bool, optional
              Whether to show a progress bar during fitting
          """
          Ciu = item_users
          if not isinstance(Ciu, scipy.sparse.csr_matrix):
              s = time.time()
              log.debug("Converting input to CSR format")
              Ciu = Ciu.tocsr()
              log.debug("Converted input to CSR in %.3fs", time.time() - s)
  
          if Ciu.dtype != np.float32:
              Ciu = Ciu.astype(np.float32)
  
          s = time.time()
          Cui = Ciu.T.tocsr()
          log.debug("Calculated transpose in %.3fs", time.time() - s)
  
          items, users = Ciu.shape
  
          s = time.time()
          # Initialize the variables randomly if they haven't already been set
          if self.user_factors is None:
              np.random.seed(self.seed) ; self.user_factors = np.random.rand(users, self.factors).astype(self.dtype)
          if self.item_factors is None:
              np.random.seed(self.seed) ; self.item_factors = np.random.rand(items, self.factors).astype(self.dtype)
  
          log.debug("Initialized factors in %s", time.time() - s)
  
          # invalidate cached norms and squared factors
          self._item_norms = None
          self._YtY = None
  
          if self.use_gpu:
              return self._fit_gpu(Ciu, Cui, show_progress)
  
          solver = self.solver
  
          log.debug("Running %i ALS iterations", self.iterations)
          with tqdm.tqdm(total=self.iterations, disable=not show_progress) as progress:
              # alternate between learning the user_factors from the item_factors and vice-versa
              for iteration in range(self.iterations):
                  s = time.time()
                  solver(Cui, self.user_factors, self.item_factors, self.regularization,
                         num_threads=self.num_threads)
                  progress.update(.5)
  
                  solver(Ciu, self.item_factors, self.user_factors, self.regularization,
                         num_threads=self.num_threads)
                  progress.update(.5)
  
                  if self.calculate_training_loss:
                      loss = _als.calculate_loss(Cui, self.user_factors, self.item_factors,
                                                 self.regularization, num_threads=self.num_threads)
                      progress.set_postfix({"loss": loss})
  
                  if self.fit_callback:
                      self.fit_callback(iteration, time.time() - s)
  
          if self.calculate_training_loss:
              log.info("Final training loss %.4f", loss)
function_tokens: def fit ( self , item_users , show_progress = True ) : Ciu = item_users if not isinstance ( Ciu , scipy . sparse . csr_matrix ) : s = time . time ( ) log . debug ( "Converting input to CSR format" ) Ciu = Ciu . tocsr ( ) log . debug ( "Converted input to CSR in %.3fs" , time . time ( ) - s ) if Ciu . dtype != np . float32 : Ciu = Ciu . astype ( np . float32 ) s = time . time ( ) Cui = Ciu . T . tocsr ( ) log . debug ( "Calculated transpose in %.3fs" , time . time ( ) - s ) items , users = Ciu . shape s = time . time ( ) # Initialize the variables randomly if they haven't already been set if self . user_factors is None : np . random . seed ( self . seed ) self . user_factors = np . random . rand ( users , self . factors ) . astype ( self . dtype ) if self . item_factors is None : np . random . seed ( self . seed ) self . item_factors = np . random . rand ( items , self . factors ) . astype ( self . dtype ) log . debug ( "Initialized factors in %s" , time . time ( ) - s ) # invalidate cached norms and squared factors self . _item_norms = None self . _YtY = None if self . use_gpu : return self . _fit_gpu ( Ciu , Cui , show_progress ) solver = self . solver log . debug ( "Running %i ALS iterations" , self . iterations ) with tqdm . tqdm ( total = self . iterations , disable = not show_progress ) as progress : # alternate between learning the user_factors from the item_factors and vice-versa for iteration in range ( self . iterations ) : s = time . time ( ) solver ( Cui , self . user_factors , self . item_factors , self . regularization , num_threads = self . num_threads ) progress . update ( .5 ) solver ( Ciu , self . item_factors , self . user_factors , self . regularization , num_threads = self . num_threads ) progress . update ( .5 ) if self . calculate_training_loss : loss = _als . calculate_loss ( Cui , self . user_factors , self . item_factors , self . regularization , num_threads = self . num_threads ) progress . set_postfix ( { "loss" : loss } ) if self . fit_callback : self . fit_callback ( iteration , time . time ( ) - s ) if self . calculate_training_loss : log . info ( "Final training loss %.4f" , loss )