Die Stimmungsanalyse in der Finanzierung ist ein leistungsstarkes Instrument zum Verständnis von Markttrends und des Investorenverhaltens. Allgemeine Stimmungsanalysemodelle bleiben jedoch aufgrund ihrer Komplexität und nuancierten Natur häufig zu kurz, wenn sie auf Finanztexte angewendet werden. In diesem Projekt wird eine Lösung vorgeschlagen, indem GPT-4O Mini, ein leichtes Sprachmodell, fein abgestimmt. Durch die Verwendung des TRC2-Datensatzes, einer Sammlung von Reuters Financial News-Artikeln mit Sentiment-Kursen des Expertenmodells Finber, möchten wir die Fähigkeit von GPT-4O Mini, Nuancen für finanzielle Stimmung zu erfassen, verbessern.
Dieses Projekt bietet einen effizienten und skalierbaren Ansatz für die Analyse der finanziellen Stimmung und öffnet die Tür für eine nuanciertere, stimmungsbasierte Analyse in der Finanzierung. Am Ende zeigen wir, dass GPT-4O Mini, wenn sie mit domänenspezifischen Daten fein abgestimmt, als praktikable Alternative zu komplexeren Modellen wie Finber in finanziellen Kontexten dienen kann.
Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.
Für dieses Projekt verwenden wir den Datensatz TRC2 (TREC Reuters Corpus, Band 2), eine Sammlung von Finanznachrichtenartikeln, die von Reuters kuratiert und über das National Institute of Standards and Technology (NIST) zur Verfügung gestellt und zur Verfügung gestellt wurden. Der TRC2 -Datensatz enthält eine umfassende Auswahl von Reuters Financial News -Artikeln, die aufgrund seiner breiten Berichterstattung und Relevanz für finanzielle Ereignisse häufig in Finanzsprachenmodellen verwendet werden.
Um den TRC2 -Datensatz zu erhalten, müssen Forscher und Organisationen den Zugriff über NIST anfordern. Der Datensatz ist bei NIST TREC Reuters Corpus erhältlich, das Einzelheiten zu Lizenzierungs- und Nutzungsvereinbarungen enthält. Sie müssen:
Sobald Sie den Datensatz erhalten haben, werden Sie vorbereiten und in Sätze für die Stimmungsanalyse unterteilt, sodass Sie Finber anwenden können, um Expertenmarkierungsklassen zu generieren.
Die Methodik zur Feinabstimmung GPT-4O-Mini mit Stimmungsetiketten, die von Finbert abgeleitet sind, besteht aus den folgenden Hauptschritten:
Um den Feinabstimmungsdatensatz zu erstellen, nutzen wir Finber, ein auf dem Finanzbereich vorgebrachten Finanzsprachenmodell. Wir wenden Finbert auf jeden Satz im TRC2 -Datensatz an und generieren Experten -Stimmungsbezeichnungen in drei Klassen: positiv, negativ und neutral. Dieser Prozess erzeugt einen beschrifteten Datensatz, in dem jeder Satz von TRC2 mit einem Gefühl verbunden ist und somit eine Grundlage für die Schulung von GPT-4O-Mini mit zuverlässigen Beschriftungen bietet.
Die gekennzeichneten Daten werden dann vorverarbeitet und in eine JSONL-Struktur formatiert, die für die Feinabstimmung von Openai geeignet ist. Wir formatieren jeden Datenpunkt mit der folgenden Struktur:
Nach der Kennzeichnung führen wir zusätzliche Vorverarbeitungsschritte durch, z. B. die Konvertierung von Etiketten in Kleinbuchstaben für Konsistenz und die Schicht der Daten, um eine ausgewogene Beschriftungsdarstellung sicherzustellen. Wir teilen den Datensatz auch in Trainings- und Validierungssätze auf, wodurch 80% der Daten für das Training und 20% für die Validierung reserviert werden, wodurch die Verallgemeinerungsfähigkeit des Modells bewertet wird.
Mit OpenAIs Feinabstimmung-API stimmen wir GPT-4O-Mini mit dem vor markierten Datensatz fein. Feinabstimmungseinstellungen wie Lernrate, Chargengröße und Anzahl der Epochen werden optimiert, um ein Gleichgewicht zwischen Modellgenauigkeit und Generalisierbarkeit zu erreichen. Dieser Prozess ermöglicht es GPT-4O Mini, aus domänenspezifischen Daten zu lernen und seine Leistung bei Aufgaben zur Analyse der finanziellen Stimmung zu verbessern.
Nach dem Training wird die Leistung des Modells anhand häufiger Stimmungsanalysemetriken wie Genauigkeit und F1-Score bewertet, was einen direkten Vergleich mit der Leistung von Finber für dieselben Daten ermöglicht. Dieses Benchmarking zeigt, wie gut GPT-4O-Mini-Klassifizierungen im Finanzbereich verallgemeinert und bestätigt, ob es Finber in Genauigkeit konsequent übertreffen kann.
Bei der Bestätigung der überlegenen Leistung ist GPT-4O Mini bereit für die Bereitstellung in realen Finanzanträgen wie Marktanalysen, Anlageberatung und automatisierte Nachrichtenstimmung. Dieses fein abgestimmte Modell bietet eine effiziente Alternative zu komplexeren Finanzmodellen und bietet robuste, skalierbare Stimmungsanalysefunktionen, die für die Integration in Finanzsysteme geeignet sind.
Wenn Sie die Grundlagen der Stimmungsanalyse kennenlernen möchten, lesen Sie unseren Artikel über die Stimmungsanalyse mit Python!
Folgen Sie diesem strukturierten, Schritt-für-Schritt-Ansatz, um nahtlos durch jede Phase des Prozesses zu navigieren. Unabhängig davon, ob Sie ein Anfänger oder erfahren sind, sorgt dieser Leitfaden sicher, dass Klarheit und erfolgreiche Implementierung von Anfang bis Ende.
Laden Sie die erforderlichen Bibliotheken und konfigurieren Sie die Umgebung.
Von Transformatoren importieren Autotokenizer, AutomodelforsequencClassification
Taschenlampe importieren
Pandas als PD importieren
von TQDM import TQDM
tokenizer = autotokenizer.from_pretrated ("prosSusai/finbert")
model = automodelforsequenceClassification.from_Pretrained ("ProSSUSAI/Finbert")
Device = Torch.Device ('CUDA' if Torch.cuda.is_available () else 'cpu'))
Modell.TO (Gerät) Def get_sentiment (Text):
Inputs = Tokenizer (Text, return_tensors = "pt", truncation = true, max_length = 512) .to (Gerät)
mit fackel.no_grad ():
Ausgänge = Modell (** Eingänge)
logits = outs.logits
Sentiment = Torch.argmax (Logits, Dim = 1) .Item ()
Sentiment_label = ["positiv", "negativ", "neutral"] [Sentiment]
Return Sentiment_LabelSie müssen den TRC2-Datensatz sorgfältig vorbereiten, um nur relevante Sätze für die Feinabstimmung beizubehalten. In den folgenden Schritten wird die Daten aus dem TRC2 -Datensatz gelesen, reinigen, aufgeteilt und gefiltert.
Angesichts der Einschränkungen der Nichtoffenlegung bietet dieser Abschnitt einen Überblick über die Datenvorverarbeitung mit Pseudocode.
# Laden Sie den komprimierten Datensatz aus der Datei
Öffnen Sie die compressed_file als Datei:
# Lesen Sie den Inhalt der Datei in den Speicher
Data = Read_file (Datei)
# Relevante Abschnitte jedes Dokuments extrahieren
Für jedes Dokument in Daten:
extrahieren document_id
Datum extrahieren
extrahieren Sie main_text_content
# Definieren Sie eine Funktion zum Reinigen und Segment -Textinhalt
Funktion Clean_and_segment_text (Text):
# Entfernen Sie unerwünschte Zeichen und Whitespace
cleaned_text = remove_special_characters (Text)
Cleaned_text = Standardize_WhiteSpace (Cleaned_text)
# Teilen Sie den gereinigten Text in Sätze oder Textsegmente auf
sätze = split_into_sences (cleaned_text)
Sätze zurückgeben
# Wenden Sie die Reinigungs- und Segmentierungsfunktion auf den Inhalt jedes Dokuments an
Für jedes Dokument in Daten:
sätze = clean_and_segment_text (document ['main_text_content'])
Speichern Sie Sätze im strukturierten Format
# Erstellen Sie eine strukturierte Datenspeicherung für einzelne Sätze
Initialisieren Sie die leere Liste von structured_data
Für jeden Satz in Sätzen:
# Sätze an strukturierte Daten anhängen
structured_data.append (Satz)
# Definieren Sie eine Funktion, um unerwünschte Sätze basierend auf bestimmten Kriterien herauszufiltern
Funktion filter_sences (Satz):
Wenn der Satz zu kurz ist:
Return falsch
Wenn der Satz bestimmte Muster enthält (z. B. Daten oder übermäßige Symbole):
Return falsch
Wenn der Satz unerwünschte Formatierungseigenschaften entspricht:
Return falsch
RECHT WAHR
# Wenden Sie den Filter auf strukturierte Daten an
filtered_data = [Satz für den Satz in structured_data wenn filter_sences (Satz)]]
# Filtern Sie die Sätze weiter basierend auf der Mindestlänge oder anderen Kriterien
Final_data = [Satz für den Satz in filtered_data if meets_minimum_length (Satz)]]
# Speichern Sie die endgültige Datenstruktur für das Modelltraining
Speichern Sie Final_Data als structured_filedf_sampled = df.sample (n = 1000000, random_state = 42) .reset_index (Drop = true)
JSON importieren
JSONL_DATA = []
Für _, Zeile in tqdm (df_sampled.Iterrows (), Total = df_sampled.shape [0]):
content = row ['Satz']
Sentiment = get_sentiment (Inhalt)
JSONL_ENTRY = {
"Nachrichten": [
{"Rolle": "System", "Inhalt": "Der Assistent ist ein Finanzexperte."},
{"Rolle": "Benutzer", "Inhalt": Inhalt},
{"Rolle": "Assistant", "Inhalt": Sentiment}
]
}
jsonl_data.append (jsonl_entry)
mit Open ('fonetuning_data.jsonl', 'w') als jsonl_file:
Für den Eintrag in JSONL_DATA:
jsonl_file.write (json.dumps (Eintrag) '\ n')) mit open ('finetuning_data.jsonl', 'r') als jsonl_file:
Data = [json.loads (Zeile) für die Zeile in jsonl_file]
Für die Eingabe in Daten:
Eintrag ["Nachrichten"] [2] ["Inhalt"] = Eintrag ["Nachrichten"] [2] ["Inhalt"]. Lower ()
mit open ('finetuning_data_lowercase.jsonl', 'w') als new_jsonl_file:
Für die Eingabe in Daten:
new_jsonl_file.write (json.dumps (Eintrag) '\ n')) zufällig importieren
random.seed (42)
random.shuffle (Daten)
split_ratio = 0,8
split_index = int (len (data) * split_ratio)
Training_data = Daten [: split_index]
validation_data = data [split_index:]
mit Open ('Training_data.jsonl', 'W') als Train_file:
Für den Eintritt in Training_Data:
train_file.write (json.dumps (Eintrag) '\ n')
mit open ('validation_data.jsonl', 'w') als val_file:
Für den Eintrag in validation_data:
val_file.write (json.dumps (Eintrag) '\ n')
Aus sklearn.model_selection importieren train_test_split
data_df = pd.dataframe ({{{
'Inhalt': [Eintrag ["Nachrichten"] [1] ["Inhalt"] für die Eingabe in Daten],
'Label': [Eintrag ["Nachrichten"] [2] ["Inhalt"] für die Eingabe in Daten]
})
df_sampled, _ = train_test_split (data_df, Stratify = data_df ['label'], test_size = 0.9, random_state = 42)
train_df, val_df = train_test_split (df_sampled, stratify = df_sampled ['label'], test_size = 0.2, random_state = 42)
def df_to_jsonl (df, Dateiname):
JSONL_DATA = []
Für _, Zeile in df.Iterrows ():
JSONL_ENTRY = {
"Nachrichten": [
{"Rolle": "System", "Inhalt": "Der Assistent ist ein Finanzexperte."},
{"Rolle": "Benutzer", "Inhalt": row ['Inhalt']},
{"Rolle": "Assistant", "Inhalt": Row ['Label']}
]
}
jsonl_data.append (jsonl_entry)
mit Open (Dateiname, 'W') als jsonl_file:
Für den Eintrag in JSONL_DATA:
jsonl_file.write (json.dumps (Eintrag) '\ n'))
df_to_jsonl (train_df, 'record_training_data.jsonl')
df_to_jsonl (val_df, 'reced_validation_data.jsonl')
Um die Leistung des fein abgestimmten GPT-4O-Mini-Modells zu bewerten, haben wir es auf einem auf Kaggle verfügbaren Datensatz für finanzielle Stimmung getestet. Dieser Datensatz enthält 5.843 gekennzeichnete Sätze in finanziellen Kontexten, die einen aussagekräftigen Vergleich zwischen dem fein abgestimmten Modell und Finbers ermöglichen.
Finbert erzielte eine Genauigkeit von 75,81%, während das fein abgestimmte GPT-4O-Mini-Modell 76,46%erreichte, was eine leichte Verbesserung zeigte.
Hier ist der Code zum Testen:
Pandas als PD importieren
OS importieren
Openai importieren
aus dotenv import load_dotenv
# Die CSV -Datei laden
CSV_FILE_PATH = 'Data.csv' # durch Ihren tatsächlichen Dateipfad ersetzen
df = pd.read_csv (csv_file_path)
# Datenframe in Textformat konvertieren
mit open ('stsences.txt', 'w', coding = 'utf-8') als f:
Für Index, Zeile in df.Iterrows ():
Satz = row ['Satz']. Strip () # Sauberer Satz
Sentiment = row ['Sentiment']. Strip (). Lower () # Sicherstellen, dass die Stimmung in Kleinbuchstaben und sauber ist
F.Write (f "{Satz} @{Sentiment} \ n")
# Lastumgebungsvariablen
load_dotenv ()
# Setzen Sie Ihren OpenAI -API -Schlüssel
openai.api_key = os.getenv ("openai_api_key") # sicherstellen, dass openai_api_key in Ihren Umgebungsvariablen festgelegt ist
# Pfad zur Datensatztextdatei
Datei_path = 'sätze.txt' # Textdatei mit Sätzen und Beschriftungen enthält
# Sätze und wahre Etiketten aus dem Datensatz lesen
Sätze = []
true_labels = []
mit open (Datei_Path, 'R', coding = 'utf-8') als Datei:
line = file.readlines ()
# Sätze und Etiketten extrahieren
Für Zeilen in Linien:
line = line.strip ()
Wenn '@' in der Schlange:
Satz, label = line.rsplit ('@', 1)
sätze.Append (Satz.strip ())
true_labels.append (label.strip ())
# Funktion, um Vorhersagen aus dem Feinabstimmungsmodell zu erhalten
Def get_openai_Predictions (Satz, model = "your_finetuned_model_name"): # Ersetzen Sie durch Ihren Modellnamen
versuchen:
response = openai.chatCompletion.create (
Modell = Modell,
Nachrichten = [
{"Rolle": "System", "Inhalt": "Sie sind ein Experte für finanzielle Analyseanalyse."},
{"Rolle": "Benutzer", "Inhalt": Satz}
],
max_tokens = 50,,
Temperatur = 0,5
)
Antwort zurücksenden ['Choices'] [0] ['Nachricht'] ['Inhalt']. Strip ()
außer Ausnahme als E:
print (f "Fehlererzeugung Vorhersage für Satz: '{Satz}'. Fehler: {e}")
zurück "unbekannt"
# Generieren Sie Vorhersagen für den Datensatz
vorhergesagt_labels = []
Für Satz in Sätzen:
Vorhersage = get_openai_Predictions (Satz)
# Normalisieren Sie die Vorhersagen auf "positiv", "neutral", "negativ".
Wenn 'positiv' in Vorhersage.lower ():
vorhergesagt_labels.Append ('positiv')
elif 'neutral' in Vorhersage.lower ():
vorhergesagt_labels.Append ('neutral')
elif "negativ" in Vorhersage.lower ():
vorhergesagt_labels.Append ('negativ')
anders:
vorhergesagt_labels.Append ('unbekannt')
# Berechnen Sie die Genauigkeit des Modells
Correy_Count = sum ([pred == true für pred, true in ZIP (Predicted_labels, true_labels)]))
Accuracy = Correct_Count / Len (Sätze)
print (f'accuracy: {Genauigkeit: .4f} ') # erwartete Ausgabe: 0,7646Durch die Kombination des Fachwissens von Finbers Financial Domain-Etiketten mit der Flexibilität von GPT-4O Mini erreicht dieses Projekt ein hochleistungsfähiges finanzielles Stimmungsmodell, das Finber in Genauigkeit übertrifft. Dieser Leitfaden und diese Methodik ebnen den Weg für replizierbare, skalierbare und interpretierbare Stimmungsanalysen, die speziell auf die Finanzindustrie zugeschnitten sind.
A. GPT-4O Mini bietet eine leichte, flexible Alternative und kann Finber bei bestimmten Aufgaben mit Feinabstimmung übertreffen. Durch die Feinabstimmung mit domänenspezifischen Daten kann GPT-4O Mini nuancierte Stimmungsmuster in Finanztexten erfassen, gleichzeitig rechnerisch effizienter und einfacher bereitgestellt werden.
Q2. Wie fordere ich den Zugriff auf den TRC2 -Datensatz an?A. Um auf den TRC2 -Datensatz zuzugreifen, senden Sie eine Anfrage über das National Institute of Standards and Technology (NIST) unter diesem Link. Überprüfen Sie die Anweisungen der Website, um Lizenz- und Nutzungsvereinbarungen abzuschließen, die in der Regel sowohl für die Forschung als auch für die kommerzielle Nutzung erforderlich sind.
Q3. Kann ich einen anderen Datensatz für die Analyse der finanziellen Stimmung verwenden?A. Sie können auch andere Datensätze wie die Financial Phrasebank oder benutzerdefinierte Datensätze mit beschrifteten Finanztexten verwenden. Das TRC2 -Datensatz passt zu Schulungsgefühlenmodellen besonders gut, da es Inhalte von Finanznachrichten enthält und eine breite Palette von Finanzthemen abdeckt.
Q4. Wie generiert Finbert die Stimmungsetiketten?A. Finbert ist ein finanzielles domänenspezifisches Sprachmodell, das für Finanzdaten und Feinhöhe für die Stimmungsanalyse voreinstimmt. Bei der Anwendung auf die TRC2 -Sätze kategorisiert es jeden Satz in ein positives, negatives oder neutrales Gefühl, basierend auf dem Sprachkontext in Finanztexten.
Q5. Warum müssen wir die Etiketten in JSONL in Kleinbuchstaben konvertieren?A. Die Umwandlung von Etiketten in Kleinbuchstaben sorgt für die Konsistenz mit den Feinabstimmungsanforderungen von OpenAI, die häufig erwarten, dass Etiketten für Fallempfindungen sind. Es hilft auch dabei, Fehlanpassungen während der Bewertung zu verhindern und eine einheitliche Struktur im JSONL -Datensatz beizubehalten.
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 vonFeinabstimmung GPT-4O Mini für die finanzielle Stimmung Analyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Windows kann nicht auf den freigegebenen Computer zugreifen
n-tes Kind
So öffnen Sie die Hosts-Datei
Drei Methoden der GPU-Virtualisierung
Was sind die Lebenszyklen von vue3?
Tabellendurchschnitt
So konvertieren Sie NEF in das JPG-Format
Können BAGS-Münzen lange gehalten werden?
wenn was bedeutet es
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
