datachain -Download - datachain Quellcode herunterladen

datachain

Anderer Quellcode

0.6.8

Herunterladen

Datenkette

DataChain ist eine moderne Pythonic-Datenrahmenbibliothek, die für künstliche Intelligenz entwickelt wurde. Es dient dazu, Ihre unstrukturierten Daten in Datensätzen zu organisieren und sie im großen Maßstab auf Ihrem lokalen Computer zu verarbeiten. Datachain abstrahiert oder verbirgt die KI-Modelle und API-Aufrufe nicht, sondern hilft, sie in den postmodernen Datenstapel zu integrieren.

Hauptmerkmale

Speicherung als Quelle der Wahrheit.
- Verarbeiten Sie unstrukturierte Daten ohne redundante Kopien aus S3, GCP, Azure und lokalen Dateisystemen.
- Multimodale Datenunterstützung: Bilder, Video, Text, PDFs, JSONs, CSVs, Parkett.
- Vereinen Sie Dateien und Metadaten in persistenten, versionierten, spaltenbasierten Datensätzen.
Python-freundliche Datenpipelines.
- Arbeiten Sie mit Python-Objekten und Objektfeldern.
- Integrierte Parallelisierung und Out-of-Memory-Computing ohne SQL oder Spark.
Datenanreicherung und -verarbeitung.
- Generieren Sie Metadaten mithilfe lokaler KI-Modelle und LLM-APIs.
- Filtern, verknüpfen und gruppieren Sie nach Metadaten. Suche nach Vektoreinbettungen.
- Übergeben Sie Datensätze an Pytorch und Tensorflow oder exportieren Sie sie zurück in den Speicher.
Effizienz.
- Parallelisierung, Out-of-Memory-Workloads und Daten-Caching.
- Vektorisierte Operationen an Python-Objektfeldern: Summe, Anzahl, Durchschnitt usw.
- Optimierte Vektorsuche.

Schnellstart

 $ pip Datenkette installieren

Auswählen von Dateien mithilfe von JSON-Metadaten

Ein Speicher besteht aus Bildern von Katzen und Hunden (dog.1048.jpg, cat.1009.jpg), kommentiert mit Ground Truth und Modellinferenzen im „JSON-Pairs“-Format, wobei jedes Bild eine passende JSON-Datei wie cat hat. 1009.json:

 {"class": "cat", "id": "1009", "num_annotators": 8,"inference": {"class": "dog", "confidence": 0.68}
}

Beispiel für das Herunterladen nur abgeleiteter „High-Confidenz-Katze“-Bilder mithilfe von JSON-Metadaten:

 from datachain import Column, DataChainmeta = DataChain.from_json("gs://datachain-demo/dogs-and-cats/*json", object_name="meta")images = DataChain.from_storage("gs://datachain-demo /dogs-and-cats/*jpg")images_id = images.map(id=Lambda-Datei: file.path.split('.')[-2])annotated = images_id.merge(meta, on="id", right_on="meta.id")likely_cats = annotated.filter((Column("meta.inference .Vertrauen") > 0,93)
                                & (Column("meta.inference.class_") == "cat"))likely_cats.export_files("high-confidence-cats/", signal="file")

Datenkuration mit einem lokalen KI-Modell

Batch-Inferenz mit einem einfachen Stimmungsmodell unter Verwendung der Transformers-Bibliothek:

 Pip-Transformatoren installieren

Der folgende Code lädt Dateien aus der Cloud herunter und wendet auf jede einzelne eine benutzerdefinierte Funktion an. Alle Dateien mit einer erkannten positiven Stimmung werden dann in das lokale Verzeichnis kopiert.

 from Transformers Import Pipelinefrom Datachain Import 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"] == "POSITIVE"chain = ( DataChain.from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file", type="text")
   .settings(parallel=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()} Dateien wurden exportiert")

13 Dateien wurden exportiert

 $ ls Output/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 Output/datachain-demo/chatbot-KiT/ | wc -l
13

LLM beurteilt Chatbots

LLMs können als universelle Klassifikatoren arbeiten. Im folgenden Beispiel verwenden wir eine kostenlose API von Mistral, um die öffentlich verfügbaren Chatbot-Dialoge zu beurteilen. Bitte holen Sie sich einen kostenlosen Mistral-API-Schlüssel unter https://console.mistral.ai

 $ pip install mistralai (Erfordert Version >=1.0.0)
$ export MISTRAL_API_KEY=_your_key_

DataChain kann API-Aufrufe parallelisieren; Die kostenlose Mistral-Stufe unterstützt bis zu 4 Anfragen gleichzeitig.

 from mistralai import Mistralfrom datachain import File, DataChain, ColumnPROMPT = „War dieser Dialog erfolgreich? Antworten Sie in einem einzigen Wort: Erfolg oder Misserfolg.“def eval_dialogue(file: File) -> bool: client = Mistral() Response = client.chat .complete( model="open-mixtral-8x22b", messages=[{"role": "system", "content": PROMPT},
                   {"role": "user", "content": file.read()}]) result = Response.choices[0].message.content return result.lower().startswith("success")chain = ( DataChain .from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file")
   .settings(parallel=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()} Dateien wurden exportiert")

Mit der obigen Anweisung berücksichtigt das Mistral-Modell 31/50 Dateien, um die erfolgreichen Dialoge zu speichern:

 $ 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/ | wc -l
31

Serialisierung von Python-Objekten

LLM-Antworten können wertvolle Informationen für die Analyse enthalten – beispielsweise die Anzahl der verwendeten Token oder die Modellleistungsparameter.

Anstatt diese Informationen aus der Mistral-Antwortdatenstruktur (Klasse ChatCompletionResponse) zu extrahieren, kann DataChain die gesamte LLM-Antwort in die interne Datenbank serialisieren:

 from mistralai import Mistralfrom mistralai.models import ChatCompletionResponsefrom datachain import File, DataChain, ColumnPROMPT = „War dieser Dialog erfolgreich? Antwort in einem einzigen Wort: Erfolg oder Misserfolg.“def eval_dialog(file: File) -> ChatCompletionResponse: client = MistralClient() return client.chat( model="open-mixtral-8x22b", messages=[{"role": "system", "content": PROMPT},
                   {"role": "user", "content": file.read()}])chain = ( DataChain.from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file")
   .settings(parallel=4, Cache=True)
   .map(response=eval_dialog)
   .map(status=Lambda-Antwort: Response.choices[0].message.content.lower()[:7])
   .save("Antwort")
)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}% Dialoge waren erfolgreich")

Ausgabe:

     Dateistatus-Antwort-Antwort-Antwort
     Namensverwendung, Verwendung, Verwendung
                   prompt_tokens total_tokensCompletion_tokens
0 1.txt Erfolg 547 548 1
1 10.txt-Fehler 3576 3578 2
2 11.txt-Fehler 626 628 2
3 12.txt-Fehler 1144 1182 38
4 13.txt Erfolg 1100 1101 1

[Begrenzt auf 5 Zeilen]
64,0 % der Dialoge waren erfolgreich

Iterieren über Python-Datenstrukturen

In den vorherigen Beispielen wurden Datensätze in der eingebetteten Datenbank (SQLite im Ordner .datachain des Arbeitsverzeichnisses) gespeichert. Diese Datensätze wurden automatisch versioniert und können mit DataChain.from_dataset("dataset_name") aufgerufen werden.

So rufen Sie einen gespeicherten Datensatz ab und durchlaufen die Objekte:

 chain = DataChain.from_dataset("response")# Eins nach dem anderen iterieren: Unterstützt Arbeitsablauf wegen unzureichendem Arbeitsspeicher für Datei, Antwort in chain.limit(5).collect("file", "response"):# Überprüfen Sie die Gesammelte Python-Objekteassert isinstance(response, ChatCompletionResponse)status = Response.choices[0].message.content[:7]tokens = Response.usage.total_tokensprint(f"{file.get_uri()}: {status}, Dateigröße: {file.size}, Tokens: {tokens}")

Ausgabe:

 gs://datachain-demo/chatbot-KiT/1.txt: Erfolg, Dateigröße: 1776, Token: 548
gs://datachain-demo/chatbot-KiT/10.txt: Fehler, Dateigröße: 11576, Token: 3578
gs://datachain-demo/chatbot-KiT/11.txt: Fehler, Dateigröße: 2045, Token: 628
gs://datachain-demo/chatbot-KiT/12.txt: Fehler, Dateigröße: 3833, Token: 1207
gs://datachain-demo/chatbot-KiT/13.txt: Erfolg, Dateigröße: 3657, Token: 1101

Vektorisierte Analysen über Python-Objekte

Einige Vorgänge können ohne Deserialisierung innerhalb der Datenbank ausgeführt werden. Berechnen wir zum Beispiel die Gesamtkosten für die Nutzung der LLM-APIs unter der Annahme, dass der Mixtral-Aufruf 2 US-Dollar pro 1 Mio. Eingabe-Token und 6 US-Dollar pro 1 Mio. Ausgabe-Token kostet:

 chain = DataChain.from_dataset("mistral_dataset")cost = chain.sum("response.usage.prompt_tokens")*0,000002
            + chain.sum("response.usage.completion_tokens")*0.000006print(f"Verbrachte ${cost:.2f} für {chain.count()}-Aufrufe")

Ausgabe:

 Habe 0,08 $ für 50 Anrufe ausgegeben

PyTorch-Datenlader

Kettenergebnisse können exportiert oder direkt an den PyTorch-Datenlader übergeben werden. Wenn wir beispielsweise daran interessiert sind, ein Bild und eine Beschriftung basierend auf dem Dateinamensuffix zu übergeben, erledigt der folgende Code dies:

 from 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 -and-cats/", type="image")
    .map(label=Lambda-Name: name.split(".")[0], params=["file.name"])
    .select("file", "label").to_pytorch(transform=processor.image_processor,tokenizer=processor.tokenizer,
    )
)loader = DataLoader(chain, batch_size=1)