Mini GPT-4O FINE untuk Analisis Sentimen Kewangan

Analisis sentimen dalam kewangan adalah alat yang berkuasa untuk memahami trend pasaran dan tingkah laku pelabur. Walau bagaimanapun, model analisis sentimen umum sering tidak berkesudahan apabila digunakan untuk teks kewangan kerana kerumitan dan sifatnya yang bernuansa. Projek ini mencadangkan penyelesaian dengan penalaan GPT-4O Mini, model bahasa ringan. Dengan menggunakan dataset TRC2, koleksi artikel berita kewangan Reuters yang dilabelkan dengan kelas sentimen oleh model pakar Finbert, kami berhasrat untuk meningkatkan keupayaan GPT-4O Mini untuk menangkap nuansa sentimen kewangan.

Projek ini memberikan pendekatan yang cekap dan berskala untuk analisis sentimen kewangan, membuka pintu untuk analisis berasaskan sentimen yang lebih baik dalam kewangan. Akhirnya, kami menunjukkan bahawa GPT-4O mini, apabila disesuaikan dengan data khusus domain, boleh berfungsi sebagai alternatif yang lebih baik untuk model yang lebih kompleks seperti Finbert dalam konteks kewangan.

Hasil pembelajaran

• Memahami proses penalaan GPT-4O mini untuk analisis sentimen kewangan menggunakan data khusus domain.
• Ketahui cara memproses dan memformat data teks kewangan untuk latihan model secara berstruktur dan berskala.
• Dapatkan pandangan mengenai penerapan analisis sentimen untuk teks kewangan dan kesannya terhadap trend pasaran.
• Ketahui cara memanfaatkan dataset yang berlabel pakar seperti Finbert untuk meningkatkan prestasi model dalam analisis sentimen kewangan.
• Terokai penggunaan praktikal model mini GPT-4O yang disesuaikan dengan aplikasi kewangan dunia sebenar seperti analisis pasaran dan pengesanan sentimen berita automatik.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Meneroka dataset: data penting untuk analisis sentimen
• Metodologi Penyelidikan: Langkah untuk Menganalisis Sentimen Kewangan
• Penalaan GPT-4O Mini untuk Analisis Sentimen Kewangan
• Kesimpulan
• Soalan yang sering ditanya

Meneroka dataset: data penting untuk analisis sentimen

Untuk projek ini, kami menggunakan dataset TRC2 (Trec Reuters Corpus, Volume 2), koleksi artikel berita kewangan yang dikendalikan oleh Reuters dan disediakan melalui Institut Piawaian dan Teknologi Kebangsaan (NIST). Dataset TRC2 termasuk pemilihan artikel berita kewangan Reuters yang komprehensif, yang sering digunakan dalam model bahasa kewangan kerana liputan dan kaitannya dengan peristiwa kewangan.

Mengakses dataset TRC2

Untuk mendapatkan dataset TRC2, penyelidik dan organisasi perlu meminta akses melalui NIST. Dataset ini boleh didapati di NIST TREC Reuters Corpus, yang memberikan butiran mengenai perjanjian pelesenan dan penggunaan. Anda perlu:

• Lawati Nisttrecreuterscorpus.
• Ikuti proses permintaan dataset yang dinyatakan di laman web.
• Memastikan pematuhan terhadap keperluan pelesenan untuk menggunakan dataset dalam projek penyelidikan atau komersial.

Sebaik sahaja anda memperoleh dataset, pra-proses dan segmennya ke dalam ayat untuk analisis sentimen, yang membolehkan anda memohon Finbert untuk menjana kelas sentimen yang berlabel pakar.

Metodologi Penyelidikan: Langkah untuk Menganalisis Sentimen Kewangan

Metodologi untuk penalaan GPT-4O mini dengan label sentimen yang diperoleh dari Finbert terdiri daripada langkah-langkah utama berikut:

Langkah1: Pelabelan Finbert

Untuk membuat dataset penalaan halus, kami memanfaatkan Finbert, model bahasa kewangan yang terlatih pada domain kewangan. Kami memohon Finbert untuk setiap ayat dalam dataset TRC2, menghasilkan label sentimen pakar di tiga kelas: positif, negatif, dan neutral. Proses ini menghasilkan dataset berlabel di mana setiap ayat dari TRC2 dikaitkan dengan sentimen, dengan itu menyediakan asas untuk latihan GPT-4O mini dengan label yang boleh dipercayai.

Langkah 2: Pemprosesan Data Preprocessing dan JSONL

Data berlabel kemudian diproses dan diformatkan ke dalam struktur JSONL yang sesuai untuk API penalaan OpenAI. Kami memformat setiap titik data dengan struktur berikut:

• Mesej sistem yang menyatakan peranan pembantu sebagai pakar kewangan.
• Mesej pengguna yang mengandungi hukuman kewangan.
• Penolong tindak balas yang menyatakan label sentimen yang diramalkan dari Finbert.

Selepas pelabelan, kami melakukan langkah -langkah preprocessing tambahan, seperti menukar label untuk huruf kecil untuk konsistensi dan stratifikasi data untuk memastikan perwakilan label seimbang. Kami juga membahagikan dataset ke dalam latihan dan set pengesahan, menempah 80% data untuk latihan dan 20% untuk pengesahan, yang membantu menilai keupayaan generalisasi model.

Langkah3: Mini GPT-4O penalaan halus

Menggunakan API Penalaan Fine OpenAI, kami menyempurnakan Mini GPT-4O dengan dataset pra-berlabel. Tetapan penalaan halus, seperti kadar pembelajaran, saiz batch, dan bilangan zaman, dioptimumkan untuk mencapai keseimbangan antara ketepatan model dan kebolehpercayaan. Proses ini membolehkan GPT-4O MINI belajar dari data khusus domain dan meningkatkan prestasinya terhadap tugas analisis sentimen kewangan.

Langkah4: Penilaian dan Penandaarasan

Selepas latihan, prestasi model dinilai menggunakan metrik analisis sentimen umum seperti ketepatan dan skor F1, yang membolehkan perbandingan langsung dengan prestasi Finbert pada data yang sama. Penandaarasan ini menunjukkan betapa baiknya GPT-4O MINI menyebarkan klasifikasi sentimen dalam domain kewangan dan mengesahkan jika ia dapat secara konsisten mengatasi Finbert dalam ketepatan.

Langkah 5: aplikasi penempatan dan praktikal

Setelah mengesahkan prestasi unggul, GPT-4O MINI bersedia untuk digunakan dalam aplikasi kewangan dunia sebenar, seperti analisis pasaran, penasihat pelaburan, dan pengesanan sentimen berita automatik. Model yang disempurnakan ini memberikan alternatif yang cekap kepada model kewangan yang lebih kompleks, yang menawarkan keupayaan analisis sentimen yang kuat dan berskala sesuai untuk integrasi ke dalam sistem kewangan.

Sekiranya anda ingin mempelajari asas -asas analisis sentimen, periksa artikel kami mengenai analisis sentimen menggunakan Python!

Penalaan GPT-4O Mini untuk Analisis Sentimen Kewangan

Ikuti pendekatan berstruktur ini, langkah demi langkah untuk menavigasi dengan lancar melalui setiap peringkat proses. Sama ada anda seorang pemula atau berpengalaman, panduan ini memastikan kejelasan dan pelaksanaan yang berjaya dari awal hingga akhir.

Langkah1: Persediaan Awal

Beban yang diperlukan perpustakaan dan konfigurasikan persekitaran.

 Dari Transformers Import Autotokenizer, AutomodelforseQuCeclassification
obor import
Import Pandas sebagai PD
Dari TQDM Import TQDM

tokenizer = autotokenizer.from_pretrained ("Prosusai/FINBERT")
model = automodelforsequenceClassification.from_pretrained ("Prosusai/Finbert")

peranti = obor.device ('cuda' jika obor.cuda.is_available () lain 'cpu')
model.to (peranti)

Langkah 2: Tentukan fungsi untuk menghasilkan label sentimen dengan FINBERT

• Fungsi ini menerima input teks, memaksimumkannya, dan menggunakan Finbert untuk meramalkan label sentimen.
• Pemetaan label: Finbert mengeluarkan tiga kelas -positif, negatif, dan neutral.

 def get_sentiment (teks):
    input = tokenizer (teks, return_tensors = "pt", truncation = true, max_length = 512) .to (peranti)
    dengan obor.no_grad ():
        output = model (** input)
    logit = outputs.logits
    sentimen = obor.Argmax (logit, red = 1) .item ()
    sentiment_label = ["positif", "negatif", "neutral"] [sentimen]
    kembali sentimen_label

Langkah 3: Data preprocessing dan sampling dataset TRC2

Anda mesti berhati-hati memproses dataset TRC2 untuk mengekalkan hanya ayat yang relevan untuk penalaan halus. Langkah -langkah berikut menggariskan cara membaca, membersihkan, memecah, dan menapis data dari dataset TRC2.

Memandangkan kekangan tidak pendedahan, seksyen ini memberikan gambaran keseluruhan peringkat tinggi mengenai aliran kerja pra-proses pra-proses denganpseudocode.

• Beban dan ekstrak data: Dataset, yang disediakan dalam format termampat, dimuatkan dan diekstrak menggunakan kaedah pengendalian teks standard. Bahagian yang berkaitan setiap dokumen telah diasingkan untuk memberi tumpuan kepada kandungan teks utama.
• Pembersihan teks dan segmentasi ayat: Selepas mengasingkan bahagian kandungan, setiap dokumen dibersihkan untuk menghapuskan aksara luaran dan memastikan konsistensi dalam pemformatan. Ini menyediakan kandungan untuk membelah ke dalam ayat atau unit teks yang lebih kecil, yang meningkatkan prestasi model dengan menyediakan segmen yang boleh diurus untuk analisis sentimen.
• Penyimpanan data berstruktur: Untuk memudahkan pemprosesan yang diselaraskan, data telah dianjurkan ke dalam format berstruktur di mana setiap baris mewakili segmen ayat atau teks individu. Persediaan ini membolehkan pemprosesan, penapisan, dan pelabelan yang cekap, menjadikannya sesuai untuk model bahasa penalaan halus.
• Penapis dan skrin untuk segmen teks yang berkaitan: Untuk mengekalkan kualiti data yang tinggi, kami menggunakan pelbagai kriteria untuk menyaring segmen teks yang tidak relevan atau bising. Kriteria ini termasuk menghapuskan segmen yang terlalu pendek, mengeluarkan mereka yang mempunyai corak tertentu yang menunjukkan kandungan bukan senten, dan tidak termasuk segmen dengan aksara khas yang berlebihan atau ciri-ciri pemformatan tertentu.
• Pra -proses akhir: Hanya segmen yang memenuhi piawaian kualiti yang telah ditetapkan untuk latihan model. Data yang ditapis disimpan sebagai fail berstruktur untuk rujukan mudah dalam aliran kerja penalaan halus.

 # Muatkan dataset termampat dari fail
buka compressed_file sebagai fail:
    # Baca kandungan fail ke dalam memori
    data = read_file (fail)

# Ekstrak bahagian yang relevan dari setiap dokumen
Untuk setiap dokumen dalam data:
    ekstrak document_id
    Tarikh ekstrak
    Ekstrak main_text_content

# Tentukan fungsi untuk membersihkan dan segmen kandungan teks
Fungsi Clean_and_Segment_text (teks):
    # Keluarkan watak dan ruang putih yang tidak diingini
    dibersihkan_text = rove_special_characters (teks)
    dibersihkan_text = standard_whitespace (dibersihkan_text)
    
    # Pecahkan teks yang dibersihkan ke dalam ayat atau segmen teks
    Kalimat = split_into_sentences (Cleaned_text)
    
    Kembali ayat

# Sapukan fungsi pembersihan dan segmentasi ke kandungan setiap dokumen
Untuk setiap dokumen dalam data:
    Kalimat = Clean_and_segment_text (dokumen ['main_text_content'])
    Jimat ayat ke format berstruktur
    
# Buat storan data berstruktur untuk ayat individu
Mulakan Senarai Kosong Structured_data

untuk setiap ayat dalam ayat:
    # Tambah ayat ke data berstruktur
    structured_data.append (ayat)

# Tentukan fungsi untuk menyaring ayat yang tidak diingini berdasarkan kriteria tertentu
fungsi filter_sentences (ayat):
    Sekiranya ayat terlalu pendek:
        kembali palsu
    Jika ayat mengandungi corak tertentu (misalnya, tarikh atau simbol yang berlebihan):
        kembali palsu
    Jika ayat sepadan dengan ciri pemformatan yang tidak diingini:
        kembali palsu
    
    kembali benar

# Sapukan penapis ke data berstruktur
filtered_data = [kalimat untuk ayat dalam structured_data jika filter_sentences (ayat)]

# Selanjutnya penapis ayat berdasarkan panjang minimum atau kriteria lain
final_data = [ayat untuk ayat dalam ditapis_data jika meets_minimum_length (ayat)]

# Simpan struktur data akhir untuk latihan model
simpan final_data sebagai berstruktur_file

• Muatkan dataset dan sampel 1,000,000 ayat secara rawak untuk memastikan saiz dataset yang boleh diurus untuk penalaan halus.
• Simpan ayat -ayat sampel dalam data data untuk membolehkan pengendalian berstruktur dan pemprosesan mudah.

 df_sampled = df.sample (n = 1000000, random_state = 42) .reset_index (drop = true)

Langkah4: Menjana label dan sediakan data jsonl untuk penalaan halus

• Loop melalui ayat-ayat sampel, gunakan Finbert untuk melabelkan setiap ayat, dan formatnya sebagai JSONL untuk GPT-4O Mini Fine-penalaan.
• Struktur untuk JSONL: Setiap entri termasuk mesej sistem, kandungan pengguna, dan tindak balas sentimen pembantu.

 Import JSON

jsonl_data = []
untuk _, baris dalam tqdm (df_sampled.iterrows (), total = df_sampled.shape [0]):
    kandungan = baris ['ayat']
    Sentimen = get_sentiment (kandungan)
    
    jsonl_entry = {
        "Mesej": [
            {"peranan": "sistem", "kandungan": "Pembantu adalah pakar kewangan."},
            {"peranan": "pengguna", "kandungan": kandungan},
            {"peranan": "pembantu", "kandungan": sentimen}
        ]
    }
    jsonl_data.append (jsonl_entry)

dengan terbuka ('finetuning_data.jsonl', 'w') sebagai jsonl_file:
    untuk kemasukan di jsonl_data:
        jsonl_file.write (json.dumps (entry) '\ n')

Langkah5: Tukar label ke huruf kecil

• Pastikan konsistensi label dengan menukar label sentimen untuk huruf kecil, menjajarkan dengan pemformatan OpenAI untuk penalaan halus.

 dengan terbuka ('finetuning_data.jsonl', 'r') sebagai jsonl_file:
    data = [json.loads (baris) untuk baris dalam jsonl_file]

untuk kemasukan data:
    Entri ["Mesej"] [2] ["Kandungan"] = entri ["Mesej"] [2] ["Kandungan"]. Lower ()

dengan terbuka ('finetuning_data_lowercase.jsonl', 'w') sebagai new_jsonl_file:
    untuk kemasukan data:
        new_jsonl_file.write (json.dumps (entry) '\ n')

Langkah 6: Shuffle dan pecahkan dataset ke dalam latihan dan set pengesahan

• Shuffle Data: Rawak urutan penyertaan untuk menghapuskan bias pesanan.
• Berpecah menjadi latihan 80% dan set pengesahan 20%.

 Import secara rawak
rawak.seed (42)

random.shuffle (data)

split_ratio = 0.8
split_index = int (len (data) * split_ratio)

latihan_data = data [: split_index]
validation_data = data [split_index:]

dengan terbuka ('latihan_data.jsonl', 'w') sebagai train_file:
    untuk kemasukan dalam latihan_data:
        train_file.write (json.dumps (entry) '\ n')

dengan terbuka ('validation_data.jsonl', 'w') sebagai val_file:
    untuk kemasukan dalam pengesahan_data:
        val_file.write (json.dumps (entry) '\ n')

Langkah7: Lakukan pensampelan berstrata dan simpan dataset yang dikurangkan

• Untuk mengoptimumkan lagi, lakukan pensampelan berstrata untuk membuat dataset yang dikurangkan sambil mengekalkan perkadaran label.
• Gunakan pensampelan berstrata: Pastikan pengagihan label yang sama merentasi kedua-dua latihan dan set pengesahan untuk penalaan yang seimbang.

 dari sklearn.model_selection import train_test_split

data_df = pd.dataFrame ({
    'kandungan': [entri ["mesej"] [1] ["kandungan"] untuk kemasukan dalam data], 
    'label': [entri ["mesej"] [2] ["kandungan"] untuk kemasukan dalam data]
})

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, nama fail):
    jsonl_data = []
    untuk _, baris dalam df.iterrows ():
        jsonl_entry = {
            "Mesej": [
                {"peranan": "sistem", "kandungan": "Pembantu adalah pakar kewangan."},
                {"peranan": "pengguna", "kandungan": row ['content']},
                {"peranan": "pembantu", "kandungan": row ['label']}
            ]
        }
        jsonl_data.append (jsonl_entry)
    
    dengan terbuka (nama fail, 'w') sebagai jsonl_file:
        untuk kemasukan di jsonl_data:
            jsonl_file.write (json.dumps (entry) '\ n')

df_to_jsonl (train_df, 'reduced_training_data.jsonl')
df_to_jsonl (val_df, 'reduced_validation_data.jsonl')

Langkah8: Fine-Tune Gpt-4o Mini Menggunakan API Penalaan Terbuka Terbuka

• Dengan fail JSONL anda yang disediakan, ikuti dokumentasi OpenAI untuk menyempurnakan GPT-4O MINI pada dataset latihan dan pengesahan yang disediakan.
• Muat naik data dan mulakan penalaan halus: Muat naik fail JSONL ke platform OpenAI dan ikuti arahan API mereka untuk memulakan proses penalaan halus.

Langkah9: Ujian dan Penilaian Model

Untuk menilai prestasi model GPT-4O Mini yang disesuaikan dengan baik, kami mengujinya pada dataset sentimen kewangan berlabel yang terdapat di Kaggle. Dataset ini mengandungi 5,843 ayat berlabel dalam konteks kewangan, yang membolehkan perbandingan yang bermakna antara model halus dan Finbert.

Finbert menjaringkan ketepatan sebanyak 75.81%, manakala model Mini GPT-4O yang disempurnakan mencapai 76.46%, menunjukkan sedikit peningkatan.

Inilah kod yang digunakan untuk ujian:

 Import Pandas sebagai PD
Import OS
Import Openai
dari dotenv import load_dotenv

# Muatkan fail CSV
csv_file_path = 'data.csv' # ganti dengan laluan fail sebenar anda
df = pd.read_csv (csv_file_path)

# Tukar DataFrame ke Format Teks
dengan terbuka ('ayat.txt', 'w', encoding = 'utf-8') sebagai f:
    untuk indeks, baris dalam df.iterrows ():
        ayat = baris ['ayat']. Strip () # Kalimat Bersih
        sentimen = baris ['Sentimen']. Strip (). Lower () # Pastikan sentimen adalah huruf kecil dan bersih
        f.write (f "{senten} @{sentimen} \ n")             

# Memuatkan pembolehubah persekitaran
LOAD_DOTENV ()

# Tetapkan kunci API Openai anda
openai.api_key = os.getenv ("openai_api_key") # memastikan openai_api_key ditetapkan dalam pembolehubah persekitaran anda

# Jalan ke fail teks dataset
file_path = 'sentences.txt' # fail teks yang mengandungi ayat dan label

# Baca ayat dan label sebenar dari dataset
ayat = []
true_labels = []

dengan buka (file_path, 'r', encoding = 'utf-8') sebagai fail:
    garis = file.readlines ()

# Ekstrak ayat dan label
untuk baris dalam baris:
    garis = line.strip ()
    jika '@' dalam talian:
        ayat, label = line.rsplit ('@', 1)
        ayat.Append (senten.strip ())
        true_labels.append (label.strip ())

# Berfungsi untuk mendapatkan ramalan dari model yang disempurnakan
def get_openai_predictions (ayat, model = "your_finetuned_model_name"): # gantikan dengan nama model anda
    Cuba:
        respons = openai.chatcompletion.create (
            model = model,
            Mesej = [
                {"Peranan": "Sistem", "Kandungan": "Anda adalah pakar analisis sentimen kewangan."},
                {"peranan": "pengguna", "kandungan": ayat}
            ],
            max_tokens = 50,
            suhu = 0.5
        )
        Kembali Respons ['Pilihan'] [0] ['Mesej'] ['Kandungan']. Strip ()
    Kecuali pengecualian sebagai e:
        cetak (f "Ramalan Ralat Ramalan untuk Kalimat: '{Senten}'. Ralat: {E}")
        Kembali "Tidak Diketahui"

# Menjana ramalan untuk dataset
Ramalan_labels = []
untuk ayat dalam ayat:
    Ramalan = get_openai_predictions (ayat)
    
    # Menormalkan ramalan kepada 'positif', 'neutral', 'negatif'
    jika 'positif' dalam ramalan.lower ():
        Ramalan_labels.append ('positif')
    elif 'neutral' dalam ramalan.lower ():
        Ramalan_labels.append ('Neutral')
    elif 'negatif' dalam ramalan.lower ():
        Ramalan_labels.append ('negatif')
    lain:
        Ramalan_labels.append ('tidak diketahui')

# Kirakan ketepatan model
betul_count = jumlah ([pred == benar untuk pred, benar dalam zip (predicted_labels, true_labels)])
ketepatan = betul_count / len (ayat)

cetak (f'accuracy: {ketepatan: .4f} ') # output yang diharapkan: 0.7646

Kesimpulan

Dengan menggabungkan kepakaran label domain kewangan Finbert dengan fleksibiliti GPT-4O MINI, projek ini mencapai model sentimen kewangan berprestasi tinggi yang melampaui Finbert dalam ketepatan. Panduan dan metodologi ini membuka jalan bagi analisis sentimen yang boleh ditiru, berskala, dan boleh diterjemahkan, khususnya disesuaikan dengan industri kewangan.

Takeaways utama

• Fine-penalaan GPT-4O mini dengan data khusus domain meningkatkan keupayaannya untuk menangkap sentimen kewangan yang bernuansa, mengatasi model seperti Finbert dalam ketepatan.
• Dataset TRC2, yang dikendalikan oleh Reuters, menyediakan artikel berita kewangan berkualiti tinggi untuk latihan analisis sentimen yang berkesan.
• Preprocessing dan pelabelan dengan Finbert membolehkan GPT-4O Mini untuk menghasilkan ramalan sentimen yang lebih tepat untuk teks kewangan.
• Pendekatan ini menunjukkan skalabilitas GPT-4O mini untuk aplikasi kewangan dunia nyata, yang menawarkan alternatif ringan kepada model kompleks.
• Dengan memanfaatkan API penalaan OpenAI, kaedah ini mengoptimumkan MINI GPT-4O untuk analisis sentimen kewangan yang cekap dan berkesan.

Soalan yang sering ditanya

Q1. Mengapa menggunakan GPT-4O Mini dan bukannya Finbert untuk analisis sentimen kewangan?

A. GPT-4O Mini menyediakan alternatif yang ringan, fleksibel dan boleh mengatasi Finbert pada tugas-tugas tertentu dengan penalaan halus. Dengan penalaan dengan data khusus domain, GPT-4O mini dapat menangkap corak sentimen nuanced dalam teks kewangan sementara menjadi lebih efisien dan mudah digunakan.

S2. Bagaimana saya meminta akses ke dataset TRC2?

A. Untuk mengakses dataset TRC2, serahkan permintaan melalui Institut Piawaian dan Teknologi Kebangsaan (NIST) di pautan ini. Semak arahan laman web untuk menyelesaikan perjanjian pelesenan dan penggunaan, biasanya diperlukan untuk kedua -dua penyelidikan dan penggunaan komersial.

Q3. Bolehkah saya menggunakan dataset yang berbeza untuk analisis sentimen kewangan?

A. Anda juga boleh menggunakan dataset lain seperti frasa kewangan atau dataset adat yang mengandungi teks kewangan berlabel. Dataset TRC2 sesuai dengan model sentimen latihan terutamanya, kerana ia termasuk kandungan berita kewangan dan meliputi pelbagai topik kewangan.

Q4. Bagaimanakah FinBert menjana label sentimen?

A. Finbert adalah model bahasa khusus domain kewangan yang pra-latihan mengenai data kewangan dan kalangan halus untuk analisis sentimen. Apabila digunakan pada ayat TRC2, ia mengkategorikan setiap ayat ke dalam sentimen positif, negatif, atau neutral berdasarkan konteks bahasa dalam teks kewangan.

S5. Kenapa kita perlu menukar label ke huruf kecil di JSONL?

A. Menukar label ke huruf kecil memastikan konsistensi dengan keperluan penalaan yang baik, yang sering mengharapkan label menjadi sensitif kes. Ia juga membantu mencegah ketidakpadanan semasa penilaian dan mengekalkan struktur seragam dalam dataset JSONL.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.

Atas ialah kandungan terperinci Mini GPT-4O FINE untuk Analisis Sentimen Kewangan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!