Penjanaan data sintetik tempatan

Anda telah mendengar kutipan terkenal "Data adalah Minyak Baru" oleh ahli matematik British Clive Humby, ia adalah petikan yang paling berpengaruh yang menggambarkan kepentingan data pada abad ke -21 tetapi, selepas perkembangan letupan model bahasa yang besar dan latihannya apa yang kita tidak mempunyai hak adalah data. Kerana kelajuan pembangunan dan kelajuan latihan model LLM hampir melampaui kelajuan penjanaan data manusia. Penyelesaiannya menjadikan data lebih halus dan khusus untuk tugas atau penjanaan data sintetik. Yang pertama adalah lebih banyak tugas pakar domain tetapi yang terakhir lebih menonjol dengan kelaparan besar masalah hari ini.

Data latihan berkualiti tinggi kekal sebagai kesesakan kritikal. Pos blog ini meneroka pendekatan praktikal untuk menghasilkan data sintetik menggunakan Llama 3.2 dan Ollama. Ia akan menunjukkan bagaimana kita boleh membuat kandungan pendidikan berstruktur secara programatik.

Hasil pembelajaran

• Memahami kepentingan dan teknik penjanaan data sintetik tempatan untuk meningkatkan latihan model pembelajaran mesin.
• Ketahui cara melaksanakan penjanaan data sintetik tempatan untuk membuat dataset berkualiti tinggi sambil mengekalkan privasi dan keselamatan.
• Dapatkan pengetahuan praktikal untuk melaksanakan pengendalian ralat yang mantap dan mekanisme semula dalam saluran paip penjanaan data.
• Belajar pengesahan JSON, teknik pembersihan, dan peranan mereka dalam mengekalkan output yang konsisten dan boleh dipercayai.
• Membangunkan kepakaran dalam merancang dan menggunakan model Pydantic untuk memastikan integriti skema data.

Jadual Kandungan

• Apakah data sintetik?
• Mengapa kita memerlukan data sintetik hari ini?
• Kesan terhadap prestasi LLM dan kecil LM
• Struktur projek dan persediaan persekitaran
• Pelaksanaan projek
• Generasi yang teguh
• Menguji automasi
• Kesimpulan
• Soalan yang sering ditanya

Apakah data sintetik?

Data sintetik merujuk kepada maklumat yang dihasilkan secara buatan yang meniru ciri-ciri data dunia sebenar sambil mengekalkan corak penting dan sifat statistik. Ia dibuat menggunakan model algoritma, simulasi, atau AI untuk menangani kebimbangan privasi, menambah data terhad, atau sistem ujian dalam senario terkawal. Tidak seperti data sebenar, data sintetik boleh disesuaikan dengan keperluan tertentu, memastikan kepelbagaian, keseimbangan, dan skalabiliti. Ia digunakan secara meluas dalam bidang seperti pembelajaran mesin, penjagaan kesihatan, kewangan, dan sistem autonomi untuk melatih model, mengesahkan algoritma, atau mensimulasikan persekitaran. Data sintetik menjembatani jurang antara kekurangan data dan aplikasi dunia sebenar sambil mengurangkan risiko etika dan pematuhan.

Mengapa kita memerlukan data sintetik hari ini?

Permintaan untuk data sintetik telah berkembang pesat disebabkan oleh beberapa faktor

• Peraturan Privasi Data : Dengan GDPR dan peraturan yang serupa, data sintetik menawarkan alternatif yang selamat untuk pembangunan dan ujian
• Kecekapan kos: Mengumpul dan memberi penjelasan data sebenar adalah mahal dan memakan masa.
• Skalabiliti : Data sintetik dapat dihasilkan dalam kuantiti yang banyak dengan variasi terkawal
• Liputan Kes Kelebihan: Kita boleh menjana data untuk senario yang jarang berlaku yang mungkin sukar dikumpulkan secara semula jadi
• Prototaip Rapid: Penyebaran cepat pada model ML tanpa menunggu pengumpulan data sebenar.
• Kurang berat sebelah: Data yang dikumpulkan dari dunia nyata mungkin rawan kesilapan dan penuh dengan kecenderungan gender, teks kaum, dan tidak selamat untuk kata -kata kanak -kanak supaya membuat model dengan jenis data ini, tingkah laku model juga sememangnya dengan kecenderungan ini. Dengan data sintetik, kita dapat mengawal tingkah laku ini dengan mudah.

Kesan terhadap prestasi LLM dan kecil LM

Data sintetik telah menunjukkan hasil yang menjanjikan dalam meningkatkan kedua -dua model bahasa besar dan kecil

• Kecekapan penalaan halus: Model-model yang disesuaikan dengan data sintetik berkualiti tinggi sering menunjukkan prestasi yang setanding dengan mereka yang terlatih pada data sebenar
• Adaptasi Domain: Data sintetik membantu menjembatani jurang domain dalam aplikasi khusus
• Peningkatan Data: Menggabungkan data sintetik dan sebenar sering menghasilkan hasil yang lebih baik menggunakan sama ada sahaja.

Struktur projek dan persediaan persekitaran

Dalam bahagian berikut, kami akan memecahkan susun atur projek dan membimbing anda melalui mengkonfigurasi persekitaran yang diperlukan.

 projek/
├── Main.py
├── keperluan.txt
├── Readme.md
└── english_qa_new.json

Sekarang kami akan menubuhkan persekitaran projek kami menggunakan Conda. Ikuti langkah di bawah

Buat persekitaran conda

 $ conda create -n sintetik -data python = 3.11

# mengaktifkan env yang baru dibuat

$ conda mengaktifkan data sintetik

Pasang perpustakaan di conda env

 PIP Pasang Pydantic Langchain-Community
PIP Pasang Langchain-ollama

Sekarang kita semua bersedia untuk memulakan pelaksanaan kod

Pelaksanaan projek

Dalam bahagian ini, kami akan menyelidiki pelaksanaan praktikal projek, yang meliputi setiap langkah secara terperinci.

Mengimport perpustakaan

Sebelum memulakan projek, kami akan membuat nama fail main.py dalam root projek dan mengimport semua perpustakaan pada fail tersebut:

 Dari Pydantic Import Basemodel, Field, ValidationError
dari langchain.prompts import promptplate
dari langchain_ollama import ollamallm
dari menaip senarai import
Import JSON
import uuid
Import Re
dari laluan import patlib
dari masa tidur import

Kini sudah tiba masanya untuk meneruskan bahagian pelaksanaan kod pada fail main.py

Pertama, kita mulakan dengan melaksanakan skema data.

Skema Data Bahasa Inggeris adalah model Pydantic yang memastikan data kami yang dihasilkan mengikuti struktur yang konsisten dengan medan yang diperlukan dan penjanaan ID automatik.

Pelaksanaan kod

 Kelas Bahasa Inggeris Question (Basemodel):
    ID: str = medan (
        default_factory = lambda: str (uuid.uuid4 ()),
        Penerangan = "Pengenal pasti unik untuk soalan",
    )
    Kategori: str = medan (..., keterangan = "Jenis Soalan")
    Soalan: str = medan (..., keterangan = "Soalan Bahasa Inggeris")
    Jawapan: str = medan (..., keterangan = "jawapan yang betul untuk soalan")
    pemikiran_process: str = medan (
        ..., keterangan = "Penjelasan proses penalaran untuk sampai di jawapannya"
    )

Sekarang, bahawa kami telah mencipta kelas data bahasa Inggeris.

Kedua, kita akan mula melaksanakan kelas soal selidik. Kelas ini adalah teras pelaksanaan projek.

Struktur kelas soal selidik

 soal selidik kelas:
    def __init __ (diri, model_name: str, output_file: jalan):
        lulus

    def clean_json_string (diri, teks: str) -> str:
        lulus

    def parse_response (diri, hasil: str) -> englishquestion:
        lulus


    def penjana_with_retries (diri, kategori: str, retries: int = 3) -> englishquestion:
        lulus

    def Generate_Questions (
        diri, kategori: senarai [str], lelaran: int
    ) -> Senarai [Bahasa Inggeris Question]:
        lulus

    def save_to_json (diri, soalan: englishquestion):
        lulus

    def load_existing_data (self) -> senarai [dict]:
        lulus

Mari langkah demi langkah melaksanakan kaedah utama

Permulaan

Inisialisasi kelas dengan model bahasa, templat segera, dan fail output. Dengan ini, kami akan membuat contoh Olamallm dengan Model_Name dan menubuhkan prompttemplate untuk menghasilkan QA dalam format JSON yang ketat.

Pelaksanaan Kod:

 def __init __ (diri, model_name: str, output_file: jalan):
        self.llm = ollamallm (model = model_name)
        self.prompt_template = promptTemplate (
            input_variables = ["kategori"],
            templat = "" "
            Menghasilkan soalan bahasa Inggeris yang menguji pemahaman dan penggunaan.
            Fokus pada {kategori} .Question akan seperti mengisi kekosongan, satu pelapik dan mut tidak jenis mcq. Tulis output dalam format JSON yang ketat ini:

            {{
                "Soalan": "<soalan khusus anda>",
                "Jawapan": "<jawapan yang betul>",
                "Thought_process": "Jelaskan alasan untuk tiba di jawapan>"
            }}

            Jangan sertakan sebarang teks di luar objek JSON.
            "" ",
        )
        self.output_file = output_file
        self.output_file.touch (exist_ok = true)</jawapan></soalan>

Pembersihan json

Tanggapan yang akan kita peroleh dari LLM semasa proses penjanaan akan mempunyai banyak aksara tambahan yang tidak perlu yang mungkin memberi data yang dihasilkan, jadi anda mesti lulus data ini melalui proses pembersihan.

Di sini, kami akan membetulkan isu pemformatan biasa dalam kekunci/nilai JSON menggunakan regex, menggantikan watak -watak yang bermasalah seperti Newline, dan watak khas.

Pelaksanaan Kod:

 def clean_json_string (diri, teks: str) -> str:
        "" "Versi yang lebih baik untuk mengendalikan JSON yang cacat atau tidak lengkap." ""
        start = text.find ("{")
        end = text.rfind ("}")

        jika start == -1 atau end == -1:
            Raise ValueError (f "No Json Object Found. Response adalah: {text}")

        json_str = teks [Mula: akhir 1]

        # Keluarkan watak khas yang mungkin memecahkan parsing json
        json_str = json_str.replace ("\ n", "") .replace ("\ r", "")
        json_str = re.sub (r "[^\ x20- \ x7e]", "", json_str)

        # Betulkan masalah pemformatan JSON biasa
        json_str = re.sub (
            r '(? <h3> Parsing respons</h3><p> Kaedah parsing akan menggunakan proses pembersihan di atas untuk membersihkan respons dari LLM, mengesahkan respons untuk konsistensi, menukar JSON yang dibersihkan ke dalam kamus python, dan memetakan kamus ke objek bahasa Inggeris.</p><p> <strong>Pelaksanaan Kod:</strong></p><pre class="brush:php;toolbar:false"> def parse_response (diri, hasil: str) -> englishquestion:
        "" "Mengurangkan tindak balas LLM dan mengesahkannya terhadap skema." ""
        dibersihkan_json = self.clean_json_string (hasil)
        parsed_result = json.loads (cleaned_json)
        kembali Bahasa Inggeris Question (** parsed_result)

Kegigihan data

Untuk, penjanaan data yang berterusan, walaupun kita boleh menggunakan beberapa pangkalan data NoSQL (MongoDB, dll) untuk ini, di sini kita menggunakan fail JSON yang mudah untuk menyimpan data yang dihasilkan.

Pelaksanaan Kod:

 def load_existing_data (self) -> senarai [dict]:
        "" "Muatkan soalan yang ada dari fail JSON." ""
        Cuba:
            dengan terbuka (self.output_file, "r") sebagai f:
                kembali json.load (f)
        Kecuali (FileNotFoundError, JSON.JSONDECODEError):
            kembali []

Generasi yang teguh

Dalam fasa penjanaan data ini, kami mempunyai dua kaedah yang paling penting:

• Menjana dengan mekanisme semula
• Kaedah penjanaan soalan

Tujuan mekanisme semula adalah untuk memaksa automasi untuk menghasilkan tindak balas sekiranya berlaku kegagalan. Ia cuba menghasilkan soalan beberapa kali (lalai adalah tiga kali) dan akan log ralat dan menambah kelewatan antara pengambilan semula. Ia juga akan menimbulkan pengecualian jika semua percubaan gagal.

Pelaksanaan Kod:

 def penjana_with_retries (diri, kategori: str, retries: int = 3) -> englishquestion:
        Untuk percubaan dalam julat (retries):
            Cuba:
                hasil = self.prompt_template | self.llm
                respons = respon
                kembali self.parse_response (respons)
            Kecuali pengecualian sebagai e:
                Cetak (
                    f "percubaan {percubaan 1}/{retries} gagal untuk kategori '{kategori}': {e}"
                )
                tidur (2) # kelewatan kecil sebelum mencuba
        Meningkatkan ValueError (
            f "gagal memproses kategori '{kategori}' selepas {retries} percubaan."
        )

Kaedah penjanaan soalan akan menghasilkan pelbagai soalan untuk senarai kategori dan menyimpannya dalam storan (di sini fail JSON). Ia akan melangkah ke atas kategori dan panggilan penjanaan_with_retries untuk setiap kategori. Dan pada akhirnya, ia akan menjimatkan setiap soalan yang berjaya dihasilkan menggunakan kaedah Save_TO_JSON.

 def Generate_Questions (
        diri, kategori: senarai [str], lelaran: int
    ) -> Senarai [Bahasa Inggeris Question]:
        "" "Menjana pelbagai soalan untuk senarai kategori." ""
        all_questions = []
        untuk _ dalam julat (lelaran):
            Untuk kategori dalam kategori:
                Cuba:
                    soalan = self.generate_with_retries (kategori)
                    self.save_to_json (soalan)
                    all_questions.append (soalan)
                    cetak (f "Soalan yang berjaya dijana untuk Kategori: {kategori}")
                Kecuali (ValidationError, ValueError) sebagai E:
                    cetak (f "kategori pemprosesan ralat '{kategori}': {e}")
        Kembali All_Questions

Memaparkan hasil di terminal

Untuk mendapatkan idea tentang apa yang dihasilkan dari LLM di sini adalah fungsi percetakan yang mudah.

 Def Display_Questions (Soalan: Senarai [EnglishQuestion]):
    Cetak ("Soalan Bahasa Inggeris \ Ngenerated:")
    untuk soalan dalam soalan:
        cetak ("\ n ---")
        cetak (f "id: {soalan.id}")
        cetak (f "soalan: {soal selidik.question}")
        cetak (f "jawapan: {soal selidik.answer}")
        cetak (f "proses pemikiran: {soal selidik.thought_process}")

Menguji automasi

Sebelum menjalankan projek anda buat fail english_qa_new.json pada root projek.

 jika __name__ == "__main__":
    Output_file = path ("english_qa_new.json")
    penjana = soal selidik (model_name = "llama3.2", output_file = output_file)

    kategori = [
        "penggunaan perkataan",
        "Phrasal ver",
        "perbendaharaan kata",
        "Idiom",
    ]
    lelaran = 2

    Generated_questions = Generator.Generate_Questions (kategori, lelaran)
    Display_Questions (Generated_questions)

Sekarang, pergi ke terminal dan taip:

 python main.py

Output:

Soalan -soalan ini akan disimpan dalam akar projek anda. Soalan yang disimpan kelihatan seperti:

Semua kod yang digunakan dalam projek ini ada di sini.

Kesimpulan

Penjanaan data sintetik telah muncul sebagai penyelesaian yang kuat untuk menangani permintaan yang semakin meningkat untuk dataset latihan berkualiti tinggi dalam era kemajuan pesat dalam AI dan LLMS. Dengan memanfaatkan alat seperti Llama 3.2 dan Ollama, bersama-sama dengan rangka kerja yang teguh seperti Pydantic, kita boleh membuat dataset berstruktur, berskala, dan bias yang disesuaikan dengan keperluan khusus. Pendekatan ini bukan sahaja mengurangkan kebergantungan pada pengumpulan data dunia yang mahal dan memakan masa tetapi juga memastikan pematuhan privasi dan etika. Semasa kami memperbaiki metodologi ini, data sintetik akan terus memainkan peranan penting dalam memacu inovasi, meningkatkan prestasi model, dan membuka peluang baru dalam pelbagai bidang.

Takeaways utama

• Penjanaan data sintetik tempatan membolehkan penciptaan dataset yang pelbagai yang dapat meningkatkan ketepatan model tanpa menjejaskan privasi.
• Melaksanakan penjanaan data sintetik tempatan dapat meningkatkan keselamatan data dengan meminimumkan pergantungan pada data sensitif dunia nyata.
• Data sintetik memastikan privasi, mengurangkan bias, dan menurunkan kos pengumpulan data.
• Dataset yang disesuaikan meningkatkan kesesuaian merentasi aplikasi AI dan LLM yang pelbagai.
• Data sintetik membuka jalan bagi pembangunan AI etika, cekap, dan inovatif.

Soalan yang sering ditanya

Q 1. Mengapa menggunakan Ollama dan bukan model berasaskan API?

A. Ollama menyediakan keupayaan penempatan tempatan, mengurangkan kos dan latensi sambil menawarkan lebih banyak kawalan ke atas proses penjanaan.

Q 2. Bagaimana kita dapat memastikan kualiti soalan yang dihasilkan?

A. Untuk mengekalkan kualiti, pelaksanaan menggunakan pengesahan Pydantic, mekanisme semula, dan pembersihan JSON. Metrik tambahan dan mengekalkan pengesahan boleh dilaksanakan.

Q 3. Apakah batasan pendekatan ini?

A. LLM tempatan mungkin mempunyai output berkualiti rendah berbanding dengan model yang lebih besar, dan kelajuan generasi boleh dibatasi oleh sumber pengkomputeran tempatan.

Q4. Adakah data sintetik selamat dan etika untuk digunakan?

A. Ya, data sintetik memastikan privasi dengan menghapuskan maklumat yang boleh dikenalpasti dan menggalakkan pembangunan AI etika dengan menangani kecenderungan data dan mengurangkan kebergantungan pada data sensitif dunia nyata.

S5. Apakah cabaran utama dalam menggunakan data sintetik?

A. Cabaran termasuk memastikan realisme data, mengekalkan kaitan domain, dan menyelaraskan ciri-ciri data sintetik dengan kes penggunaan dunia sebenar untuk latihan model yang berkesan.

Atas ialah kandungan terperinci Penjanaan data sintetik tempatan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!