docarray
v0.40.0
Die Datenstruktur für multimodale Daten
Beachten Sie, dass die Readme, die Sie derzeit anzeigen, für Docarray> 0,30 ist, in dem einige signifikante Änderungen gegenüber Docarray 0.21 vorgestellt werden. Wenn Sie den älteren Docarray <= 0,21 weiterhin verwenden möchten, stellen Sie sicher, dass Sie es über
pip install docarray==0.21. Weitere Informationen finden Sie in der Codebasis, Dokumentation und seiner Hot-Fixes-Filiale.
Docarray ist eine Python -Bibliothek, die für die Darstellung, Übertragung, Speicherung und Abruf von multimodalen Daten gekonnt gefertigt wurde. Das Design ist auf die Entwicklung multimodaler KI -Anwendungen zugeschnitten und garantiert eine nahtlose Integration in die umfangreichen Ökosysteme Python und maschinelles Lernen. Ab Januar 2022 ist Docarray offen unter der Apache -Lizenz 2.0 verteilt und genießt derzeit den Status eines Sandbox -Projekts innerhalb der LF AI & Data Foundation.
Führen Sie den folgenden Befehl aus, um Docarray aus der CLI zu installieren:
pip install -U docarrayHINWEIS Um Docarray <= 0,21 zu verwenden, stellen Sie sicher, dass Sie über
pip install docarray==0.21und schauen Sie sich die Codebasis und die Docs und die Hot-Fixes-Filiale an.
Neu in Docarray? Abhängig von Ihrem Anwendungsfall und Ihrem Hintergrund gibt es mehrere Möglichkeiten, über Docarray zu erfahren:
Docarray ermöglicht es Ihnen, Ihre Daten auf eine Weise darzustellen , die von Natur aus auf maschinelles Lernen abgestimmt ist.
Dies ist besonders vorteilhaft für verschiedene Szenarien:
Mit Pydantic vertraut? Sie werden erfreut sein zu erfahren, dass Docarray nicht nur auf Pydantic konstruiert ist, sondern auch eine vollständige Kompatibilität beibehält! Darüber hinaus haben wir einen bestimmten Abschnitt, der Ihren Bedürfnissen gewidmet ist!
Im Wesentlichen erleichtert Docarray die Datenrepräsentation in einer Weise, die Python Datacklasse widerspiegelt, wobei maschinelles Lernen eine integrale Komponente ist:
from docarray import BaseDoc
from docarray . typing import TorchTensor , ImageUrl
import torch
# Define your data model
class MyDocument ( BaseDoc ):
description : str
image_url : ImageUrl # could also be VideoUrl, AudioUrl, etc.
image_tensor : TorchTensor [ 1704 , 2272 , 3 ] # you can express tensor shapes!
# Stack multiple documents in a Document Vector
from docarray import DocVec
vec = DocVec [ MyDocument ](
[
MyDocument (
description = "A cat" ,
image_url = "https://example.com/cat.jpg" ,
image_tensor = torch . rand ( 1704 , 2272 , 3 ),
),
]
* 10
)
print ( vec . image_tensor . shape ) # (10, 1704, 2272, 3)Schauen wir uns genauer an, wie Sie Ihre Daten mit Docarray darstellen können:
from docarray import BaseDoc
from docarray . typing import TorchTensor , ImageUrl
from typing import Optional
import torch
# Define your data model
class MyDocument ( BaseDoc ):
description : str
image_url : ImageUrl # could also be VideoUrl, AudioUrl, etc.
image_tensor : Optional [
TorchTensor [ 1704 , 2272 , 3 ]
] = None # could also be NdArray or TensorflowTensor
embedding : Optional [ TorchTensor ] = NoneSie können also nicht nur die Arten Ihrer Daten definieren, sondern auch die Form Ihrer Tensoren angeben!
# Create a document
doc = MyDocument (
description = "This is a photo of a mountain" ,
image_url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
)
# Load image tensor from URL
doc . image_tensor = doc . image_url . load ()
# Compute embedding with any model of your choice
def clip_image_encoder ( image_tensor : TorchTensor ) -> TorchTensor : # dummy function
return torch . rand ( 512 )
doc . embedding = clip_image_encoder ( doc . image_tensor )
print ( doc . embedding . shape ) # torch.Size([512])Natürlich können Sie Dokumente in eine verschachtelte Struktur zusammenstellen:
from docarray import BaseDoc
from docarray . documents import ImageDoc , TextDoc
import numpy as np
class MultiModalDocument ( BaseDoc ):
image_doc : ImageDoc
text_doc : TextDoc
doc = MultiModalDocument (
image_doc = ImageDoc ( tensor = np . zeros (( 3 , 224 , 224 ))), text_doc = TextDoc ( text = 'hi!' )
) Sie arbeiten selten mit einem einzelnen Datenpunkt gleichzeitig, insbesondere in Anwendungen für maschinelles Lernen. Aus diesem Grund können Sie problemlos mehrere Documents sammeln:
DocumentsBeim Erstellen oder Interaktion mit einem ML -System möchten Sie normalerweise mehrere Dokumente (Datenpunkte) gleichzeitig verarbeiten.
Docarray bietet dafür zwei Datenstrukturen:
DocVec : Ein Vektor von Documents . Alle Tensoren in den Dokumenten werden in einen einzelnen Tensor gestapelt. Perfekt für die Batch -Verarbeitung und die Verwendung innerhalb von ML -Modellen .DocList : Eine Liste von Documents . Alle Tensoren in den Dokumenten werden als IS gehalten. Perfekt zum Streaming, Wiederholung und Mischung von Daten . Schauen wir sie uns an, beginnend mit DocVec :
from docarray import DocVec , BaseDoc
from docarray . typing import AnyTensor , ImageUrl
import numpy as np
class Image ( BaseDoc ):
url : ImageUrl
tensor : AnyTensor # this allows torch, numpy, and tensor flow tensors
vec = DocVec [ Image ]( # the DocVec is parametrized by your personal schema!
[
Image (
url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
tensor = np . zeros (( 3 , 224 , 224 )),
)
for _ in range ( 100 )
]
) Im obigen Code -Snippet wird DocVec durch den Dokumenttyp parametrisiert, den Sie damit verwenden möchten: DocVec[Image] .
Das mag zunächst komisch aussehen, aber wir sind zuversichtlich, dass Sie sich schnell daran gewöhnen werden! Außerdem können wir einige coole Dinge tun, wie zum Beispiel den Zugriff auf die Felder, die Sie in Ihrem Dokument definiert haben :
tensor = vec . tensor # gets all the tensors in the DocVec
print ( tensor . shape ) # which are stacked up into a single tensor!
print ( vec . url ) # you can bulk access any other field, too Die zweite Datenstruktur, DocList , funktioniert auf ähnliche Weise:
from docarray import DocList
dl = DocList [ Image ]( # the DocList is parametrized by your personal schema!
[
Image (
url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
tensor = np . zeros (( 3 , 224 , 224 )),
)
for _ in range ( 100 )
]
)Sie können weiterhin auf die Felder Ihres Dokuments zugreifen:
tensors = dl . tensor # gets all the tensors in the DocList
print ( type ( tensors )) # as a list of tensors
print ( dl . url ) # you can bulk access any other field, too Und Sie können Dokumente einfügen, entfernen und an Ihren DocList anhängen:
# append
dl . append (
Image (
url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
tensor = np . zeros (( 3 , 224 , 224 )),
)
)
# delete
del dl [ 0 ]
# insert
dl . insert (
0 ,
Image (
url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
tensor = np . zeros (( 3 , 224 , 224 )),
),
) Und Sie können nahtlos zwischen DocVec und DocList wechseln:
vec_2 = dl . to_doc_vec ()
assert isinstance ( vec_2 , DocVec )
dl_2 = vec_2 . to_doc_list ()
assert isinstance ( dl_2 , DocList )Docarray erleichtert die Übertragung Ihrer Daten in einer von Natur aus mit maschinellen Lernen kompatibelen Weise.
Dies beinhaltet die native Unterstützung für Protobuf und GRPC sowie HTTP und Serialisierung an JSON, Jsonschema, Base64 und Bytes.
Diese Funktion ist für mehrere Szenarien von Vorteil:
Kennen Sie Fastapi? Sie werden erfreut sein, dass Docarray mit Fastapi die volle Kompatibilität beibehält! Außerdem haben wir einen speziellen Abschnitt speziell für Sie!
Bei der Datenübertragung ist die Serialisierung ein entscheidender Schritt. Lassen Sie uns darüber eingehen, wie Docarray diesen Prozess optimiert:
from docarray import BaseDoc
from docarray . typing import ImageTorchTensor
import torch
# model your data
class MyDocument ( BaseDoc ):
description : str
image : ImageTorchTensor [ 3 , 224 , 224 ]
# create a Document
doc = MyDocument (
description = "This is a description" ,
image = torch . zeros (( 3 , 224 , 224 )),
)
# serialize it!
proto = doc . to_protobuf ()
bytes_ = doc . to_bytes ()
json = doc . json ()
# deserialize it!
doc_2 = MyDocument . from_protobuf ( proto )
doc_4 = MyDocument . from_bytes ( bytes_ )
doc_5 = MyDocument . parse_raw ( json )Natürlich ist Serialisierung nicht alles, was Sie brauchen. Schauen Sie sich also an, wie sich Docarray in Jina und Fastapi integriert.
Nach dem Modellieren und möglicherweise verteilen Sie Ihre Daten, möchten Sie sie normalerweise irgendwo speichern . Dort tritt Docarray ein!
Dokumentgeschäfte bieten eine nahtlose Möglichkeit, wie der Name schon sagt, dass Sie Ihre Dokumente speichern. Sei es lokal oder remote, Sie können alles über dieselbe Benutzeroberfläche tun:
Mit der Dokumentspeicherschnittstelle können Sie Dokumente zu und von mehreren Datenquellen mit derselben Benutzeroberfläche schieben und ziehen.
Lassen Sie uns beispielsweise sehen, wie das mit On-Disk-Speicher funktioniert:
from docarray import BaseDoc , DocList
class SimpleDoc ( BaseDoc ):
text : str
docs = DocList [ SimpleDoc ]([ SimpleDoc ( text = f'doc { i } ' ) for i in range ( 8 )])
docs . push ( 'file://simple_docs' )
docs_pull = DocList [ SimpleDoc ]. pull ( 'file://simple_docs' )Mit Dokumentindizes können Sie Ihre Dokumente in einer Vektor-Datenbank für ein effizientes Ähnlichkeitsabruf indexieren.
Dies ist nützlich für:
Derzeit unterstützen Dokumentindizes Weaviate , Qdrant , Elasticsearch , Redis , Mongo Atlas und HNSWLIB mit weiteren kommen!
Mit der Dokumentindex -Schnittstelle können Sie Dokumente aus mehreren Vektor -Datenbanken indexieren und abrufen, alle mit derselben Benutzeroberfläche.
Es unterstützt Ann Vector -Suche, Textsuche, Filterung und Hybridsuche.
from docarray import DocList , BaseDoc
from docarray . index import HnswDocumentIndex
import numpy as np
from docarray . typing import ImageUrl , ImageTensor , NdArray
class ImageDoc ( BaseDoc ):
url : ImageUrl
tensor : ImageTensor
embedding : NdArray [ 128 ]
# create some data
dl = DocList [ ImageDoc ](
[
ImageDoc (
url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
tensor = np . zeros (( 3 , 224 , 224 )),
embedding = np . random . random (( 128 ,)),
)
for _ in range ( 100 )
]
)
# create a Document Index
index = HnswDocumentIndex [ ImageDoc ]( work_dir = '/tmp/test_index' )
# index your data
index . index ( dl )
# find similar Documents
query = dl [ 0 ]
results , scores = index . find ( query , limit = 10 , search_field = 'embedding' )Abhängig von Ihrem Hintergrund und Anwendungsfall gibt es für Sie verschiedene Möglichkeiten, Docarray zu verstehen.
Wenn Sie Docarray Version 0.30.0 oder niedriger verwenden, sind Sie mit der DataClass -API vertraut.
Docarray> = 0,30 ist diese Idee, ernst genommen. Jedes Dokument wird über eine DataClass-ähnliche Schnittstelle erstellt, die mit freundlicher Genehmigung von Pydantic.
Dies gibt die folgenden Vorteile:
Möglicherweise sind Sie auch mit unseren alten Dokumentgeschäften für die Vektor -DB -Integration vertraut. Sie werden jetzt als Dokumentindizes bezeichnet und bieten die folgenden Verbesserungen an (siehe hier für die neue API):
Im Moment unterstützen Dokumentindizes Weaviate , Qdrant , Elasticsearch , Redis , Mongo Atlas , genaue Suche nach nächster Nachbarn und HNSWLIB mit weiteren.
Wenn Sie aus Pydantic stammen, können Sie Docarray -Dokumente als entsaftete pydantische Modelle und Docarray als Sammlung von Leckereien um sie herum sehen.
Insbesondere haben wir uns vor dem Ersetzen der ML -Welt für die ML -Welt vorbereitet, sondern indem wir sie ersetzen, sondern indem wir auf dem neuesten Stand bauen!
Dies bedeutet, dass Sie die folgenden Vorteile erhalten:
.load() eine URL zum Bild Tensor, Texturl kann Textdokumente laden und tokenisieren usw. Der offensichtlichste Vorteil hier ist die erstklassige Unterstützung für ML-zentrische Daten wie {Torch, TF, ...}Tensor , Embedding usw.
Dies beinhaltet praktische Funktionen wie die Validierung der Form eines Tensors:
from docarray import BaseDoc
from docarray . typing import TorchTensor
import torch
class MyDoc ( BaseDoc ):
tensor : TorchTensor [ 3 , 224 , 224 ]
doc = MyDoc ( tensor = torch . zeros ( 3 , 224 , 224 )) # works
doc = MyDoc ( tensor = torch . zeros ( 224 , 224 , 3 )) # works by reshaping
try :
doc = MyDoc ( tensor = torch . zeros ( 224 )) # fails validation
except Exception as e :
print ( e )
# tensor
# Cannot reshape tensor of shape (224,) to shape (3, 224, 224) (type=value_error)
class Image ( BaseDoc ):
tensor : TorchTensor [ 3 , 'x' , 'x' ]
Image ( tensor = torch . zeros ( 3 , 224 , 224 )) # works
try :
Image (
tensor = torch . zeros ( 3 , 64 , 128 )
) # fails validation because second dimension does not match third
except Exception as e :
print ()
try :
Image (
tensor = torch . zeros ( 4 , 224 , 224 )
) # fails validation because of the first dimension
except Exception as e :
print ( e )
# Tensor shape mismatch. Expected(3, 'x', 'x'), got(4, 224, 224)(type=value_error)
try :
Image (
tensor = torch . zeros ( 3 , 64 )
) # fails validation because it does not have enough dimensions
except Exception as e :
print ( e )
# Tensor shape mismatch. Expected (3, 'x', 'x'), got (3, 64) (type=value_error)Wenn Sie aus Pytorch kommen, können Sie Docarray hauptsächlich als eine Möglichkeit sehen, Ihre Daten zu organisieren, während sie durch Ihr Modell fließen .
Es bietet Ihnen mehrere Vorteile:
Docarray kann direkt in ML -Modellen verwendet werden, um multimodaldata zu verarbeiten und darzustellen. Auf diese Weise können Sie Ihre Daten mithilfe von Docarrays Abstraktionen tief in nn.Module unterhalten und ein fastapi-kompatibles Schema liefert, das den Übergang zwischen Modelltraining und Modellservice erleichtert.
Um die Wirkung davon zu erkennen, beobachten wir zunächst eine Vanille-Pytorch-Implementierung eines Tri-modalen ML-Modells:
import torch
from torch import nn
def encoder ( x ):
return torch . rand ( 512 )
class MyMultiModalModel ( nn . Module ):
def __init__ ( self ):
super (). __init__ ()
self . audio_encoder = encoder ()
self . image_encoder = encoder ()
self . text_encoder = encoder ()
def forward ( self , text_1 , text_2 , image_1 , image_2 , audio_1 , audio_2 ):
embedding_text_1 = self . text_encoder ( text_1 )
embedding_text_2 = self . text_encoder ( text_2 )
embedding_image_1 = self . image_encoder ( image_1 )
embedding_image_2 = self . image_encoder ( image_2 )
embedding_audio_1 = self . image_encoder ( audio_1 )
embedding_audio_2 = self . image_encoder ( audio_2 )
return (
embedding_text_1 ,
embedding_text_2 ,
embedding_image_1 ,
embedding_image_2 ,
embedding_audio_1 ,
embedding_audio_2 ,
) Nicht sehr einfach für die Augen, wenn Sie uns fragen. Und noch schlimmer, wenn Sie eine weitere Modalität hinzufügen müssen, müssen Sie jeden Teil Ihrer Codebasis berühren, den forward() ändern und dadurch eine ganze Reihe von Änderungen vorab vornommen.
Lassen Sie uns nun sehen, wie der gleiche Code mit Docarray aussieht:
from docarray import DocList , BaseDoc
from docarray . documents import ImageDoc , TextDoc , AudioDoc
from docarray . typing import TorchTensor
from torch import nn
import torch
def encoder ( x ):
return torch . rand ( 512 )
class Podcast ( BaseDoc ):
text : TextDoc
image : ImageDoc
audio : AudioDoc
class PairPodcast ( BaseDoc ):
left : Podcast
right : Podcast
class MyPodcastModel ( nn . Module ):
def __init__ ( self ):
super (). __init__ ()
self . audio_encoder = encoder ()
self . image_encoder = encoder ()
self . text_encoder = encoder ()
def forward_podcast ( self , docs : DocList [ Podcast ]) -> DocList [ Podcast ]:
docs . audio . embedding = self . audio_encoder ( docs . audio . tensor )
docs . text . embedding = self . text_encoder ( docs . text . tensor )
docs . image . embedding = self . image_encoder ( docs . image . tensor )
return docs
def forward ( self , docs : DocList [ PairPodcast ]) -> DocList [ PairPodcast ]:
docs . left = self . forward_podcast ( docs . left )
docs . right = self . forward_podcast ( docs . right )
return docsSieht viel besser aus, nicht wahr? Sie gewinnen sofort die Lesbarkeit und Wartbarkeit von Code. Und für den gleichen Preis können Sie Ihr Pytorch -Modell in eine Fastapi -App verwandeln und Ihre Dokumentschema -Definition wiederverwenden (siehe unten). Alles wird pythonisch behandelt, indem sich auf Typ -Hinweise verlassen.
Wie der Pytorch -Ansatz können Sie auch DocArray mit TensorFlow verwenden, um multimodale Daten in Ihrem ML -Modell zu verarbeiten und darzustellen.
Zunächst einmal, um Docarray mit TensorFlow zu verwenden, müssen wir es zunächst wie folgt installieren:
pip install tensorflow==2.12.0
pip install protobuf==3.19.0
Im Vergleich zur Verwendung von Docarray mit Pytorch gibt es einen Hauptunterschied TensorFlowTensor der Verwendung tf.Tensor TensorFlowTensor : Während Docarrays TorchTensor eine Unterklasse von torch.Tensor tf.Tensor tf.Tensor Sein .tensor -Attribut.
Wie wirkt sich das auf Sie aus? Wenn Sie auf die Tensor -Daten zugreifen möchten, um beizutieren, Operationen mit ihr oder an Ihr ML -Modell geben, anstatt Ihre TensorFlowTensor -Instanz zu übergeben, müssen Sie auf das .tensor -Attribut zugreifen.
Dies würde wie Folgendes aussehen:
from typing import Optional
from docarray import DocList , BaseDoc
import tensorflow as tf
class Podcast ( BaseDoc ):
audio_tensor : Optional [ AudioTensorFlowTensor ] = None
embedding : Optional [ AudioTensorFlowTensor ] = None
class MyPodcastModel ( tf . keras . Model ):
def __init__ ( self ):
super (). __init__ ()
self . audio_encoder = AudioEncoder ()
def call ( self , inputs : DocList [ Podcast ]) -> DocList [ Podcast ]:
inputs . audio_tensor . embedding = self . audio_encoder (
inputs . audio_tensor . tensor
) # access audio_tensor's .tensor attribute
return inputsDokumente sind pydantische Modelle (mit einer Wendung) und als solche sind sie vollständig mit Fastapi kompatibel!
Aber warum sollten Sie sie verwenden und nicht die pydantischen Modelle, die Sie bereits kennen und lieben? Gute Frage!
Um den Deal zu versiegeln, zeigen wir Ihnen, wie einfach Dokumente in Ihre Fastapi -App Dokumente dokumentieren:
import numpy as np
from fastapi import FastAPI
from docarray . base_doc import DocArrayResponse
from docarray import BaseDoc
from docarray . documents import ImageDoc
from docarray . typing import NdArray , ImageTensor
class InputDoc ( BaseDoc ):
img : ImageDoc
text : str
class OutputDoc ( BaseDoc ):
embedding_clip : NdArray
embedding_bert : NdArray
app = FastAPI ()
def model_img ( img : ImageTensor ) -> NdArray :
return np . zeros (( 100 , 1 ))
def model_text ( text : str ) -> NdArray :
return np . zeros (( 100 , 1 ))
@ app . post ( "/embed/" , response_model = OutputDoc , response_class = DocArrayResponse )
async def create_item ( doc : InputDoc ) -> OutputDoc :
doc = OutputDoc (
embedding_clip = model_img ( doc . img . tensor ), embedding_bert = model_text ( doc . text )
)
return doc
input_doc = InputDoc ( text = '' , img = ImageDoc ( tensor = np . random . random (( 3 , 224 , 224 ))))
async with AsyncClient ( app = app , base_url = "http://test" ) as ac :
response = await ac . post ( "/embed/" , data = input_doc . json ())Genau wie ein vanille -pydantisches Modell!
Jina hat Docarray als seine Bibliothek für die Vertretung und Serialisierung von Dokumenten übernommen.
Jina ermöglicht es, Modelle und Dienste zu bedienen, die mit Docarray erstellt werden, mit denen Sie diese Anwendungen bedienen und skalieren können, um die Serialisierungskapabiliten von Docarray vollständig zu nutzen.
import numpy as np
from jina import Deployment , Executor , requests
from docarray import BaseDoc , DocList
from docarray . documents import ImageDoc
from docarray . typing import NdArray , ImageTensor
class InputDoc ( BaseDoc ):
img : ImageDoc
text : str
class OutputDoc ( BaseDoc ):
embedding_clip : NdArray
embedding_bert : NdArray
def model_img ( img : ImageTensor ) -> NdArray :
return np . zeros (( 100 , 1 ))
def model_text ( text : str ) -> NdArray :
return np . zeros (( 100 , 1 ))
class MyEmbeddingExecutor ( Executor ):
@ requests ( on = '/embed' )
def encode ( self , docs : DocList [ InputDoc ], ** kwargs ) -> DocList [ OutputDoc ]:
ret = DocList [ OutputDoc ]()
for doc in docs :
output = OutputDoc (
embedding_clip = model_img ( doc . img . tensor ),
embedding_bert = model_text ( doc . text ),
)
ret . append ( output )
return ret
with Deployment (
protocols = [ 'grpc' , 'http' ], ports = [ 12345 , 12346 ], uses = MyEmbeddingExecutor
) as dep :
resp = dep . post (
on = '/embed' ,
inputs = DocList [ InputDoc ](
[ InputDoc ( text = '' , img = ImageDoc ( tensor = np . random . random (( 3 , 224 , 224 ))))]
),
return_type = DocList [ OutputDoc ],
)
print ( resp )Wenn Sie Docarray als Universal Vector Database -Client gestoßen haben, können Sie sich dies am besten als eine neue Art von ORM für Vektordatenbanken vorstellen. Die Aufgabe von Docarrays ist es, multimodale, verschachtelte und domänenspezifische Daten aufzunehmen und sie einer Vektor-Datenbank zuzuordnen, dort zu speichern und so durchsuchbar zu werden:
from docarray import DocList , BaseDoc
from docarray . index import HnswDocumentIndex
import numpy as np
from docarray . typing import ImageUrl , ImageTensor , NdArray
class ImageDoc ( BaseDoc ):
url : ImageUrl
tensor : ImageTensor
embedding : NdArray [ 128 ]
# create some data
dl = DocList [ ImageDoc ](
[
ImageDoc (
url = "https://upload.wikimedia.org/wikipedia/commons/2/2f/Alpamayo.jpg" ,
tensor = np . zeros (( 3 , 224 , 224 )),
embedding = np . random . random (( 128 ,)),
)
for _ in range ( 100 )
]
)
# create a Document Index
index = HnswDocumentIndex [ ImageDoc ]( work_dir = '/tmp/test_index2' )
# index your data
index . index ( dl )
# find similar Documents
query = dl [ 0 ]
results , scores = index . find ( query , limit = 10 , search_field = 'embedding' )Derzeit unterstützt Docarray die folgenden Vektor -Datenbanken:
Eine Integration von OpenSearch erfolgt derzeit.
Natürlich ist dies nur eines der Dinge, die Docarray tun kann. Deshalb ermutigen wir Sie, den Rest dieses Readme zu überprüfen!
Mit Docarray können Sie externe Daten über Langchain mit LLMs anschließen. DocArray bietet Ihnen die Freiheit, flexible Dokumentschemata festzulegen und aus verschiedenen Backends für den Speichern von Dokumenten zu wählen. Nach dem Erstellen Ihres Dokumentindex können Sie ihn mit DocarrayRetriever mit Ihrer Langchain -App verbinden.
Installieren Sie Langchain über:
pip install langchain from docarray import BaseDoc , DocList
from docarray . typing import NdArray
from langchain . embeddings . openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings ()
# Define a document schema
class MovieDoc ( BaseDoc ):
title : str
description : str
year : int
embedding : NdArray [ 1536 ]
movies = [
{ "title" : "#1 title" , "description" : "#1 description" , "year" : 1999 },
{ "title" : "#2 title" , "description" : "#2 description" , "year" : 2001 },
]
# Embed `description` and create documents
docs = DocList [ MovieDoc ](
MovieDoc ( embedding = embeddings . embed_query ( movie [ "description" ]), ** movie )
for movie in movies
) from docarray . index import (
InMemoryExactNNIndex ,
HnswDocumentIndex ,
WeaviateDocumentIndex ,
QdrantDocumentIndex ,
ElasticDocIndex ,
RedisDocumentIndex ,
MongoDBAtlasDocumentIndex ,
)
# Select a suitable backend and initialize it with data
db = InMemoryExactNNIndex [ MovieDoc ]( docs ) from langchain . chat_models import ChatOpenAI
from langchain . chains import ConversationalRetrievalChain
from langchain . retrievers import DocArrayRetriever
# Create a retriever
retriever = DocArrayRetriever (
index = db ,
embeddings = embeddings ,
search_field = "embedding" ,
content_field = "description" ,
)
# Use the retriever in your chain
model = ChatOpenAI ()
qa = ConversationalRetrievalChain . from_llm ( model , retriever = retriever )Alternativ können Sie eingebaute Vektorgeschäfte verwenden. Langchain unterstützt zwei Vektorgeschäfte: DocarrayinMemorysearch und Docarrayhnswsearch. Beide sind benutzerfreundlich und eignen sich am besten für kleine bis mittlere Datensätze.
Docarray ist eine Marke von LF AI Projects, LLC
