text: Title: None value in optional search fields of index documents cause errors
  Body: The current implementation of `InMemoryExactNNIndex` does not allow None value in search fields even when they are defined as  Optional, for example:
  ```python
  import torch
  from typing import Optional
  
  from docarray import BaseDoc, DocList
  from docarray.typing import TorchTensor
  from docarray.index import InMemoryExactNNIndex
  
  
  class TestDoc(BaseDoc):
      embedding: Optional[TorchTensor[768]]
  
  # Some of the documents have the embedding field set to None
  dl = DocList[TestDoc]([TestDoc(embedding=(torch.rand(768,) if i%2 else None)) for i in range(5)])
  
  index = InMemoryExactNNIndex[TestDoc](dl)
  index.find(torch.rand((768,)), search_field="embedding", limit=3)
  ```
  This will cause the following error:
  ```
  ---------------------------------------------------------------------------
  TypeError                                 Traceback (most recent call last)
  Cell In[1], line 15
       12 dl = DocList[TestDoc]([TestDoc(embedding=(torch.rand(768,) if i%2 else None)) for i in range(5)])
       14 index = InMemoryExactNNIndex[TestDoc](dl)
  ---> 15 index.find(torch.rand((768,)), search_field="embedding", limit=3)
  
  File ~/miniconda3/envs/CloneDetection/lib/python3.9/site-packages/docarray/index/backends/in_memory.py:238, in InMemoryExactNNIndex.find(self, query, search_field, limit, **kwargs)
      234     return FindResult(documents=[], scores=[])  # type: ignore
      236 config = self._column_infos[search_field].config
  --> 238 docs, scores = find(
      239     index=self._docs,
      240     query=query,
      241     search_field=search_field,
      242     limit=limit,
      243     metric=config['space'],
      244 )
      245 docs_with_schema = DocList.__class_getitem__(cast(Type[BaseDoc], self._schema))(
      246     docs
      247 )
      248 return FindResult(documents=docs_with_schema, scores=scores)
  
  File ~/miniconda3/envs/CloneDetection/lib/python3.9/site-packages/docarray/utils/find.py:114, in find(index, query, search_field, metric, limit, device, descending)
       51 """
       52 Find the closest Documents in the index to the query.
       53 Supports PyTorch and NumPy embeddings.
     (...)
      111     and the second element contains the corresponding scores.
      112 """
      113 query = _extract_embedding_single(query, search_field)
  --> 114 docs, scores = find_batched(
      115     index=index,
      116     query=query,
      117     search_field=search_field,
      118     metric=metric,
      119     limit=limit,
      120     device=device,
      121     descending=descending,
      122 )
      123 return FindResult(documents=docs[0], scores=scores[0])
  
  File ~/miniconda3/envs/CloneDetection/lib/python3.9/site-packages/docarray/utils/find.py:207, in find_batched(index, query, search_field, metric, limit, device, descending)
      204 comp_backend = embedding_type.get_comp_backend()
      206 # extract embeddings from query and index
  --> 207 index_embeddings = _extract_embeddings(index, search_field, embedding_type)
      208 query_embeddings = _extract_embeddings(query, search_field, embedding_type)
      210 # compute distances and return top results
  
  File ~/miniconda3/envs/CloneDetection/lib/python3.9/site-packages/docarray/utils/find.py:269, in _extract_embeddings(data, search_field, embedding_type)
      267 if isinstance(data, DocList):
      268     emb_list = list(AnyDocArray._traverse(data, search_field))
  --> 269     emb = embedding_type._docarray_stack(emb_list)
      270 elif isinstance(data, (DocVec, BaseDoc)):
      271     emb = next(AnyDocArray._traverse(data, search_field))
  
  File ~/miniconda3/envs/CloneDetection/lib/python3.9/site-packages/docarray/typing/tensor/abstract_tensor.py:293, in AbstractTensor._docarray_stack(cls, seq)
      290 comp_backend = cls.get_comp_backend()
      291 # at runtime, 'T' is always the correct input type for .stack()
      292 # but mypy doesn't know that, so we ignore it here
  --> 293 return cls._docarray_from_native(comp_backend.stack(seq))
  
  File ~/miniconda3/envs/CloneDetection/lib/python3.9/site-packages/docarray/computation/torch_backend.py:46, in TorchCompBackend.stack(cls, tensors, dim)
       42 @classmethod
       43 def stack(
       44     cls, tensors: Union[List['torch.Tensor'], Tuple['torch.Tensor']], dim: int = 0
       45 ) -> 'torch.Tensor':
  ---> 46     return torch.stack(tensors, dim=dim)
  
  TypeError: expected Tensor as element 0 in argument 0, but got NoneType
  ```
  
  Is there any way to either filter those documents with None value or ignore them when performing vector search?
  Thanks!