Testa e distribuisci rapidamente soluzioni di ricerca vettoriale con il Bootcamp Milvus 2.0
Con il rilascio di Milvus 2.0, il team ha rinnovato il bootcamp di Milvus. Il nuovo bootcamp migliorato offre guide aggiornate ed esempi di codice più facili da seguire per una varietà di casi d'uso e distribuzioni. Inoltre, questa nuova versione è aggiornata per Milvus 2.0, una versione ripensata del database vettoriale più avanzato al mondo.
Metti alla prova il tuo sistema con benchmark su dataset da 1M e 100M
La directory benchmark contiene test di benchmark vettoriali da 1 milione e 100 milioni che indicano come il tuo sistema reagirà a dataset di dimensioni diverse.
Esplora e crea soluzioni popolari di ricerca per similarità vettoriale
La directory solution include i casi d'uso più popolari della ricerca per similarità vettoriale. Ogni caso d'uso contiene una soluzione notebook e una soluzione distribuibile con docker. I casi d'uso includono:
- Ricerca per similarità di immagini
- Ricerca per similarità di video
- Ricerca per similarità di audio
- Sistema di raccomandazione
- Ricerca molecolare
- Sistema di risposta alle domande
Distribuisci rapidamente un'applicazione completamente realizzata su qualsiasi sistema
Le soluzioni di distribuzione rapida sono soluzioni dockerizzate che consentono agli utenti di distribuire applicazioni completamente realizzate su qualsiasi sistema. Queste soluzioni sono ideali per brevi demo, ma richiedono lavoro aggiuntivo per essere personalizzate e comprese rispetto ai notebook.
Usa notebook specifici per scenario per distribuire facilmente applicazioni preconfigurate
I notebook contengono un semplice esempio di distribuzione di Milvus per risolvere il problema in un determinato caso d'uso. Ciascuno degli esempi può essere eseguito dall'inizio alla fine senza la necessità di gestire file o configurazioni. Ogni notebook è inoltre facile da seguire e modificabile, il che li rende file di base ideali per altri progetti.
Esempio di notebook per la ricerca per similarità di immagini
La ricerca per similarità di immagini è una delle idee fondamentali alla base di molte tecnologie diverse, incluse le auto autonome che riconoscono oggetti. Questo esempio spiega come creare facilmente programmi di visione artificiale con Milvus.
Questo esempio copre tre cose:
- Server Milvus
- Server Redis (per l'archiviazione dei metadati)
- Modello Resnet-18 preaddestrato.
Passaggio 1: Scarica i pacchetti richiesti
Inizia scaricando tutti i pacchetti richiesti per questo progetto. Questo notebook include una tabella che elenca i pacchetti da utilizzare.
pip install -r requirements.txt
Passaggio 2: Avvio del server
Dopo che i pacchetti sono stati installati, avvia i server e assicurati che entrambi funzionino correttamente. Assicurati di seguire le istruzioni corrette per avviare i server Milvus e Redis.
Passaggio 3: Scarica i dati del progetto
Per impostazione predefinita, questo notebook scarica un estratto dei dati VOCImage da usare come esempio, ma qualsiasi directory con immagini dovrebbe funzionare purché segua la struttura dei file visibile all'inizio del notebook.
! gdown "https://drive.google.com/u/1/uc?id=1jdudBiUu41kL-U5lhH3ari_WBRXyedWo&export=download"
! tar -xf 'VOCdevkit.zip'
! rm 'VOCdevkit.zip'
Passaggio 4: Connettiti ai server
In questo esempio, i server sono in esecuzione sulle porte predefinite sul localhost.
connections.connect(host="127.0.0.1", port=19537)
red = redis.Redis(host = '127.0.0.1', port=6379, db=0)
Passaggio 5: Creare una collection
Dopo aver avviato i server, crea una collection in Milvus per memorizzare tutti i vettori. In questo esempio, la dimensione è impostata su 512, la dimensione dell'output di resnet-18, e la metrica di similarità è impostata sulla distanza euclidea (L2). Milvus supporta una varietà di diverse metriche di similarità.
collection_name = "image_similarity_search"
dim = 512
default_fields = [
schema.FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
schema.FieldSchema(name="vector", dtype=DataType.FLOAT_VECTOR, dim=dim)
]
default_schema = schema.CollectionSchema(fields=default_fields, description="Image test collection")
collection = Collection(name=collection_name, schema=default_schema)
Passaggio 6: Creare un indice per la collection
Una volta creata la collection, crea un indice per essa. In questo caso, viene utilizzato l'indice IVF_SQ8. Questo indice richiede il parametro 'nlist', che indica a Milvus quanti cluster creare all'interno di ciascun datafile (segmento). Diversi indici richiedono parametri diversi.
default_index = {"index_type": "IVF_SQ8", "params": {"nlist": 2048}, "metric_type": "L2"}
collection.create_index(field_name="vector", index_params=default_index)
collection.load()
Passaggio 7: Configurare il modello e il data loader
Dopo aver creato l'indice IVF_SQ8, configura la rete neurale e il data loader. Il resnet-18 pytorch preaddestrato utilizzato in questo esempio è privo del suo ultimo livello, che comprime i vettori per la classificazione e potrebbe perdere informazioni preziose.
model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet18', pretrained=True)
encoder = torch.nn.Sequential(*(list(model.children())[:-1]))
Il dataset e il data loader devono essere modificati in modo da poter preelaborare e raggruppare in batch le immagini fornendo anche i percorsi dei file delle immagini. Questo può essere fatto con un dataloader torchvision leggermente modificato. Per la preelaborazione, le immagini devono essere ritagliate e normalizzate poiché il modello resnet-18 è stato addestrato su una dimensione e un intervallo di valori specifici.
dataset = ImageFolderWithPaths(data_dir, transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])]))
dataloader = torch.utils.data.DataLoader(dataset, num_workers=0, batch_si
Passaggio 8: Inserire i vettori nella collection
Con la collection configurata, le immagini possono essere elaborate e caricate nella collection creata. Per prima cosa, le immagini vengono prelevate dal dataloader ed eseguite attraverso il modello resnet-18. Gli embedding vettoriali risultanti vengono poi inseriti in Milvus, che restituisce un ID univoco per ciascun vettore. Gli ID dei vettori e i percorsi dei file immagine vengono quindi inseriti come coppie chiave-valore nel server Redis.
steps = len(dataloader)
step = 0
for inputs, labels, paths in dataloader:
with torch.no_grad():
output = encoder(inputs).squeeze()
output = output.numpy()
mr = collection.insert([output.tolist()])
ids = mr.primary_keys
for x in range(len(ids)):
red.set(str(ids[x]), paths[x])
if step%5 == 0:
print("Insert Step: " + str(step) + "/" + str(steps))
step += 1
Passaggio 9: Eseguire una ricerca di similarità vettoriale
Una volta inseriti tutti i dati in Milvus e Redis, è possibile eseguire la ricerca effettiva di similarità vettoriale. Per questo esempio, tre immagini selezionate casualmente vengono estratte dal server Redis per una ricerca di similarità vettoriale.
random_ids = [int(red.randomkey()) for x in range(3)]
search_images = [x.decode("utf-8") for x in red.mget(random_ids)]
Queste immagini passano prima attraverso lo stesso preprocessing che si trova nel Passaggio 7 e vengono poi inviate al modello resnet-18.
transform_ops = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
embeddings = [transform_ops(Image.open(x)) for x in search_images]
embeddings = torch.stack(embeddings, dim=0)
with torch.no_grad():
embeddings = encoder(embeddings).squeeze().numpy()
Poi gli embedding vettoriali risultanti vengono utilizzati per eseguire una ricerca. Per prima cosa, imposta i parametri di ricerca, inclusi il nome della raccolta da cercare, nprobe (il numero dei cluster da cercare) e top_k (il numero di vettori restituiti). In questo esempio, la ricerca dovrebbe essere molto rapida.
search_params = {"metric_type": "L2", "params": {"nprobe": 32}}
start = time.time()
results = collection.search(embeddings, "vector", param=search_params, limit=3, expr=None)
end = time.time() - start
Passaggio 10: Risultati della ricerca di immagini
Gli ID dei vettori restituiti dalle query vengono utilizzati per trovare le immagini corrispondenti. Matplotlib viene poi utilizzato per visualizzare i risultati della ricerca di immagini.
Figura 1.
Figura 2.
Figura 3.
Scopri come distribuire Milvus in diversi ambienti
La sezione deployments del nuovo bootcamp contiene tutte le informazioni per utilizzare Milvus in diversi ambienti e configurazioni. Include la distribuzione di Mishards, l'uso di Kubernetes con Milvus, il bilanciamento del carico e altro ancora. Ogni ambiente dispone di una guida dettagliata passo dopo passo che spiega come far funzionare Milvus al suo interno.
Non fare lo sconosciuto
- Leggi il nostro blog.
- Interagisci con la nostra community open-source su Slack.
- Usa o contribuisci a Milvus, il database vettoriale più popolare al mondo, su GitHub.
Continua a leggere
Democratizing AI: Making Vector Search Powerful and Affordable
Zilliz democratizes AI vector search with Milvus 2.6 and Zilliz Cloud for powerful, affordable scalability, cutting costs in infrastructure, operations, and development.
Vector Databases vs. Key-Value Databases
Use a vector database for AI-powered similarity search; use a key-value database for high-throughput, low-latency simple data lookups.
Selecting the Right ETL Tools for Unstructured Data to Prepare for AI
Learn the right ETL tools for unstructured data to power AI. Explore key challenges, tool comparisons, and integrations with Milvus for vector search.