Kā izveidot dzīvu attēlu meklēšanu ar redzes modeli un vaicājumu ar dabisko valodu

Šajā blogā mēs izveidosim tiešraides attēlu meklēšanu un vaicāsim to ar dabisko valodu. Piemēram, jūs varat meklēt "elefantu" vai "skaistu dzīvnieku" ar attēlu sarakstu kā ievadi.

Mēs izmantosim multimodālo ievietošanas modeli, lai saprastu un ievietotu attēlu, un izveidotu vektoru indeksu efektīvai atlasīšanai. Mēs izmantosim CocoIndex, lai izveidotu indeksēšanas plūsmu, tas ir ļoti efektīvs reāllaika datu transformācijas framework. Darbības laikā jūs varat pievienot jaunus failus mapei, un tas tikai apstrādā mainītos failus un tiks indeksēts minūtē.

Tas mums daudz nozīmētu, ja jūs varētu nokrist zvaigzniCocoIndex uz GitHubJa šis tutoriāls ir noderīgs

Tehnoloģijas

Koka indekss

Koka indekssir ļoti jaudīga reāllaika datu transformācijas sistēma AI.

Klips ViT-L/14

Klips ViT-L/14ir spēcīgs redzes valodas modelis, kas var saprast gan attēlus, gan tekstus. tas ir apmācīts, lai saskaņotu vizuālās un teksta pārstāvības kopīgā ievietošanas telpā, padarot to perfektu mūsu attēlu meklēšanas lietošanas gadījumam.

Mūsu projektā mēs izmantojam CLIP, lai:

1. Izveidojiet attēlu ievietojumus tieši
2. Pārvērst dabiskās valodas meklēšanas vaicājumus tajā pašā ievietošanas telpā
3. Ieslēdziet semantisko meklēšanu, salīdzinot vaicājumu ievietojumus ar virsrakstu ievietojumiem

Rēzeknes

Rēzeknesir augstas veiktspējas vectoru datu bāze. Mēs to izmantojam, lai uzglabātu un vaicātu ievietojumus.

Ātrums

Ātrumsir moderns, ātrs (augstas veiktspējas) tīmekļa framework, lai izveidotu API ar Python 3.7 +, pamatojoties uz standarta Python tipa padomiem.

Priekšnoteikumi

• Instalējiet Postgres. CocoIndex izmanto Postgres, lai izsekotu datu līniju pakāpeniskai apstrādei.
• Instalējiet Qdrant

Indeksa plūsmas definīcija

Flow dizains

Plūsmas diagramma ilustrē, kā mēs apstrādāsim mūsu kodu bāzi:

1. Lasīt attēlu failus no vietējās failu sistēmas
2. Izmantojiet CLIP, lai izprastu un iestrādātu attēlu
3. Iebūvējumi tiek glabāti vektoru datubāzē atlases nolūkā

1. ievietojiet attēlus

@cocoindex.flow_def(name="ImageObjectEmbedding")
def image_object_embedding_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope):
    data_scope["images"] = flow_builder.add_source(
        cocoindex.sources.LocalFile(path="img", included_patterns=["*.jpg", "*.jpeg", "*.png"], binary=True),
        refresh_interval=datetime.timedelta(minutes=1)  # Poll for changes every 1 minute
    )
    img_embeddings = data_scope.add_collector()

flow_builder.add_sourcetiks izveidota tabula ar apakšlodziņiem (filename,contentMēs varam atsaukties uzDokumentācijaVairāk par detaļām.

2. apstrādāt katru attēlu un vākt informāciju.

2.1 Iekļaujiet attēlu ar CLIP

@functools.cache
def get_clip_model() -> tuple[CLIPModel, CLIPProcessor]:
    model = CLIPModel.from_pretrained(CLIP_MODEL_NAME)
    processor = CLIPProcessor.from_pretrained(CLIP_MODEL_NAME)
    return model, processor

Tās@functools.cacheŠajā gadījumā tas nodrošina, ka mēs ielādējam CLIP modeli un procesoru tikai vienu reizi.

@cocoindex.op.function(cache=True, behavior_version=1, gpu=True)
def embed_image(img_bytes: bytes) -> cocoindex.Vector[cocoindex.Float32, Literal[384]]:
    """
    Convert image to embedding using CLIP model.
    """
    model, processor = get_clip_model()
    image = Image.open(io.BytesIO(img_bytes)).convert("RGB")
    inputs = processor(images=image, return_tensors="pt")
    with torch.no_grad():
        features = model.get_image_features(**inputs)
    return features[0].tolist()

embed_imageir pielāgota funkcija, kas izmanto CLIP modeli, lai pārvērstu attēlu par vektoru iebūvi. tā pieņem attēla datus bitu formātā un atgriež sarakstu ar plūstošo punktu numuriem, kas pārstāv attēla iebūvi.

Funkcija atbalsta caching caurcacheparametrs. Kad tas ir ieslēgts, izpildītājs glabā funkcijas rezultātus atkalizmantošanas laikā atkalizmantošanai, kas ir īpaši noderīgi aprēķinu intensīvām darbībām.Dokumentācija.

Tad mēs apstrādāsim katru attēlu un apkoposim informāciju.

with data_scope["images"].row() as img:
    img["embedding"] = img["content"].transform(embed_image)
    img_embeddings.collect(
        id=cocoindex.GeneratedField.UUID,
        filename=img["filename"],
        embedding=img["embedding"],
    )

2.3 Iekārtas savākšana

Eksportējiet ievietojumus uz tabulu Qdrant.

img_embeddings.export(
    "img_embeddings",
    cocoindex.storages.Qdrant(
        collection_name="image_search",
        grpc_url=QDRANT_GRPC_URL,
    ),
    primary_key_fields=["id"],
    setup_by_user=True,
)

Izvēlieties indeksu

Iebūvējiet vaicājumu ar CLIP, kas kartē gan tekstu, gan attēlus vienā un tajā pašā iebūvētajā telpā, ļaujot meklēt starpmodālu līdzību.

def embed_query(text: str) -> list[float]:
    model, processor = get_clip_model()
    inputs = processor(text=[text], return_tensors="pt", padding=True)
    with torch.no_grad():
        features = model.get_text_features(**inputs)
    return features[0].tolist()

FastAPI Endpoint definīcija/searchIzmanto semantisko attēlu meklēšanu.

@app.get("/search")
def search(q: str = Query(..., description="Search query"), limit: int = Query(5, description="Number of results")):
    # Get the embedding for the query
    query_embedding = embed_query(q)
    
    # Search in Qdrant
    search_results = app.state.qdrant_client.search(
        collection_name="image_search",
        query_vector=("embedding", query_embedding),
        limit=limit
    )
    

Tas meklē Qdrant vectoru datubāzi, lai atrastu līdzīgus iebūvējumus.limitRezultāti

# Format results
out = []
for result in search_results:
    out.append({
        "filename": result.payload["filename"],
        "score": result.score
    })
return {"results": out}

Šis gala punkts ļauj semantisko attēlu meklēšanu, kur lietotāji var atrast attēlus, aprakstot tos dabiskā valodā, nevis izmantojot precīzus atslēgvārdu atbilstības.

Pielietojums

Ātrais ugunsgrēks

app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)
# Serve images from the 'img' directory at /img
app.mount("/img", StaticFiles(directory="img"), name="img")

FastAPI lietojumprogrammu iestatīšana ar CORS middleware un statisko failu apkalpošanu Lietojumprogramma ir konfigurēta šādi:

• Atļaut krusteniskās izcelsmes pieprasījumus no jebkuras izcelsmes
• Statisko attēlu faili no 'img' direktorijas
• API gala punktu apstrāde attēlu meklēšanas funkcionalitātei

@app.on_event("startup")
def startup_event():
    load_dotenv()
    cocoindex.init()
    # Initialize Qdrant client
    app.state.qdrant_client = QdrantClient(
        url=QDRANT_GRPC_URL,
        prefer_grpc=True
    )
    app.state.live_updater = cocoindex.FlowLiveUpdater(image_object_embedding_flow)
    app.state.live_updater.start()

Startēšanas notikumu pārvaldnieks inicializē lietojumprogrammu, kad tā pirmo reizi tiek uzsākta.

1. load_dotenv(): ielādē vides mainīgos no .env faila, kas ir noderīgs konfigurācijai, piemēram, API atslēgām un URL
2. cocoindex.init(): Initializē CocoIndex sistēmu, izveidojot nepieciešamās sastāvdaļas un konfigurācijas
3. Qdrant Client Setup:
   • Creates a new QdrantClient instance
   • Configures it to use the gRPC URL specified in environment variables
   • Enables gRPC preference for better performance
   • Stores the client in the FastAPI app state for access across requests
4. Live Updater Setup:
   • Creates a FlowLiveUpdater instance for the image_object_embedding_flow
   • This enables real-time updates to the image search index
   • Starts the live updater to begin monitoring for changes

Šī inicializācija nodrošina, ka visas nepieciešamās sastāvdaļas ir pareizi konfigurētas un darbojas, kad tiek uzsākta lietojumprogramma.

frontē

Jūs varat pārbaudīt frontend koduŠeitMēs apzināti saglabājām vienkāršu un minimālisku, lai koncentrētos uz attēlu meklēšanas funkcionalitāti.

Laiks izklaidēties!

• Create a collection in Qdrant

  curl -X PUT 'http://localhost:6333/collections/image_search' \
  -H 'Content-Type: application/json' \
  -d '{
      "vectors": {
      "embedding": {
          "size": 768,
          "distance": "Cosine"
      }
      }
  }'
  

• Setup indexing flow

  cocoindex setup main.py
  

  It is setup with a live updater, so you can add new files to the folder and it will be indexed within a minute.

• Run backend

  uvicorn main:app --reload --host 0.0.0.0 --port 8000
  

• Run frontend

  cd frontend
  npm install
  npm run dev
  

Iet uzhttp://localhost:51742 Meklēt

Pievienojiet vēl vienu attēlu uzimgSīkdatnes, piemēram, šoMīļie zirnekļi, vai jebkuru attēlu, kas jums patīk.Pagaidiet minūti, līdz jaunais attēls tiek apstrādāts un indeksēts.

Ja vēlaties uzraudzīt indeksēšanas progresu, varat to apskatīt CocoInsightcocoindex server -ci main.py .

Finally - we are constantly improving, and more features and examples are coming soon. If you love this article, please give us a star ⭐ at GitHub to help us grow. Thanks for reading!