Pengarang: Muttineni Sai Rohith
Awalnya diterbitkan di Towards AI the World’s Leading AI and Technology News and Media Company. Jika Anda sedang membangun produk atau layanan terkait AI, kami mengundang Anda untuk mempertimbangkan untuk menjadi sponsor AI. Di Towards AI, kami membantu menskalakan AI dan startup teknologi. Biarkan kami membantu Anda melepaskan teknologi Anda kepada massa.
Pada artikel ini, kami akan mencoba membangun model Klasifikasi BERT untuk mendeteksi Berita Palsu menggunakan Python.
Munculnya media sosial memperkuat pengaruh Berita Palsu di masyarakat kita. Orang sering menganggap apa pun yang mereka baca/dengar sebagai Benar, dan itu mempengaruhi dunia dalam skala besar, baik secara politik maupun finansial. Jadi Hari Ini Kami akan mengembangkan aplikasi yang dapat Mendeteksi Berita Palsu secara otomatis menggunakan Model BERT dan Python.
Memuat Data
Data yang digunakan dalam artikel ini dapat ditemukan di sini. Salin data, unzip dan tempel ke folder Anda. Mari kita mulai kode kita dengan mengimpor perpustakaan —
impor panda sebagai pd
impor csv
Setelah Anda menyalin data —
df_fake = pd.read_csv(“Fake.csv”) df_true = pd.read_csv(“Benar.csv”)
Sumber: Keluaran
Kami telah mengimpor data dan membuat dua DataFrames. Sekarang mari kita lakukan pembersihan dan Analisis data —
kita akan memulainya dengan membuat sebuah dataframe dengan menggabungkan kedua DataFrames diatas.
df_fake[“Label”] = “Palsu”
df_true[“Label”] = “Benar”
Untuk membedakan Berita Palsu/Benar, kami menambahkan Kolom baru — Label.. Yang akan menjadi Kolom dependen kami.
df = pd.concat([df_fake,df_true]) df = df.sample(frac=1).reset_index(drop=True)
Di atas, kami menggabungkan DataFrames dan Mengacaknya.
Akhirnya, kami memiliki Data kami siap —
df.head(5)
Sumber: Keluaran
Mari kita periksa apakah ada nilai yang hilang —
df.isnull().sum()
Sumber: Keluaran
Analisis data
Jadi Sekarang mari kita coba dan analisis beberapa kolom dalam data kita — Seperti yang kita ketahui, judul dan teks diperlukan, karena kita harus memprediksi label tergantung pada mereka; Dan jelas bahwa tanggal tidak memainkan peran besar dalam memprediksi apakah berita itu Palsu atau Benar. Mari Memvisualisasikan kolom subjek menggunakan perpustakaan Seaborn —
impor matplotlib.pyplot sebagai plt
impor seaborn sebagai sns #Membuat Gambar
fig, axes = plt.subplots(1,2, figsize = (15,6)) #Menambahkan histogram1 – Berita Palsu
sns.histplot(df_fake.subject, palette = ‘Set1’, alpha = 0.5, ax = axes[0])
kapak[0].tick_params(sumbu = ‘x’, rotasi = 90)
kapak[0].set_title(‘Subjek Berita Palsu’) #Menambahkan histogram2 – Berita Asli
sns.histplot(df_true.subject, palette = ‘Set1’, alpha = 0.5, ax = axes[1])
kapak[1].tick_params(sumbu = ‘x’, rotasi = 90)
kapak[1].set_title(‘True News Subject’) #Mencetak jumlah Subyek
print(“Subjek Berita Palsu : “,dict(df_fake.subject.value_counts()))
print(“Subjek Berita Sejati : “,dict(df_true.subject.value_counts()))
Sumber: Keluaran
Seperti yang bisa kita lihat, kolom subjek memiliki nilai yang berbeda di kedua DataFrames. Jadi Kami tidak dapat memasukkan kolom itu lebih jauh.
Mari kita lihat apakah datanya seimbang atau tidak.
sns.histplot(df.Label, palette = ‘Set1’, alpha = 0.5) plt.tick_params(axis = ‘x’, rotation = 90) plt.title(‘True VS Fake News’) df.Label.value_counts()
Sumber: Keluaran df[“text”] = df[“title”]+df[“text”] #mempertimbangkan teks dan judul sebagai X
Seperti yang kita lihat, kolom Label dalam format Object, mari kita Encode ke format Numerik.
df[‘Label’] = df[‘Label’].map({‘Benar’:1, ‘Palsu’:0})
Di sini karena kita hanya perlu Encode dua nilai, saya telah menggunakan metode map() dari DataFrame Python. Namun untuk penjelasan rinci tentang metode Python Encoding, lihat artikel saya di bawah ini:
Metode Pengkodean untuk menyandikan data Kategoris dalam Pembelajaran Mesin
Jadi data kami sudah siap. Mari kita lakukan train-test-split Data —
dari sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, stratify = y, test_size = 0.2, random_state = 10)
Kami memiliki data pelatihan dan pengujian kami, Jadi mari Pelajari tentang Model BERT Sekarang.
MODEL BERT
BERT Singkatan dari Bi-Directional Encoder Representations dari Transformers. Ini terdiri dari beberapa Encoder Transformer yang ditumpuk bersama. Ini menggunakan Transformers untuk memahami hubungan kontekstual antara kata-kata dalam kalimat/teks. Transformer BERT umumnya memiliki dua mekanisme: Encoder yang membaca input teks dan decoder yang memprediksi tugas yang diberikan.
Salah satu alasan utama kinerja BERT yang baik pada tugas NLP yang berbeda adalah penggunaan Semi-Supervised Learning. Ini berarti model dilatih untuk tugas tertentu yang memungkinkannya memahami pola bahasa. Setelah pelatihan, model (BERT) memiliki kemampuan pemrosesan bahasa yang dapat digunakan untuk memberdayakan model lain yang kami bangun dan latih menggunakan pembelajaran terawasi.
Awalnya, BERT dirilis dalam dua Ukuran — model Dasar dan Besar. BERT(BASE) memiliki 12 lapisan dalam tumpukan Encoder, sedangkan BERT(LARGE) memiliki 24 lapisan dalam tumpukan Encoder.
Model BERT mengambil klasifikasi token (CLS) sebagai input terlebih dahulu, diikuti dengan urutan kata. Kemudian melewati input ke lapisan di atas. Setiap lapisan menerapkan self-attention dan meneruskan hasilnya melalui jaringan feedforward setelah itu, diteruskan ke encoder berikutnya. Model mengeluarkan vektor ukuran sesuai dengan ukuran BERT. Jika kita ingin mengeluarkan classifier dari model ini, kita dapat mengambil output yang sesuai dengan token CLS.
Vektor terlatih ini dapat digunakan untuk melakukan sejumlah tugas seperti klasifikasi, terjemahan, dll.,
Deteksi Berita Palsu
Jadi Mari kita berkonsentrasi pada tugas kita dan memulai klasifikasi — Seperti yang dikatakan, kita perlu meneruskan Nilai tokenized sebagai Input ke Model BERT. Jadi mari kita gunakan tokenizer dari perpustakaan transformer.
Tokenisasi
Mari kita mulai dengan memasang trafo yang menyediakan Model BERT.
!pip menginstal transformer
Mari kita mulai tokenisasi —
Dalam metode ini, kita akan menggunakan AutoTokenizer dari Model BERT (basis) —
Mirip dengan semua jaringan saraf, transformer tidak dapat memproses teks input mentah secara langsung, Jadi kita perlu tokenize input dan mengubahnya menjadi angka. Tokenisasi melakukan fungsi berikut — Ini membagi teks input menjadi token (kata, huruf, dll.), Memetakan setiap token dengan bilangan bulat unik dan mengaturnya sesuai dengan model.
Karena kami menggunakan Model BERT BASE untuk aplikasi kami, kami juga menggunakan AutoTokenizer yang sesuai untuk tokenisasi.
dari transformer impor AutoTokenizer def tokenize(X): X = tokenizer(
teks = daftar(X),
add_special_tokens = Benar,
panjang_maks = 100,
pemotongan = Benar,
bantalan = ‘max_length’,
return_tensors = ‘tf’,
return_token_type_ids = Salah,
return_attention_mask = Benar,
verbose = benar
) kembalikan X tokenizer = AutoTokenizer.from_pretrained(‘bert-base-uncased’)
Mari kita tokenize nilai-nilainya —
X_train_token = tokenize(X_train)
X_test_token = tokenize(X_test)
Merancang Model
Mengimpor Perpustakaan yang Diperlukan —
impor tensorflow sebagai tf
dari keras.models import Model, Sequential
dari keras.layers import Input, Dense, Dropout, Embedding
dari tensorflow.keras.optimizers impor Adam
dari transformer impor TFBertModel
Merancang Fungsi BERT —
Panjang = 100 def get_model(): dropout_rate = 0.2 input_ids = Input(bentuk = (Panjang,), dtype = tf.int32, name = ‘input_ids’)
input_mask = Input(bentuk = (Panjang,), dtype = tf.int32, nama = ‘input_mask’) embeddings = bert([input_ids, input_mask])[1] #keluaran pooler
cetak (penyematan)
out = Dropout(0.2)(embeddings) #64 unit lapisan padat keluar = Padat(64,aktivasi = ‘relu’)(keluar)
keluar = Putus sekolah(0.2)(keluar) y = Padat(1,aktivasi = ‘sigmoid’)(keluar) model = Model(masukan=[input_ids, input_mask]keluaran=y)
model.layers[2].trainable = True #define optimizer
pengoptimal = Adam(learning_rate=1e-05, epsilon=1e-08, decay=0.01,clipnorm=1.0) #kompilasi model
model.compile(optimizer = pengoptimal, loss = ‘binary_crossentropy’, metrics = ‘accuracy’) mengembalikan model
Memuat Model BERT —
bert = TFBertModel.from_pretrained(‘bert-base-uncased’)
Mari kita plot Model BERT Dibuat —
model = get_model()
tf.keras.utils.plot_model(model)
Sumber: Keluaran
Kami telah membuat Model sesuai dengan penjelasan di atas.
Melatih Model Kami
from keras.callbacks import EarlyStopping history = model.fit(x = {‘input_ids’:X_train_tokens[‘input_ids’],’input_mask’:X_train_tokens[‘attention_mask’]}, y = y_train, epochs=3, validasi_split = 0.2, batch_size = 64, callback=[EarlyStopping( monitor=’val_accuracy’ ,mode=’max’, patience=3,verbose=False,restore_best_weights=True)])
Sumber: Keluaran
Seperti yang bisa kita lihat, kita mendapatkan Akurasi Pelatihan 99,9%. Mari Mengevaluasi model kita —
yhat = np.where(model.predict({ ‘input_ids’ : X_test_seq[‘input_ids’] ‘input_mask’ : X_test_seq[‘attention_mask’]}) >=0.5,1,0) print(classification_report(y_test,yhat))
Sumber: Keluaran
Kami dapat melihat model kami berkinerja sangat baik bahkan pada data evaluasi.
Kita bisa menggunakan model ini, bahkan untuk mengevaluasi setiap berita harian yang kita lihat.
Itu saja, Teman-teman …… Untuk mengikuti konten saya dan tahu lebih banyak tentang saya, lihat artikel saya di bawah ini —
Program Mitra Menengah dan Perjalanan Saya Selanjutnya
Selamat Coding….
Deteksi Berita Palsu menggunakan BERT Model Python awalnya diterbitkan di Towards AI on Medium, di mana orang-orang melanjutkan percakapan dengan menyoroti dan menanggapi cerita ini.
Diterbitkan melalui Menuju AI
