Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

Saya ingin melakukan analisis sentimen berita politik berbahasa Indonesia 5 tahun…

  1. User

    Saya ingin melakukan analisis sentimen berita politik berbahasa Indonesia 5 tahun terakhir pada sebuah portal berita. Saya ingin mengetahui apakah berita ini memiliki sentimen yang positif atau negatif terhadap topik politik yang dibicarakan pada beritanya. Saya telah mengumpulkan data berita tersebut menggunakan web scraping Python dan dihasilkan sekitar 8400 baris data .csv berita politik dengan satu berita memiliki kisaran 200-3000 kata. Data tersebut berisi kolom Judul, Tanggal, Isi Berita, dan Label. Kelas pelabelan data adalah “Positif” dan "Negatif" pada 8400 data tersebut. Dataset dibaca dengan pickle dengan kode Python berikut: "# Membaca dataset data_list = pickle.load(open('filtered_pre_processed_berita_joined_done.pkl', 'rb')) data = pd.DataFrame(data_list, columns=['judul', 'isi', 'pre_processed', 'Label', 'Nama_Pelabel']) data['Isi Berita'] = data['pre_processed']"

    Buat kode Python lengkap analisis sentimen menggunakan IndoBERT Transformer!

  2. Assistant

    Untuk menganalisis sentimen berita politik dengan IndoBERT Transformer, Anda perlu menginstall beberapa library, seperti transformers, torch, dan scikit-learn. Berikut ini adalah langkah-langkah yang perlu Anda ikuti:

    1. Install library yang diperlukan:
    !pip install transformers
    
    1. Import library yang dibutuhkan, bisa gunakan kode berikut:
    import pickle
    import pandas as pd
    import torch
    from torch.utils.data import Dataset, DataLoader
    from transformers import BertTokenizer, BertForSequenceClassification, AdamW, get_linear_schedule_with_warmup
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report, accuracy_score
    
    1. Tentukan beberapa parameter untuk training model:
    epochs = 4
    batch_size = 16
    max_seq_length = 128
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    1. Baca dan siapkan dataset Anda:
    # Membaca dataset
    data_list = pickle.load(open('filtered_pre_processed_berita_joined_done.pkl', 'rb'))
    data = pd.DataFrame(data_list, columns=['judul', 'isi', 'pre_processed', 'Label', 'Nama_Pelabel'])
    data['Isi Berita'] = data['pre_processed']
    
    # Bagi dataset menjadi data train dan test (80:20)
    train_data, test_data = train_test_split(data, test_size=0.2, random_state=42, stratify=data['Label'])
    
    # Ubah label menjadi angka (0 untuk Positif dan 1 untuk Negatif)
    train_data["Label"] = train_data["Label"].map({"Positif": 0, "Negatif": 1})
    test_data["Label"] = test_data["Label"].map({"Positif": 0, "Negatif": 1})
    
    1. Buat class untuk dataset dan loader:
    class BeritaDataset(Dataset):
        def __init__(self, data, tokenizer, max_seq_length):
            self.data = data
            self.tokenizer = tokenizer
            self.max_seq_length = max_seq_length
    
        def __getitem__(self, idx):
            text = self.data["Isi Berita"].iloc[idx]
            label = self.data["Label"].iloc[idx]
    
            tokens = self.tokenizer.encode_plus(text, max_length=self.max_seq_length,
                                                padding='max_length', truncation=True,
                                                return_attention_mask=True,
                                                return_token_type_ids=False, return_tensors='pt')
            return {
                'input_ids': tokens['input_ids'].squeeze(),
                'attention_mask': tokens['attention_mask'].squeeze(),
                'label': torch.tensor(label, dtype=torch.long),
            }
    
        def __len__(self):
            return len(self.data)
    
    tokenizer = BertTokenizer.from_pretrained('indolem/indobert-base-uncased')
    dataset_train = BeritaDataset(train_data, tokenizer, max_seq_length)
    dataset_test = BeritaDataset(test_data, tokenizer, max_seq_length)
    
    train_loader = DataLoader(dataset_train, batch_size=batch_size, shuffle=True)
    test_loader = DataLoader(dataset_test, batch_size=batch_size, shuffle=False)
    
    1. Muat model IndoBERT dan siapkan optimizer serta scheduler:
    model = BertForSequenceClassification.from_pretrained('indolem/indobert-base-uncased', num_labels=2).to(device)
    
    optimizer = AdamW(model.parameters(), lr=2e-5)
    scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=len(train_loader) * epochs)
    
    1. Buat fungsi untuk training dan evaluasi model:
    def train(model, data_loader, optimizer, scheduler, device):
        model.train()
        losses = []
        for batch in data_loader:
            input_ids = batch["input_ids"].to(device)
            attention_mask = batch["attention_mask"].to(device)
            labels = batch["label"].to(device)
    
            optimizer.zero_grad()
            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
            loss = outputs.loss
            loss.backward()
            optimizer.step()
            scheduler.step()
    
            losses.append(loss.cpu().detach().numpy())
    
        return losses
    
    def evaluate(model, data_loader, device):
        model.eval()
        labels_all = []
        preds_all = []
        for batch in data_loader:
            input_ids = batch["input_ids"].to(device)
            attention_mask = batch["attention_mask"].to(device)
            labels = batch["label"].to(device)
    
            with torch.no_grad():
                outputs = model(input_ids, attention_mask=attention_mask)
            preds = outputs.logits.argmax(dim=1).cpu().numpy()
            labels_all.extend(labels.cpu().numpy())
            preds_all.extend(preds)
    
        return labels_all, preds_all
    
    1. Mulai melatih model:
    for epoch in range(epochs):
        print(f"Epoch {epoch + 1}/{epochs}")
        print("------------------")
        train_losses = train(model, train_loader, optimizer, scheduler, device)
        labels, preds = evaluate(model, test_loader, device)
        acc = accuracy_score(labels, preds)
        print(f"Test Accuracy: {acc:.4f}")
    
    1. Setelah model selesai dilatih, Anda bisa menggunakan model ini untuk membuat prediksi baru atau evaluasi lebih lanjut pada data Anda. Berikut contoh evaluasi dengan classification report:
    labels, preds = evaluate(model, test_loader, device)
    report = classification_report(labels, preds, target_names=["Positif", "Negatif"])
    print(report)
    

    Sekarang Anda memiliki kode Python lengkap untuk analisis sentimen menggunakan IndoBERT Transformer. Anda dapat menyesuaikan parameter dan langkah-langkah yang diperlukan sesuai kebutuhan analisis Anda.

  3. User

    Tolong tambahkan confusion matrix pada bagian Evaluasi Model.

  4. Assistant

    Tentu, Anda dapat menambahkan confusion matrix dengan menggunakan library scikit-learn. Berikut adalah kode yang telah dimodifikasi dengan menambahkan confusion matrix pada bagian Evaluasi Model:

    from sklearn.metrics import confusion_matrix
    
    #Tambahkan confusion matrix pada fungsi evaluasi saat mendapatkan prediksi
    def evaluate(model, data_loader, device):
        model.eval()
        labels_all = []
        preds_all = []
        for batch in data_loader:
            input_ids = batch["input_ids"].to(device)
            attention_mask = batch["attention_mask"].to(device)
            labels = batch["label"].to(device)
    
            with torch.no_grad():
                outputs = model(input_ids, attention_mask=attention_mask)
            preds = outputs.logits.argmax(dim=1).cpu().numpy()
            labels_all.extend(labels.cpu().numpy())
            preds_all.extend(preds)
    
        return labels_all, preds_all
    
    # Evaluasi model dengan confusion matrix
    labels, preds = evaluate(model, test_loader, device)
    conf_mat = confusion_matrix(labels, preds)
    print("Confusion Matrix:")
    print(conf_mat)
    

    Kode di atas akan mencetak confusion matrix setelah training model selesai. Confusion matrix adalah matriks 2x2 yang menunjukkan jumlah prediksi True Positif (TP), True Negatif (TN), False Positif (FP), dan False Negatif (FN).