So bauen Sie ein Python -Paket mit Lag -Bewerter mit Gedichten

Einführung

Stellen Sie sich vor, Sie möchten ein Python -Paket produzieren, das das Potenzial hat, die Art und Weise, wie Entwickler und Datenanalysten ihre Modelle bewerten, vollständig zu verändern. Die Reise beginnt mit einem einfachen Konzept: einem flexiblen Tool zur Bewertung von Lappen, mit dem verschiedene Metriken und Randumstände verwaltet werden können. Sie werden von der Initialisierung Ihres Pakets mit Gedichten zum Erstellen einer soliden Evaluator -Klasse und dem Testen Ihres Codes beim Eintauchen in diesen Beitrag übergehen. Sie erhalten Kenntnisse darüber, wie Sie Ihr Paket erstellen, Bleu- und Rouge -Scores berechnen und online veröffentlichen. Am Ende haben Sie mehr Einblicke in die Python-Verpackungen und die Open-Source-Beiträge erhalten und haben zusätzlich zu einem Arbeitsinstrument, das von der Öffentlichkeit für die Nutzung bereit ist.

Lernergebnisse

• Lernen Sie, ein Python -Paket mithilfe von Poesie zu initialisieren und zu strukturieren.
• Entwickeln und implementieren Sie eine Evaluator -Klasse für mehrere Metriken.
• Berechnen und bewerten Sie Metriken wie Bleu- und Rouge -Scores.
• Schreiben und führen Sie Tests aus, um die Codefunktion und Robustheit sicherzustellen.
• Erstellen und veröffentlichen Sie ein Python -Paket für PYPI, einschließlich Handhabung von Verteilungen und Lizenzierung.

Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.

Inhaltsverzeichnis

• Initialisieren Sie Ihr Paket mit Gedichten
• Entwerfen der Kern -Evaluator -Klasse
• Definieren von Evaluator -Klasse
• Implementierung von Bewertungsmetriken
• Berechnung von Bleu -Scores
• Messung von Rouge -Scores
• Testen Sie Ihr Paket
• Bauen Sie das Rad
• Erstellen von Quell- und Binärverteilungen
• Veröffentlichen Sie das Paket
• Häufig gestellte Fragen

Initialisieren Sie Ihr Paket mit Gedichten

Nachdem wir die Anforderungen haben, können wir zunächst ein neues Python -Paket mithilfe von Poesie initialisieren. Der Grund für die Auswahl der Poesie ist:

• Es wird die Notwendigkeit der Verwaltung mehrerer virtueller Umgebungen beseitigt.
• Es unterstützt alle Arten von Python -Paketformaten, sowohl native als auch Legacy -Pakete.
• Es sorgt für die richtige Version auch für die Abhängigkeiten durch die Datei "poetry.lock".
• Pypi bereit mit einem einzigen Befehl.

Installieren Sie die Gedichte mit dem Befehl für fast das gesamte Betriebssystem:

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

Anschließend können wir ein neues Repository mit der Boilerplate mit dem folgenden Befehl erstellen.

 Poesie New Package_Name

Es gibt nur wenige generische Fragen, für die Sie die Eingabetaste drücken und sie als Standardeinstellung lassen können. Dann landen Sie in einer Ordnerstruktur ähnlich.

 Poesie-Demo

├── PYProject.toml

├── Readme.md

├── Poetry_Demo

│ └── __init__.py

└── Tests

└── __init__.py

Obwohl die Struktur in Ordnung ist, können wir das "SRC" -Layout im Vergleich zum "Flat" -Layout verwenden, wie in der offiziellen Python -Dokumentation erläutert. Wir werden das "src` -Layout" im Rest des Blogs verfolgen.

Entwerfen der Kern -Evaluator -Klasse

Das Herz unseres Pakets enthält den gesamten Quellcode, um das Python Evaluator -Paket zu versorgen. Es enthält die Basisklasse, die von allen Metriken, die wir haben möchten, geerbt werden. Daher muss diese Klasse der robusteste und größte Vorsicht sein, der während des Baus gepflegt werden muss. Diese Klasse verfügt über die erforderliche Logik, die für die grundlegende Initialisierung benötigt wird, eine Methode, um das Ergebnis aus der Metrik zu erhalten, und eine andere Methode (n), um die Benutzereingaben zu behandeln, um leicht konsumierbar zu sein.

Alle diese Methoden müssen ihren eigenen Umfang und die richtigen Datentypen definiert haben. Der Grund, sich mehr auf die Datentypen zu konzentrieren, liegt darin, dass Python dynamisch getippt wird. Daher müssen wir die ordnungsgemäße Verwendung von Variablen sicherstellen, da diese Fehler nur zur Laufzeit verursachen. Daher müssen Testsuiten vorhanden sein, um diese winzigen Fehler zu erfassen, anstatt einen dedizierten Typ-Checking-Compiler zu verwenden. Nun und gut, wenn wir in Python die richtige Tippen verwenden.

Definieren von Evaluator -Klasse

Jetzt, da wir gesehen haben, was die gesamte Evaluator -Klasse enthalten muss und warum es das Wichtigste ist, bleiben wir mit der Umsetzung derselben. Für den Aufbau dieser Klasse erben wir die von Python bereitgestellte ABC -abstrakte Basisklasse. Der Grund für die Auswahl dieser Klasse ist, dass sie alle konkreten Merkmale enthält, auf denen wir unsere Evaluator -Basisklasse erstellen können. Definieren wir nun die Eingänge und Ausgänge der Evaluator -Klasse.

• Eingaben : Kandidaten [Liste der String], Referenzen [Liste der String]
• Methoden : `padding` (Um sicherzustellen, dass die Länge der Kandidaten und Referenzen gleich ist),` get_score` (Methode zur Berechnung des Endergebnisses der Bewertungsmetriken)

 # src/evaluator_blog/evaluator.py

Warnungen importieren
Aus dem Typing Import Union, Liste
von ABC Import ABC, AbstractMethod


Klassenbasisvaluator (ABC):
    Def __init __ (Selbst, Kandidaten: Liste, Referenzen: Liste) -> Keine:
        self.candidates = Kandidaten
        self.references = referenzen

    @StaticMethod
    Def Padding (
        Kandidaten: Liste [STR], Referenzen: List [STR]
    ) -> Union [Liste [STR], Liste [STR]]:
        """_Zusammenfassung_

        Args:
            Kandidaten (Liste [STR]): Die aus der LLM generierte Antwort
            Referenzen (Liste [STR]): Die Antwort, gegen die gemessen werden soll

        Rückgaben:
            Union [Liste [STR], Liste [STR]]: Gewährleistet die gleiche Länge der "Kandidaten" und "Referenzen"
        "" "
        _msg = str (
            "" "
            Die Länge der Referenzen und Kandidaten (Hypothese) ist nicht dasselbe.
            "" "
        )
        Warnungen.Warn (_msg)
        max_length = max (len (Kandidaten), Len (Referenzen))
        Candidaten.extend ([""] * (max_length - len (Kandidaten)))
        referenzen.extend ([""] * (max_length - len (referenzen)))
        Kandidaten zurückgeben, Referenzen

    @StaticMethod
    Def list_to_string (l: list) -> str:
        behaupten (
            Len (l)> = 1
        ), "Stellen Sie sicher, dass die Länge der Nachricht größer oder gleich 1 ist"

        return str (l [0])

    @abstractMethod
    def get_score (self) -> float:
        "" "
        Methode zur Berechnung des Endergebnisses der Bewertungsfunktion.

        Rückgaben:
            Schwimmpunktwert der gewählten Bewertungsmetrik.
        "" "

Hier können wir feststellen, dass die Methode `__init () __` die erforderlichen Parameter enthält, die die grundlegende Anforderung für alle Evaluator -Metrik -IE -Kandidaten und -referenzen darstellen.

Dann enthält die Polsterung, die erforderlich ist, um sowohl die "Kandidaten" als auch "Referenzen" zu gewährleisten, die gleiche Länge wie die statische Methode, da wir dies nicht jedes Mal initialisieren müssen, wenn wir anrufen. Daher enthält der StaticMethod Decorator die erforderliche Logik.

Schließlich verwenden wir für den "Get_Score ()` Wir verwenden den AbstractMethod Decorator, was bedeutet, dass alle Klassen, die die Basis -Evaluator -Klasse erben, diese Methode definitiv enthalten müssen.

Implementierung von Bewertungsmetriken

Jetzt kommt das Herzstück der Implementierung der Bibliothek, der Bewertung der Metriken. Derzeit verwenden wir für die Berechnung die jeweiligen Bibliotheken, die die Aufgabe ausführen und die metrische Punktzahl anzeigen. Wir verwenden hauptsächlich "Kandidaten", dh die von LLM erzeugte Antwort und "Referenzen" dh die Grundwahrheit und wir berechnen den Wert. Der Einfachheit halber berechnen wir den Bleu- und Rouge -Score. Diese Logik ist für alle auf dem Markt erhältlichen Metriken erweiterbar.

Berechnung von Bleu -Scores

Als zweisprachige Bewertungsstuddie abgekürzt ist eine der häufigsten Bewertungsmetriken der maschinellen Übersetzung (Kandidaten), die schnell, kostengünstig und sprachunabhängig sind. Es hat marginale Fehler im Vergleich zur manuellen Bewertung. Es vergleicht die Nähe der maschinellen Übersetzung mit den professionellen menschlichen Reaktionen (Referenzen) und gibt die Bewertung als metrische Punktzahl im Bereich von 0-1 zurück, wobei irgendetwas in Richtung 1 als enger Match bezeichnet wird. Sie betrachten N-Gramm (s) (Stücke von N Wörtern) in einem Satz von Kandidaten. Z.B. Unigrams (1 Gramm) berücksichtigt jedes Wort von Kandidaten und Referenzen und gibt die als Präzisionsbewertung bezeichnete normalisierte Punktzahl zurück.

Es funktioniert jedoch nicht immer gut, wenn man bedenkt, ob das gleiche Wort mehrmals angezeigt wird, dass es für jedes Erscheinungsbild für jedes Erscheinungsbild berücksichtigt wird, was normalerweise falsch ist. Daher verwendet BLEU eine modifizierte Präzisionsbewertung, in der die Anzahl der Wortübereinstimmungen zusammengehalten und mit der Anzahl der Wörter im Kandidaten normalisiert. Ein weiterer Haken hier ist, dass das Wort nicht berücksichtigt wird. Daher berücksichtigt die BLEU-Punktzahl mehrere N-Gramm und zeigt die Genauigkeit von 1 bis 4 Gramm mit anderen Parametern an.

Vorteile

• Schnellere Berechnung und einfache Berechnungen.
• Weit verbreitete und einfach zu regnalifizierende Ergebnisse.

Nachteile

• Betrachtet die Bedeutung der Übersetzung nicht.
• Berücksichtigt das Satzformat nicht.
• Obwohl es zweisprachig ist, kämpft es mit nicht englischen Sprachen.
• Es ist schwer zu berechnen, wenn menschliche Übersetzungen bereits tokenisiert werden.

 # src/evaluator_blog/metrics/bleu.py

Aus dem Einteichen von Importliste, Callable, optional
von src.evaluator_blog.evaluator import baseevaluator

von nltk.translate.bleu_score import corpus_bleu, glättungsfunktion

"" "
BLEU -Implementierung aus NLTK
"" "
Klasse Bleuscore (Basievaluator):
    def __init __ (
        selbst,
        Kandidaten: Liste [STR],
        Referenzen: Liste [STR],
        Gewichte: Optional [Liste [float]] = keine,
        Smoothing_function: Optional [Callable] = None,
        auto_reweigh: optional [bool] = false,
    ) -> Keine:
        "" "
        Berechnen Sie den BLEU -Score (zweisprachige Bewertungsstuddy) von
        Papineni, Kishore, Salim Roukos, Todd Ward und Wei-Jing Zhu. 2002.
        "BLEU: Eine Methode zur automatischen Bewertung der maschinellen Übersetzung."
        In Proceedings of ACL. https://aclanthology.org/p02-1040.pdf

            Args:
                Gewichte (optional [Liste [Float]], optional): Die Gewichte, die auf jeden BLEU_SCORE angewendet werden müssen. Standardmäßig keine.
                SHORYING_FUNCTION (optional [aufrufbar], optional): Eine aufrufbare Funktion zur Überwindung des Problems der Sparsität von Trainingsdaten, indem die Wahrscheinlichkeitsmassenverteilung von Wörtern hinzugefügt oder angepasst wird. Standardmäßig keine.
                auto_reweigh (optional [bool], optional): Einheitlich um die maximale Hypotheselängen einheitlich umgewichtet, wenn die größte Reihenfolge von N-Gramm  Float:
        "" "
        Berechnen Sie den BLEU -Wert für die angegebenen Kandidaten und Referenzen.

        Args:
            Kandidaten (Liste [STR]): Liste der Kandidatensätze
            Referenzen (Liste [STR]): Liste der Referenzsätze
            Gewichte (optional [List [Float]], optional): Gewichte für die BLEU -Score -Berechnung. Standardmäßig (1.0, 0, 0, 0)
            glättung_function (optional [Funktion]): Glättungstechnik für Segment-Level-BLEU-Ergebnisse

        Rückgaben:
            Float: Der berechnete BLEU -Wert.
        "" "
        # Überprüfen Sie, ob die Länge der Kandidaten und Referenzen gleich ist
        Wenn len (self.candidates)! = len (self.references):
            self.candidates, self.references = self.padding (
                self.candidates, self.references
            )

        # Berechnen Sie die BLEU -Punktzahl
        return corpus_bleu (
            list_of_references = self.references,
            hypothesen = self.candidates,
            Gewichte = self.gewichtet,
            Smoothing_function = self.smoothing_function,
            auto_reweigh = self.auto_reweigh,
        )

Messung von Rouge -Scores

Abgekürzte als Rückruf-orientierte Zweitbesetzung für die Gisting-Bewertung ist eines der gängigen Bewertungsmetriken für den Vergleich von Modellgenerierten Zusammenfassungen mit mehreren Menschenzusammenfassungen. Auf naive Weise vergleicht es die N-Gramm sowohl der Maschine als auch der von Menschen erzeugten Zusammenfassung. Dies wird als Rouge-N-Rückruf-Score bezeichnet. Um mehr Relevanz in der maschinellen Zusammenfassung der menschlichen Zusammenfassung zu gewährleisten, können wir die Präzisionsbewertung berechnen. Da wir sowohl Präzisions- als auch Rückruf-Scores haben, können wir den F1-Score berechnen. Es wird normalerweise empfohlen, mehrere Werte von "n" zu berücksichtigen. Eine kleine Variante in Rouge ist die Rouge-L-Punktzahl, die die Abfolge von Wörtern berücksichtigt und die LCs berechnet (längste gemeinsame Subsequenz). Auf die gleiche Weise können wir die Präzision und Rückrufbewertung erhalten. Ein geringfügiger Vorteil hier ist, dass es die Molekularität des Satzes berücksichtigt und relevante Ergebnisse erzielt.

Vorteile

• Hochwirksam zur Bewertung der Qualität der automatischen Textübersicht durch Vergleich von N-Gramm und am längsten gemeinsamen Subsequenzen.
• Rouge kann auf jede Sprache angewendet werden, wodurch es für mehrsprachige Textanalysen und -bewertung vielseitig ist.

Nachteile

• Rouge konzentriert sich auf Textanpassungen auf Oberflächenebene (N-Gramm), die möglicherweise nicht eine tiefere semantische Bedeutung und Kohärenz erfassen.
• Die Genauigkeit von Rouge hängt stark von der Qualität und Repräsentativität der Referenzzusammenfassungen ab

 # src/evaluator_blog/metrics/rouge.py

Warnungen importieren
Aus dem Einteichen von Importliste, Gewerkschaft, Dikt
von ..Valuator Import Baseevaluator
von Rouge_Score importieren Sie Rouge_Scorer


Klasse Rougescore (Baseevaluator):
    def __init __ (
        selbst,
        Kandidaten: Liste,
        Referenzen: Liste,
        Rouge_types: Optional [Union [STR, TUPLE [STR]] = [
            "Rouge1",
            "Rouge2",
            "Rougel",
            "Rougelsum",
        ],
        Use_Stemmer: Optional [bool] = false,
        split_summaries: optional [bool] = false,
        Tokenizer: Optional [Callable] = None,
    ) -> Keine:
        Super () .__ init __ (Kandidaten, Referenzen)

        # Standard `rouge_types` ist alles, sonst der Benutzer angegeben
        Wenn is inance (Rouge_types, STR):
            self.rouge_types = [rouge_types]
        anders:
            self.rouge_types = rouge_types

        # Aktivieren Sie `Use_Stemmer`, um Wortsuffixe zu entfernen, um die Übereinstimmungsfähigkeit zu verbessern
        self.use_stemmer = use_stemmer

        # Wenn aktiviert überprüft wird, ob neue Zeilen zwischen den Sätzen für `rougelsum` hinzugefügt werden sollen
        self.split_summaries = split_summaries

        # Aktivieren Sie `tokenizer` Wenn der Benutzer definiert ist oder die Standardeinstellung` rouge_scorer` verwendet
        # https://github.com/google-research/google-research/blob/master/rouge/rouge_scorer.py#l83
        If Tokenizer:
            self.tokenizer = tokenizer
        anders:
            self.tokenizer = keine
            _msg = str (
                "" "
                Verwendung des Standard -Tokenizers
                "" "
            )
            Warnungen.Warn (_msg)

    def get_score (self) -> dict:
        "" "
        Rückgaben:
            DICT: JSON -Wert der Bewertung für die entsprechende Metrik
        "" "
        scorer = rouge_scorer.rougescorer (
            Rouge_types = self.rouge_types,
            use_stemmer = self.use_stemmer,
            Tokenizer = self.tokenizer,
            split_summaries = self.split_summaries,
        )

        return scorer.score (self.list_to_string (self.candidates), self.list_to_string (self.references)))

Testen Sie Ihr Paket

Nachdem wir die Quelldatei vor der tatsächlichen Verwendung vorbereitet haben, müssen wir die Arbeitsweise des Codes überprüfen. Hier kommt die Testphase ins Bild. Im Python Library Format/Convention/Best Practice schreiben wir alle Tests unter dem Ordner mit dem Namen "Tests/". Diese Namenskonvention erleichtert es den Entwicklern leicht zu verstehen, dass dieser Ordner seine Bedeutung hat. Obwohl wir mehrere Entwicklungstools haben, können wir die Bibliothek mithilfe von Typprüfung, Fehlerbehandlung und vielem mehr einschränken. Dies richtet sich an die erste Überprüfungs- und Testrunde. Um jedoch Kantenfälle und Ausnahmen zu gewährleisten, können wir Unittest und Pytestas die Frameworks verwenden. Nachdem dies gesagt wurde, machen wir uns einfach mit der Grundlage der "unittest" -Bibliothek ein, um die grundlegenden Tests einzurichten.

Schreiben effektiver Unit -Tests

Die wichtigsten Begriffe in Bezug auf "Unittest" sind die Testfall und die Testsuite.

• Testfall : Kleinste Testeinheit, bei der wir die Eingaben anhand einer Reihe von Ausgängen bewerten.
• Testsuite : Eine Sammlung von Testfällen, Suiten oder beides. Wird verwendet, um Tests zu aggregieren, um zusammenzuarbeiten.
• Namenskonvention : Dies muss mit `tests_` dem Dateinamen sowie dem Funktionsnamen vorangestellt werden. Der Grund ist, dass der Parser sie erkennt und zur Testsuite hinzufügt.

Bauen Sie das Rad

Das Rad ist im Grunde ein Python -Paket, das IE installiert ist, wenn wir den Befehl `pip install ` ausführen. Der Inhalt des Rades wird in der Datei '.wl' gespeichert. Die Raddatei wird bei `dist/` gespeichert. Es gibt eine gebaute Verteilung von `.wl` und die Quellverteilung` .gz`. Da wir Poesie verwenden, können wir die Verteilung mit dem Befehl Build erstellen:

 Poesie Build

Es erzeugt die Rad- und ZIP -Datei im Ordner "dist/" im Ordner des Ordners.

 dist/
├── package_name-0.0.1-py3-none-any.wl
└── package_name-0.0.1.tar.gz

Aliter, der äquivalente Python -Befehl, installiert das "Build" -Paket und dann den Befehl Build aus dem Stammwurzel des Ordners.

 Python3 -m PIP Installation -Upgrade Build
Python3 -m Build

Erstellen von Quell- und Binärverteilungen

Sehen wir uns nun nach Erstellen von Quell- und Binärverteilungen.

Quellverteilung (SDIST)

`sdist` ist die Quellverteilung des Pakets, das Quellcode und Metadaten enthält, um aus externen Tools wie PIP oder Poesie zu erstellen. "SDist" muss vor "Bdist" gebaut werden. Wenn `pip` die Build -Verteilung nicht findet, wirkt die Quellverteilung als Fallback. Dann baut es ein Rad heraus und installiert dann die Paketanforderungen.

Binärverteilung (BDIST)

`bdist` enthält die erforderlichen Dateien, die an den richtigen Speicherort des Zielgeräts verschoben werden müssen. Eines der am besten unterstützten Formate ist `.wl`. Hinweis darauf, dass es keine Python -Dateien zusammengestellt hat.

Lizenz

Während Open-Sourcing das Paket in die externe Welt immer ratsam ist, eine Lizenz zu haben, die zeigt, inwieweit Ihr Code wiederverwendet werden kann. Beim Erstellen eines Repositorys in GitHub haben wir die Möglichkeit, die Lizenz dort auszuwählen. Es erstellt eine "Lizenz" -Datei mit Nutzungsoptionen. Wenn Sie sich nicht sicher sind, welche Lizenz zu wählen ist, ist diese externe Ressource perfekt für die Rettung.

Veröffentlichen Sie das Paket

Nachdem wir alle Anforderungen haben, müssen wir das Paket in der externen Welt veröffentlichen. Wir verwenden also den Befehl veröffentlichen, der alle Schritte mit einem einzigen Befehl abstrahiert.

test.pypi.org

Wenn Sie sich nicht sicher sind, wie das Paket ausführen oder zu Testzwecken eine TEST -Zwecke erfolgt, wird empfohlen, auf einen Test zu veröffentlichen. Dies gibt uns die Flexibilität, das Paket zu testen, bevor wir es mit allen teilen.

pypi.org

Das offizielle Python -Paket enthält alle privaten und öffentlichen Software, die von der Python -Community veröffentlicht wurden. Für Autoren und Organisationen ist es nützlich, ihre Pakete über ein offizielles zentrales Repository zu teilen. Alles, was es braucht, um Ihr Paket für die Welt zu veröffentlichen, ist dieser einzelne Befehl.

 Poesie Publish - -build --username $ pypi_username -password $ pypi_password

Abschluss

Am Ende dieses Artikels haben Sie erfolgreich ein Python -Paket veröffentlicht, das von Millionen verwendet werden kann. Wir haben ein neues Paket mit Poesie initialisiert, an dem Anwendungsfall gearbeitet, die Tests geschrieben, das Paket erstellt und sie im PYPI -Repository veröffentlicht. Dies wird mehr Wert für sich selbst verleihen und Ihnen auch helfen, die verschiedenen Open-Source-Python-Paket-Repositorys zu verstehen, wie sie strukturiert sind. Last but not least ist dies nur der Anfang und wir können es so erweiterbar wie möglich machen. Wir können uns auf die Open-Source-Python-Pakete und -verteilungen beziehen und uns von demselben inspirieren lassen.

Key Takeaways

• Master Python -Paketerstellung und -management mit Poesie.
• Implementieren und passen Sie die Bewertungsmetriken für verschiedene Anwendungsfälle an.
• Erstellen und testen Sie robuste Python -Pakete mit Unit -Test -Frameworks.
• Veröffentlichen Sie Ihr Paket bei PYPI und verstehen Sie die Verteilungsformate.
• Gewinnen Sie Einblicke in die Open-Source-Paketentwicklung und die Lizenzpraktiken.

Häufig gestellte Fragen

Q1. Was ist der Zweck dieses Artikels?

A. Der Artikel hilft Ihnen dabei, ein Python -Paket zu erstellen und zu veröffentlichen, mit dem Sie sich auf ein Rag -Evaluator -Tool konzentrieren können, das von der Community für verschiedene Evaluierungsmetriken verwendet werden kann.

Q2. Warum sollte ich Gedichte für die Verwaltung meines Python -Pakets verwenden?

A. Poesie vereinfacht das Abhängigkeitsmanagement und die Verpackung durch Integration von Versionssteuerung, virtuellen Umgebungen und Veröffentlichung von Aufgaben in ein einzelnes Tool, wodurch die Entwicklung und Verteilung erleichtert wird.

Q3. Welche Bewertungsmetriken sind im Artikel behandelt?

A. Der Artikel beschreibt, wie die BLEU- und Rouge-Scores berechnet werden, die üblicherweise verwendet werden, um die Qualität des maschinengenerierten Textes im Vergleich zu Referenztexten zu bewerten.

Q4. Wie kann ich die Funktionalität meines Python -Pakets testen?

A. Sie können Ihr Paket mit Frameworks wie Unittest oder PyTest testen, um sicherzustellen, dass der Code wie erwartet funktioniert und Randfälle behandelt und vor der Veröffentlichung Vertrauen gewährleistet.

Q5. Was sind die Schritte zur Veröffentlichung eines Python -Pakets?

A. Erstellen Sie Ihr Paket mit Poesie oder Build, testen Sie es auf test.pypi.org und veröffentlichen Sie es dann im offiziellen pypi.org -Repository mit dem Befehl poetry veröffentlichen, um es der Öffentlichkeit zur Verfügung zu stellen.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonSo bauen Sie ein Python -Paket mit Lag -Bewerter mit Gedichten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!