Sie haben das berühmte Zitat „Daten ist das neue Öl“ des britischen Mathematikers Clive Humby gehört. Es ist das einflussreichste Zitat, das die Bedeutung von Daten im 21. Jahrhundert beschreibt, aber nach der explosiven Entwicklung des großen Sprachmodells und dessen Schulung sind die Daten nicht richtig. Weil die Entwicklungsgeschwindigkeit und die Trainingsgeschwindigkeit des LLM -Modells die Datenerzeugungsgeschwindigkeit des Menschen nahezu übertreffen. Die Lösung macht die Daten raffinierter und spezifischer für die Aufgabe oder die synthetische Datenerzeugung. Ersteres ist der mehr Domain -Experten, aber letztere ist für den riesigen Hunger der heutigen Probleme deutlicher.
Die hochwertigen Trainingsdaten bleiben ein kritischer Engpass. In diesem Blog -Beitrag wird ein praktischer Ansatz zur Generierung von synthetischen Daten mit Lama 3.2 und Ollama untersucht. Es wird zeigen, wie wir strukturierte Bildungsinhalte programmatisch erstellen können.
Synthetische Daten beziehen sich auf künstlich generierte Informationen, die die Eigenschaften realer Daten nachahmen und gleichzeitig wesentliche Muster und statistische Eigenschaften bewahren. Es wird unter Verwendung von Algorithmen, Simulationen oder KI -Modellen erstellt, um Datenschutzbedenken zu beheben, begrenzte Daten oder Testsysteme in kontrollierten Szenarien zu erweitern. Im Gegensatz zu realen Daten können synthetische Daten auf spezifische Anforderungen zugeschnitten werden und die Vielfalt, das Gleichgewicht und die Skalierbarkeit sicherstellen. Es wird häufig in Bereichen wie maschinellem Lernen, Gesundheitswesen, Finanzen und autonomen Systemen verwendet, um Modelle zu trainieren, Algorithmen zu validieren oder Umgebungen zu simulieren. Synthetische Daten überbrücken die Lücke zwischen Datenknappheit und realen Anwendungen und reduzieren gleichzeitig ethische und Compliance-Risiken.
Die Nachfrage nach synthetischen Daten hat aufgrund mehrerer Faktoren exponentiell gewachsen
Synthetische Daten haben vielversprechende Ergebnisse zur Verbesserung der großen und kleinen Sprachmodelle gezeigt
Im folgenden Abschnitt werden wir das Projektlayout aufschlüsseln und Sie durch die Konfiguration der erforderlichen Umgebung führen.
Projekt/ ├── main.py ├── Anforderungen.txt ├── Readme.md └── English_Qa_New.json
Jetzt werden wir unsere Projektumgebung mit Conda einrichten. Folgen Sie den folgenden Schritten
$ conda erstellen -n -synthetische Daten Python = 3.11 # Aktivieren Sie die neu erstellte Env $ conda aktivieren synthetische Daten
PIP Installieren Sie pydantische Langchain Langchain-Gemeinschaft PIP Installieren Sie Langchain-Olmama
Jetzt sind wir alle eingerichtet, um die Code -Implementierung zu starten
In diesem Abschnitt werden wir uns mit der praktischen Implementierung des Projekts befassen und jeden Schritt im Detail abdecken.
Vor dem Starten des Projekts erstellen wir einen Dateinamen main.py im Projektroot und importieren alle Bibliotheken in dieser Datei:
aus pydantischem Import -Basemodel, Feld, ValidationError von Langchain.prompts importieren Sie promptemplate von Langchain_ollama import ollamallm Aus dem Einteichen der Einfuhrliste JSON importieren uUid importieren Import Re vom Pathlib -Importpfad Zum Zeitpunkt des Imports
Jetzt ist es an der Zeit, den Code -Implementierungsteil in der Main.py -Datei fortzusetzen
Zunächst beginnen wir mit der Implementierung des Datenschemas.
Das englische Datenschema ist ein pydantisches Modell, das sicherstellt, dass unsere generierten Daten einer konsistenten Struktur mit den erforderlichen Feldern und der automatischen ID -Erzeugung folgen.
Klasse englischQuestion (Basemodel):
ID: STR = Feld (
default_factory = lambda: str (uUid.uuid4 ()),
Beschreibung = "Eindeutige Kennung für die Frage",
)
Kategorie: Str = Feld (..., Beschreibung = "Fragetyp")
Frage: Str = Feld (..., Beschreibung = "Die englischsprachige Frage")
Antwort: Str = Feld (..., Beschreibung = "Die richtige Antwort auf die Frage")
thoughd_process: str = field (
..., Beschreibung = "Erläuterung des Argumentationsprozesses, um zur Antwort zu gelangen."
)Jetzt, da wir die englischquestionsdatenklasse erstellt haben.
Zweitens werden wir mit der Implementierung der FragGenerator -Klasse beginnen. Diese Klasse ist der Kern der Projektimplementierung.
Klassenfragelnerator:
def __init __ (self, model_name: str, output_file: Pfad):
passieren
Def Clean_json_string (Selbst, Text: str) -> str:
passieren
Def Parse_Response (Selbst, Ergebnis: STR) -> EnglishQuestion:
passieren
Def generate_with_retries (self, kategorie: str, retries: int = 3) -> englischQuestion:
passieren
Def generate_questions (
Selbst, Kategorien: Liste [STR], Iterationen: int
) -> LISTE [EnglishQuestion]:
passieren
Def Save_to_json (Selbst, Frage: englischQuestion):
passieren
Def load_existing_data (self) -> list [dict]:
passierenLassen Sie uns Schritt für Schritt die Schlüsselmethoden implementieren
Initialisieren Sie die Klasse mit einem Sprachmodell, einer Eingabeaufforderungsvorlage und einer Ausgabedatei. Damit werden wir eine Instanz von Ollamallm mit model_name erstellen und eine promptTemplate für die Generierung von QA in einem strengen JSON -Format einrichten.
Code -Implementierung:
def __init __ (self, model_name: str, output_file: Pfad):
self.llm = ollamallm (model = model_name)
self.prompt_template = fordertemplate (
input_variables = ["Kategorie"],
template = "" ""
Generieren Sie eine englischsprachige Frage, die Verständnis und Nutzung testet.
Konzentrieren Sie sich auf {Kategorie} .Question wird wie Füllen Sie die Leerzeichen, einen Liner und Mut nicht MCQ -Typ aus. Schreiben Sie die Ausgabe in diesem strengen JSON -Format:
{{{{
"Frage": "<ihre spezifische frage>",
"Antwort": "Die richtige Antwort>",
"Thought_process": "<erkl sie die argumentation antwort zu erreichen>"
}}
Fügen Sie keinen Text außerhalb des JSON -Objekts an.
"" ",
)
self.output_file = output_file
self.output_file.touch (exist_ok = true)</erkl></ihre>Antworten, die wir während des Erzeugungsprozesses von der LLM erhalten, haben viele unnötige zusätzliche Zeichen, die die generierten Daten ausweisen können, sodass Sie diese Daten durch einen Reinigungsprozess übergeben müssen.
Hier beheben wir das gemeinsame Formatierungsproblem in JSON -Tasten/Werten mit Regex, wodurch problematische Zeichen wie Newline und Sonderzeichen ersetzt werden.
Code -Implementierung:
Def Clean_json_string (Selbst, Text: str) -> str:
"" "Verbesserte Version, um missgebildete oder unvollständige JSON zu verarbeiten." "" "
start = text.find ("{")
end = text.rfind ("}")
wenn start == -1 oder end == -1:
ValueError erhöhen (f "Kein JSON -Objekt gefunden. Antwort war: {text}")
JSON_STR = Text [Start: Ende 1]
# Entfernen Sie alle Sonderzeichen, die JSON -Parsen brechen könnten
json_str = json_str.replace ("\ n", "") .replace ("\ r", "")
json_str = re.sub (r "[^\ x20- \ x7e]", "", json_str)
# Problemen mit gemeinsamen JSON -Formatierungsproblemen beheben
json_str = re.sub (
r '(? <h3> Antwort Parsen</h3><p> Die Parsing -Methode verwendet den obigen Reinigungsprozess, um die Antworten aus dem LLM zu reinigen, die Antwort auf Konsistenz zu validieren, den gereinigten JSON in ein Python -Wörterbuch umzuwandeln und das Wörterbuch einem englischQuellosenobjekt zuzuordnen.</p><p> <strong>Code -Implementierung:</strong></p><pre class="brush:php;toolbar:false"> Def Parse_Response (Selbst, Ergebnis: STR) -> EnglishQuestion:
"" Analysieren die LLM -Antwort und validieren Sie sie gegen das Schema. "" "
cleaned_json = self.clean_json_string (Ergebnis)
parsed_result = json.loads (cleaned_json)
Return EnglishQuestion (** Parsed_result)Für die persistente Datenerzeugung, obwohl wir einige NoSQL -Datenbanken (MongoDB usw.) verwenden können, verwenden wir hier eine einfache JSON -Datei, um die generierten Daten zu speichern.
Code -Implementierung:
Def load_existing_data (self) -> list [dict]:
"" Vorhandene Fragen aus der JSON -Datei laden "" ""
versuchen:
mit offen (self.output_file, "r") als f:
Return JSON.LOAD (f)
außer (FilenotFoundError, json.jSondeCodeError):
zurückkehren []In dieser Phase der Datenerzeugung haben wir zwei wichtigste Methoden:
Der Zweck des Wiederholungsmechanismus ist es, die Automatisierung zu erzwingen, um bei einem Fehler eine Antwort zu erzeugen. Es versucht mehrmals eine Frage zu generieren (die Standardeinstellung beträgt dreimal), und es werden Fehler protokolliert und eine Verzögerung zwischen den Wiederholungen hinzufügen. Es wird auch eine Ausnahme hervorrufen, wenn alle Versuche scheitern.
Code -Implementierung:
Def generate_with_retries (self, kategorie: str, retries: int = 3) -> englischQuestion:
Für den Versuch im Bereich (Wiederholungen):
versuchen:
result = self.prompt_template | self.llm
Antwort = result.invoke (input = {"Kategorie": Kategorie})
return self.parse_response (Antwort)
außer Ausnahme als E:
drucken(
f "Versuch {Versuch 1}/{Retries} fehlgeschlagen für die Kategorie '{Kategorie}': {e}"
)
Schlaf (2) # kleine Verzögerung vor dem Wiederieren
ValueError erhöhen (
f "konnte die Kategorie '{Kategorie}' nach {retries} Versuchen nicht verarbeiten."
)Die Fragengenerierungsmethode generiert mehrere Fragen für eine Liste von Kategorien und speichert sie im Speicher (hier JSON -Datei). Es wird die Kategorien über die Kategorien iteriert und für jede Kategorie generating_with_retries -Methoden aufrufen. Im letzten Fall speichert es jede erfolgreich generierte Frage mit Save_to_json -Methode.
Def generate_questions (
Selbst, Kategorien: Liste [STR], Iterationen: int
) -> LISTE [EnglishQuestion]:
"" "Generieren Sie mehrere Fragen für eine Liste von Kategorien." "" "
All_Questions = []
für _ im Bereich (Iterationen):
Für Kategorie in Kategorien:
versuchen:
Frage = self.generate_with_retries (Kategorie)
self.save_to_json (Frage)
All_questions.Append (Frage)
print (f "erfolgreich generierte Frage für Kategorie: {Kategorie}")
außer (validationError, valueError) als e:
print (f "Fehlerverarbeitungskategorie '{Kategorie}': {e}")
Rückgabe all_questionsEine einfache Druckfunktion zu erhalten, was die Antworten aus LLM aus LLM hervorrufen.
Def display_questions (Fragen: Liste [englischQuestion]):
print ("\ ngenerated englische Fragen:")
Für Fragen in Fragen:
print ("\ n ---")
print (f "id: {Frage.id}")
print (f "Frage: {Frage.Question}")
print (f "Antwort: {Frage.answer}")
print (f "Gedankenprozess: {Frage.Dhought_process}")Erstellen Sie vor dem Ausführen Ihres Projekts eine englisch_qa_new.json -Datei auf dem Projektroot.
Wenn __name__ == "__main__":
Output_file = path ("english_qa_new.json")
Generator = FragEGenerator (model_name = "lama3.2", output_file = output_file)
Kategorien = [
"Wortnutzung",
"Phrasal ver",
"Vokabular",
"Redewendungen",
]
Iterationen = 2
generated_questions = Generator.generate_Questions (Kategorien, Iterationen)
display_questions (generated_questions)
Gehen Sie nun zum Terminal und zum Typ:
Python main.py
Ausgabe:
Diese Fragen werden in Ihrer Projektwurzel gespeichert. Gespeicherte Frage sehen aus wie:
Der gesamte in diesem Projekt verwendete Code ist hier.
Die Erzeugung der synthetischen Daten hat sich als leistungsstarke Lösung entwickelt, um die wachsende Nachfrage nach hochwertigen Schulungsdatensätzen im Zeitalter schneller Fortschritte in AI und LLMs zu befriedigen. Durch die Nutzung von Tools wie LLAMA 3.2 und Ollama sowie robusten Frameworks wie Pydantic können wir strukturierte, skalierbare und verzerrungsfreie Datensätze erstellen, die auf bestimmte Anforderungen zugeschnitten sind. Dieser Ansatz verringert nicht nur die Abhängigkeit von der kostspieligen und zeitaufwändigen Datenerfassung in der realen Welt, sondern gewährleistet auch die Privatsphäre und die ethische Einhaltung. Während wir diese Methoden verfeinern, werden synthetische Daten weiterhin eine entscheidende Rolle bei der Steigerung der Innovation, der Verbesserung der Modellleistung und der Erschließung neuer Möglichkeiten in verschiedenen Bereichen spielen.
A. Ollama bietet lokale Bereitstellungsfunktionen und senkt die Kosten und die Latenz und bietet gleichzeitig mehr Kontrolle über den Erzeugungsprozess.
F 2. Wie können wir die Qualität der generierten Fragen sicherstellen?A. Um die Qualität aufrechtzuerhalten, verwendet die Implementierung die pydantische Validierung, die Wiederholungsmechanismen und die JSON -Reinigung. Zusätzliche Metriken und Aufrechterhaltung der Validierung können implementiert werden.
Q 3.. Was sind die Grenzen dieses Ansatzes?A. Lokale LLMs können im Vergleich zu größeren Modellen eine niedrigere Qualität aufweisen, und die Erzeugungsgeschwindigkeit kann durch lokale Rechenressourcen begrenzt werden.
Q4. Sind synthetische Daten sicher und ethisch zu verwenden?A. Ja, synthetische Daten sorgen für die Privatsphäre, indem identifizierbare Informationen beseitigt und die ethische KI-Entwicklung fördert, indem Datenverzerrungen behandelt und die Abhängigkeit von sensiblen Daten der realen Welt verringert werden.
Q5. Was sind die wichtigsten Herausforderungen bei der Verwendung von synthetischen Daten?A. Zu den Herausforderungen gehört die Gewährleistung des Datenrealismus, die Aufrechterhaltung der Domänenrelevanz und die Ausrichtung der synthetischen Dateneigenschaften mit realen Anwendungsfällen für ein effektives Modelltraining.
Das obige ist der detaillierte Inhalt vonLokale synthetische Datenerzeugung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Einführung in Screenshot-Tastenkombinationen in Win10
So verwenden Sie Shuffle
Linux View IP-Befehl
Empfohlene benutzerfreundliche und formelle Software-Apps für Währungsspekulationen im Jahr 2024
Aktuelles Ranking der digitalen Währungsbörsen
HTML zum Erstellen von Webseiten
Was soll ich tun, wenn mein Laufwerk C rot wird?
So stellen Sie gelöschte Dateien auf dem Computer wieder her
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
