code: def test_predict_ranks():
      no_users, no_items = (10, 100)
  
      train = sp.coo_matrix((no_users, no_items), dtype=np.float32)
      train = sp.rand(no_users, no_items, format="csr", random_state=42)
  
      model = LightFM()
      model.fit_partial(train)
  
      # Compute ranks for all items
      rank_input = sp.csr_matrix(np.ones((no_users, no_items)))
      ranks = model.predict_rank(rank_input, num_threads=2).todense()
  
      assert np.all(ranks.min(axis=1) == 0)
      assert np.all(ranks.max(axis=1) == no_items - 1)
  
      for row in range(no_users):
          assert np.all(np.sort(ranks[row]) == np.arange(no_items))
  
      # Train set exclusions. All ranks should be zero
      # if train interactions is dense.
      ranks = model.predict_rank(
          rank_input,
          train_interactions=rank_input,
          check_intersections=False,
      ).todense()
      assert np.all(ranks == 0)
  
      # Max rank should be num_items - 1 - number of positives
      # in train in that row
      ranks = model.predict_rank(
          rank_input,
          train_interactions=train,
          check_intersections=False,
      ).todense()
      assert np.all(
          np.squeeze(np.array(ranks.max(axis=1)))
          == no_items - 1 - np.squeeze(np.array(train.getnnz(axis=1)))
      )
  
      # check error is raised when train and test have interactions in common
      with pytest.raises(ValueError):
          model.predict_rank(
              train, train_interactions=train, check_intersections=True
          )
  
      # check error not raised when flag is False
      model.predict_rank(
          train, train_interactions=train, check_intersections=False
      )
  
      # check no errors raised when train and test have no interactions in common
      not_train = (
          sp.rand(no_users, no_items, format="csr", random_state=43)
          - train
      )
      not_train.data[not_train.data < 0] = 0
      not_train.eliminate_zeros()
      model.predict_rank(
          not_train, train_interactions=train, check_intersections=True
      )
  
      # Make sure ranks are computed pessimistically when
      # there are ties (that is, equal predictions for every
      # item will assign maximum rank to each).
      model.user_embeddings = np.zeros_like(model.user_embeddings)
      model.item_embeddings = np.zeros_like(model.item_embeddings)
      model.user_biases = np.zeros_like(model.user_biases)
      model.item_biases = np.zeros_like(model.item_biases)
  
      ranks = model.predict_rank(rank_input, num_threads=2).todense()
  
      assert np.all(ranks.min(axis=1) == 99)
      assert np.all(ranks.max(axis=1) == 99)
  
      # Wrong input dimensions
      with pytest.raises(ValueError):
          model.predict_rank(sp.csr_matrix((5, 5)), num_threads=2)
  
imports: import numpy
  import pytest
  import scipy.sparse
  from lightfm.lightfm import LightFM
label_desc: Use image node_id 11 for calling a global function with example usage: test_predict_ranks() without return types