code: def fit(self, matrix, epochs=5, no_threads=2, verbose=False):
          
  
          shape = matrix.shape
  
          if (len(shape) != 2 or
              shape[0] != shape[1]):
              raise Exception('Coocurrence matrix must be square')
  
          if not sp.isspmatrix_coo(matrix):
              raise Exception('Coocurrence matrix must be in the COO format')
  
          random_state = check_random_state(self.random_state)
          self.word_vectors = ((random_state.rand(shape[0],
                                                  self.no_components) - 0.5)
                               / self.no_components)
          self.word_biases = np.zeros(shape[0],
                                      dtype=np.float64)
  
          self.vectors_sum_gradients = np.ones_like(self.word_vectors)
          self.biases_sum_gradients = np.ones_like(self.word_biases)
  
          shuffle_indices = np.arange(matrix.nnz, dtype=np.int32)
  
          if verbose:
              print('Performing %s training epochs '
                    'with %s threads' % (epochs, no_threads))
  
          for epoch in range(epochs):
  
              if verbose:
                  print('Epoch %s' % epoch)
  
              # Shuffle the coocurrence matrix
              random_state.shuffle(shuffle_indices)
  
              fit_vectors(self.word_vectors,
                          self.vectors_sum_gradients,
                          self.word_biases,
                          self.biases_sum_gradients,
                          matrix.row,
                          matrix.col,
                          matrix.data,
                          shuffle_indices,
                          self.learning_rate,
                          self.max_count,
                          self.alpha,
                          self.max_loss,
                          int(no_threads))
  
              if not np.isfinite(self.word_vectors).all():
                  raise Exception('Non-finite values in word vectors. '
                                  'Try reducing the learning rate or the '
                                  'max_loss parameter.')
docs: Estimate the word embeddings.
  
          Parameters:
          - scipy.sparse.coo_matrix matrix: coocurrence matrix
          - int epochs: number of training epochs
          - int no_threads: number of training threads
          - bool verbose: print progress messages if True