Comment construire un package Python évaluateur de chiffon avec poésie

Introduction

Imaginez que vous êtes sur le point de produire un package Python qui a le potentiel de transformer complètement la façon dont les développeurs et les analystes de données évaluent leurs modèles. Le voyage commence par un concept simple: un outil d'évaluation des chiffons flexible qui peut gérer une variété de métriques et de circonstances de bord. Vous passerez de l'initialisation de votre package avec de la poésie à la création d'une classe d'évaluatrice solide et à la test de votre code pendant que vous plongez dans ce post. Vous obtiendrez des connaissances sur la façon de créer votre package, de calculer les scores Bleu et Rouge et de le publier en ligne. À la fin, vous aurez acquis un aperçu de l'emballage Python et des contributions open source en plus d'avoir un outil de travail prêt à utiliser par le grand public.

Résultats d'apprentissage

• Apprenez à initialiser et à structurer un package Python à l'aide de la poésie.
• Développer et implémenter une classe d'évaluatrice pour plusieurs mesures.
• Calculez et évaluez les mesures telles que les scores BLEU et Rouge.
• Écrivez et exécutez des tests pour assurer la fonctionnalité du code et la robustesse.
• Créez et publiez un package Python à PYPI, y compris la gestion des distributions et des licences.

Cet article a été publié dans le cadre du Blogathon de la science des données.

Table des matières

• Initialiser votre package avec de la poésie
• Concevoir la classe d'évaluatrice de base
• Définition de la classe d'évaluatrice
• Mise en œuvre des mesures d'évaluation
• Calcul des scores BLEU
• Mesurer les scores rouges
• Tester votre package
• Construisez la roue
• Création de distributions source et binaire
• Publier le package
• Questions fréquemment posées

Initialiser votre package avec de la poésie

Maintenant que nous avons les exigences, nous pouvons commencer par initialiser un nouveau package Python à l'aide de la poésie. La raison du choix de la poésie est:

• Il supprime la nécessité de gérer plusieurs environnements virtuels.
• Il prend en charge tous les types de formats de package Python, à la fois natifs et hérités.
• Il garantit la bonne version même pour les dépendances via le fichier `poetry.lock`.
• PYPI prêt avec une seule commande.

Installez la poésie à l'aide de la commande pour presque tout le système d'exploitation:

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

Ensuite, nous pouvons créer un nouveau référentiel avec le chauffeur à l'aide de la commande suivante.

 poésie Nouveau package_name

Il y aura peu de questions génériques pour lesquelles vous pourrez appuyer sur l'entrée et la laisser par défaut. Ensuite, vous atterrirez dans une structure de dossiers similaire à celle-ci.

 amateur de poésie

├fiques

├fiques

├fiqueslo Poetry_Demo

│ └── __init__.py

Tests

└── __init__.py

Bien que la structure soit très bien, nous pouvons utiliser la disposition «SRC» par rapport à la disposition «plate» comme discuté dans la documentation officielle Python. Nous suivrons la disposition `` SRC »dans le reste du blog.

Concevoir la classe d'évaluatrice de base

Le cœur de notre package contient tout le code source pour alimenter le package d'évaluateur Python. Il contient la classe de base qui va être héritée par toutes les mesures que nous souhaitons avoir. Cette classe doit donc être le plus robuste et le plus grand soin doit être pris pendant la construction. Cette classe aura la logique nécessaire nécessaire pour l'initialisation de base, une méthode pour obtenir le résultat de la métrique et une autre méthode pour gérer l'entrée des utilisateurs à être facilement consommable.

Toutes ces méthodes doivent avoir leur propre portée et les types de données appropriés définis. La raison de se concentrer davantage sur les types de données est que le python est dynamiquement typé. Par conséquent, nous devons assurer l'utilisation appropriée des variables car ces erreurs provoquent uniquement des erreurs. Il doit donc y avoir des suites de tests pour attraper ces erreurs minuscules, plutôt que d'utiliser un compilateur de vérification de type dédié. Bien et bon si nous utilisons une frappe appropriée en python.

Définition de la classe d'évaluatrice

Maintenant que nous avons vu ce que la classe d'évaluatrice doit contenir et pourquoi c'est la plus importante qui nous reste avec la mise en œuvre de la même chose. Pour la construction de cette classe, nous héritons de la classe de base ABC - abstraite fournie par Python. La raison du choix de cette classe est qu'elle contient toutes les fonctionnalités en béton sur lesquelles nous pouvons construire notre classe de base d'évaluatrice. Définissons maintenant les entrées et sorties de la classe Evaluator.

• Entrées : candidats [liste de chaîne], références [liste de chaîne]
• Méthodes : `` Padding '(pour s'assurer que la durée des candidats et des références est la même), «get_score» (méthode pour calculer le résultat final des mesures d'évaluation)

 # src / evaluator_blog / evaluator.py

avertissements d'importation
de la saisie du syndicat d'import, liste
De ABC Import ABC, AbstractMethod


Class BaseeValuator (ABC):
    Def __init __ (self, candidats: liste, références: liste) -> Aucun:
        self.andIdated = candidats
        self.references = références

    @StaticMethod
    padding de def (
        candidats: liste [str], références: liste [str]
    ) -> Union [list [str], list [str]]:
        """_résumé_

        Args:
            candidats (liste [str]): la réponse générée à partir de la LLM
            références (liste [str]): la réponse à mesurer contre

        Renvoie:
            Union [List [Str], List [Str]]: assure une durée égale des «candidats» et des «références»
        "" "
        _msg = str (
            "" "
            La durée des références et des candidats (hypothèse) ne sont pas les mêmes.
            "" "
        )
        avertissements.warn (_msg)
        max_length = max (len (candidats), Len (références))
        candidats.extend ([""] * (max_length - Len (candidats)))
        références.extend ([""] * (max_length - len (références)))
        retour aux candidats, références

    @StaticMethod
    def list_to_string (l: list) -> str:
        affirmer (
            len (l)> = 1
        ), "Assurez-vous que la longueur du message est supérieure ou égale à 1"

        return str (l [0])

    @abstractMethod
    def get_score (self) -> float:
        "" "
        Méthode pour calculer le résultat final de la fonction de score.

        Renvoie:
            Valeur du point flottant de la métrique d'évaluation choisie.
        "" "

Ici, nous pouvons constater que la méthode `__INIT () __` `contient les paramètres requis qui sont l'exigence de base pour toute mesure des candidats et références de l'évaluateur.

Ensuite, le rembourrage requis pour garantir à la fois les «candidats» et les «références» contiennent la même longueur définie que la méthode statique car nous n'avons pas besoin d'initialiser chaque fois que nous appelons. Par conséquent, le décorateur StaticMethod contient la logique requise.

Enfin, pour le `get_score () ', nous utilisons le décorateur AbstractMethod, ce qui signifie que toutes les classes qui héritent de la classe de l'évaluateur de base doivent certainement contenir cette méthode.

Mise en œuvre des mesures d'évaluation

Vient maintenant au cœur de la mise en œuvre de la bibliothèque, l'évaluation des mesures. Actuellement pour le calcul, nous utilisons des bibliothèques respectives qui effectuent la tâche et affichent le score métrique. Nous utilisons principalement des «candidats», c'est-à-dire la réponse générée par LLM et les «références», c'est-à-dire la vérité au sol et nous calculons respectivement la valeur. Pour plus de simplicité, nous calculons le score Bleu et Rouge. Cette logique est extensible à toutes les mesures disponibles sur le marché.

Calcul des scores BLEU

Abrévié en tant qu'évaluation de l'évaluation bilingue est l'une des mesures d'évaluation courantes de la traduction automatique (candidats) qui est rapide, peu coûteuse et indépendante du langage. Il a des erreurs marginales par rapport à l'évaluation manuelle. Il compare la proximité de la traduction automatique avec les réponses humaines professionnelles (références) et renvoie l'évaluation en tant que score métrique dans la plage de 0-1, tout vers 1 étant qualifié de correspondance étroite. Ils considèrent que N-gram (s) (morceaux de n mots) dans une phrase des candidats. Par exemple, par exemple Les unigrammes (1 gramme) considèrent chaque mot des candidats et références et renvoient le score normalisé appelé score de précision.

Mais cela ne fonctionne pas toujours bien étant donné que si le même mot apparaît plusieurs fois, il explique le score final pour chaque apparence qui est généralement incorrect. Par conséquent, Bleu utilise un score de précision modifié où il coupe le nombre de correspondances de mots et le normalise avec le nombre de mots chez le candidat. Une autre prise ici est qu'elle ne prend pas en compte le mot. Par conséquent, le score BLEU considère plusieurs grammes N et affiche les scores de précision de 1 à 4 grammes avec d'autres paramètres.

Avantages

• Calcul plus rapide et calculs simples impliqués.
• Les résultats largement utilisés et faciles à comparer.

Désavantage

• Ne considère pas la signification de la traduction.
• Ne prend pas en compte le format de phrase.
• Bien qu'il soit bilingue, il lutte avec des langues non anglophones.
• Difficile de calculer les scores lorsque les traductions humaines sont déjà tokenisées.

 # src / evaluator_blog / metrics / bleu.py

à partir de la liste d'importation, appelant, facultatif
de src.evaluator_blog.evaluator import baseevaluator

de nltk.translate.bleu_score Import Corpus_bleu, SmoothingFunction

"" "
Implémentation BLEU de NLTK
"" "
classe Bleuccore (BaseeValuator):
    def __init __ (
        soi,
        candidats: liste [str],
        Références: liste [Str],
        poids: facultatif [list [float]] = aucun,
        smoothing_function: facultatif [callable] = aucun,
        auto_reweigh: facultatif [bool] = false,
    ) -> Aucun:
        "" "
        Calculer le score BLEU (sous-étude d'évaluation bilingue) à partir de
        Papineni, Kishore, Salim Roukos, Todd Ward et Wei-Jing Zhu. 2002.
        "BLEU: une méthode d'évaluation automatique de la traduction machine."
        Dans les actes de l'ACL. https://aclanthology.org/p02-1040.pdf

            Args:
                Poids (facultatif [liste [float]], facultatif): les poids qui doivent être appliqués à chaque bleu_score. Par défaut à aucun.
                Smoothing_Function (Facultatif [appelant], facultatif): une fonction appelable pour surmonter le problème de la rareté des données de formation en ajoutant ou en ajustant la distribution de masse de probabilité des mots. Par défaut à aucun.
                auto_reweigh (facultatif [bool], facultatif): redéautage uniformément basé sur des longueurs d'hypothèse maximales si le plus grand ordre de n-grammes  float:
        "" "
        Calculez le score BLEU pour les candidats et références donnés.

        Args:
            candidats (liste [str]): liste des phrases des candidats
            Références (liste [Str]): liste des phrases de référence
            Poids (Facultatif [Liste [Float]], Facultatif): Poids pour le calcul du score BLEU. Par défaut à (1.0, 0, 0, 0)
            Smoothing_Function (facultatif [fonction]): technique de lissage pour pour les scores BLEU au niveau du segment

        Renvoie:
            Float: le score BLEU calculé.
        "" "
        # Vérifiez si la durée des candidats et des références est égale
        Si Len (self.candits)! = Len (self.references):
            self.Candidates, self.references = self.padding (
                self.candits, self.references
            )

        # Calculez le score BLEU
        return corpus_bleu (
            list_of_references = self.references,
            Hypothèses = self.andIdatedates,
            poids = self.weights,
            smoothing_function = self.smoothing_function,
            auto_reweigh = self.auto_reweigh,
        )

Mesurer les scores rouges

Abrévié en tant que sous-étude orientée vers le rappel pour l'évaluation de l'escroquerie est l'une des mesures d'évaluation courantes pour comparer des résumés générés par le modèle avec plusieurs résumés humains. De manière naïve, il compare les n-grammes de la machine et le résumé généré par l'homme. C'est ce qu'on appelle le score de rappel Rouge-N. Pour assurer une pertinence plus pertinente dans le résumé généré par la machine pour le résumé humain, nous pouvons calculer le score de précision. Comme nous avons à la fois des scores de précision et de rappel, nous pouvons calculer le score F1. Il est normalement recommandé de considérer plusieurs valeurs de `n`. Une petite variante à Rouge est le score Rouge-L qui considère la séquence des mots et calcule le LCS (la plus longue subséquence commune). De la même manière, nous pouvons obtenir le score de précision et de rappel. Un léger avantage ici est qu'il considère la molécularité de la phrase et produit des résultats pertinents.

Avantages

• Très efficace pour évaluer la qualité de la résumé de texte automatique en comparant les n-grammes et les plus longues sous-séquences courantes.
• Rouge peut être appliqué à n'importe quelle langue, ce qui le rend polyvalent pour l'analyse et l'évaluation multilingues du texte.

Désavantage

• Rouge se concentre sur la correspondance du texte au niveau de la surface (n-grammes), qui pourrait ne pas capturer une signification et une cohérence sémantiques plus profondes.
• La précision de Rouge dépend fortement de la qualité et de la représentativité des résumés de référence

 # src / evaluator_blog / metrics / rouge.py

avertissements d'importation
de la liste d'importation de type, syndical, dict, appelant, tuple, facultatif
De ..Evaluator import BaseeValuator
De Rouge_score Importer Rouge_scorer


classe Rougescore (BaseeValuator):
    def __init __ (
        soi,
        candidats: liste,
        Références: liste,
        rouge_types: facultatif [union [str, tuple [str]]] = [
            "Rouge1",
            "Rouge2",
            "Rougel",
            "Rougelsum",
        ],
        use_stemmer: facultatif [bool] = false,
        Split_summaries: facultatif [bool] = false,
        tokenizer: facultatif [callable] = aucun,
    ) -> Aucun:
        super () .__ init __ (candidats, références)

        # Par défaut `rouge_types` est tout, sinon l'utilisateur a spécifié
        Si Isinstance (Rouge_Types, Str):
            self.rouge_types = [rouge_types]
        autre:
            self.rouge_types = rouge_types

        # Activer «use_stemmer» pour supprimer les suffixes de mots pour améliorer la capacité de correspondance
        self.use_stemmer = use_stemmer

        # Si activé vérifie si vous devez ajouter des lignes de nouvelles entre les phrases pour «Rougelsum»
        self.split_summaries = split_summaries

        # Activer «Tokenizer» si l'utilisateur a défini ou bien utiliser le «Rouge_scorer» par défaut
        # https://github.com/google-research/google-research/blob/master/rouge/rouge_scorer.py#l83
        Si Tokenizer:
            self.tokenizer = tokenizer
        autre:
            self.tokenizer = aucun
            _msg = str (
                "" "
                Utilisation du jetons par défaut
                "" "
            )
            avertissements.warn (_msg)

    def get_score (self) -> dict:
        "" "
        Renvoie:
            Dict: valeur JSON de l'évaluation de la métrique correspondante
        "" "
        buteur = rouge_scorer.rougesCorer (
            rouge_types = self.rouge_types,
            use_stemmer = self.use_stemmer,
            tokenizer = self.tokenizer,
            Split_summaries = self.split_summaries,
        )

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

Tester votre package

Maintenant que nous avons le fichier source prêt avant l'utilisation réelle, nous devons vérifier le fonctionnement du code. C'est là que la phase de test entre en scène. Dans Python Library Format / Convention / Best Practice, nous écrivons tous les tests dans le dossier nommé `Tests /`. Cette convention de dénomination permet aux développeurs de comprendre facilement que ce dossier a sa signification. Bien que nous ayons plusieurs outils de développement, nous pouvons restreindre la bibliothèque à l'aide de la vérification du type, de la gestion des erreurs et bien plus encore. Cela s'adresse au premier cycle de vérification et de test. Mais pour garantir des cas de bord et des exceptions, nous pouvons utiliser unittest Unittest, etyTestas les frameworks incontournables. Cela étant dit, nous allons simplement avec la configuration des tests de base à l'aide de la bibliothèque `Unittest`.

Rédaction de tests unitaires efficaces

Les termes clés à connaître en ce qui concerne «unittest» est le cas de test et la suite de tests.

• Cas de test : la plus petite unité de test où nous évaluons les entrées par rapport à un ensemble de sorties.
• Suite de test : une collection de cas de test, de suites ou les deux. Utilisé pour agréger les tests pour travailler ensemble.
• Convention de dénomination : cela doit être préfixé avec `tests_` au nom du fichier ainsi qu'au nom de la fonction. La raison en est que l'analyseur les détectera et les ajoutera à la suite de tests.

Construisez la roue

La roue est essentiellement un package Python, c'est-à-dire installé lorsque nous exécutons la commande `pip install `. Le contenu de la roue est stocké dans le fichier '.whl'. Le fichier de roue est stocké à `dist /`. Il y a une distribution construite `.whl` et la distribution source` .gz`. Puisque nous utilisons la poésie, nous pouvons construire la distribution à l'aide de la commande de construction:

 Build de poésie

Il génère la roue et le fichier zip à l'intérieur du dossier `Dist /` dans la racine du dossier.

 dist /
├── Package_name-0.0.1-py3-non-any.whl
└fiques-package_name-0.0.1.tar.gz

Aliter, la commande Python équivalente installe le package `Build` puis exécute la commande build à partir de la racine du dossier.

 Python3 -M Pip Install - Build-grade
Python3 -M Build

Création de distributions source et binaire

Passons maintenant à la création de distributions source et binaire.

Distribution des sources (SDIST)

`sdist` est la distribution source du package qui contient du code source et des métadonnées à construire à partir d'outils externes comme PIP ou Poetry. «SDIST» doit être construit avant «Bdist». Si `Pip` ne trouve pas la distribution de build, la distribution de source agit comme une repli. Ensuite, il en construit une roue, puis installe les exigences du package.

Distribution binaire (BDIST)

«BDIST» contient les fichiers nécessaires qui doivent être déplacés vers l'emplacement correct du périphérique cible. L'un des formats les mieux soutenus est «.whl». Point à noter qu'il n'a pas compilé les fichiers Python.

Licence

Lors de l'ouverture du package vers le monde externe, il est toujours conseillé d'avoir une licence qui montre dans quelle mesure votre code peut être réutilisé. Lors de la création d'un référentiel dans GitHub, nous avons la possibilité d'y sélectionner la licence. Il crée un fichier «licence» avec des options d'utilisation. Si vous n'êtes pas sûr de la licence à choisir, cette ressource externe est parfaite pour le sauvetage.

Publier le package

Maintenant que nous avons toutes les exigences dont nous avons besoin pour publier le package dans le monde extérieur. Nous utilisons donc la commande Publish qui résout toutes les étapes avec une seule commande.

test.pypi.org

Si vous ne savez pas comment le package fonctionnerait ou à des fins de test, il est conseillé de publier sur un test.pypi.org plutôt que de télécharger directement vers le référentiel officiel. Cela nous donne la flexibilité de tester le package avant de le partager avec tout le monde.

pypi.org

Le package Python officiel contient tous les logiciels privés et publics publiés par la communauté Python. Il est utile pour les auteurs et les organisations de partager leurs packages via un référentiel central officiel. Tout ce qu'il faut pour publier votre package dans le monde, c'est cette commande unique.

 Poetry Publish --Build --Username $ PYPI_UNERNAME - Password $ pyPi_password

Conclusion

À la fin de cet article, vous avez publié avec succès un package Python prêt à être utilisé par des millions. Nous avons initialisé un nouveau package en utilisant la poésie, travaillé sur le cas d'utilisation, rédigé les tests, construit le package et les avons publiés dans le référentiel PYPI. Cela ajoutera plus de valeur pour vous-même et vous aidera également à comprendre les divers référentiels de packages Python open source sur la façon dont ils sont structurés. Enfin et surtout, ce n'est que le début et nous pouvons le rendre aussi extensible que possible. Nous pouvons nous référer aux packages et distributions Python open source, et nous inspirer de la même chose.

Principaux à retenir

• Master Python Package Creation and Management with Poetry.
• Mettre en œuvre et personnaliser les mesures d'évaluation pour divers cas d'utilisation.
• Créer et tester des packages Python robustes avec des cadres de test unitaires.
• Publiez votre package sur PYPI et comprenez les formats de distribution.
• Gardez un aperçu des pratiques de développement de packages open source et de licence.

Questions fréquemment posées

Q1. Quel est le but de cet article?

A. L'article vous aide à créer et à publier un package Python, en se concentrant sur un outil d'évaluateur de chiffon qui peut être utilisé par la communauté pour diverses mesures d'évaluation.

Q2. Pourquoi devrais-je utiliser la poésie pour gérer mon package Python?

A. La poésie simplifie la gestion et l'emballage des dépendances en intégrant le contrôle de version, les environnements virtuels et les tâches de publication dans un seul outil, ce qui facilite le développement et la distribution.

Q3. Quelles mesures d'évaluation sont couvertes dans l'article?

A. L'article détaille comment calculer les scores Bleu et Rouge, qui sont couramment utilisés pour évaluer la qualité du texte généré par la machine par rapport aux textes de référence.

Q4. Comment puis-je tester les fonctionnalités de mon package Python?

A. Vous pouvez tester votre package à l'aide de frameworks comme Unittest ou PyTest pour vous assurer que le code fonctionne comme prévu et gère les cas Edge, en fournissant la confiance avant la publication.

Q5. Quelles sont les étapes pour publier un package Python?

A. Construisez votre package à l'aide de la poésie ou de la construction, testez-le sur test.pypi.org, puis publiez-le dans le référentiel officiel PYPI.org à l'aide de la commande Poetry Publish pour la mettre à la disposition du public.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!