datachain
0.6.8
DataChain est une bibliothèque de trames de données Pythonic moderne conçue pour l'intelligence artificielle. Il est conçu pour organiser vos données non structurées en ensembles de données et les gérer à grande échelle sur votre machine locale. Datachain ne fait pas abstraction ni ne cache les modèles d'IA et les appels d'API, mais aide à les intégrer dans la pile de données postmoderne.
Le stockage comme source de vérité.
Traitez les données non structurées sans copies redondantes à partir de S3, GCP, Azure et des systèmes de fichiers locaux.
Prise en charge des données multimodales : images, vidéo, texte, PDF, JSON, CSV, parquet.
Unissez les fichiers et les métadonnées dans des ensembles de données persistants, versionnés et en colonnes.
Pipelines de données compatibles avec Python.
Opérez sur des objets Python et des champs d'objet.
Parallélisation intégrée et calcul de mémoire insuffisante sans SQL ni Spark.
Enrichissement et traitement des données.
Générez des métadonnées à l'aide de modèles d'IA locaux et d'API LLM.
Filtrez, rejoignez et regroupez par métadonnées. Recherche par intégrations vectorielles.
Transmettez des ensembles de données à Pytorch et Tensorflow, ou exportez-les vers un stockage.
Efficacité.
Parallélisation, charges de travail insuffisantes en mémoire et mise en cache des données.
Opérations vectorisées sur les champs d'objets Python : somme, nombre, moyenne, etc.
Recherche de vecteurs optimisée.
$ pip installer la chaîne de données
Un stockage se compose d'images de chats et de chiens (dog.1048.jpg, cat.1009.jpg), annotées avec une vérité terrain et des inférences de modèle au format « json-pairs », où chaque image possède un fichier JSON correspondant comme cat. 1009.json :
{"class": "cat", "id": "1009", "num_annotators": 8,"inference": {"class": "dog", "confidence": 0.68}
}Exemple de téléchargement uniquement d'images déduites « chat de haute confiance » à l'aide de métadonnées JSON :
à partir de la colonne d'importation de la chaîne de données, DataChainmeta = DataChain.from_json("gs://datachain-demo/dogs-and-cats/*json", object_name="meta")images = DataChain.from_storage("gs://datachain-demo /chiens-et-chats/*jpg")images_id = images.map(id=fichier lambda : file.path.split('.')[-2])annotated = images_id.merge(meta, on="id", right_on="meta.id")likely_cats = annotated.filter((Column("meta.inference .confiance") > 0,93)
& (Column("meta.inference.class_") == "cat"))likely_cats.export_files("high-confidence-cats/", signal="file")Inférence par lots avec un modèle de sentiment simple utilisant la bibliothèque de transformateurs :
pip installer des transformateurs
Le code ci-dessous télécharge les fichiers dans le cloud et applique une fonction définie par l'utilisateur à chacun d'eux. Tous les fichiers avec un sentiment positif détecté sont ensuite copiés dans le répertoire local.
depuis le pipeline d'importation des transformateurs depuis l'importation de la chaîne de données DataChain, Columnclassifier = pipeline("sentiment-analysis", device="cpu",model="distilbert/distilbert-base-uncased-finetuned-sst-2-english")def is_positive_dialogue_ending(file) - > bool:dialogue_ending = file.read()[-512:]return classifier(dialogue_ending)[0]["label"] == Chaîne "POSITIVE" = ( DataChain.from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file", type="text")
.settings (parallèle = 8, cache = True)
.map(is_positive=is_positive_dialogue_ending)
.save("file_response")
)positive_chain = chain.filter(Column("is_positive") == True)positive_chain.export_files("./output")print(f"{positive_chain.count()} les fichiers ont été exportés")13 fichiers ont été exportés
$ ls sortie/datachain-demo/chatbot-KiT/ 15.txt 20.txt 24.txt 27.txt 28.txt 29.txt 33.txt 37.txt 38.txt 43.txt ... $ ls sortie/datachain-demo/chatbot-KiT/ | toilettes -l 13
Les LLM peuvent fonctionner comme des classificateurs universels. Dans l'exemple ci-dessous, nous utilisons une API gratuite de Mistral pour évaluer les boîtes de dialogue du chatbot accessibles au public. Veuillez obtenir une clé API Mistral gratuite sur https://console.mistral.ai
$ pip install mistralai (Nécessite une version >=1.0.0) $ export MISTRAL_API_KEY=_votre_clé_
DataChain peut paralléliser les appels d'API ; le niveau gratuit Mistral prend en charge jusqu'à 4 demandes en même temps.
from mistralai import Mistralfrom datachain import File, DataChain, ColumnPROMPT = "Cette boîte de dialogue a-t-elle réussi ? Répondez en un seul mot : Succès ou Échec."def eval_dialogue(file: File) -> bool: client = Mistral() réponse = client.chat .complete( model="open-mixtral-8x22b", messages=[{"role": "system", "content": PROMPT},
{"role": "user", "content": file.read()}]) résultat = réponse.choices[0].message.content return result.lower().startswith("success")chain = ( DataChain .from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file")
.settings (parallèle = 4, cache = True)
.map(is_success=eval_dialogue)
.save("mistral_files")
)successful_chain = chain.filter(Column("is_success") == True)successful_chain.export_files("./output_mistral")print(f"{successful_chain.count()} les fichiers ont été exportés")Avec les instructions ci-dessus, le modèle Mistral considère 31/50 fichiers pour contenir les dialogues réussis :
$ ls output_mistral/datachain-demo/chatbot-KiT/ 1.txt 15.txt 18.txt 2.txt 22.txt 25.txt 28.txt 33.txt 37.txt 4.txt 41.txt ... $ ls output_mistral/datachain-demo/chatbot-KiT/ | toilettes -l 31
Les réponses LLM peuvent contenir des informations précieuses pour l'analyse, telles que le nombre de jetons utilisés ou les paramètres de performances du modèle.
Au lieu d'extraire ces informations de la structure de données de réponse Mistral (classe ChatCompletionResponse), DataChain peut sérialiser l'intégralité de la réponse LLM vers la base de données interne :
from mistralai import Mistralfrom mistralai.models import ChatCompletionResponsefrom datachain import File, DataChain, ColumnPROMPT = "Cette boîte de dialogue a-t-elle réussi ? Répondez en un seul mot : succès ou échec." def eval_dialog(file: File) -> ChatCompletionResponse: client = MistralClient() return client.chat( model="open-mixtral-8x22b", messages=[{"role": "system", "contenu": PROMPT},
{"role": "user", "content": file.read()}])chain = ( DataChain.from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file")
.settings (parallèle = 4, cache = True)
.map(response=eval_dialog)
.map(status=réponse lambda : response.choices[0].message.content.lower()[:7])
.save("réponse")
)chain.select("file.name", "status", "response.usage").show(5)success_rate = chain.filter(Column("status") == "success").count() / chain .count()print(f"{100*success_rate:.1f}% des boîtes de dialogue ont réussi")Sortir:
état du fichier réponse réponse réponse
nom utilisation utilisation utilisation
prompt_tokens total_tokens complétion_tokens
0 1.txt succès 547 548 1
1 Échec du 10.txt 3576 3578 2
2 Échec du 11.txt 626 628 2
3 Échec du fichier 12.txt 1144 1182 38
4 13.txt succès 1100 1101 1
[Limité à 5 lignes]
64,0 % des dialogues ont réussiDans les exemples précédents, les jeux de données étaient enregistrés dans la base de données embarquée (SQLite dans le dossier .datachain du répertoire de travail). Ces ensembles de données ont été automatiquement versionnés et sont accessibles à l'aide de DataChain.from_dataset("dataset_name").
Voici comment récupérer un ensemble de données enregistré et parcourir les objets :
chain = DataChain.from_dataset("response")# Itération un par un : prise en charge du workflow de manque de mémoire pour le fichier, réponse dans chain.limit(5).collect("file", "response") :# vérifier le objets Python collectésassert isinstance(response, ChatCompletionResponse)status = réponse.choices[0].message.content[:7]tokens = réponse.usage.total_tokensprint(f"{file.get_uri()} : {status}, taille du fichier : {file.size}, jetons : {tokens}")Sortir:
gs://datachain-demo/chatbot-KiT/1.txt : Succès, taille du fichier : 1776, jetons : 548 gs://datachain-demo/chatbot-KiT/10.txt : Échec, taille du fichier : 11 576, jetons : 3 578 gs://datachain-demo/chatbot-KiT/11.txt : Échec, taille du fichier : 2045, jetons : 628 gs://datachain-demo/chatbot-KiT/12.txt : Échec, taille du fichier : 3833, jetons : 1207 gs://datachain-demo/chatbot-KiT/13.txt : Succès, taille du fichier : 3657, jetons : 1101
Certaines opérations peuvent s'exécuter dans la base de données sans désérialisation. Par exemple, calculons le coût total d'utilisation des API LLM, en supposant que l'appel Mixtral coûte 2 $ pour 1 million de jetons d'entrée et 6 $ pour 1 million de jetons de sortie :
chain = DataChain.from_dataset("mistral_dataset")cost = chain.sum("response.usage.prompt_tokens")*0,000002
+ chain.sum("response.usage.completion_tokens")*0.000006print(f"Dépensé ${cost:.2f} en {chain.count()} appels")Sortir:
Dépensé 0,08 $ pour 50 appels
Les résultats de la chaîne peuvent être exportés ou transmis directement au chargeur de données PyTorch. Par exemple, si nous souhaitons transmettre une image et une étiquette basée sur le suffixe du nom de fichier, le code suivant le fera :
depuis torch.utils.data import DataLoaderfrom transformers import CLIPProcessorfrom datachain import C, DataChainprocessor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")chain = (DataChain.from_storage("gs://datachain-demo/dogs -et-chats/", type="image")
.map(label=nom lambda : name.split(".")[0], params=["file.name"])
.select("file", "label").to_pytorch(transform=processor.image_processor,tokenizer=processor.tokenizer,
)
)loader = DataLoader (chaîne, batch_size=1)Commencer
Multimodal (essayez dans Colab)
Évaluations LLM (essayer dans Colab)
Lecture des métadonnées JSON (essayez dans Colab)
Les contributions sont les bienvenues. Pour en savoir plus, consultez le Guide du contributeur.
Documents
Signalez un problème si vous rencontrez des problèmes
Discussion Discorde
Gazouillement
