Base de datos vectorial Milvus

Base de datos vectorial Milvus

Capítulo 1 Descripción general de Milvus

Milvus se creó en 2019 con un único objetivo: almacenar, indexar y administrar una gran cantidad de vectores de incrustación generados por redes neuronales profundas y otros modelos de aprendizaje automático (ML ) .

objeto de almacenamiento: vector

NOTE：embedding vectors是对非结构化数据的特征抽象，比如电子邮件、物联网传感器数据、Instagram照片、蛋白质结构等等。现代嵌入技术用于将非结构化数据转换为嵌入向量，从数学上讲，嵌入向量是浮点数或二进制数的数组。

Milvus puede analizar la correlación entre dos vectores calculando su distancia de similitud, si los dos vectores incrustados son muy similares, significa que las fuentes de datos originales también son similares.

1.1 Aplicaciones relacionadas

• Búsqueda de similitud de imágenes: las imágenes se pueden buscar y devuelven instantáneamente las imágenes más similares de una base de datos masiva.

• Búsqueda de similitud de video: al convertir fotogramas clave en vectores y enviar los resultados a Milvus, se pueden buscar y recomendar miles de millones de videos casi en tiempo real.

• Búsqueda de similitud de audio: consulte rápidamente datos de audio masivos, como voz, música, efectos de sonido y sonidos superficialmente similares.

• Búsqueda de similitud molecular: Realice una búsqueda rápida de similitud, búsqueda de subestructura o búsqueda de superestructura para moléculas específicas.

• Sistema de recomendación: Recomendación

Sitio web oficial: https://milvus.io/bootcamp/

1.2 ¿Cómo está diseñado Milvus?

Como base de datos vectorial nativa de la nube, Milvus separa el almacenamiento y la computación por diseño. Para mejorar la resiliencia y la flexibilidad, todos los componentes de Milvus no tienen estado.

El sistema se divide en cuatro niveles:

• Capa de acceso: la capa de acceso consta de un conjunto de proxies sin estado que sirven como capa frontal para el sistema y punto final para el usuario.

• Servicio de Coordinación: El Servicio de Coordinación asigna tareas a los nodos trabajadores y actúa como el cerebro del sistema.

• Nodos trabajadores: los nodos trabajadores son como brazos y piernas, que son ejecutores tontos, siguen las instrucciones del servicio de coordinación y ejecutan comandos DML/DDL activados por los usuarios.

• Almacenamiento: El almacenamiento es la columna vertebral del sistema y es responsable de la persistencia de los datos. Incluye metaalmacenamiento, log

Consulte Descripción general de la arquitectura para obtener más información .

1.3 Herramientas de desarrollo

Milvus cuenta con el respaldo de ricas API y herramientas para facilitar DevOps.

Milvus tiene bibliotecas de clientes envueltas en la parte superior de la API de Milvus que se pueden usar para insertar, eliminar y consultar datos mediante programación desde el código de la aplicación.

PyMilvus

SDK de Node.js

Ir SDK

SDK de Java

Capítulo 2 Inicio rápido

2.1 Instalar Milvus

Instalar usando docker-composeMilvus Standalone

【Paso 1】Descargar milvus-standalone-docker-compose.ymly guardar comodocker-compose.yml

https://github.com/milvus-io/milvus/releases/download/v2.2.3/milvus-standalone-docker-compose.yml

linux

wget https://github.com/milvus-io/milvus/releases/download/v2.2.3/milvus-standalone-docker-compose.yml -O docker-compose.yml

[Paso 2] En docker-compose.ymlel mismo directorio que , inicie todos docker-composelos servicios y ejecútelos en segundo plano

docker-compose up -d

[Paso 3] Muestra docker-composetodos los contenedores que actualmente están programados para ejecutarse

docker-compose ps

Fuera de servicio

docker-compose down

Eliminar datos después de detener Milvus, ejecutar

sudo rm -rf  volumes

Capítulo 3 Aprendizaje

Descarga previa: PyMilvus 2.2.2

pip3 install pymilvus==2.2.2 -i https://pypi.tuna.tsinghua.edu.cn/simple

3.1Administrar conexiones de Milvus (administración de conexiones)

Cómo conectar y desconectar el servidor Milvus

milvus admite dos puertos: 19530 , 9091

• gRPC admite el puerto 19530

  Es el puerto predeterminado cuando se conectan servidores Milvus de diferentes sdk de Milvus.

• La API RESTful admite el puerto 9091

  Se usa cuando se conecta al servidor Milvus usando un cliente HTTP.

Conectarse al servidor Milvus

Establezca una conexión Milvus. Antes de hacer nada, asegúrese de estar conectado al servidor Milvus.

Código de muestra:

from pymilvus import connections

connections.connect(
  alias="default", 
  host='localhost', 
  port='19530'
)

Parámetro	Descripción
alias	El alias para la conexión de Milvus a construir.
host	Dirección IP del servidor Milvus.
port	Puerto del servidor Milvus.

Valor de retorno: la conexión Milvus creada por los parámetros pasados

NOTA: El número máximo de conexiones es 65.536.

Servidor Milvus desconectado

Código de muestra:

connections.disconnect("default")

Parámetro	Descripción
alias	El alias del servidor Milvus del que desconectarse.

3.2 Manage Collections (gestión de colecciones)

La colección a crear debe contener un campo de clave principal y un campo de vector . Los tipos de datos admitidos por el campo de clave principal son INT64 y String.

Preparar esquema

Primero, prepare los parámetros, incluido el esquema de campo, el esquema de colección y el nombre de la colección.

Código de muestra:

from pymilvus import CollectionSchema, FieldSchema, DataType

book_id = FieldSchema(
  name="book_id", 
  dtype=DataType.INT64, 
  is_primary=True, 
)

book_name = FieldSchema(
  name="book_name", 
  dtype=DataType.VARCHAR, 
  max_length=200,
)

word_count = FieldSchema(
  name="word_count", 
  dtype=DataType.INT64,  
)

book_intro = FieldSchema(
  name="book_intro", 
  dtype=DataType.FLOAT_VECTOR, 
  dim=2
)

schema = CollectionSchema(
  fields=[book_id, book_name, word_count, book_intro], 
  description="Test book search"
)

collection_name = "book"

Parámetro	Descripción	Opción
FieldSchema	El esquema de los campos de la colección que se va a crear.	N / A
name	El nombre del campo a crear.	N / A
dtype	El tipo de datos del campo a crear.	DataType.INT64、DataType.VARCHAR、DataType.BOOL、DataType.INT64``DataType.FLOAT、DataType.DOUBLE BINARY_VECTOR FLOAT_VECTOR
is_primaryEl campo clave principal es obligatorio	Si el campo a crear es la clave principal	TrueoFalse
auto_id(El campo clave principal es obligatorio)	Habilite o deshabilite la asignación automática de ID (clave principal).	TrueoFalse
max_length(requerido para el campo VARCHAR)	La longitud máxima de cadena que se permite insertar.	[1, 65,535]
dim(el campo vectorial es obligatorio)	La dimensionalidad del vector.	[1, 32,768]
description(opcional)	Descripción del campo.	N / A
CollectionSchema	El esquema de la colección que se va a crear.	N / A
fields	Los campos de la colección a crear.	N / A
description(opcional)	Una descripción de la colección a crear.	N / A
collection_name	El nombre de la colección a crear.	N / A

crear una colección

Código de muestra:

from pymilvus import Collection
collection = Collection(
    name=collection_name, 
    schema=schema, 
    using='default', 
    shards_num=2
    )

Parámetro	Descripción	Opción
usingopcional	Elija en qué servidor de Milvus se creará la colección especificando aquí el alias del servidor.	N / A
shards_numopcional	El número de fragmentos para que se cree la colección.	[1256]
properties: collection.ttl.secondsopcional	TTL (Tiempo de vida de la colección) es el tiempo de vencimiento de la colección. Los datos de las colecciones caducadas se limpiarán y no se incluirán en búsquedas ni consultas. TTL es en segundos.	El valor debe ser 0 o mayor. 0 significa desactivar TTL.

límite

Característica	Límite máximo
Longitud del nombre de una colección	255 caracteres
Número de particiones en una colección	4,096
Número de campos en una colección	64
Número de fragmentos en una colección	256

Modificar una colección

Código de muestra:

collection.set_properties(properties={
    
    "collection.ttl.seconds": 1800})

TTL (Tiempo de vida de la colección) es el tiempo de vencimiento de los datos en la colección. Los datos vencidos en la colección se limpiarán y no se incluirán en búsquedas o consultas. TTL es en segundos. El valor debe ser 0 o mayor. El valor predeterminado es 0, es decir, la función TTL está deshabilitada.

Verifique la información de la colección

Comprobar si existe colección

from pymilvus import utility

utility.has_collection("book")

Consulta la información específica de la colección

from pymilvus import Collection
collection = Collection("book") # Get an existing collection.

collection.schema             # Return the schema.CollectionSchema of the collection.
collection.description        # Return the description of the collection.
collection.name               # Return the name of the collection.
collection.is_empty           # Return the boolean value that indicates if the collection is empty.
collection.num_entities          # Return the number of entities in the collection.
collection.primary_field         # Return the schema.FieldSchema of the primary key field.
collection.partitions            # Return the list[Partition] object.
collection.indexes               # Return the list[Index] object.
collection.properties		# Return the expiration time of data in the collection.

Enumere todas las colecciones en esta instancia de Milvus.

from pymilvus import utility
utility.list_collections()

Soltar una colección (eliminar una colección)

from pymilvus import utility
utility.drop_collection("book")

Colección Alias ​​​​(alias de colección)

Gestión de alias de colección; la longitud de un alias no puede exceder los 255 caracteres

Crear un alias de colección

from pymilvus import utility
utility.create_alias(
  collection_name = "book",
  alias = "publication"
)

eliminar el alias de la colección

from pymilvus import utility
utility.drop_alias(alias = "publication")

Cambiar el alias de la colección

from pymilvus import utility
utility.alter_alias(
  collection_name = "book",
  alias = "publication"
)

Cargar una colección (cargar una colección)

Cargue la colección en la memoria; todas las operaciones de búsqueda y consulta en Milvus se realizan en la memoria.

Código de muestra:

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load(replica_number=2)

Parámetro	Descripción
partition_name(opcional)	Nombre de partición para cargar
replica_number(opcional)	el número de la copia a cargar

obtener información de copia

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load(replica_number=2)    # Load collection as 2 replicas
result = collection.get_replicas()
print(result)

Liberar una colección (liberar una colección)

Libera una colección de la memoria para reducir el uso de memoria.

Código de muestra:

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.release()

3.3 Administrar particiones (administración de particiones)

Crear una partición (crear una partición)

Milvus permite que grandes cantidades de datos vectoriales se dividan en una pequeña cantidad de particiones, y las búsquedas y otras operaciones se pueden restringir a una partición para mejorar el rendimiento .

Una colección consta de una o más particiones. Al crear una nueva colección, Milvus crea una partición predeterminada _default.

El número de particiones en una colección no puede exceder 4096

Ejemplo: Construir novelas de partición en el libro de colección.

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.create_partition("novel")

Verificar información de partición (verificar información de partición)

1) Comprobar si hay una particióncollection.has_partition()

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.has_partition("novel")

2) Listar todas las particionescollection.partitions

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.partitions

Soltar particiones

Eliminar las particiones en la colección especificada

collection.drop_partition("novel")

Parámetro	Descripción
partition_name	El nombre de la partición a eliminar.

Cargar una partición

cargar la partición en la memoria

将分区而不是整个集合加载到内存中可以显著降低内存使用，Milvus中的所有搜索和查询操作都在内存中执行。

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load(["novel"], replica_number=2)

from pymilvus import Partition
partition = Partition("novel")       # Get an existing partition.
partition.load(replica_number=2)

Parameter	Description
partition_name	分区名称。
replica_number (optional)	要加载的副本的编号。

Get replica information（获取副本信息）

示例代码：

from pymilvus import Partition
partition = Partition("novel")       # Get an existing partition.
partition.load(replica_number=2)     # Load partition as 2 replicas
result = partition.get_replicas()
print(result)

Release a Partition（释放分区）

在执行搜索或查询操作后，将分区从内存中释放，以减少对内存的占用。

示例代码：

from pymilvus import Partition
partition = Partition("novel")       # Get an existing partition.
partition.release()

Parameter	Description
partition_name	分区的名称

3.4Manage Data（数据管理）

Insert Entities（插入实体）

Prepare data（准备数据）

首先，准备要插入的数据。要插入的数据的数据类型必须与集合的模式匹配，否则Milvus将引发异常。

import random
data = [
  [i for i in range(2000)],
  [str(i) for i in range(2000)],
  [i for i in range(10000, 12000)],
  [[random.random() for _ in range(2)] for _ in range(2000)],
]

Insert data to Milvus（数据存储）

指定partition_name，选择将数据插入哪个分区。

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
mr = collection.insert(data)

Parameter	Description
data	Data to insert into Milvus.
partition_name (optional)	要插入数据的分区名称。

Delete Entities（删除实体）

Milvus支持通过布尔表达式过滤的主键删除实体。

Prepare boolean expression

Milvus只支持删除带有明确指定主键的实体，这可以通过术语 in实现

其他运算符只能用于向量搜索中的查询或标量过滤。

下面的示例过滤主键值为0和1的数据。

expr = "book_id in [0,1]"

Delete entities

删除满足布尔表达式的实体。Milvus返回已删除实体的ID列表。

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.delete(expr)

Parameter	Description
expr	布尔表达式，指定要删除的实体。
partition_name (optional)	删除实体的分区名称。

3.5Manage Indexes（索引管理）

Build an Index on Vectors

向量索引是元数据的组织单位，用于加速向量相似性搜索。如果没有建立在向量上的索引，Milvus将默认执行暴力搜索。

下面的例子用欧几里得距离(L2)作为相似度度量来构建一个1024个集群的IVF_FLAT索引。

更多的相似度测量：https://milvus.io/docs/metric.md

Prepare index parameter

index_params = {
    
    
  "metric_type":"L2",
  "index_type":"IVF_FLAT",
  "params":{
    
    "nlist":1024}
}

参数说明：

1）metric_type 用于度量向量相似性的度量类型。

• 浮点向量
  • L2 (Euclidean distance) 欧几里得距离
  • IP (Inner product) 内积（即点积）
• 二进制向量
  • JACCARD (Jaccard distance) 杰卡德距离
  • TANIMOTO (Tanimoto distance) Tanimoto距离
  • HAMMING (Hamming distance) 海明距离
  • SUPERSTRUCTURE (Superstructure)
  • SUBSTRUCTURE (Substructure)

2）index_type 用于加速向量搜索的索引类型。

• 浮点向量

  • FLAT (FLAT)
  • IVF_FLAT (IVF_FLAT)
  • IVF_SQ8 (IVF_SQ8)
  • IVF_PQ (IVF_PQ)
  • HNSW (HNSW)
  • ANNOY (ANNOY)
  • DISKANN* (DISK_ANN)

• 二进制向量

  • BIN_FLAT (BIN_FLAT)
  • BIN_IVF_FLAT (BIN_IVF_FLAT)

3）params

针对索引构建参数，请参阅内存索引和磁盘索引。See In-memory Index and On-disk Index for more information.

Build index

针对向量字段构建索引

通过指定向量字段名和索引参数来构建索引。

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.create_index(
  field_name="book_intro", 
  index_params=index_params
)

Parameter	Description
field_name	要在其上构建索引的向量字段的名称。
index_params	要构建的索引的参数。

Build an Index on Scalars

针对标量构建索引。

不像向量，向量有大小和方向，标量只有大小。Milvus将单个数字和字符串视为标量。下面是Milvus中标量字段可用数据类型的列表。

为了加快混合搜索中的属性过滤，从Milvus v2.1.0开始，可以在标量字段上构建索引。

Build index

针对标量构建索引

要在标量字段上构建索引，不需要设置任何索引参数。标量字段索引名的默认值为default_idx。您可以将它设置为另一个合适的值。

下面的代码片段假设一个名为book的集合已经存在，并且要在字符串字段book_name上创建索引。

from pymilvus import Collection

collection = Collection("book")   
collection.create_index(
  field_name="book_name", 
  index_name="scalar_index",
)
collection.load()

一旦创建了索引，可以在向量相似度搜索中包含一个布尔表达式:

search_param = {
    
    
  "data": [[0.1, 0.2]],
  "anns_field": "book_intro",
  "param": {
    
    "metric_type": "L2", "params": {
    
    "nprobe": 10}},
  "limit": 2,
  "expr": "book_name like \"Hello%\"", 
}
res = collection.search(**search_param)

Drop an Index（删除一个索引）

示例代码：

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.drop_index()

3.6Search And Query

Conduct a Vector Similarity Search（向量相似度搜索）

Milvus中的向量相似搜索，计算查询向量与集合中具有指定相似度量的向量之间的距离，并返回最相似的结果。通过指定筛选标量字段或主键字段的布尔表达式【boolean expression 】，您可以执行混合搜索【 hybrid search 】，甚至使用Time Travel【 Time Travel】进行搜索。

需求：在包含图书ID(主键)、字数(标量字段)和图书介绍(向量字段)的2000行数据集上执行向量相似度搜索，模拟基于向量搜索某些图书的情况。Milvus将根据定义的查询向量和搜索参数返回最相似的结果。

Load collection 加载集合

Milvus中的所有搜索和查询操作都在内存中执行。在进行向量相似性搜索之前，将集合加载到内存中。

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load()

Prepare search parameters 准备查询参数

准备适合搜索场景的参数。

下面的示例定义了搜索策略，使用欧几里得距离计算距离，并从IVF_FLAT索引构建的10个最近的群集中检索向量。

search_params = {
    
    "metric_type": "L2", "params": {
    
    "nprobe": 10}, "offset": 5}

Parameter	Description
metric_type	用于度量向量的相似性策略。See Simlarity Metrics for more information.
params	特定于索引的搜索参数. See Vector Index for more information.

Conduct a vector search 执行向量查询

若要在特定分区 partition中搜索，请指定分区名称列表。

results = collection.search(
	data=[[0.1, 0.2]], 
	anns_field="book_intro", 
	param=search_params,
	limit=10, 
	expr=None,
	consistency_level="Strong"
)

Parameter	Description
data	用于搜索的向量
anns_field	要搜索的字段的名称。
param	特定于索引的搜索参数。See Vector Index for more information.
offset	返回集中要跳过的结果数。这个值和“limit”的和应该小于16384。
limit	数最相似的结果返回。这个值和offset的和应该小于16384。
expr	用于过滤属性的布尔表达式. See Boolean Expression Rules for more information.
partition_names (optional)	要搜索的分区的名称列表。
output_fields (optional)	要返回的字段的名称。当前版本不支持向量字段。
timeout (optional)	允许RPC的持续时间(以秒为单位)。当设置为None时，客户端等待服务器响应或发生错误。
round_decimal (optional)	返回距离的小数位数
consistency_level (optional)	搜索的一致性级别。

检查最相似向量的主键值及其距离。

results[0].ids
results[0].distances

释放在Milvus中加载的集合，以减少搜索完成时的内存消耗。

collection.release()

Conduct a Hybrid Search（混合搜索）

混合搜索本质上是带有属性过滤的向量搜索，通过指定过滤标量字段或主键字段的布尔表达式，可以用某些条件限制搜索。

需求：假设根据向量化搜索某些书籍，但只想要字数在特定范围内的书籍，然后可以指定布尔表达式来过滤搜索参数中的word_count字段。Milvus将只在与表达式匹配的实体中搜索相似的向量。

Load collection（加载集合）

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load()

Conduct a hybrid vector search（执行混合向量搜索）

通过指定布尔表达式，可以在向量搜索期间过滤实体的标量字段。

示例代码：将搜索范围限制为指定的word_count值范围内的向量。

search_param = {
    
    
  "data": [[0.1, 0.2]],
  "anns_field": "book_intro",
  "param": {
    
    "metric_type": "L2", "params": {
    
    "nprobe": 10}},
  "offset": 0,
  "limit": 2,
  "expr": "word_count <= 11000",
}
res = collection.search(**search_param)

NOTE：collection.search返回结果为 SearchResult对象，一个可迭代的2d数组类，其第一个维度是要查询的向量数(nq)，第二个维度是极限数(topk)。

Conduct a Vector Query（向量查询）

与向量相似度搜索不同，向量查询通过基于布尔表达式的标量过滤来检索向量。Milvus支持标量字段中的许多数据类型和各种布尔表达式。布尔表达式对标量字段或主键字段进行筛选，并检索与筛选器匹配的所有结果。

需求：对2000行的图书ID(主键)、字数(标量字段)和图书介绍(向量字段)数据集执行向量查询，模拟根据其ID查询某些图书的情况。

Load collection（加载集合）

from pymilvus import Collection
collection = Collection("book")      # Get an existing collection.
collection.load()

Conduct a vector query（执行向量查询）

res = collection.query(
  expr = "book_id in [2,4,6,8]",
  offset = 0,
  limit = 10, 
  output_fields = ["book_id", "book_intro"],
  consistency_level="Strong"
)

3.7Similarity Metrics

在Milvus中，相似性度量用于度量向量之间的相似性。选择一个好的距离度量有助于显著提高分类和聚类性能。下表显示了这些广泛使用的相似性度量如何与各种输入数据形式和Milvus索引相匹配。

欧式距离（L2）

其中，a = (a₁, a₂，…)， a_n) 、b = (b₁, b₂，…， b_n)是n维欧几里德空间中的两个点。

适用于连续性数据

内积（IP）

两个向量之间的内积定义如下:

其中A和B是向量。