Unduhan datachain - pengunduhan kode sumber datachain

datachain

Kode sumber lainnya

0.6.8

Unduh

Rantai Data

DataChain adalah pustaka bingkai data Pythonic modern yang dirancang untuk kecerdasan buatan. Itu dibuat untuk mengatur data tidak terstruktur Anda ke dalam kumpulan data dan mengaturnya dalam skala besar di mesin lokal Anda. Datachain tidak mengabstraksi atau menyembunyikan model AI dan panggilan API, namun membantu mengintegrasikannya ke dalam tumpukan data postmodern.

Fitur Utama

Penyimpanan sebagai Sumber Kebenaran.
- Memproses data tidak terstruktur tanpa salinan berlebihan dari S3, GCP, Azure, dan sistem file lokal.
- Dukungan data multimodal: gambar, video, teks, PDF, JSON, CSV, parket.
- Satukan file dan metadata menjadi kumpulan data kolom yang persisten, berversi.
Pipeline data yang ramah terhadap Python.
- Beroperasi pada objek Python dan bidang objek.
- Paralelisasi bawaan dan komputasi di luar memori tanpa SQL atau Spark.
Pengayaan dan Pemrosesan Data.
- Hasilkan metadata menggunakan model AI lokal dan API LLM.
- Filter, gabung, dan kelompokkan berdasarkan metadata. Telusuri berdasarkan penyematan vektor.
- Teruskan kumpulan data ke Pytorch dan Tensorflow, atau ekspor kembali ke penyimpanan.
Efisiensi.
- Paralelisasi, beban kerja kehabisan memori, dan cache data.
- Operasi vektor pada bidang objek Python: jumlah, hitungan, rata-rata, dll.
- Pencarian vektor yang dioptimalkan.

Mulai Cepat

 $ pip instal rantai data

Memilih file menggunakan metadata JSON

Penyimpanan terdiri dari gambar kucing dan anjing (dog.1048.jpg, cat.1009.jpg), dianotasi dengan kebenaran dasar dan kesimpulan model dalam format 'json-pairs', di mana setiap gambar memiliki file JSON yang cocok seperti cat. 1009.json:

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

Contoh mendownload hanya gambar kesimpulan "kucing berkeyakinan tinggi" menggunakan metadata JSON:

 dari kolom impor datachain, 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 file: file.path.split('.')[-2])dijelaskan = images_id.merge(meta, on="id", right_on="meta.id")likely_cats = dianotasi.filter((Column("meta.inference.confident") > 0,93)
                                & (Kolom("meta.inference.class_") == "cat"))likely_cats.export_files("high-confident-cats/", signal="file")

Kurasi data dengan model AI lokal

Inferensi batch dengan model sentimen sederhana menggunakan pustaka transformator:

 pip instal trafo

Kode di bawah mengunduh file ke cloud, dan menerapkan fungsi yang ditentukan pengguna untuk masing-masing file. Semua file dengan sentimen positif terdeteksi kemudian disalin ke direktori lokal.

 dari pipa impor transformatordari rantai data impor Rantai Data, Pengklasifikasi Kolom = pipa("analisis-sentimen", perangkat="cpu",model="distilbert/distilbert-base-uncased-finetuned-sst-2-english")def is_positif_dialog_ending(file) - > bool:dialogue_ending = file.read()[-512:]pengklasifikasi kembali(dialogue_ending)[0]["label"] == Rantai "POSITIF" = ( DataChain.from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file", type="text")
   .settings(paralel=8, cache=Benar)
   .map(is_positif=is_positif_dialog_berakhir)
   .simpan("file_respon")
)rantai_positif = rantai.filter(Kolom("is_positif") == Benar)rantai_positif.file_ekspor("./output")cetak(f"{rantai_positif.count()} file diekspor")

13 file diekspor

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

LLM menilai chatbots

LLM dapat berfungsi sebagai pengklasifikasi universal. Pada contoh di bawah, kami menggunakan API gratis dari Mistral untuk menilai dialog chatbot yang tersedia untuk umum. Silakan dapatkan kunci API Mistral gratis di https://console.mistral.ai

 $ pip install mistralai (Membutuhkan versi >=1.0.0)
$ ekspor MISTRAL_API_KEY=_kunci_Anda_

DataChain dapat memparalelkan panggilan API; tingkat Mistral gratis mendukung hingga 4 permintaan secara bersamaan.

 from mistralai import Mistralfrom datachain import File, DataChain, ColumnPROMPT = "Apakah dialog ini berhasil? Jawab dalam satu kata: Berhasil atau Gagal."def eval_dialogue(file: File) -> bool: client = Mistral() respon = client.chat .lengkap( model="open-mixtral-8x22b", pesan=[{"role": "system", "content": PROMPT},
                   {"role": "user", "content": file.read()}]) result = respon.choices[0].message.content mengembalikan result.lower().startswith("success")chain = ( DataChain .from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file")
   .settings(paralel=4, cache=Benar)
   .map(is_success=eval_dialogue)
   .simpan("mistral_files")
)successful_chain = chain.filter(Column("is_success") == True)successful_chain.export_files("./output_mistral")print(f"{successful_chain.count()} file diekspor")

Dengan instruksi di atas, model Mistral mempertimbangkan file 31/50 untuk mengadakan dialog yang berhasil:

 $ ls keluaran_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/ | toilet -l
31

Membuat serial objek Python

Respons LLM mungkin berisi informasi berharga untuk analitik – seperti jumlah token yang digunakan, atau parameter kinerja model.

Daripada mengekstraksi informasi ini dari struktur data respons Mistral (kelas ChatCompletionResponse), DataChain dapat membuat serialisasi seluruh respons LLM ke DB internal:

 from mistralai import Mistralfrom mistralai.models import ChatCompletionResponsefrom datachain import File, DataChain, ColumnPROMPT = "Apakah dialog ini berhasil? Jawab dalam satu kata: Berhasil atau Gagal."def eval_dialog(file: File) -> ChatCompletionResponse: client = MistralClient() kembalikan klien.chat( model="open-mixtral-8x22b", pesan=[{"role": "system", "content": MENGINGATKAN},
                   {"peran": "pengguna", "konten": file.read()}])chain = ( DataChain.from_storage("gs://datachain-demo/chatbot-KiT/", object_name="file")
   .settings(paralel=4, cache=Benar)
   .peta(respons=eval_dialog)
   .map(status=lambda respon: respon.choices[0].message.content.lower()[:7])
   .simpan("respon")
)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}% dialog berhasil")

Keluaran:

     respons respons status file
     penggunaan penggunaan penggunaan nama
                   prompt_tokens total_tokens penyelesaian_tokens
0 1.txt berhasil 547 548 1
1 10.txt kegagalan 3576 3578 2
2 11.txt kegagalan 626 628 2
3 12.txt kegagalan 1144 1182 38
4 13.txt sukses 1100 1101 1

[Dibatasi 5 baris]
64,0% dialog berhasil

Mengulangi struktur data Python

Pada contoh sebelumnya, kumpulan data disimpan dalam database tertanam (SQLite di folder .datachain pada direktori kerja). Kumpulan data ini secara otomatis dibuat versinya, dan dapat diakses menggunakan DataChain.from_dataset("dataset_name").

Berikut ini cara mengambil kumpulan data yang disimpan dan mengulangi objek:

 chain = DataChain.from_dataset("response")# Iterasi satu per satu: mendukung alur kerja kehabisan memori untuk file, respons dalam chain.limit(5).collect("file", "response"):# verifikasi objek Python yang dikumpulkan menegaskan isinstance(response, ChatCompletionResponse)status = respon.choices[0].message.content[:7]tokens = respon.usage.total_tokensprint(f"{file.get_uri()}: {status}, ukuran file: {file.size}, token: {tokens}")

Keluaran:

 gs://datachain-demo/chatbot-KiT/1.txt: Berhasil, ukuran file: 1776, token: 548
gs://datachain-demo/chatbot-KiT/10.txt: Kegagalan, ukuran file: 11576, token: 3578
gs://datachain-demo/chatbot-KiT/11.txt: Kegagalan, ukuran file: 2045, token: 628
gs://datachain-demo/chatbot-KiT/12.txt: Kegagalan, ukuran file: 3833, token: 1207
gs://datachain-demo/chatbot-KiT/13.txt: Berhasil, ukuran file: 3657, token: 1101

Analisis yang divektorkan pada objek Python

Beberapa operasi dapat berjalan di dalam DB tanpa deserialisasi. Misalnya, mari kita hitung total biaya penggunaan LLM API, dengan asumsi biaya panggilan Mixtral adalah $2 per 1 juta token masukan dan $6 per 1 juta token keluaran:

 rantai = DataChain.from_dataset("mistral_dataset")biaya = rantai.sum("response.usage.prompt_tokens")*0,000002
            + chain.sum("response.usage.completion_tokens")*0.000006print(f"Menghabiskan ${cost:.2f} pada {chain.count()} panggilan")

Keluaran:

 Menghabiskan $0,08 untuk 50 panggilan

Pemuat data PyTorch

Hasil rantai dapat diekspor atau diteruskan langsung ke pemuat data PyTorch. Misalnya, jika kita tertarik untuk meneruskan gambar dan label berdasarkan akhiran nama file, kode berikut akan melakukannya:

 dari 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 -dan-kucing/", ketik="gambar")
    .map(label=nama lambda: nama.split(".")[0], params=["file.nama"])
    .select("file", "label").to_pytorch(transform=processor.image_processor,tokenizer=processor.tokenizer,
    )
)loader = DataLoader(rantai, ukuran_batch=1)