The data structure for unstructured data
DocArray is a library for nested, unstructured data in transit, including text, image, audio, video, 3D mesh, etc. It allows deep-learning engineers to efficiently process, embed, search, recommend, store, and transfer the data with a Pythonic API.
🌌 Rich data types: super-expressive data structure for representing complicated/mixed/nested text, image, video, audio, 3D mesh data.
🐍 Pythonic experience: designed to be as easy as a Python list. If you know how to Python, you know how to DocArray. Intuitive idioms and type annotation simplify the code you write.
🧑🔬 Data science powerhouse: greatly accelerate data scientists' work on embedding, matching, visualizing, evaluating via Torch/TensorFlow/ONNX/PaddlePaddle on CPU/GPU.
🚡 Data in transit: optimized for network communication, ready-to-wire at anytime with fast and compressed serialization in Protobuf, bytes, base64, JSON, CSV, DataFrame.
🎡 Scale to big data: handle out-of-memory data via on-disk document store while staying with exact same API experience. Supporting classic databases and vector databases to enable faster nearest neighbour search.
👒 For modern apps: GraphQL support makes your server versatile on request and response; built-in data validation and JSON Schema (OpenAPI) help you build reliable webservices.
🛸 Integrate with IDE: pretty-print and visualization on Jupyter notebook & Google Colab; comprehensive auto-complete and type hint in PyCharm & VS Code.
Read more on why should you use DocArray and comparison to alternatives.
Requires Python 3.7+ and numpy only:
pip install docarrayor via Conda:
conda install -c conda-forge docarrayCommonly used features can be enabled via pip install "docarray[common]".
DocArray consists of three simple concepts:
- Document: a data structure for easily representing nested, unstructured data.
- DocumentArray: a container for efficiently accessing, manipulating, and understanding multiple Documents.
- Dataclass: a high-level API for intuitively representing multimodal data.
Let's see DocArray in action with some examples.
The following news article card can be easily represented via docarray.dataclass and type annotation:
|
from docarray import dataclass, Document
from docarray.typing import Image, Text, JSON
@dataclass
class WPArticle:
banner: Image
headline: Text
meta: JSON
a = WPArticle(
banner='https://.../cat-dog-flight.png',
headline='Everything to know about flying with pets, ...',
meta={
'author': 'Nathan Diller',
'Column': 'By the Way - A Post Travel Destination',
},
)
d = Document(a) |
Let's search for top-5 similar sentences of she smiled too much in "Pride and Prejudice".
from docarray import Document, DocumentArray
d = Document(uri='https://www.gutenberg.org/files/1342/1342-0.txt').load_uri_to_text()
da = DocumentArray(Document(text=s.strip()) for s in d.text.split('\n') if s.strip())
da.apply(Document.embed_feature_hashing, backend='process')
q = (
Document(text='she smiled too much')
.embed_feature_hashing()
.match(da, metric='jaccard', use_scipy=True)
)
print(q.matches[:5, ('text', 'scores__jaccard__value')])[['but she smiled too much.',
'_little_, she might have fancied too _much_.',
'She perfectly remembered everything that had passed in',
'tolerably detached tone. While she spoke, an involuntary glance',
'much as she chooses.”'],
[0.3333333333333333, 0.6666666666666666, 0.7, 0.7272727272727273, 0.75]]
Here the feature embedding is done by simple feature hashing and distance metric is Jaccard distance. You have better embeddings? Of course you do! We look forward to seeing your results!
When your data is too big, storing in memory is probably not a good idea. DocArray supports multiple storage backends such as SQLite, Weaviate, Qdrant and ANNLite. They are all unified under the exact same user experience and API. Take the above snippet as an example, you only need to change one line to use SQLite:
da = DocumentArray(
(Document(text=s.strip()) for s in d.text.split('\n') if s.strip()),
storage='sqlite',
)The code snippet can still run as-is. All APIs remain the same, the code after are then running in a "in-database" manner.
Besides saving memory, one can leverage storage backends for persistence, faster retrieval (e.g. on nearest-neighbour queries).
Let's use DocArray and the Totally Looks Like dataset to build a simple meme image search. The dataset contains 6,016 image-pairs stored in /left and /right. Images that share the same filename are perceptually similar. For example:
| left/00018.jpg | right/00018.jpg | left/00131.jpg | right/00131.jpg |
|---|---|---|---|
 |
 |
 |
 |
Our problem is given an image from /left, can we find its most-similar image in /right? (without looking at the filename of course).
First we load images. You can go to Totally Looks Like website, unzip and load images as below:
from docarray import DocumentArray
left_da = DocumentArray.from_files('left/*.jpg')Or you can simply pull it from Jina Cloud:
left_da = DocumentArray.pull('demo-leftda', show_progress=True)You will see a running progress bar to indicate the downloading process.
To get a feeling of the data you will handle, plot them in one sprite image:
left_da.plot_image_sprites()
Let's do some standard computer vision pre-processing:
from docarray import Document
def preproc(d: Document):
return (
d.load_uri_to_image_tensor() # load
.set_image_tensor_normalization() # normalize color
.set_image_tensor_channel_axis(-1, 0)
) # switch color axis for the PyTorch model later
left_da.apply(preproc)Did I mention apply works in parallel?
Now convert images into embeddings using a pretrained ResNet50:
import torchvision
model = torchvision.models.resnet50(pretrained=True) # load ResNet50
left_da.embed(model, device='cuda') # embed via GPU to speed upThis step takes ~30 seconds on GPU. Beside PyTorch, you can also use TensorFlow, PaddlePaddle, or ONNX models in .embed(...).
You can visualize the embeddings via tSNE in an interactive embedding projector:
left_da.plot_embeddings()
Fun is fun, but recall our goal is to match left images against right images and so far we have only handled the left. Let's repeat the same procedure for the right:
| Pull from Cloud | Download, unzip, load from local |
|---|---|
right_da = (
DocumentArray.pull('demo-rightda', show_progress=True)
.apply(preproc)
.embed(model, device='cuda')
) |
right_da = (
DocumentArray.from_files('right/*.jpg').apply(preproc).embed(model, device='cuda')
) |
We can now match the left to the right and take the top-9 results.
left_da.match(right_da, limit=9)Let's inspect what's inside left_da matches now:
for d in left_da:
for m in d.matches:
print(d.uri, m.uri, m.scores['cosine'].value)left/02262.jpg right/03459.jpg 0.21102
left/02262.jpg right/02964.jpg 0.13871843
left/02262.jpg right/02103.jpg 0.18265384
left/02262.jpg right/04520.jpg 0.16477376
...
Or shorten the loop as one-liner using the element & attribute selector:
print(left_da['@m', ('uri', 'scores__cosine__value')])Better see it.
(
DocumentArray(left_da[8].matches, copy=True)
.apply(
lambda d: d.set_image_tensor_channel_axis(
0, -1
).set_image_tensor_inv_normalization()
)
.plot_image_sprites()
)
What we did here is revert the preprocessing steps (i.e. switching axis and normalizing) on the copied matches, so that you can visualize them using image sprites.
Serious as you are, visual inspection is surely not enough. Let's calculate the recall@K. First we construct the groundtruth matches:
groundtruth = DocumentArray(
Document(uri=d.uri, matches=[Document(uri=d.uri.replace('left', 'right'))])
for d in left_da
)Here we create a new DocumentArray with real matches by simply replacing the filename, e.g. left/00001.jpg to right/00001.jpg. That's all we need: if the predicted match has the identical uri as the groundtruth match, then it is correct.
Now let's check recall rate from 1 to 5 over the full dataset:
for k in range(1, 6):
print(
f'recall@{k}',
left_da.evaluate(
groundtruth, hash_fn=lambda d: d.uri, metric='recall_at_k', k=k, max_rel=1
),
)recall@1 0.02726063829787234
recall@2 0.03873005319148936
recall@3 0.04670877659574468
recall@4 0.052194148936170214
recall@5 0.0573470744680851
More metrics can be used such as precision_at_k, ndcg_at_k, hit_at_k.
If you think a pretrained ResNet50 is good enough, let me tell you with Finetuner you could do much better in just 10 extra lines of code. Here is how.
You can save a DocumentArray to binary, JSON, dict, DataFrame, CSV or Protobuf message with/without compression. In its simplest form,
left_da.save('left_da.bin')To reuse it, do left_da = DocumentArray.load('left_da.bin').
If you want to transfer a DocumentArray from one machine to another or share it with your colleagues, you can do:
left_da.push('my_shared_da')Now anyone who knows the token my_shared_da can pull and work on it.
left_da = DocumentArray.pull('my_shared_da')Intrigued? That's only scratching the surface of what DocArray is capable of. Read our docs to learn more.
- Check out the Learning Bootcamp to get started with DocArray.
- Use Discussions to talk about your use cases, questions, and support queries.
- Join our Slack community and chat with other community members about ideas.
- Join our Engineering All Hands meet-up to discuss your use case and learn Jina's new features.
- When? The second Tuesday of every month
- Where? Zoom (see our public events calendar/.ical) and live stream on YouTube
- Subscribe to the latest video tutorials on our YouTube channel
DocArray is backed by Jina AI and licensed under Apache-2.0. We are actively hiring AI engineers, solution engineers to build the next neural search ecosystem in open-source.