Qu’est-ce qu’un schéma dynamique ?
Cet article est écrit conjointement par Yujian Tang et Zhenshan Cao.
Chaque base de données possède un schéma, mais tous ne sont pas dynamiques. Les bases de données SQL ont des schémas prédéfinis, qui ne changent généralement pas. Lorsque vous la créez, vous indiquez à la base de données à quoi vous voulez que chaque table ressemble et vous imposez que chaque entrée corresponde au schéma de cette table. Les bases de données NoSQL ont généralement un schéma dynamique (ou peuvent être sans schéma). Les attributs de chaque objet n’ont pas à être définis lorsque vous créez vos bases de données.
Pour la base de données vectorielle Milvus, le schéma dynamique est un schéma qui change à mesure que vous ajoutez des données. Par exemple, la prise en charge du schéma dynamique signifie que vous pouvez traiter la saisie de données comme vous le feriez avec une base de données NoSQL et ajouter des données au format JSON. Auparavant, Milvus appliquait strictement un schéma. Nous avons publié une option de schéma dynamique dans Milvus 2.2.9 il y a quelques mois et l’avons rendue facile à mettre en œuvre.
Dans cet article, nous aborderons :
- Qu’est-ce qu’un schéma de base de données ?
- Qu’est-ce qu’un schéma de base de données vectorielle ?
- Comment utiliser le schéma dynamique avec la base de données vectorielle Milvus
- Comment la fonctionnalité de schéma dynamique est implémentée dans Milvus
Avantages et inconvénients des schémas dynamiques
Résumé des schémas dynamiques pour les bases de données vectorielles
Qu’est-ce qu’un schéma de base de données ?
Les schémas structurent la manière dont les données sont insérées et stockées dans une base de données. L’exemple ci-dessus montre comment vous pourriez créer un schéma de base de données normalisé pour une base de données relationnelle. Dans l’exemple ci-dessus, la table centrale comporte quatre colonnes. Cette base de données aurait quatre tables et un schéma pour chaque table.
Trois tables auraient des schémas à deux colonnes, et celle du centre aurait un schéma à quatre colonnes. Les schémas des colonnes incluraient également des définitions de données. Les colonnes “Employee”, “Title” et “DeptName” seraient toutes des chaînes, ou des VARCHAR. Très probablement, “CourseID” le serait aussi. “EmpID” et “DeptID” seraient des entiers, et “Date” pourrait être de type date ou également de type VARCHAR.
Qu’est-ce qu’un schéma de base de données vectorielle ?
L’image ci-dessous montre une entrée dans une instance de Zilliz, le service de base de données vectorielle entièrement géré de Milvus, que j’utilise pour mon projet Chat Towards Data Science. Si nous devions la définir comme un schéma de base de données relationnelle, nous aurions 11 colonnes. Il y aurait six colonnes de chaînes ou VARCHAR - “id”, “paragraph”, “subtitle”, “publication”, “article_url” et “title”. Trois des cinq autres colonnes seraient un type de données INT quelconque - “reading_time”, “responses” et “claps”. Les deux colonnes restantes seraient un type DATE, “date”, et ce que nous appelons un “FLOAT_VECTOR”, le vecteur d’intégration.
Comment utiliser le schéma dynamique avec la base de données vectorielle Milvus ?
Milvus est une base de données vectorielle open source populaire conçue pour les performances, l’évolutivité et la fiabilité. Nous avons publié une option de schéma dynamique dans Milvus 2.2.9 il y a quelques mois et l’avons rendue facile à mettre en œuvre.
L’extrait de code suivant montre comment activer et utiliser la fonctionnalité de schéma dynamique dans Milvus, ainsi que comment insérer des données dans des champs dynamiques et effectuer des recherches filtrées.
from pymilvus import (
connections,
FieldSchema, CollectionSchema, DataType,
Collection,
)
DIMENSION = 8
COLLECTION_NAME = "books"
connections.connect("default", host="localhost", port="19530")
fields = [
FieldSchema(name='id', dtype=DataType.INT64, is_primary=True),
FieldSchema(name='title', dtype=DataType.VARCHAR, max_length=200),
FieldSchema(name='embeddings', dtype=DataType.FLOAT_VECTOR, dim=DIMENSION)
]
schema = CollectionSchema(fields=fields, enable_dynamic_field=True)
collection = Collection(name=COLLECTION_NAME, schema=schema)
data_rows = [
{"id": 1, "title": "Lord of the Flies",
"embeddings": [0.64, 0.44, 0.13, 0.47, 0.74, 0.03, 0.32, 0.6],
"isbn": "978-0399501487"},
{"id": 2, "title": "The Great Gatsby",
"embeddings": [0.9, 0.45, 0.18, 0.43, 0.4, 0.4, 0.7, 0.24],
"author": "F. Scott Fitzgerald"},
{"id": 3, "title": "The Catcher in the Rye",
"embeddings": [0.43, 0.57, 0.43, 0.88, 0.84, 0.69, 0.27, 0.98],
"claps": 100},
]
collection.insert(data_rows)
collection.create_index("embeddings", {"index_type": "FLAT", "metric_type": "L2"})
collection.load()
vector_to_search = [0.57, 0.94, 0.19, 0.38, 0.32, 0.28, 0.61, 0.07]
result = collection.search(
data=[vector_to_search],
anns_field="embeddings",
param={},
limit=3,
expr="claps > 30 || title =='The Great Gatsby'",
output_fields=["title", "author", "claps", "isbn"],
consistency_level="Strong")
for hits in result:
for hit in hits:
print(hit.to_dict())
Dans la collection créée "books", nous définissons un schéma avec trois champs : id, title et embeddings. L’id est la clé primaire, un identifiant unique de chaque ligne, au format INT64. Le title représente le nom du livre avec le type VARCHAR, et l’embedding est une colonne vectorielle à 8 dimensions. Dans cet article, les données vectorielles sont définies aléatoirement dans le code à des fins de démonstration.
schema = CollectionSchema(fields=fields, enable_dynamic_field=True)
collection = Collection(name=COLLECTION_NAME, schema=schema)
Nous activons le schéma dynamique en passant un champ à l’objet CollectionSchema lors de la définition. Tout ce que nous faisons est d’ajouter le schéma enable_dynamic_field et de le définir sur True.
data_rows = [
{"id": 1, "title": "Lord of the Flies",
"embeddings": [0.64, 0.44, 0.13, 0.47, 0.74, 0.03, 0.32, 0.6],
"isbn": "978-0399501487"},
{"id": 2, "title": "The Great Gatsby",
"embeddings": [0.9, 0.45, 0.18, 0.43, 0.4, 0.4, 0.7, 0.24],
"author": "F. Scott Fitzgerald"},
{"id": 3, "title": "The Catcher in the Rye",
"embeddings": [0.43, 0.57, 0.43, 0.88, 0.84, 0.69, 0.27, 0.98],
"claps": 100},
]
Dans le code ci-dessus, nous insérons trois lignes de données. Les données pour id=1 incluent le champ dynamique isbn, id=2 inclut author, et id=3 inclut claps. Ces champs dynamiques ont différents types, notamment des types chaîne (isbn et author) et des types entier (claps).
result = collection.search(
data=[vector_to_search],
anns_field="embeddings",
param={},
limit=3,
expr="claps > 30 || title =='The Great Gatsby'",
output_fields=["title", "author", "claps", "isbn"],
consistency_level="Strong")
Dans le code ci-dessus, nous effectuons une recherche hybride combinant une recherche ANNS (Approximate Nearest Neighbors) avec un filtrage basé sur des champs dynamiques. La requête vise à récupérer les données des lignes qui satisfont aux conditions spécifiées dans le paramètre expr. La sortie inclut les champs title, author, claps et isbn s’ils sont présents. Le paramètre expr permet un filtrage basé sur les champs du schéma (title) et les champs dynamiques (claps).
Après l’exécution du code, les résultats de sortie sont les suivants :
{'id': 2, 'distance': 0.40939998626708984, 'entity': {'title': 'The Great Gatsby', 'author': 'F. Scott Fitzgerald'}}
{'id': 3, 'distance': 1.8463000059127808, 'entity': {'title': 'The Catcher in the Rye', 'claps': 100}}
Comment la fonctionnalité Dynamic Schema est-elle implémentée dans Milvus ?
Le noyau de Milvus permet aux utilisateurs d’ajouter des champs dynamiques avec différents noms et types de données à chaque ligne de données à l’aide d’une colonne méta masquée. Lorsque les utilisateurs créent une table et activent les champs dynamiques, une colonne masquée nommée $meta est créée avec la table. La colonne masquée utilise JSON comme type de données, car il s’agit d’un format de données indépendant du langage, largement pris en charge par les langages de programmation modernes pour générer et analyser des données au format JSON.
Milvus organise les données dans une structure en colonnes. Lors de l’insertion, les données des champs dynamiques de chaque ligne sont regroupées dans un élément de données JSON, et toutes les lignes de données JSON forment ensemble la colonne masquée $meta.
Quels sont les avantages et les inconvénients du schéma dynamique ?
Les schémas dynamiques présentent des avantages et des inconvénients, répondant à différents besoins en matière de modélisation des données.
Avantages
- Les schémas dynamiques sont faciles à configurer, ce qui les rend accessibles à un large éventail d’utilisateurs sans nécessiter de configurations complexes.
- Les schémas dynamiques s’adaptent aux changements des modèles de données au fil du temps, permettant aux développeurs d’ajuster sans restructuration majeure.
Inconvénients :
- La recherche filtrée avec des schémas dynamiques est beaucoup plus lente qu’avec des schémas fixes.
- L’insertion en masse sur un schéma dynamique est compliquée.
Pour relever ces défis, Milvus a intégré un modèle d’exécution vectorisé afin d’améliorer l’efficacité de la recherche filtrée. Contrairement au modèle volcano conventionnel, qui traite une ligne de données à la fois via des opérateurs invoqués, le modèle d’exécution vectorisé traite des lots entiers de données simultanément. Ce paradigme de calcul optimise la localité des données pendant le calcul, ce qui entraîne une amélioration significative des performances globales du système.
À l’avenir, nous continuerons d’améliorer les capacités d’indexation scalaire dans Milvus 2.4. Cette amélioration vise à accélérer la recherche filtrée grâce à l’indexation inversée pour les champs statiques et dynamiques, promettant de meilleures performances et une plus grande efficacité dans la gestion et l’interrogation des schémas dynamiques.
Résumé des schémas dynamiques pour les bases de données vectorielles
Dans cet article, nous avons examiné les schémas de base de données. Nous avons utilisé un exemple de schéma de base de données relationnelle pour mieux comprendre les schémas. Les bases de données relationnelles ont des schémas stricts qui doivent être définis. Les schémas doivent comporter des champs définis, et les champs doivent avoir des types de données définis. C’est ainsi que le schéma de Milvus était auparavant imposé.
Cependant, Milvus n’a en réalité besoin de savoir que comment deux champs sont définis. Premièrement, l’ID de l’entrée, et deuxièmement, le champ d’embedding. Le reste des champs n’a pas besoin d’être défini, mais il peut l’être. Avec l’introduction du schéma dynamique, transmis à l’aide du paramètre enable_dynamic_field, Milvus n’a plus besoin que les autres champs soient définis.
Les schémas dynamiques sont à double tranchant : ils offrent une facilité de configuration, de la flexibilité et de l’efficacité, mais non sans compromis. Par exemple, la recherche filtrée avec des schémas dynamiques est plus lente qu’avec des schémas fixes, et l’insertion en masse sur des schémas dynamiques est plus compliquée. Milvus a utilisé un modèle d’exécution vectorisé pour relever les défis liés aux schémas dynamiques, optimisant ainsi les performances globales du système. Nous améliorerons également les capacités d’indexation scalaire dans Milvus 2.4 afin d’améliorer les performances et l’efficacité dans la gestion et l’interrogation des schémas dynamiques.
Continuer à lire
VidTok: Rethinking Video Processing with Compact Tokenization
VidTok tokenizes videos to reduce redundancy while preserving spatial and temporal details for efficient processing.
AI Integration in Video Surveillance Tools: Transforming the Industry with Vector Databases
Discover how AI and vector databases are revolutionizing video surveillance with real-time analysis, faster threat detection, and intelligent search capabilities for enhanced security.
Why Deepseek is Waking up AI Giants Like OpenAI And Why You Should Care
Discover how DeepSeek R1's open-source AI model with superior reasoning capabilities and lower costs is disrupting the AI landscape and challenging tech giants like OpenAI.