Vous avez entendu la célèbre citation ?Data Is the New Oil? du mathématicien britannique Clive Humby, c'est la citation la plus influente qui décrit l'importance des données au 21e siècle mais, après le développement explosif du modèle de grande langue et sa formation, ce que nous n'avons pas droit, ce sont les données. Parce que la vitesse de développement et la vitesse d'entra?nement du modèle LLM dépassent presque la vitesse de génération de données des humains. La solution rend les données plus raffinées et spécifiques à la tache ou à la génération de données synthétiques. Le premier est les taches chargées d'experts les plus du domaine, mais le second est plus important pour l'énorme faim des problèmes d'aujourd'hui.

Les données de formation de haute qualité restent un goulot d'étranglement critique. Ce billet de blog explore une approche pratique de la génération de données synthétiques à l'aide de LLAMA 3.2 et Olllama. Il montrera comment nous pouvons créer un contenu éducatif structuré par programme.

Résultats d'apprentissage

• Comprendre l'importance et les techniques de la génération locale de données synthétiques pour améliorer la formation du modèle d'apprentissage automatique.
• Apprenez à implémenter la génération locale de données synthétiques pour créer des ensembles de données de haute qualité tout en préservant la confidentialité et la sécurité.
• Gardez une connaissance pratique de la mise en ?uvre de mécanismes de gestion des erreurs robustes et de réessayer dans les pipelines de génération de données.
• Apprenez la validation JSON, les techniques de nettoyage et leur r?le dans le maintien de sorties cohérentes et fiables.
• Développez une expertise dans la conception et l'utilisation de modèles pydantes pour assurer l'intégrité du schéma de données.

Table des matières

• Qu'est-ce que les données synthétiques?
• Pourquoi avons-nous besoin de données synthétiques aujourd'hui?
• Impact sur LLM et les petites performances LM
• Structure du projet et configuration de l'environnement
• Mise en ?uvre du projet
• Génération robuste
• Tester l'automatisation
• Conclusion
• Questions fréquemment posées

Qu'est-ce que les données synthétiques?

Les données synthétiques se réfèrent aux informations générées artificiellement qui imitent les caractéristiques des données du monde réel tout en préservant les modèles essentiels et les propriétés statistiques. Il est créé à l'aide d'algorithmes, de simulations ou de modèles d'IA pour répondre aux problèmes de confidentialité, augmenter des données limitées ou des systèmes de test dans des scénarios contr?lés. Contrairement aux données réelles, les données synthétiques peuvent être adaptées à des exigences spécifiques, en garantissant la diversité, l'équilibre et l'évolutivité. Il est largement utilisé dans des domaines tels que l'apprentissage automatique, les soins de santé, la finance et les systèmes autonomes pour former des modèles, valider des algorithmes ou simuler des environnements. Les données synthétiques comblent l'écart entre la rareté des données et les applications du monde réel tout en réduisant les risques éthiques et de conformité.

Pourquoi avons-nous besoin de données synthétiques aujourd'hui?

La demande de données synthétiques s'est développée de fa?on exponentielle en raison de plusieurs facteurs

• Règlements sur la confidentialité des données : avec le RGPD et les réglementations similaires, les données synthétiques offrent une alternative s?re pour le développement et les tests
• Capacité: collectionner et annoter les données réelles co?te cher et prend du temps.
• Scalabilités : les données synthétiques peuvent être générées en grande quantité avec des variations contr?lées
• Couverture de cas de bord: nous pouvons générer des données pour des scénarios rares qui pourraient être difficiles à collecter naturellement
• Prototypage rapide: itération rapide sur les modèles ML sans attendre la collecte de données réelles.
• Moins biaisé: les données recueillies dans le monde réel peuvent être sujettes aux erreurs et pleines de biais de genre, de texte raciste et pas sans danger pour les mots des enfants, donc pour faire un modèle avec ce type de données, le comportement du modèle est également intrinsèquement avec ces biais. Avec les données synthétiques, nous pouvons contr?ler facilement ces comportements.

Impact sur LLM et les petites performances LM

Les données synthétiques ont montré des résultats prometteurs dans l'amélioration des modèles de langage grand et petit

• Efficacité de réglage fin: les modèles affinés sur des données synthétiques de haute qualité montrent souvent des performances comparables à celles formées sur des données réelles
• Adaptation du domaine: les données synthétiques aident à pont les lacunes du domaine dans des applications spécialisées
• Augmentation des données: la combinaison de données synthétiques et réelles donne souvent de meilleurs résultats en utilisant l'un seul.

Structure du projet et configuration de l'environnement

Dans la section suivante, nous décomposons la disposition du projet et vous guiderons à travers la configuration de l'environnement requis.

 projet/
├fique
├til les exigences.txt
├fiques
└── English_qa_new.json

Nous allons maintenant configurer notre environnement de projet à l'aide de conda. Suivez les étapes ci-dessous

Créer un environnement conda

 $ conda créer -N Python de données synthétiques = 3,11

# activer l'env nouvellement créé

$ conda activer les données synthétiques

Installez des bibliothèques dans conda env

 PIP installe Pydantic Langchain Langchain-Community
pip install Langchain-eLlama

Maintenant, nous sommes tous configurés pour démarrer l'implémentation du code

Mise en ?uvre du projet

Dans cette section, nous nous plongerons dans la mise en ?uvre pratique du projet, couvrant chaque étape en détail.

Importation de bibliothèques

Avant de démarrer le projet, nous créerons un nom de fichier main.py dans la racine du projet et importerons toutes les bibliothèques de ce fichier:

 de Pydantic Import Basemodel, champ, validationerror
à partir de Langchain.prompts Importer PromptTemplate
De Langchain_ollama Import Ollamallm
de la liste d'importation
Importer JSON
importer uuid
Importer RE
à partir du chemin d'importation Pathlib
à partir de temps pour sommeil

Il est maintenant temps de continuer la pièce d'implémentation de code sur le fichier main.py

Tout d'abord, nous commen?ons par la mise en ?uvre du schéma de données.

Le schéma de données EnglishQuestion est un modèle pydatique qui garantit que nos données générées suivent une structure cohérente avec les champs requis et la génération automatique d'identification.

Implémentation de code

 Classe EnglishQuestion (BasEmodel):
    id: str = champ (
        default_factory = lambda: str (uuid.uuid4 ()),
        description = "Identifiant unique pour la question",
    )
    Catégorie: str = champ (..., description = "type de question")
    Question: str = champ (..., description = "La question de la langue anglaise")
    Réponse: str = champ (..., description = "la bonne réponse à la question")
    think_process: str = champ (
        ..., Description = "Explication du processus de raisonnement pour arriver à la réponse"
    )

Maintenant, que nous avons créé la classe de données EnglishQuestion.

Deuxièmement, nous commencerons à mettre en ?uvre la classe QuestionGenerator. Cette classe est au c?ur de la mise en ?uvre du projet.

Structure des classes de type de remise en question

 Class QuestionGenerator:
    DEF __INIT __ (Self, Model_name: Str, Output_file: Path):
        passer

    def Clean_json_string (self, texte: str) -> str:
        passer

    def parse_response (self, résultat: str) -> EnglishQuestion:
        passer


    Def Generate_With_Retties (self, catégorie: Str, Retries: int = 3) -> EnglishQuestion:
        passer

    Def Generate_questions (
        Self, catégories: liste [str], itérations: int
    ) -> Liste [EnglishQuestion]:
        passer

    def Save_To_Json (Self, Question: EnglishQuestion):
        passer

    def load_existing_data (self) -> list [dict]:
        passer

étape par étape implémente les méthodes clés

Initialisation

Initialisez la classe avec un modèle de langue, un modèle d'invite et un fichier de sortie. Avec cela, nous créerons une instance d'OllaMallm avec Model_name et configurerons un instomplate pour générer un QA dans un format JSON strict.

Implémentation du code:

 DEF __INIT __ (Self, Model_name: Str, Output_file: Path):
        self.llm = ollaMallm (modèle = modèle_name)
        self.prompt_template = promptTEmplate (
            input_variables = ["catégorie"],
            template = "" "
            Générez une question de langue anglaise qui teste la compréhension et l'utilisation.
            Focus sur {catégorie}. écrivez la sortie dans ce format JSON strict:

            {{
                "Question": "<votre question sp>",
                "Réponse": "<la bonne r>",
                "Thought_process": "<expliquez le raisonnement pour arriver la r>"
            }}

            N'incluez aucun texte en dehors de l'objet JSON.
            "" ",
        )
        self.output_file = output_file
        self.output_file.touch (exist_ok = true)</expliquez></la></votre>

Nettoyage JSON

Les réponses que nous obtiendrons du LLM pendant le processus de génération auront de nombreux caractères supplémentaires inutiles qui peuvent équilibrer les données générées, vous devez donc transmettre ces données par un processus de nettoyage.

Ici, nous allons résoudre le problème de formatage commun dans les touches / valeurs JSON à l'aide de Regex, en remplacement des caractères problématiques tels que Newline et des caractères spéciaux.

Implémentation du code:

 def Clean_json_string (self, texte: str) -> str:
        "" "Version améliorée pour gérer JSON malformé ou incomplet." ""
        start = text.find ("{")
        end = text.rfind ("}")

        Si start == -1 ou end == -1:
            augmenter ValueError (f "Aucun objet JSON trouvé. La réponse était: {text}")

        JSON_STR = Text [Début: fin 1]

        # Supprimer tous les caractères spéciaux qui pourraient casser l'analyse JSON
        json_str = json_str.replace ("\ n", "") .replace ("\ r", "")
        json_str = re.sub (r "[^ \ x20- \ x7e]", "", json_str)

        # Résoudre les problèmes de formatage JSON communs
        json_str = re.sub (
            r '(? <h3> Analyse de réponse</h3><p> La méthode d'analyse utilisera le processus de nettoyage ci-dessus pour nettoyer les réponses du LLM, validera la réponse pour la cohérence, convertir le JSON nettoyé en dictionnaire Python et cartographier le dictionnaire en un objet d'anglais.</p><p> <strong>Implémentation du code:</strong></p><pre class="brush:php;toolbar:false"> def parse_response (self, résultat: str) -> EnglishQuestion:
        "" "Analyser la réponse LLM et la valider contre le schéma." ""
        nettoyée_json = self.clean_json_string (résultat)
        parsed_result = json.loads (nettoyée_json)
        Retour anglais

Persévérance des données

Pour, génération de données persistantes, bien que nous puissions utiliser certaines bases de données NoSQL (MongoDB, etc.) pour cela, nous utilisons ici un fichier JSON simple pour stocker les données générées.

Implémentation du code:

 def load_existing_data (self) -> list [dict]:
        "" "Chargez les questions existantes du fichier JSON." ""
        essayer:
            avec ouvert (self.output_file, "r") comme f:
                return json.load (f)
        sauf (filenotfounderror, json.jSondeCodeError):
            retour []

Génération robuste

Dans cette phase de génération de données, nous avons deux méthodes les plus importantes:

• Générer avec le mécanisme de réessayer
• Méthode de génération de questions

Le but du mécanisme de réessayer est de forcer l'automatisation à générer une réponse en cas de défaillance. Il essaie de générer une question plusieurs fois (la valeur par défaut est trois fois) et enregistrera les erreurs et ajoutera un retard entre les tentatives. Il augmentera également une exception si toutes les tentatives échouent.

Implémentation du code:

 Def Generate_With_Retties (self, catégorie: Str, Retries: int = 3) -> EnglishQuestion:
        pour la tentative de portée (RETRES):
            essayer:
                result = self.prompt_template | self.llm
                réponse = result.invoke (input = {"catégorie": catégorie})
                return self.parse_response (réponse)
            sauf exception comme e:
                imprimer(
                    f "Tentative {tentative 1} / {Retries} a échoué pour la catégorie '{catégorie}': {e}"
                )
                sommeil (2) # petit retard avant de réessayer
        augmenter ValueError (
            f "échec de la catégorie de la catégorie '{catégorie}' After {Retries} tentatives."
        )

La méthode de génération de questions générera plusieurs questions pour une liste de catégories et les enregistrera dans le stockage (ici le fichier JSON). Il iratera sur les catégories et appellera la méthode génération_with_retrries pour chaque catégorie. Et dans le dernier, il sauvera chaque question générée avec succès à l'aide de la méthode SAVE_TO_JSON.

 Def Generate_questions (
        Self, catégories: liste [str], itérations: int
    ) -> Liste [EnglishQuestion]:
        "" "Générez plusieurs questions pour une liste de catégories." ""
        all_questions = []
        pour _ dans la gamme (itérations):
            pour la catégorie dans les catégories:
                essayer:
                    Question = self.generate_with_retries (catégorie)
                    self.save_to_json (question)
                    all_questions.append (question)
                    Imprimer (F "Question générée avec succès pour la catégorie: {catégorie}")
                Sauf (validationError, ValueError) comme e:
                    print (f "Catégorie de traitement d'erreur '{catégorie}': {e}")
        retourner toutes les questions

Affichage des résultats sur le terminal

Pour avoir une idée de quelles sont les réponses qui produisent à partir de LLM, voici une simple fonction d'impression.

 Def Display_questions (Questions: List [EnglishQuestion]):
    Imprimer ("\ ngenerated English Questions:")
    pour la question dans les questions:
        print ("\ n ---")
        print (f "id: {question.id}")
        Imprimer (f "Question: {question.quoistion}")
        print (f "Réponse: {question.answer}")
        imprimer (F "Processus de réflexion: {question.thought_process}")

Tester l'automatisation

Avant d'exécuter votre projet, créez un fichier anglais_qa_new.json sur la racine du projet.

 Si __name__ == "__main__":
    Output_file = path ("anglais_qa_new.json")
    Generator = QuesterGenerator (Model_Name = "LLAMA3.2", output_file = output_file)

    catégories = [
        "Utilisation des mots",
        "Phrasal ver",
        "vocabulaire",
        "idiomes",
    ]]
    itérations = 2

    généré_questions = générateur.
    Display_questions (généré_questions)

Maintenant, allez au terminal et type:

 python main.py

Sortir:

Ces questions seront enregistrées dans la racine de votre projet. La question enregistrée ressemble à:

Tout le code utilisé dans ce projet est ici.

Conclusion

La génération de données synthétiques est devenue une solution puissante pour répondre à la demande croissante de jeux de données de formation de haute qualité à l'ère des progrès rapides dans l'IA et les LLM. En tirant parti d'outils comme Llama 3.2 et Olllama, ainsi que des cadres robustes comme Pyndantic, nous pouvons créer des ensembles de données structurés, évolutifs et sans biais adaptés à des besoins spécifiques. Cette approche réduit non seulement la dépendance à l'égard de la collecte de données réelles co?teuse et chronophage, mais assure également la confidentialité et la conformité éthique. Alors que nous affinons ces méthodologies, les données synthétiques continueront de jouer un r?le central dans la conduite de l'innovation, l'amélioration des performances du modèle et le déverrouillage de nouvelles possibilités dans divers domaines.

Principaux à retenir

• La génération de données synthétiques locales permet la création de divers ensembles de données qui peuvent améliorer la précision du modèle sans compromettre la confidentialité.
• La mise en ?uvre de la génération locale de données synthétiques peut améliorer considérablement la sécurité des données en minimisant la dépendance à l'égard des données sensibles du monde réel.
• Les données synthétiques garantissent la confidentialité, réduisent les biais et diminuent les co?ts de collecte des données.
• Les ensembles de données sur mesure améliorent l'adaptabilité entre diverses applications AI et LLM.
• Les données synthétiques ouvrent la voie au développement d'IA éthique, efficace et innovant.

Questions fréquemment posées

A. Olllama offre des capacités de déploiement locales, réduisant les co?ts et la latence tout en offrant plus de contr?le sur le processus de génération.

A. Pour maintenir la qualité, la mise en ?uvre utilise la validation pydatique, les mécanismes de réessayer et le nettoyage JSON. Des mesures supplémentaires et la validation de maintien peuvent être implémentées.

A. Les LLM locaux peuvent avoir une production de qualité inférieure par rapport aux modèles plus importants, et la vitesse de génération peut être limitée par les ressources informatiques locales.

A. Oui, les données synthétiques garantissent la confidentialité en supprimant les informations identifiables et favorisent le développement d'IA éthique en abordant les biais de données et en réduisant la dépendance sur les données sensibles du monde réel.

A. Les défis incluent la garantie du réalisme des données, le maintien de la pertinence du domaine et l'alignement des caractéristiques des données synthétiques avec des cas d'utilisation du monde réel pour une formation de modèle efficace.

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!