              batch_size=1024):
          '''For each of the given vectors, find the single entry most similar
          to it, by cosine.
  
          Queries are by vector. Results are returned as an array of keys,
          or a tuple of (keys, scores) if return_scores=True. If `queries` is
          large, the calculations are performed in chunks, to avoid consuming
          too much memory. You can set the `batch_size` to control the size/space
          trade-off during the calculations.
          '''
          xp = get_array_module(self.data)
  
          vectors = self.data / xp.linalg.norm(self.data, axis=1, keepdims=True)
  
          best_rows = xp.zeros((queries.shape[0],), dtype='i')
 
</s> remove     def most_similar(self, queries, *, return_scores=False, return_rows=False,
            batch_size=1024):
        '''For each of the given vectors, find the single entry most similar
 </s> add     def most_similar(self, queries, *, batch_size=1024):
        """For each of the given vectors, find the single entry most similar </s> remove         key (unicode / int): The key to add.
        vector (numpy.ndarray / None): A vector to add for the key.
        row (int / None): The row-number of a vector to map the key to.
 </s> add         key (int): The key to add.
        vector (ndarray / None): A vector to add for the key.
        row (int / None): The row number of a vector to map the key to.
        RETURNS (int): The row the vector was added to. </s> remove         if return_rows and return_scores:
            return (keys, best_rows, scores)
        elif return_rows:
            return (keys, best_rows)
        elif return_scores:
            return (keys, scores)
        else:
            return keys
 </s> add         return (keys, best_rows, scores) </s> remove 
        RETURNS: A StringStore object, holding the key-to-string mapping.
 </s> add         RETURNS: A `StringStore` object, holding the key-to-string mapping. </s> remove         """Returns True if no keys are available for new keys."""
 </s> add         """RETURNS (int) The number of keys in the table. Note that this is the
        number of all keys, not just unique vectors."""
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
              batch_size=1024):
          '''For each of the given vectors, find the single entry most similar
          to it, by cosine.
  
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
        Queries are by vector. Results are returned as a `(keys, best_rows,
        scores)` tuple. If `queries` is large, the calculations are performed in
        chunks, to avoid consuming too much memory. You can set the `batch_size`
        to control the size/space trade-off during the calculations.

        queries (ndarray): An array with one or more vectors.
        batch_size (int): The batch size to use.
        RETURNS (tuple): The most similar entry as a `(keys, best_rows, scores)`
            tuple.
        """
          xp = get_array_module(self.data)
  
          vectors = self.data / xp.linalg.norm(self.data, axis=1, keepdims=True)
  
          best_rows = xp.zeros((queries.shape[0],), dtype='i')
keep keep keep keep replace replace replace replace replace replace keep keep keep keep keep
 Update docstrings and simplify most_similar 
spacy/vectors.pyx