Laporan summary Modul 5 kegiatan 2&3

Nama : DIMAS RIZAL SURYA S

NIM : 202010370311162
Kelas : ML- A
Tugas 2 – Klasifikasi Teks
Transfer learning juga dapat diterapkan pada tugas klasifikasi teks (text
classification). Dalam konteks ini, model pre-trained yang telah dilatih pada tugas
pemrosesan bahasa alami atau natural language processing (NLP) yang besar dapat
diadaptasi untuk tugas klasifikasi teks yang lebih spesifik.

Ada beberapa model pre-trained yang sering digunakan untuk transfer learning
dalam tugas klasifikasi teks. Berikut beberapa model yang populer:

1. BERT (Bidirectional Encoder Representation from Tranformers)

2. GPT (Generative Pre-trained Transformer)
3. XLNet
4. RoBERTa
5. Dan lainnya

Implementation

Pada implementasi ke klasifikasi teks kita akan menggunakan model BERT.

BERT adalah singkatan dari Bidirectional Encoder Representations from
Transformers, yang merupakan model pre-trained dalam bidang pemrosesan bahasa
alami (NLP). BERT dikembangkan oleh peneliti dari Google AI pada tahun 2018
dan telah menjadi terobosan penting dalam pengembangan model NLP.

Kelebihan utama BERT adalah kemampuannya dalam menghasilkan representasi

teks yang lebih kaya dan pemahaman yang lebih baik tentang makna kata dalam
konteks. Model BERT telah menjadi dasar bagi berbagai teknologi NLP dan telah
digunakan dalam berbagai tugas seperti klasifikasi teks, ekstraksi informasi,
penterjemahan, dan banyak lagi.
 • Import library yang diperlukan

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import
pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Conv1D, Dense,
MaxPooling1D, Flatten, LSTM,BatchNormalization
from keras.utils import to_categorical
from sklearn.metrics import classification_report,
confusion_matrix
from keras.callbacks import EarlyStopping
import re
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import PorterStemmer
import matplotlib.pyplot as plt
from imblearn.over_sampling import SMOTE
from keras.optimizers import Adam
• Load Dataset
# Load dataset
import io
datasetPath = io.BytesIO(uploaded['cleaned_reviews.csv'])
df = pd.read_csv(datasetPath)

• Dataset sample ( head or tail dataset)

• Melakukan Exploration Data Analyst

Lakukan Pre-processing dan Data Augmentation yang menurut kamu
memberikan dataset yang lebih efisien
• Preprocessing dan Data Augmentation
A. Menghapus missing value pada dataset
Pada dataset ditemukan missing value pada fitur ’cleaned_review’
dengan jumlah 17340. Kemudian missing value tersebut dihilangkan
agar data lebih bersih. Data yang bersih akan lebih mudah dianalisis
dan hasil lebih akurat.

B. Melakukan pengecekan duplikat dalam data

Pada dataset ini dilakukan pengecekan, tidak terdapat duplikat
dalam data .

df['cleaned_review'].fillna('0', inplace=True)

C. menghitung kemunculan setiap sentimen di set validasi

sentiment_counts = df['sentiments'].value_counts()

# Plot bar chart

plt.figure(figsize=(8, 6))
sentiment_counts.plot(kind='bar', color=['red',
'green', 'blue'])
plt.title('Sentiment Distribution')
plt.xlabel('Sentiment')
plt.ylabel('Count')
plt.xticks(rotation=0)
plt.show()
 Teknik Oversampling Minoritas Sintetis (SMOTE) adalah teknik
statistik untuk meningkatkan jumlah kasus dalam himpunan data Anda
dengan cara yang seimbang. Komponen bekerja dengan menghasilkan
instans baru dari kasus minoritas yang di berikan sebagai input.
Implementasi SMOTE ini tidak mengubah jumlah kasus mayoritas.

# Plot diagram batang untuk sampel ulang sentimen

plt.figure(figsize=(8, 6))

resampled_sentiment_counts.plot(kind='bar', color=['red',
'green', 'blue'])
plt.title('Resampled Sentiment Distribution after SMOTE')
plt.xlabel('Sentiment')
plt.ylabel('Count')
plt.xticks(rotation=0)
plt.show()
 #Mencetak setiap token dalam urutan dan kata yang sesuai

for token in padded_sequence:

if token != 0:
print(f"Token: {token}, Word:
{reverse_word_index[token]}")

• Implementasikan transfer learning dengan menggunakan model

**BERT** (Bidirectional Encoder Representations from Transformers)
atau lainnya
• Modelling
A. Melakukan splitting dataset
Dalam tahap ini dataset dibagi menjadi test size dan train set
dengan perbandingan 70:10, validation 20.
# Splitting (70% train, 20% validation, 10% test)
x_train, x_temp, y_train, y_temp =
train_test_split(x_resampled, label_encoded_categorical,
test_size=0.3, random_state=42)
x_val, x_test, y_val, y_test = train_test_split(x_temp,
y_temp, test_size=1/3, random_state=42)
Teknik Oversampling Minoritas Sintetis (SMOTE) adalah teknik
statistik untuk meningkatkan jumlah kasus dalam himpunan data Anda
dengan cara yang seimbang. Komponen bekerja dengan menghasilkan
instans baru dari kasus minoritas yang di berikan sebagai input.
Implementasi SMOTE ini tidak mengubah jumlah kasus mayoritas.

# Plot diagram batang untuk sampel ulang sentimen

plt.figure(figsize=(8, 6))

resampled_sentiment_counts.plot(kind='bar', color=['red',
'green', 'blue'])
plt.title('Resampled Sentiment Distribution after SMOTE')
plt.xlabel('Sentiment')
plt.ylabel('Count')
plt.xticks(rotation=0)
plt.show()
# Model dengan lapisan Penyematan menggunakan penyematan GloVe yang
telah di pre-trained sebelumnya
model = Sequential()
model.add(Embedding(input_dim=len(word_index) + 1,
output_dim=100, weights=[embedding_weights],
input_length=max_sequence_length, trainable=True))
model.add(LSTM(64, return_sequences=True, dropout=0.1))
model.add(BatchNormalization())
model.add(LSTM(32, return_sequences=False, dropout=0.1))
model.add(BatchNormalization())
model.add(Dense(3, activation='softmax'))
 B. Melakukan Label Encoder
Tahap ini penting dilaakukan untuk mengubah nilai-nilai kategori
menjadi angka atau labe. Terdapat 3 (tiga) fitur yang akan dirubah
yaitu fitur ’text’, fitur ’ actual label’, fitur ‘predicted label’.
# Create an empty list to store data

data = []

# Assuming you have 'x_val' as the list of text data,

'y_val_classes' as the true labels, and
'y_val_pred_class' as the predicted labels

# Convert class labels back to their original labels

actual_labels = le.inverse_transform(y_val_classes)
predicted_labels = le.inverse_transform(y_val_pred_class)

# Loop through the data and create rows

for text, actual, predicted in zip(y_val, actual_labels,
predicted_labels):
data.append([text, actual, predicted])

# Create a DataFrame from the list of data

results_df = pd.DataFrame(data, columns=['Text', 'Actual
Label', 'Predicted Label'])

# Display the DataFrame

print(results_df)

• Lakukan Fit Model dengan epoch yang anda tentukan

adam = Adam(learning_rate=0.001)
model.compile(loss='categorical_crossentropy', optimizer=adam, metrics=['accuracy'])
history = model.fit(x_train, y_train, validation_data=(x_val, y_val), batch_size=32,
epochs=10)
• Evaluate Model dengan menampilkan Plot, Loss, Accuracy serta
Classification Report
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']

loss = history.history['loss']
val_loss = history.history['val_loss']

# Assuming that your history object contains data for 10

epochs
epochs_range = range(10)

plt.figure(figsize=(14, 5))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, acc, label='Training Accuracy')
plt.plot(epochs_range, val_acc, label='Validation
Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss, label='Training Loss')
plt.plot(epochs_range, val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()
• Lakukan predict pada data test hasil splitting kemudian lakukan
perbandingan antara true label dan predict labelnya
# Get Predictions
y_train_pred = model.predict(x_train)
y_val_pred = model.predict(x_val)

# Convert probabilities to class labels

y_train_pred_class = np.argmax(y_train_pred, axis=1)
y_val_pred_class = np.argmax(y_val_pred, axis=1)

# Convert one-hot encoded targets bact to labels

y_train_classes = np.argmax(y_train, axis=1)
y_val_classes = np.argmax(y_val, axis=1)

# Compute and print classification report for training data

print("Training Data:")
print(classification_report(y_train_classes,
y_train_pred_class, target_names=le.classes_))

# Compute and print classification report for validation

data
print("Validation data:")
print(classification_report(y_val_classes, y_val_pred_class,
target_names=le.classes_))
# prediksi kelas di validasi data dan confusion matrix

import sklearn

import seaborn as sns

# Predict classes on validation data
y_val_pred = model.predict(x_val)
y_val_pred_class = np.argmax(y_val_pred, axis=1)

# Convert one-hot encoded targets back to labels

y_val_classes = np.argmax(y_val, axis=1)

# Compute confusion matrix

conf_matrix = confusion_matrix(y_val_classes,
y_val_pred_class)

# Plot confusion matrix as heatmap

plt.figure(figsize=(10,8))
sns.heatmap(conf_matrix, annot=True, fmt="d",
cmap="gist_stern", cbar=False, xticklabels=le.classes_,
yticklabels=le.classes_)
plt.title("Confusion Matrix")
plt.ylabel('Actual Class')
plt.xlabel("Predict Class")
plt.show()
# Predict classes on the test set

y_test_pred = model.predict(x_test)

# Convert probabilities to class labels

y_test_pred_class = np.argmax(y_test_pred, axis=1)

# Convert one-hot encoded targets back to labels

y_test_classes = np.argmax(y_test, axis=1)

# Compute and print classification report for test data

print("Test Data:")
print(classification_report(y_test_classes,
y_test_pred_class, target_names=le.classes_))
Tugas 3 – Klasifikasi Tabular
• Import library yang diperlukan

# Import library yang diperlukan

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report,
accuracy_score
from pytorch_tabnet.tab_model import TabNetClassifier
from sklearn.preprocessing import LabelEncoder
• Load Dataset
# 2. Load Dataset
datasetPath = r"/content/sample_data/income.csv"
df = pd.read_csv(datasetPath)
df.head()

• Dataset sample ( head or tail dataset)

• Melakukan Exploration Data Analyst

Lakukan Pre-processing dan Data Augmentation yang menurut kamu
memberikan dataset yang lebih efisien
• Preprocessing dan Data Augmentation
A. Menghapus missing value pada dataset
Pada dataset ditemukan missing value pada fitur ’cleaned_review’
dengan jumlah 17340. Kemudian missing value tersebut dihilangkan
agar data lebih bersih. Data yang bersih akan lebih mudah dianalisis
dan hasil lebih akurat.
df['workclass'].fillna('0', inplace=True)
df['occupation'].fillna('0', inplace=True)
df['native-country'].fillna('0', inplace=True)

B. Melakukan Label Encoder

Tahap ini penting dilaakukan untuk mengubah nilai-nilai kategori
menjadi angka atau labe. Terdapat 3 (tiga) fitur yang akan dirubah
yaitu fitur ’workclass’, fitur ’ education’, fitur ‘material-status’, fitur
‘occupation’, fitur ‘relationship’, fitur ‘race’, fitur ‘gender’, fitur
’native-country’.
# Encode fitur kategorikal menggunakan LabelEncoder
label_encoder = LabelEncoder()
categorical_columns = ['workclass', 'education', 'marital-
status', 'occupation', 'relationship', 'race', 'gender',
'native-country']
for column in categorical_columns:
df[column] = label_encoder.fit_transform(df[column])

# memisahkan fitur dan label

# Pisahkan fitur dan label
X = df.drop('income_>50K', axis=1)
y = df['income_>50K']

• Lakukan Fit Model dengan epoch yang anda tentukan

clf = TabNetClassifier()
clf.fit(
X_train=train_df.drop('income_>50K', axis=1).values,
y_train=train_df['income_>50K'].values,
eval_set=[(train_df.drop('income_>50K', axis=1).values,
train_df['income_>50K'].values),
(test_df.drop('income_>50K', axis=1).values,
test_df['income_>50K'].values)],
max_epochs=20
)
# Cetak atau gunakan metrik evaluasi sesuai kebutuhan
# Assuming clf is your TabNetClassifier instance
y_train_pred = clf.predict(train_df.drop('income_>50K',
axis=1).values)
y_test_pred = clf.predict(test_df.drop('income_>50K',
axis=1).values)

# Training set evaluation

train_accuracy =
accuracy_score(train_df['income_>50K'].values, y_train_pred)
train_classification_report =
classification_report(train_df['income_>50K'].values,
y_train_pred)

# Print or use the evaluation metrics as needed

print("Training Accuracy:", train_accuracy)
print("Training Classification Report:\n",
train_classification_report)
#Visualisasi confusion matrix
# Visualisasi Confusion Matrix
# Generate confusion matrix

y_true = [1, 0, 1, 2, 1, 0, 1, 2, 2, 0]
y_pred = [1, 0, 1, 2, 1, 0, 1, 1, 2, 0]

train_confusion_matrix = confusion_matrix(y_true, y_pred)

sns.heatmap(train_confusion_matrix, annot=True, fmt='d',

cmap='Blues', cbar=False)
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.title('Training Confusion Matrix')
plt.show()

# Test set evaluation

test_accuracy = accuracy_score(test_df['income_>50K'].values,
y_test_pred)
test_classification_report =
classification_report(test_df['income_>50K'].values,
y_test_pred)
print("\nTest Accuracy:", test_accuracy)
print("Test Classification Report:\n",
test_classification_report)

# Visualisasi Confusion Matrix Test

y_true = [1, 0, 1, 2, 1, 0, 1, 2, 2, 0]
y_pred = [1, 0, 1, 2, 1, 0, 1, 1, 2, 0]

test_confusion_matrix = confusion_matrix(y_true, y_pred)

sns.heatmap(test_confusion_matrix, annot=True, fmt='d',

cmap='Blues', cbar=False)
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.title('Test Confusion Matrix')
plt.show()
# Lakukan prediksi pada data test hasil splitting
y_test_pred = clf.predict(test_df.drop('income_>50K',
axis=1).values)

# Hitung confusion matriks untuk data test

test_confusion_matrix =
confusion_matrix(test_df['income_>50K'].values, y_test_pred)

# Print hasil matriks kebingungan

print("Test Confusion Matrix:\n", test_confusion_matrix)

# Visualisasi matriks kebingungan untuk data test

sns.heatmap(test_confusion_matrix, annot=True, fmt='d',
cmap='Blues', cbar=False)
plt.xlabel('Predicted Labels')
plt.ylabel('True Labels')
plt.title('Test Confusion Matrix')
plt.show()