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 tâche ou à la génération de données synthétiques. Le premier est les tâches 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.
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é.
La demande de données synthétiques s'est développée de façon exponentielle en raison de plusieurs facteurs
Les données synthétiques ont montré des résultats prometteurs dans l'amélioration des modèles de langage grand et petit
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
$ conda créer -N Python de données synthétiques = 3,11 # activer l'env nouvellement créé $ conda activer les données synthétiques
PIP installe Pydantic Langchain Langchain-Community pip install Langchain-eLlama
Maintenant, nous sommes tous configurés pour démarrer l'implémentation du code
Dans cette section, nous nous plongerons dans la mise en œuvre pratique du projet, couvrant chaque étape en détail.
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.
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.
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
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>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 anglaisPour, 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 []Dans cette phase de génération de données, nous avons deux méthodes les plus importantes:
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 questionsPour 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}")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.
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.
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.
Q 2. Comment pouvons-nous assurer la qualité des questions générées?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.
Q 3. Quelles sont les limites de cette approche?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.
Q4. Les données synthétiques sont-elles sécurisées et éthiques à utiliser?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.
Q5. Quels sont les principaux défis dans l'utilisation des données synthétiques?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!
La différence entre Win7 32 bits et 64 bits
Comment annuler le compte Douyin sur Douyin
utilisation du format_numéro
Méthodes de réparation des vulnérabilités du système informatique
Quelle est la différence entre USB-C et TYPE-C
Quels sont les langages de programmation ?
Site officiel d'Okex
Cache mybatis de premier niveau et cache de deuxième niveau
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
