docarray
v0.40.0
멀티 모달 데이터의 데이터 구조
참고 현재보고있는 readme는 Docarray> 0.30에 대한 것입니다. 이전 Docarray <= 0.21을 계속 사용하려면
pip install docarray==0.21통해 설치하십시오. 자세한 내용은 코드베이스, 문서 및 핫픽스 브랜치를 참조하십시오.
Docarray는 다중 모달 데이터의 표현, 전송, 저장 및 검색을 위해 전문적으로 제작 된 Python 라이브러리입니다. 멀티 모달 AI 애플리케이션 개발을 위해 맞춤화 된 설계는 광범위한 파이썬 및 기계 학습 생태계와의 원활한 통합을 보장합니다. 2022 년 1 월 현재, Docarray는 Apache License 2.0에 따라 공개적으로 배포되며 현재 LF AI & Data Foundation 내에서 샌드 박스 프로젝트 상태를 누리고 있습니다.
CLI에서 docarray를 설치하려면 다음 명령을 실행하십시오.
pip install -U docarraydocarray <= 0.21을 사용 하려면
pip install docarray==0.21통해 설치하고 코드베이스 및 문서 및 핫픽스 브랜치를 확인하십시오.
Docarray를 처음 접했습니까? 유스 케이스와 배경에 따라 docarray에 대해 배우는 여러 가지 방법이 있습니다.
Docarray는 본질적으로 기계 학습에 적합한 방식으로 데이터를 표현할 수 있도록합니다.
이것은 특히 다양한 시나리오에 유리합니다.
Pydantic에 익숙합니까? Docarray가 Pydantic 위에 건설되었을뿐만 아니라 그것과의 완전한 호환성을 유지한다는 것을 알게되어 기쁩니다! 또한 귀하의 요구에 전념하는 특정 섹션이 있습니다!
본질적으로 Docarray는 Python Dataclasses를 반영하는 방식으로 데이터 표현을 용이하게하며 기계 학습은 필수 구성 요소입니다.
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)docarray와 함께 데이터를 어떻게 표현할 수 있는지 자세히 살펴 보겠습니다.
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 ] = None따라서 데이터 유형을 정의 할 수있을뿐만 아니라 텐서의 모양을 지정할 수도 있습니다!
# 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])물론 문서를 중첩 된 구조로 구성 할 수 있습니다.
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!' )
) 한 번에 단일 데이터 포인트, 특히 기계 학습 응용 프로그램에서 거의 작업하지 않습니다. 그렇기 때문에 여러 Documents 쉽게 수집 할 수 있습니다.
Documents 를 수집하십시오ML 시스템을 구축하거나 상호 작용할 때 일반적으로 여러 문서 (데이터 포인트)를 한 번에 처리하려고합니다.
Docarray는 다음과 같은 두 가지 데이터 구조를 제공합니다.
DocVec : Documents 의 벡터. 문서의 모든 텐서는 단일 텐서에 쌓입니다. 배치 처리 및 ML 모델 내부의 사용에 적합합니다 .DocList : Documents 목록. 문서의 모든 텐서는 그대로 유지됩니다. 스트리밍, 재 계급 및 데이터 셔플 링에 적합합니다 . 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 )
]
) 위의 코드 스 니펫에서 DocVec 사용하려는 문서 유형으로 매개 변수화 됩니다 : DocVec[Image] .
이것은 처음에는 이상하게 보일지 모르지만, 우리는 당신이 빨리 익숙해 질 것이라고 확신합니다! 게다가, 문서에서 정의한 필드에 대량으로 액세스 할 수있는 것과 같은 멋진 일을 할 수 있습니다.
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 두 번째 데이터 구조 인 DocList 는 비슷한 방식으로 작동합니다.
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 )
]
)문서의 필드에 여전히 대량 액세스 할 수 있습니다.
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 DocList 에 문서를 삽입, 제거 및 추가 할 수 있습니다.
# 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 )),
),
) DocVec 와 DocList 원활하게 전환 할 수 있습니다.
vec_2 = dl . to_doc_vec ()
assert isinstance ( vec_2 , DocVec )
dl_2 = vec_2 . to_doc_list ()
assert isinstance ( dl_2 , DocList )Docarray는 본질적으로 기계 학습과 호환되는 방식으로 데이터의 전송을 용이하게합니다.
여기에는 Protobuf 및 GRPC 에 대한 기본 지원과 HTTP 및 JSON, JSONSCHEMA, BASE64 및 바이트에 대한 직렬화가 포함됩니다.
이 기능은 여러 시나리오에 유리한 것으로 판명됩니다.
Fastapi에 익숙합니까? Docarray가 Fastapi와의 모든 호환성을 유지한다는 사실을 알게되어 기쁩니다! 또한, 우리는 당신을위한 전용 섹션이 있습니다!
데이터 전송과 관련하여 직렬화는 중요한 단계입니다. Docarray 가이 과정을 간소화하는 방법을 살펴 보겠습니다.
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 )물론 일련의 직렬화만으로도 필요한 것은 아닙니다. Docarray가 Jina 및 Fastapi 와 어떻게 통합되는지 확인하십시오.
데이터를 모델링하고 배포 한 후에는 데이터를 어딘가에 저장 하려고합니다. 그것이 Docarray가 들어오는 곳입니다!
문서 저장소는 이름에서 알 수 있듯이 문서를 저장하는 완벽한 방법을 제공합니다. 로컬 또는 원격으로 동일한 사용자 인터페이스를 통해 모든 작업을 수행 할 수 있습니다.
Document Store 인터페이스를 사용하면 동일한 사용자 인터페이스를 사용하여 문서를 여러 데이터 소스를 오가는 것으로 푸시하고 당길 수 있습니다.
예를 들어, 디스크 스토리지에서 어떻게 작동하는지 살펴 보겠습니다.
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' )문서 색인을 사용하면 효율적인 유사성 기반 검색을 위해 벡터 데이터베이스 에 문서를 색인화 할 수 있습니다.
이것은 다음에 유용합니다.
현재 문서 색인은 Weaviate , Qdrant , Elasticsearch , Redis , Mongo Atlas 및 Hnswlib을 지원합니다.
문서 색인 인터페이스를 사용하면 동일한 사용자 인터페이스와 함께 여러 벡터 데이터베이스에서 문서를 색인하고 검색 할 수 있습니다.
ANN 벡터 검색, 텍스트 검색, 필터링 및 하이브리드 검색을 지원합니다.
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' )배경 및 사용 사례에 따라 docarray를 이해하는 방법이 다릅니다.
Docarray 버전 0.30.0 이하를 사용하는 경우 Dataclass API에 익숙합니다.
docarray> = 0.30은 그 아이디어입니다. 모든 문서는 Pydantic의 제공되는 Dataclass와 같은 인터페이스를 통해 작성됩니다.
이것은 다음과 같은 장점을 제공합니다.
벡터 DB 통합을위한 오래된 문서 저장에 익숙 할 수도 있습니다. 이제 문서 색인 이라고하며 다음과 같은 개선 사항을 제공합니다 (새 API 참조).
현재 문서 색인은 Weaviate , Qdrant , Elasticsearch , Redis , Mongo Atlas , 정확한 가장 가까운 이웃 검색 및 HNSWLIB를 지원합니다.
Pydantic 출신이라면 Docarray 문서를 Pydantic Models를 주스로 보이고 Docarray를 주변의 케이크 모음으로 볼 수 있습니다.
보다 구체적으로, 우리는 Pydantic을 ML 세계에 적합하게 만들기 시작했습니다.
이것은 다음과 같은 혜택을 얻는 것을 의미합니다.
.load() image 텐서의 URL, TextUrl은 텍스트 문서 등을로드하고 토큰 화 할 수 있습니다. 여기서 가장 분명한 장점은 {Torch, TF, ...}Tensor , Embedding 등과 같은 ML 중심 데이터에 대한 일류 지원 입니다.
여기에는 텐서 모양의 검증과 같은 편리한 기능이 포함됩니다.
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)Pytorch에서 온 경우 Docarray를 주로 모델을 통해 흐르는 데이터를 구성하는 방법으로 볼 수 있습니다.
몇 가지 장점을 제공합니다.
Docarray는 ML 모델 내부에서 직접 사용하여 Multimodaldata를 처리하고 나타낼 수 있습니다. 이를 통해 nn.Module 내부의 DocArray의 추상화를 사용하여 데이터에 대해 추론 할 수 있으며 모델 교육과 모델 서빙 간의 전환을 완화시키는 FastApi 호환 스키마를 제공합니다.
이것의 효과를 보려면 먼저 삼중 모달 ML 모델의 바닐라 파이토치 구현을 관찰합시다.
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 ,
) 당신이 우리에게 묻는다면 눈은 그리 쉽지 않습니다. 더 나쁜 것은, 하나 더 양식을 추가해야한다면 코드 기반의 모든 부분을 터치하고, forward() 반환 유형을 변경하고 그로부터 하류에서 많은 변화를 만들어야합니다.
이제 Docarray에서 동일한 코드가 어떻게 보이는지 봅시다.
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 docs훨씬 좋아 보이지 않습니까? 당신은 즉시 코드 가독성과 유지 보수 성에서 승리합니다. 또한 동일한 가격으로 Pytorch 모델을 Fastapi 앱으로 전환하고 문서 스키마 정의를 재사용 할 수 있습니다 (아래 참조). 모든 것은 유형 힌트에 의존하여 피닉 방식으로 처리됩니다.
Pytorch 접근 방식과 마찬가지로 Tensorflow와 함께 Docarray를 사용하여 ML 모델 내에서 멀티 모달 데이터를 처리하고 표현할 수도 있습니다.
먼저, Tensorflow와 함께 docarray를 사용하려면 먼저 다음과 같이 설치해야합니다.
pip install tensorflow==2.12.0
pip install protobuf==3.19.0
Pytorch와 함께 Docarray를 사용하는 것과 비교할 때 Tensorflow와 함께 사용할 때는 한 가지 주요 차이점이 있습니다. Docarray의 TorchTensor torch.Tensor 의 서브 클래스이지만 TensorFlowTensor 의 경우는 아닙니다. tf.Tensor 의 기술적 한계로 인해 Docarray의 TensorFlowTensor 는 tf.Tensor 의 서브 클래스가 아니지만 Orthing tf.Tensor a T. .tensor 속성.
이것이 당신에게 어떤 영향을 미칩니 까? 텐서 데이터에 액세스하려면 TensorFlowTensor 인스턴스를 넘기는 대신 작업을 수행하거나 ML 모델에 전달하려면 .tensor 속성에 액세스해야합니다.
이것은 다음과 같습니다.
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 inputs문서는 Pydantic 모델 (비틀림)이므로 Fastapi와 완전히 호환됩니다!
그러나 왜 당신이 이미 알고 사랑하고 사랑하는 피기 틱 모델이 아니라 왜 그것들을 사용해야합니까? 좋은 질문!
그리고 거래를 봉인하려면 Fastapi 앱에 얼마나 쉽게 문서를 문서화하는지 보여 드리겠습니다.
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 ())바닐라 피다 틱 모델처럼!
Jina는 Docarray를 문서를 대표하고 직렬화하기위한 도서관으로 채택했습니다.
Jina는 Docarray로 구축 된 모델과 서비스를 제공하여 Docarray의 직렬화 성능을 최대한 활용하여 이러한 응용 프로그램을 제공하고 확장 할 수 있습니다.
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 )DocArray를 범용 벡터 데이터베이스 클라이언트로 만난 경우 벡터 데이터베이스를위한 새로운 종류의 ORM 으로 생각할 수 있습니다. Docarray의 작업은 멀티 모달, 중첩 및 도메인 별 데이터를 가져 와서 벡터 데이터베이스에 매핑하고 저장하여 검색 할 수 있도록하는 것입니다.
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' )현재 Docarray는 다음 벡터 데이터베이스를 지원합니다.
OpenSearch의 통합이 현재 진행 중입니다.
물론 이것은 Docarray가 할 수있는 일 중 하나 일 뿐이 므로이 readme의 나머지 부분을 확인하는 것이 좋습니다!
docarray를 사용하면 Langchain을 통해 외부 데이터를 LLM에 연결할 수 있습니다. Docarray는 유연한 문서 스키마를 설정하고 문서 저장을위한 다른 백엔드 중에서 자유롭게 선택할 수 있습니다. 문서 색인을 작성한 후 docarrayretriever를 사용하여 Langchain 앱에 연결할 수 있습니다.
Langchain 설치를 통해 :
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 )또는 내장 벡터 매장을 사용할 수 있습니다. Langchain은 DocarrayinMemorySearch 및 DocarrayhnswSearch의 두 벡터 저장소를 지원합니다. 둘 다 사용자 친화적이며 중소형 데이터 세트에 가장 적합합니다.
Docarray는 LF AI Projects, LLC의 상표입니다
