Cara Membina Pakej Python Rag Evaluator dengan Puisi

Pengenalan

Bayangkan bahawa anda akan menghasilkan pakej Python yang berpotensi untuk mengubah cara pemaju dan penganalisis data menilai model mereka. Perjalanan bermula dengan konsep yang mudah: alat penilaian kain fleksibel yang dapat menguruskan pelbagai metrik dan keadaan kelebihan. Anda akan pergi dari memulakan pakej anda dengan puisi untuk membuat kelas penilai pepejal dan menguji kod anda semasa anda menyelam ke dalam siaran ini. Anda akan mendapat pengetahuan tentang cara membuat pakej anda, mengira skor Bleu dan Rouge, dan menyiarkannya dalam talian. Akhirnya, anda akan mendapat lebih banyak wawasan mengenai pembungkusan python dan sumbangan sumber terbuka selain mempunyai alat kerja yang siap digunakan oleh orang awam.

Hasil pembelajaran

• Belajar untuk memulakan dan menyusun pakej Python menggunakan puisi.
• Membangun dan melaksanakan kelas penilai untuk pelbagai metrik.
• Hitung dan menilai metrik seperti skor Bleu dan Rouge.
• Tulis dan laksanakan ujian untuk memastikan fungsi dan keteguhan kod.
• Membina dan menerbitkan pakej Python ke PYPI, termasuk pengendalian pengedaran dan pelesenan.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Memulakan pakej anda dengan puisi
• Merancang Kelas Penilai Teras
• Menentukan kelas penilai
• Melaksanakan metrik penilaian
• Mengira skor BLEU
• Mengukur skor rouge
• Menguji pakej anda
• Bina roda
• Mewujudkan sumber dan pengagihan binari
• Menerbitkan pakej
• Soalan yang sering ditanya

Memulakan pakej anda dengan puisi

Sekarang kita mempunyai keperluan yang boleh kita mulakan dengan memulakan pakej Python baru menggunakan puisi. Sebab untuk memilih puisi adalah:

• Ia menghilangkan keperluan untuk menguruskan pelbagai persekitaran maya.
• Ia menyokong semua jenis format pakej Python, kedua -dua pakej asli dan warisan.
• Ia memastikan versi yang betul walaupun untuk kebergantungan melalui fail `Poetry.Lock`.
• Pypi bersedia dengan satu arahan.

Pasang puisi menggunakan arahan untuk hampir semua OS:

 curl -ssl https://install.python-poetry.org | python3 -

Kemudian kita boleh membuat repositori baru dengan boilerplate menggunakan arahan berikut.

 POETRY BARU PAKEL_NAME

Terdapat beberapa soalan generik yang boleh anda tekan oleh Enter dan biarkan ia sebagai lalai. Kemudian anda akan mendarat dalam struktur folder yang serupa dengan ini.

 Puisi-Demo

├── pyproject.toml

├── Readme.md

├── Poetry_demo

│ └── __init__.py

└── Ujian

└── __init__.py

Walaupun strukturnya baik -baik saja, kita boleh menggunakan susun atur `src` berbanding dengan susun atur flat seperti yang dibincangkan dalam dokumentasi Python rasmi. Kami akan mengikuti susun atur `src` di seluruh blog.

Merancang Kelas Penilai Teras

Jantung pakej kami mengandungi semua kod sumber untuk menguasai pakej evaluator python. Ia mengandungi kelas asas yang akan diwarisi oleh semua metrik yang kami mahu. Oleh itu, kelas ini harus menjadi penjagaan yang paling mantap dan sangat mesti diambil semasa pembinaan. Kelas ini akan mempunyai logik yang diperlukan untuk permulaan asas, kaedah untuk mendapatkan hasil dari metrik, dan kaedah lain untuk mengendalikan input pengguna untuk dimakan dengan mudah.

Semua kaedah ini mesti mempunyai skop mereka sendiri dan jenis data yang betul ditakrifkan. Alasan untuk memberi tumpuan lebih kepada jenis data adalah kerana Python ditaip secara dinamik. Oleh itu, kita mesti memastikan penggunaan pembolehubah yang betul kerana kesilapan ini hanya pada masa runtime. Oleh itu, mesti ada suite ujian untuk menangkap kesilapan minit ini, dan bukannya menggunakan pengkompil pemeriksaan jenis khusus. Baiklah dan baik jika kita menggunakan menaip yang betul di Python.

Menentukan kelas penilai

Sekarang kita melihat apa yang semua kelas penilai mesti mengandungi dan mengapa ia adalah yang paling penting kita ditinggalkan dengan pelaksanaan yang sama. Untuk membina kelas ini, kami mewarisi kelas asas ABC - abstrak yang disediakan oleh Python. Alasan untuk memilih kelas ini adalah bahawa ia mengandungi semua ciri konkrit di mana kita boleh membina kelas asas evaluator kami. Sekarang mari kita tentukan input dan output kelas evaluator.

• Input : Calon [Senarai String], Rujukan [Senarai String]
• Kaedah : `padding` (untuk memastikan panjang calon dan rujukan adalah sama),` get_score` (kaedah untuk mengira hasil akhir metrik penilaian)

 # src/evaluator_blog/evaluator.py

amaran import
dari menaip kesatuan import, senarai
Dari ABC Import ABC, AbstrakMethod


Kelas BaseEvaluator (ABC):
    def __init __ (diri, calon: senarai, rujukan: senarai) -> Tiada:
        self.candidates = calon
        Self.References = Rujukan

    @staticmethod
    Padding def (
        Calon: Senarai [STR], Rujukan: Senarai [STR]
    ) -> kesatuan [senarai [str], senarai [str]]:
        "" "_summary_

        Args:
            Calon (Senarai [STR]): Sambutan yang dihasilkan dari LLM
            Rujukan (Senarai [STR]): Tanggapan yang akan diukur terhadap

        Pulangan:
            Kesatuan [Senarai [STR], Senara
        "" "
        _msg = str (
            "" "
            Panjang rujukan dan calon (hipotesis) tidak sama.
            "" "
        )
        Amaran.warn (_msg)
        max_length = max (len (calon), len (rujukan))
        calon.extend ([""] * (max_length - len (calon))))
        rujukan.extend ([""] * (max_length - len (rujukan))))
        Kembali calon, rujukan

    @staticmethod
    def list_to_string (l: senarai) -> str:
        menegaskan (
            len (l)> = 1
        ), "Pastikan panjang mesej lebih besar daripada atau sama dengan 1"

        kembali str (l [0])

    @AbstractMethod
    def get_score (diri) -> terapung:
        "" "
        Kaedah untuk mengira hasil akhir fungsi skor.

        Pulangan:
            Nilai titik terapung metrik penilaian yang dipilih.
        "" "

Di sini kita dapati bahawa kaedah `__init () __` mengandungi parameter yang diperlukan yang merupakan keperluan asas bagi mana -mana calon dan rujukan metrik evaluator IE.

Kemudian padding yang diperlukan untuk memastikan kedua -dua `calon` dan` rujukan` mengandungi panjang yang sama yang ditakrifkan sebagai kaedah statik kerana kita tidak perlu memulakannya setiap kali kita panggil. Oleh itu, penghias StaticMethod mengandungi logik yang diperlukan.

Akhirnya, untuk `get_score ()` kami menggunakan penghias abstrakMethod yang bermaksud semua kelas yang mewarisi kelas penilai asas pastinya mesti mengandungi kaedah ini.

Melaksanakan metrik penilaian

Kini datanglah hati pelaksanaan perpustakaan, penilaian metrik. Pada masa ini untuk pengiraan kami menggunakan perpustakaan masing -masing yang melaksanakan tugas dan memaparkan skor metrik. Kami terutamanya menggunakan `calon` iaitu tindak balas yang dihasilkan oleh LLM dan` rujukan` iaitu kebenaran tanah dan kami mengira nilai masing -masing. Untuk kesederhanaan kita mengira skor Bleu dan Rouge. Logik ini boleh diperpanjang kepada semua metrik yang terdapat di pasaran.

Mengira skor BLEU

Disingkat sebagai penilaian dwibahasa yang difahami adalah salah satu metrik penilaian umum terjemahan mesin (calon) yang cepat, murah, dan bebas bahasa. Ia mempunyai kesilapan marginal berbanding dengan penilaian manual. Ia membandingkan kedekatan terjemahan mesin ke respons manusia profesional (rujukan) dan mengembalikan penilaian sebagai skor metrik dalam julat 0-1, dengan apa-apa ke arah 1 yang disebut sebagai perlawanan yang dekat. Mereka menganggap n-gram (ketulan n perkataan) dalam ayat dari calon. Cth. Unigrams (1 gram) menganggap setiap perkataan dari calon dan rujukan dan mengembalikan skor normal yang disebut sebagai skor ketepatan.

Tetapi ia tidak semestinya berfungsi dengan baik mempertimbangkan jika perkataan yang sama muncul beberapa kali ia menyumbang skor akhir untuk setiap penampilan yang biasanya tidak betul. Oleh itu, Bleu menggunakan skor ketepatan yang diubahsuai di mana ia klip bilangan perlawanan perkataan dan menormalkannya dengan bilangan perkataan dalam calon. Satu lagi tangkapan di sini adalah tidak mengambil perkataan pesanan. Oleh itu, skor BLEU menganggap pelbagai n-gram dan memaparkan skor ketepatan 1-4 gram dengan parameter lain.

Kelebihan

• Pengiraan lebih cepat dan pengiraan mudah yang terlibat.
• Digunakan secara meluas dan mudah untuk menanda aras.

Kekurangan

• Tidak menganggap makna terjemahan.
• Tidak mengambil kira format ayat.
• Walaupun ia adalah dwibahasa, ia berjuang dengan bahasa bukan bahasa Inggeris.
• Sukar untuk mengira skor apabila terjemahan manusia sudah ditolak.

 # src/evaluator_blog/metrics/bleu.py

dari menaip senarai import, boleh dipanggil, pilihan
dari src.evaluator_blog.Evaluator Import BaseEvaluator

dari nltk.translate.bleu_score import corpus_bleu, smoothingfunction

"" "
Pelaksanaan Bleu dari NLTK
"" "
Kelas Bleuscore (BaseEvaluator):
    def __init __ (
        diri,
        Calon: Senarai [str],
        Rujukan: Senarai [str],
        Berat: pilihan [senarai [float]] = tiada,
        Smoothing_function: Pilihan [Callable] = Tiada,
        AUTO_REWEIGH: Pilihan [BOOL] = FALSE,
    ) -> Tiada:
        "" "
        Kirakan skor BLEU (penilaian dwibahasa yang difahami) dari
        Papineni, Kishore, Salim Roukos, Todd Ward, dan Wei-Jing Zhu. 2002.
        "Bleu: Kaedah untuk penilaian automatik terjemahan mesin."
        Dalam Prosiding ACL. https://aclanthology.org/p02-1040.pdf

            Args:
                Berat (pilihan [senarai [float]], pilihan): Berat yang mesti digunakan untuk setiap bleu_score. Lalai kepada tiada.
                Smoothing_function (pilihan [callable], pilihan): Fungsi yang boleh dipanggil untuk mengatasi masalah kekurangan data latihan dengan menambahkan atau menyesuaikan kebarangkalian pengagihan kata -kata. Lalai kepada tiada.
                AUTO_REWEIGH (Pilihan [BOOL], Pilihan): Peraturan semula seragam berdasarkan panjang hipotesis maksimum jika pesanan terbesar n-gram  Terapung:
        "" "
        Kirakan skor BLEU untuk calon dan rujukan yang diberikan.

        Args:
            Calon (Senarai [STR]): Senarai ayat calon
            Rujukan (Senarai [STR]): Senarai ayat rujukan
            Berat (pilihan [senarai [float]], pilihan): Berat untuk pengiraan skor BLEU. Lalai ke (1.0, 0, 0, 0)
            Smoothing_function (pilihan [fungsi]): Teknik pelicinan untuk skor BLEU peringkat segmen

        Pulangan:
            Float: Skor BLEU yang dikira.
        "" "
        # Periksa sama ada panjang calon dan rujukan adalah sama
        jika len (self.candidates)! = len (self.References):
            self.candidates, self.references = self.padding (
                self.candidates, self.references
            )

        # Kirakan skor BLEU
        kembali corpus_bleu (
            list_of_references = self.references,
            hipotesis = self.candidates,
            Berat = self.weights,
            smoothing_function = self.smoothing_function,
            auto_reweigh = self.auto_reweigh,
        )

Mengukur skor rouge

Disingkat sebagai pengertian berorientasikan ingat untuk penilaian gist adalah salah satu metrik penilaian umum untuk membandingkan ringkasan model yang dihasilkan dengan pelbagai ringkasan manusia. Dengan cara yang naif, ia membandingkan n-gram kedua-dua mesin dan ringkasan yang dihasilkan oleh manusia. Ini dipanggil skor Rouge-N ingat. Untuk memastikan lebih banyak perkaitan dalam ringkasan mesin yang dihasilkan kepada ringkasan manusia kita dapat mengira skor ketepatan. Seperti yang kita mempunyai kedua-dua ketepatan dan markah ingat kita boleh mengira skor F1. Ia biasanya disyorkan untuk mempertimbangkan pelbagai nilai `n`. Varian kecil dalam Rouge adalah skor Rouge-L yang menganggap urutan kata-kata dan mengira LCS (berikutnya yang paling lama). Dengan cara yang sama, kita boleh mendapatkan skor ketepatan dan ingat. Kelebihan sedikit di sini adalah menganggap molekul kalimat dan menghasilkan hasil yang relevan.

Kelebihan

• Sangat berkesan untuk menilai kualiti ringkasan teks automatik dengan membandingkan n-gram dan berikutnya yang paling lama.
• Rouge boleh digunakan untuk mana -mana bahasa, menjadikannya serba boleh untuk analisis dan penilaian teks berbilang bahasa.

Kekurangan

• Rouge memberi tumpuan kepada pemadanan teks peringkat permukaan (n-gram), yang mungkin tidak menangkap makna dan koheren semantik yang lebih mendalam.
• Ketepatan rouge sangat bergantung pada kualiti dan perwakilan ringkasan rujukan

 # src/evaluator_blog/metrics/rouge.py

amaran import
dari menaip senarai import, kesatuan, dict, callable, tuple, pilihan
dari ..Evaluator Import BaseEvaluator
dari rouge_score import rouge_scorer


Kelas Rougescore (BaseEvaluator):
    def __init __ (
        diri,
        Calon: Senarai,
        Rujukan: Senarai,
        Rouge_types: Pilihan [Union [str, tuple [str]] = [
            "Rouge1",
            "Rouge2",
            "Rougel",
            "Rougelsum",
        ],
        use_stemmer: pilihan [bool] = palsu,
        split_summaries: pilihan [bool] = palsu,
        Tokenizer: Pilihan [Callable] = Tiada,
    ) -> Tiada:
        super () .__ init __ (calon, rujukan)

        # Lalai `rouge_types` adalah semua, lain yang ditentukan pengguna
        jika isinstance (rouge_types, str):
            self.rouge_types = [rouge_types]
        lain:
            self.rouge_types = rouge_types

        # Dayakan `use_stemmer` untuk mengeluarkan akhiran perkataan untuk meningkatkan keupayaan yang sepadan
        self.use_stemmer = use_stemmer

        # Jika diaktifkan cek sama ada untuk menambah garis baru antara ayat untuk `rougelsum`
        self.split_summaries = split_summaries

        # Dayakan `tokenizer` jika pengguna ditakrifkan atau gunakan lalai` rouge_scorer`
        # https://github.com/google-research/google-research/blob/master/rouge/rouge_scorer.py#l83
        jika tokenizer:
            self.tokenizer = tokenizer
        lain:
            self.tokenizer = tiada
            _msg = str (
                "" "
                Menggunakan tokenizer lalai
                "" "
            )
            Amaran.warn (_msg)

    def get_score (diri) -> dict:
        "" "
        Pulangan:
            Dict: Nilai JSON penilaian untuk metrik yang sepadan
        "" "
        Scorer = rouge_scorer.rougescorer (
            rouge_types = self.rouge_types,
            use_stemmer = self.use_stemmer,
            tokenizer = self.tokenizer,
            split_summaries = self.split_summaries,
        )

        pulangan skor.score (self.list_to_string (self.candidates), self.list_to_string (self.references))

Menguji pakej anda

Sekarang kita mempunyai fail sumber siap sebelum penggunaan sebenar kita mesti mengesahkan kerja kod. Di sinilah fasa ujian masuk ke dalam gambar. Dalam format perpustakaan/konvensyen/amalan terbaik Python, kami menulis semua ujian di bawah folder bernama `test/`. Konvensyen penamaan ini memudahkan pemaju memahami bahawa folder ini mempunyai kepentingannya. Walaupun kami mempunyai pelbagai alat pembangunan, kami dapat menyekat perpustakaan menggunakan pemeriksaan jenis, pengendalian ralat, dan banyak lagi. Ini memenuhi pusingan pertama pemeriksaan dan ujian. Tetapi untuk memastikan kes-kes dan pengecualian, kita boleh menggunakan Unittest, andpytestas rangka kerja. Dengan itu dikatakan, kami hanya pergi dengan menubuhkan ujian asas menggunakan perpustakaan `unittest`.

Menulis ujian unit yang berkesan

Istilah utama untuk mengetahui berkenaan dengan `Unittest` adalah kes ujian dan suite ujian.

• Kes ujian : Unit terkecil ujian di mana kita menilai input terhadap satu set output.
• Ujian Suite : Koleksi kes ujian, suite atau kedua -duanya. Digunakan untuk mengagregatkan ujian untuk bekerjasama.
• Konvensyen Penamaan : Ini mesti diawali dengan `tests_` ke nama fail serta nama fungsi. Alasannya ialah parser akan mengesannya dan menambahkannya ke suite ujian.

Bina roda

Roda pada dasarnya adalah pakej python iaitu dipasang apabila kami menjalankan perintah `Pip Install `. Kandungan roda disimpan dalam fail '.whl'. Fail roda disimpan di `dist/`. Terdapat pengedaran yang dibina `.whl` dan pengedaran sumber` .gz`. Oleh kerana kita menggunakan puisi kita dapat membina pengedaran menggunakan perintah binaan:

 binaan puisi

Ia menghasilkan fail roda dan zip di dalam folder `Dist/` dalam akar folder.

 dist/
├── Package_name-0.0.1-py3-none-any.whl
└── Package_name-0.0.1.tar.gz

Aliter, perintah python setara memasang pakej `binaan` dan kemudian menjalankan arahan binaan dari akar folder.

 PILI
python3 -m membina

Mewujudkan sumber dan pengagihan binari

Marilah kita melihat untuk mewujudkan sumber dan pengagihan binari.

Pengagihan Sumber (SDIST)

`sdist` adalah pengagihan sumber pakej yang mengandungi kod sumber dan metadata untuk membina dari alat luaran seperti PIP atau puisi. `sdist` dikehendaki dibina sebelum` bdist`. Jika `PIP` tidak menemui pengedaran binaan, pengedaran sumber bertindak sebagai sandaran. Kemudian ia membina roda keluar dan kemudian memasang keperluan pakej.

Pengagihan Perduaan (BDIST)

`Bdist` mengandungi fail yang diperlukan yang perlu dipindahkan ke lokasi yang betul dari peranti sasaran. Salah satu format yang paling disokong adalah `.whl`. Titik yang perlu diperhatikan ia tidak menyusun fail python.

Lesen

Walaupun sumber terbuka pakej ke dunia luaran, ia sentiasa dinasihatkan untuk mempunyai lesen yang menunjukkan sejauh mana kod anda boleh digunakan semula. Semasa membuat repositori di GitHub kami mempunyai pilihan untuk memilih lesen di sana. Ia mewujudkan fail `lesen` dengan pilihan penggunaan. Sekiranya anda tidak pasti lesen yang akan dipilih maka sumber luaran ini adalah yang sempurna untuk menyelamatkannya.

Menerbitkan pakej

Sekarang kita mempunyai semua keperluan yang kita perlukan untuk menerbitkan pakej ke dunia luaran. Oleh itu, kami menggunakan perintah penerbitan yang abstrak semua langkah dengan satu arahan.

test.pypi.org

Jika anda tidak pasti bagaimana pakej akan melaksanakan atau untuk tujuan ujian, dinasihatkan untuk menerbitkan ke test.pypi.org dan bukannya secara langsung memuat naik ke repositori rasmi. Ini memberi kita fleksibiliti untuk menguji pakej sebelum berkongsi dengan semua orang.

pypi.org

Pakej Python rasmi mengandungi semua perisian swasta dan awam yang diterbitkan oleh komuniti Python. Ia berguna untuk penulis dan organisasi untuk berkongsi pakej mereka melalui repositori pusat rasmi. Semua yang diperlukan untuk menerbitkan pakej anda ke dunia adalah arahan tunggal ini.

 Puisi Publish -Membina --USERNAME $ PYPI_USERNAME --PASSWORD $ PYPI_PASSWORD

Kesimpulan

Menjelang akhir artikel ini, anda telah berjaya menerbitkan pakej Python yang siap digunakan oleh berjuta -juta. Kami telah memulakan pakej baru menggunakan puisi, bekerja pada kes penggunaan, menulis ujian, membina pakej, dan menerbitkannya ke repositori Pypi. Ini akan menambah lebih banyak nilai untuk diri sendiri dan juga membantu anda memahami pelbagai repositori pakej Python sumber terbuka tentang bagaimana mereka berstruktur. Akhir sekali, ini hanya permulaan dan kita boleh menjadikannya sebagai extensible yang mungkin. Kita boleh merujuk kepada pakej dan pengagihan Python sumber terbuka, dan mendapatkan inspirasi dari yang sama.

Takeaways utama

• Penciptaan dan pengurusan pakej Master Python dengan puisi.
• Melaksanakan dan menyesuaikan metrik penilaian untuk kes -kes penggunaan yang pelbagai.
• Membina dan menguji pakej python yang teguh dengan rangka kerja ujian unit.
• Terbitkan pakej anda ke PYPI dan memahami format pengedaran.
• Dapatkan pandangan mengenai pembangunan pakej sumber terbuka dan amalan pelesenan.

Soalan yang sering ditanya

Q1. Apakah tujuan artikel ini?

A. Artikel ini membantu anda membuat dan menerbitkan pakej Python, yang memberi tumpuan kepada alat penilai RAG yang boleh digunakan oleh masyarakat untuk pelbagai metrik penilaian.

S2. Mengapa saya harus menggunakan puisi untuk menguruskan pakej python saya?

A. Puisi memudahkan pengurusan dan pembungkusan pergantungan dengan mengintegrasikan kawalan versi, persekitaran maya, dan tugas penerbitan ke dalam satu alat, menjadikan pembangunan dan pengedaran lebih mudah.

Q3. Apakah metrik penilaian yang diliputi dalam artikel?

A. Artikel terperinci bagaimana untuk mengira skor Bleu dan Rouge, yang biasa digunakan metrik untuk menilai kualiti teks yang dihasilkan oleh mesin berbanding dengan teks rujukan.

Q4. Bagaimana saya boleh menguji fungsi pakej python saya?

A. Anda boleh menguji pakej anda menggunakan rangka kerja seperti Unittest atau Pytest untuk memastikan kod berfungsi seperti yang diharapkan dan mengendalikan kes kelebihan, memberikan keyakinan sebelum diterbitkan.

S5. Apakah langkah -langkah untuk menerbitkan pakej Python?

A. Bina pakej anda menggunakan puisi atau membina, menguji ia di test.pypi.org, dan kemudian menerbitkannya ke repositori Pypi.org rasmi menggunakan perintah penerbitan puisi untuk menjadikannya tersedia kepada orang ramai.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.

Atas ialah kandungan terperinci Cara Membina Pakej Python Rag Evaluator dengan Puisi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!