Pendahuluan

Artikel ini merupakan refleksi pembelajaran kolektif dari kelompok kami tentang materi Natural Language Processing (NLP) yang dipelajari pada minggu ke-5 hingga minggu ke-7. Dalam periode ini, kami mempelajari berbagai aspek penting dalam pengembangan model NLP modern, dengan fokus utama pada arsitektur Transformer yang telah merevolusi bidang pemrosesan bahasa alami.

Berdasarkan modul pembelajaran yang disusun oleh Bapak Feliks VP Samosir, S.Pd., M.Kom., kami memperoleh pemahaman mendalam tentang dasar-dasar arsitektur Transformer, kerangka kerja encoder-decoder, mekanisme perhatian (attention mechanism), dan ekosistem Hugging Face

Transformer telah menjadi fondasi penting dalam kemajuan NLP beberapa tahun terakhir. Sejak diperkenalkan melalui paper “Attention is All You Need” oleh Vaswani et al. pada 2017, model ini telah mengatasi berbagai keterbatasan pendekatan sebelumnya dan menghasilkan peningkatan performa yang signifikan pada berbagai tugas NLP. Artikel ini akan membahas tiga topik utama yang kami pelajari: pengantar arsitektur Transformer, teknik klasifikasi teks, dan anatomi detail dari model Transformer.

Minggu 5: Memahami Model Transformer: Dari Struktur Fundamental hingga Aplikasi Praktis dengan Hugging Face (Pengantar Transformer) — Ilham Daulay — Rifai Martin

Minggu ke-5 diawali dengan pengenalan terhadap evolusi arsitektur Transformer sebagaimana dijelaskan dalam modul NLP_Mod5_Intro_to_Transformers. Kami mempelajari bagaimana Transformer, yang diperkenalkan dalam paper “Attention Is All You Need” (2017) oleh Google, telah merevolusi bidang NLP bersama dengan model-model seperti ULMFiT, GPT, dan BERT.

Pembahasan dimulai dari keterbatasan arsitektur rekuren (RNN dan LSTM) yang sebelumnya mendominasi bidang NLP. Meskipun efektif, RNN memiliki kelemahan fundamental: komputasinya bersifat berurutan(sequentil) dan tidak dapat diparalelkan.

Hal ini menyebabkan pemrosesan teks panjang menjadi tidak efisien, dengan informasi penting seringkali hilang saat jarak antar kata terlalu jauh.

Kami kemudian memahami kerangka kerja encoder-decoder yang menjadi dasar Transformer. Modul menjelaskan bagaimana encoder mengubah kalimat input (misalnya “Transformers are great!”) menjadi representasi numerik atau context vector, yang kemudian digunakan decoder untuk menghasilkan output (misalnya terjemahan “Transformer sind grossartig!”).

Namun, pendekatan ini masih memiliki masalah “information bottleneck” ketika mengompres seluruh input ke dalam satu vektor.

Inovasi kunci dari Transformer adalah mekanisme attention, yang memungkinkan decoder untuk mengakses seluruh hidden states dari encoder, bukan hanya state terakhir.

Lebih jauh lagi, Transformer memperkenalkan self-attention, dimana setiap kata dalam urutan dapat “memperhatikan” semua kata lainnya, memungkinkan pemahaman konteks yang lebih kaya dan pemrosesan paralel yang efisien.

Dalam self-attention, setiap kata diproyeksikan ke tiga vektor: Query (Q), Key (K), dan Value (V). Attention scores dihitung antara queries dan keys, lalu digunakan untuk menggabungkan values dengan bobot yang sesuai. Implementasi dasarnya dapat dirumuskan sebagai:

# Simplified implementation of multi-head attention
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.d_model = d_model
        self.num_heads = num_heads
        self.head_dim = d_model // num_heads
        
        self.q_linear = nn.Linear(d_model, d_model)
        self.k_linear = nn.Linear(d_model, d_model)
        self.v_linear = nn.Linear(d_model, d_model)
        self.out_linear = nn.Linear(d_model, d_model)
        
    def forward(self, q, k, v, mask=None):
        batch_size = q.size(0)
        
        # Linear projections and reshape
        q = self.q_linear(q).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        k = self.k_linear(k).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        v = self.v_linear(v).view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)
        
        # Scaled dot-product attention
        scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.head_dim)
        
        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)
            
        attention_weights = F.softmax(scores, dim=-1)
        output = torch.matmul(attention_weights, v)
        
        # Reshape and final linear projection
        output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
        
        return self.out_linear(output)

Pada bagian akhir modul, kami mempelajari konsep transfer learning dalam NLP dan bagaimana ekosistem Hugging Face telah menyederhanakan penggunaan model-model pretrained Transformer.

Perbandingan antara supervised learning (kiri) dan transfer learning (kanan). Supervised learning melatih dan mengevaluasi model pada domain/tugas yang sama, sementara transfer learning mengekstrak pengetahuan dari tugas sumber (Domain A) dan menerapkannya ke tugas target yang berbeda (Domain B) dengan mempertahankan Body A sebagai inisialisasi.

Hugging Face menyediakan akses ke ribuan model untuk berbagai tugas NLP, dengan antarmuka yang konsisten dan mudah digunakan.

Sebagai contoh, kami dapat menjalankan klasifikasi sentimen hanya dengan beberapa baris kode:

from transformers import pipeline

classifier = pipeline("text-classification")
result = classifier("Saya sangat menyukai kuliah NLP ini.")
print(result)  # Output: [{'label': 'POSITIVE', 'score': 0.9998}]

Melalui pembelajaran ini, kami memahami bahwa kombinasi arsitektur Transformer dengan transfer learning telah membuka era baru dalam NLP, memungkinkan pengembangan aplikasi bahasa yang lebih canggih dengan data terbatas dan komputasi yang lebih efisien.

Minggu 6: Teknik Klasifikasi Teks Menggunakan Transformer: Dari Tahap Pengolahan Data hingga Evaluasi Kinerja Model — Vaniasyifaa— Kartikasofia

Pada minggu ke-6, kami mempelajari teknik klasifikasi teks menggunakan model Transformer. Klasifikasi teks dalam NLP dapat digunakan untuk berbagai tugas, seperti memberi tag pada ulasan pelanggan, memisahkan email spam, dan melakukan analisis sentimen. Misalnya, mengidentifikasi emosi seperti “marah” atau “gembira” dalam tweet tentang suatu produk.

DistilBERT, versi ringan dari BERT, cocok untuk tugas ini karena tetap memiliki performa yang baik namun lebih kecil dan efisien, memungkinkan pelatihan cepat dalam beberapa menit.

Pembahasan dimulai dengan pengenalan library Hugging Face yang menyediakan tiga komponen utama — Datasets, Tokenizers, dan Transformers — untuk memudahkan proses dari teks mentah hingga model yang telah disesuaikan. Dengan library ini, model dapat langsung digunakan untuk menganalisis tweet baru secara efisien.

Kami menggunakan dataset dari artikel “CARER: Contextualized Affect Representations for Emotion Recognition (2018)” untuk menganalisis emosi dalam tweet berbahasa Inggris. Berbeda dari dataset analisis sentimen biasa yang hanya memiliki polaritas positif dan negatif, dataset ini mencakup enam emosi dasar: kemarahan, jijik, ketakutan, kegembiraan, kesedihan, dan kejutan.

Datasets menyediakan metode set_format() yang memungkinkan kita mengubah format keluaran dari Dataset, memudahkan konversi ke DataFrame untuk analisis lebih lanjut.

Kami kemudian menganalisis distribusi kelas untuk memahami keseimbangan dataset. Hal ini penting karena dataset dengan distribusi kelas yang tidak seimbang memerlukan penanganan khusus, baik dari segi training loss maupun metrik evaluasi.

Dari analisis tersebut, kami menemukan bahwa dataset sangat tidak seimbang. Kelas joy dan sadness muncul cukup sering, sedangkan kelas love dan surprise jauh lebih jarang — hanya 5–10 kali lebih sedikit. Untuk mengatasi ketidakseimbangan ini, beberapa strategi yang dapat diterapkan adalah:

• Melakukan oversampling secara acak pada kelas minoritas
• Melakukan undersampling secara acak pada kelas mayoritas
• Mengumpulkan lebih banyak data berlabel dari kelas yang kurang terwakili

Model berbasis Transformer memiliki batas maksimum panjang urutan masukan, yang disebut maximum context size. Untuk aplikasi yang menggunakan DistilBERT, batas maksimum ini adalah 512 token. Kami menganalisis panjang tweet dalam dataset dan menemukan bahwa mayoritas tweet memiliki panjang sekitar 15 kata, jauh di bawah batas maksimum.

Bagian penting lainnya yang kami pelajari adalah proses tokenisasi. Model seperti DistilBERT memerlukan teks yang sudah di-tokenisasi, yaitu diubah menjadi unit kecil dan vektor numerik. Metode tokenisasi bisa berbasis karakter (memecah per huruf) atau kata (memisahkan tiap kata).

Salah satu teknik tokenisasi kata yang sederhana adalah dengan menggunakan spasi (whitespace) untuk memecah teks. Beberapa tokenizer kata memiliki aturan tambahan untuk menangani tanda baca. Kita juga bisa menerapkan teknik stemming atau lemmatisasi, yang menormalkan kata-kata ke bentuk dasarnya.

Kami secara khusus mempelajari tokenisasi subkata (subword tokenization), yang menggabungkan kelebihan tokenisasi berbasis karakter dan kata.

Metode ini memecah kata langka menjadi unit-unit yang lebih kecil sambil mempertahankan kata umum sebagai satu kesatuan, meningkatkan efisiensi sekaligus memungkinkan model memahami kata kompleks atau kata yang salah eja.

Tokenisasi subkata dipelajari dari korpus pre-training menggunakan aturan statistik dan algoritma. Salah satu algoritma populer adalah WordPiece, yang digunakan dalam tokenizer untuk BERT dan DistilBERT. Prinsip kerja WordPiece adalah:

• Kata umum tetap sebagai satu token (misalnya: “hello” → [“hello”])
• Kata yang jarang dipecah menjadi beberapa sub-token (misalnya: “unfriendly” → [“un”, “##friendly”])
• Prefix “##” menandakan bahwa token tersebut merupakan bagian dari kata sebelumnya

Berikut adalah contoh implementasi tokenisasi menggunakan WordPiece:

from transformers import DistilBertTokenizer

# Load tokenizer DistilBERT
tokenizer = DistilBertTokenizer.from_pretrained("distilbert-base-uncased")

# Tokenisasi kata "unfriendly"
tokens = tokenizer.tokenize("The staff was unfriendly.")
ids = tokenizer.convert_tokens_to_ids(tokens)

# Cetak hasil tokenisasi
print("Tokens:", tokens)
print("Token IDs:", ids)

Output yang dihasilkan menunjukkan bagaimana kata “unfriendly” dipecah menjadi dua token:

Tokens: ['the', 'staff', 'was', 'un', '##friendly', '.']
Token IDs: [1996, 3096, 2001, 4895, 21337, 1012]

Langkah terakhir yang kami pelajari adalah penyiapan data input untuk model, termasuk padding dan truncation untuk memastikan semua input memiliki panjang yang sama:

from transformers import DistilBertTokenizer
# Load tokenizer DistilBERT
tokenizer = DistilBertTokenizer.from_pretrained("distilbert-base-uncased")
# Contoh teks dengan kata "unfriendly"
sentences = ["The staff was unfriendly.", "Her attitude was unfriendly and rude."]
# Tokenisasi dengan max_length 8 dan padding
tokens = tokenizer(sentences, padding="max_length", max_length=8, truncation=True, return_tensors="pt")
# Cetak hasil tokenisasi
print("Token IDs:\n", tokens["input_ids"])
print("Attention Mask:\n", tokens["attention_mask"])

Melalui pembelajaran ini, kami memahami bagaimana memproses dan mempersiapkan data teks untuk klasifikasi menggunakan model Transformer, mulai dari tokenisasi hingga penanganan masalah ketidakseimbangan kelas. Pengetahuan ini memberikan dasar yang kuat untuk mengimplementasikan model klasifikasi teks yang efektif untuk berbagai aplikasi NLP.

Minggu 7: Mengurai Struktur Transformer: Mekanisme Self-Attention, Ragam Arsitektur, dan Implementasi dalam Bidang NLP Christoffelhm — Rifai Martin

Pada minggu ke-7, kami mempelajari anatomi transformer secara mendalam. Fokus pembelajaran adalah menganalisis elemen utama model transformer, menjelaskan peran berbagai arsitektur transformer, dan menghubungkan komponen-komponen tersebut dengan aplikasinya dalam NLP.

Pembahasan dimulai dengan mendalami arsitektur Transformer, yang terdiri dari dua komponen utama:

1. Encoder: Bertugas mengonversi urutan token input menjadi rangkaian vektor embedding (hidden state/konteks). Proses ini mengandalkan positional embeddings untuk menangkap informasi urutan teks.
2. Decoder: Menggunakan hidden state dari encoder untuk secara bertahap menghasilkan urutan token output. Decoder menjaga hubungan sebab-akibat dengan hanya memperhatikan token-token yang telah dihasilkan sebelumnya.

Kami mempelajari bahwa terdapat tiga jenis utama model Transformer yang diterapkan untuk tugas-tugas NLP berbeda:

• Encoder-only: Digunakan untuk tugas-tugas seperti klasifikasi teks dan Named Entity Recognition (NER) dengan memanfaatkan attention secara bidirectional.
• Decoder-only: Cocok untuk melengkapi urutan teks dengan memprediksi kata berikutnya secara berulang, menggunakan mekanisme causal/autoregressive attention.
• Encoder-decoder: Ideal untuk pemetaan kompleks dari satu urutan teks ke urutan lain, seperti pada terjemahan mesin dan peringkasan teks.

Komponen kritis dari arsitektur Transformer adalah mekanisme self-attention. Kami mempelajari proses detail Scaled Dot-Product Attention yang melibatkan beberapa langkah penting:

1. Proyeksi Embedding: Setiap token embedding diproyeksikan menjadi tiga vektor terpisah: query (Q), key (K), dan value (V).
2. Perhitungan Skor Attention: Hubungan antara setiap vektor query dan key dihitung menggunakan operasi dot product, menghasilkan matriks berukuran n×n.
3. Normalisasi Skor: Skor dot product dikalikan dengan scaling factor dan diterapkan fungsi softmax untuk mendapatkan probabilitas.
4. Pembaruan Embedding: Matriks bobot attention yang telah dinormalisasi dikalikan dengan vektor value untuk masing-masing token, menghasilkan representasi kontekstual.Diskusi Kolektif

# Implementasi sederhana Scaled Dot-Product Attention
def scaled_dot_product_attention(query, key, value, mask=None):
    dim_k = query.size(-1)
    scores = torch.bmm(query, key.transpose(1, 2)) / sqrt(dim_k)
    
    if mask is not None:
        scores = scores.masked_fill(mask == 0, float("-inf"))
        
    weights = F.softmax(scores, dim=-1)
    return weights.bmm(value)

Mekanisme self-attention memungkinkan model memberikan “perhatian” yang berbeda untuk setiap token, sehingga menghasilkan Contextualized Embeddings. Misalnya dalam kalimat “time flies like an arrow”, kata “flies” dapat diinterpretasikan sebagai kata kerja karena konteks dari seluruh kalimat.

Selain self-attention, kami juga mempelajari Multi-Head Attention — pendekatan yang memungkinkan model menangkap berbagai jenis hubungan dalam teks secara simultan. Dengan membagi ruang embedding menjadi beberapa heads, setiap head dapat fokus pada aspek semantik yang berbeda, misalnya:

• Satu head mengamati interaksi antara subjek dan kata kerja
• Head lain dapat fokus pada atribut atau kata sifat di sekitar kata benda

class MultiHeadAttention(nn.Module):
    def __init__(self, config):
        super().__init__()
        embed_dim = config.hidden_size
        num_heads = config.num_attention_heads
        head_dim = embed_dim // num_heads
        self.heads = nn.ModuleList(
            [AttentionHead(embed_dim, head_dim) for _ in range(num_heads)]
        )
        self.output_linear = nn.Linear(embed_dim, embed_dim)

    def forward(self, hidden_state):
        # Menggabungkan output dari setiap attention head
        x = torch.cat([h(hidden_state) for h in self.heads], dim=-1)
        # Melalui lapisan linier untuk mendapatkan tensor berukuran [batch_size, seq_len, hidden_dim]
        x = self.output_linear(x)
        return x

Feed-Forward Layer adalah komponen penting lainnya dalam Transformer. Lapisan ini terdiri dari dua transformasi linear dengan aktivasi non-linear di antaranya, berfungsi memproses setiap posisi secara independen.

Feed-forward layer membantu Transformer memahami hubungan antar kata sehingga terjemahan yang dihasilkan lebih akurat dan alami.

Contoh Kode Implementasi Fee-Forward Layer

class FeedForward(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.linear_1 = nn.Linear(config.hidden_size, config.intermediate_size)
        self.linear_2 = nn.Linear(config.intermediate_size, config.hidden_size)
        self.gelu = nn.GELU()
        self.dropout = nn.Dropout(config.hidden_dropout_prob)

    def forward(self, x):
        x = self.linear_1(x)
        x = self.gelu(x)
        x = self.linear_2(x)
        x = self.dropout(x)
        return x

Contoh Konteks Penerjemahan :
Misalkan kita ingin menerjemahkan kalimat Saya suka makan nasi goreng ke bahasa Inggris:

1. Encoder: Mengubah kalimat bahasa Indonesia menjadi serangkaian vektor.
2. Feed-forward layer: Memproses vektor-vektor tersebut dan mempelajari hubungan antar kata.
3. Decoder: Menggunakan informasi yang telah diproses untuk menghasilkan kalimat bahasa Inggris, misalnya, I like to eat fried rice.

Komponen terakhir yang kami pelajari adalah Decoder Transformer, yang menggunakan tiga jenis lapisan utama:

1. Masked Multi-Head Self-Attention: Memastikan decoder hanya melihat token yang telah dihasilkan sebelumnya.
2. Encoder-Decoder Attention: Memungkinkan decoder “mengintip” informasi dari kalimat sumber (output encoder).
3. Feed-Forward Network: Memproses representasi untuk menghasilkan output akhir.

Melalui pembelajaran mendalam ini, kami memahami bagaimana berbagai komponen Transformer bekerja sama untuk menangani berbagai tugas NLP — dari klasifikasi dan pengenalan entitas hingga terjemahan dan peringkasan teks. Kami juga mempelajari bagaimana model-model seperti XLM-RoBERTa dapat digunakan untuk Named Entity Recognition lintas bahasa, menunjukkan kemampuan transfer zero-shot yang mengesankan dengan skor F1 hingga 86,8% pada data bahasa Jerman dan performa baik pada bahasa Prancis dan Italia meskipun tanpa fine-tuning khusus.

Kesimpulan

Pembelajaran tentang model Transformer selama tiga minggu ini telah memberikan pemahaman yang komprehensif tentang salah satu kemajuan paling signifikan dalam bidang NLP. Dari konsep dasar hingga implementasi praktis, kami telah mengeksplorasi berbagai aspek arsitektur ini dan aplikasinya dalam tugas-tugas seperti klasifikasi teks.

Beberapa poin penting yang kami peroleh:

1. Fleksibilitas Arsitektur: Transformer dapat diadaptasi untuk berbagai tugas NLP, dari pemahaman teks (BERT) hingga generasi teks (GPT), menunjukkan fleksibilitas yang luar biasa.
2. Transfer Learning: Pendekatan pre-training followed by fine-tuning telah merevolusi cara kita mengembangkan model NLP, memungkinkan hasil yang baik bahkan dengan data latih yang terbatas.
3. Ekosistem yang Matang: Tools seperti Hugging Face Transformers menyederhanakan proses implementasi dan eksperimen, memungkinkan fokus pada solusi masalah daripada detail implementasi.
4. Tantangan Komputasi: Meskipun powerful, model Transformer memerlukan resource komputasi yang signifikan, mendorong penelitian dalam efisiensi dan optimisasi.
5. Interpretabilitas: Memahami bagaimana model membuat keputusan tetap menjadi tantangan, membuka peluang untuk penelitian dalam interpretabilitas dan explainable AI.

Dalam konteks aplikasi nyata, pemahaman ini sangat relevan untuk pengembangan berbagai solusi NLP, seperti chatbot, sistem pencarian, analisis sentimen, dan banyak lagi. Melihat ke depan, kami berharap dapat menerapkan pengetahuan ini dalam proyek-proyek praktis dan terus mengikuti perkembangan terbaru dalam bidang yang dinamis ini.

The Power of Looking Before You Leap

Imagine building a house without first examining the foundation. That’s exactly what many data scientists do when they jump straight into model building without proper Exploratory Data Analysis (EDA). In this article, we’ll dive deep into how EDA can transform your machine learning projects, using the IMDB movie reviews dataset as our guide.

Prerequisites

Before we begin, make sure you have:

• Basic Python knowledge
• Familiarity with pandas and numpy
• Understanding of basic statistics
• Python environment with required libraries installed

# Required libraries
!pip install pandas numpy matplotlib seaborn wordcloud nltk

The Evolution of EDA: More Than Just Data Cleaning

When John Tukey introduced EDA in the 1970s, data science wasn’t even a term. Today, it’s become the cornerstone of successful machine learning projects. But why is it so crucial?

The Four Pillars of Modern EDA:

1. Data Understanding
2. Pattern Recognition
3. Hypothesis Generation
4. Anomaly Detection

Hands-on with IMDB Datase

1. Initial Data Exploration

Let’s start by loading our dataset and understanding its basic structure:

import pandas as pd
import numpy as np
from datasets import load_dataset

# Load dataset
dataset = load_dataset("imdb", split="train")
df = pd.DataFrame(dataset)

# Basic information
print("Dataset Dimensions:", df.shape)
print("\nDataset Information:")
df.info()

# Check missing values
print("\nMissing Values Check:")
print(df.isnull().sum())

Output:

Dataset Dimensions: (25000, 2)

Dataset Information:
RangeIndex: 25000 entries, 0 to 24999
Data columns (total 2 columns):
 #   Column  Non-Null Count  Dtype 
---  ------  --------------  ----- 
 0   text    25000 non-null  object
 1   label   25000 non-null  int64 
dtypes: int64(1), object(1)
memory usage: 390.8+ KB

Missing Values Check:
text     0
label    0
dtype: int64

💡 Key Insight: Our dataset is perfectly balanced with no missing values — a rare luxury in real-world data science!

2. Deep Dive into Text Analysis

Now, let’s examine the characteristics of our reviews:

# Import required libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datasets import load_dataset

# Set style for better visualization
plt.style.use('seaborn')

# Load dataset and create DataFrame
dataset = load_dataset("imdb", split="train")
df = pd.DataFrame(dataset)

# Calculate basic text metrics
df['text_length'] = df['text'].apply(len)  # Character length
df['word_count'] = df['text'].apply(lambda x: len(x.split()))  # Word count

# Statistical analysis
print("\nText Length Statistics (characters):")
print(df['text_length'].describe())

print("\nWord Count Statistics:")
print(df['word_count'].describe())

# Create visualization
plt.figure(figsize=(15, 5))

# 1. Word Count Distribution
plt.subplot(1, 2, 1)
sns.histplot(data=df, x='word_count', bins=50)
plt.title('Distribution of Review Lengths')
plt.xlabel('Word Count')
plt.ylabel('Frequency')

# 2. Box Plot for Word Count
plt.subplot(1, 2, 2)
sns.boxplot(data=df[['word_count']])
plt.title('Word Count Distribution (Box Plot)')
plt.ylabel('Word Count')

plt.tight_layout()
plt.show()

# Additional statistical insights
print("\nDetailed Statistical Analysis:")
print("-" * 50)
print(f"Total number of reviews: {len(df)}")
print(f"Average words per review: {df['word_count'].mean():.2f}")
print(f"Median words per review: {df['word_count'].median():.2f}")
print(f"Standard deviation: {df['word_count'].std():.2f}")
print(f"Shortest review: {df['word_count'].min()} words")
print(f"Longest review: {df['word_count'].max()} words")
print("\nQuantile Analysis:")
print(f"25th percentile: {df['word_count'].quantile(0.25):.2f} words")
print(f"75th percentile: {df['word_count'].quantile(0.75):.2f} words")
print(f"90th percentile: {df['word_count'].quantile(0.90):.2f} words")

# Check for reviews of different lengths
print("\nReview Length Categories:")
print(f"Very short reviews (<50 words): {len(df[df['word_count'] < 50])}")
print(f"Short reviews (50-150 words): {len(df[(df['word_count'] >= 50) & (df['word_count'] < 150)])}")
print(f"Medium reviews (150-300 words): {len(df[(df['word_count'] >= 150) & (df['word_count'] < 300)])}")
print(f"Long reviews (300+ words): {len(df[df['word_count'] >= 300])}")

Statistical Analysis Results

Basic Statistics

• Mean Length: 233.79 words per review
• Median Length: 174 words
• Standard Deviation: 173.73 words
• Range: 10 to 2,470 words

Distribution Analysis

📊 Key Insights:

1. Central Tendency

• Most reviews cluster between 100–300 words
• The median (174 words) is lower than the mean (233.79 words), indicating right skew

1. Distribution Pattern

• Right-skewed distribution (long tail)
• Most reviews are of moderate length
• Some extremely long reviews (>1000 words) present as outliers

1. Length Categories

• Very short reviews (<50 words): Small minority
• Short reviews (50–150 words): Common
• Medium reviews (150–300 words): Most frequent
• Long reviews (300+ words): Significant tail

Implications for Analysis

1. Data Preprocessing

• Consider truncating extremely long reviews
• May need to pad very short reviews
• Potential for length normalization

1. Model Considerations

• Need to handle variable length inputs
• Consider computational impact of long reviews
• Possible need for length-based stratification

1. Quality Indicators

• Good variety in review lengths
• No missing or zero-length reviews
• Natural distribution pattern typical of user-generated content

3. Sentiment Analysis Patterns

# Sentiment distribution visualization
plt.figure(figsize=(10, 6))
sns.countplot(data=df, x='label')
plt.title('Distribution of Review Sentiments')
plt.xlabel('Sentiment (0: Negative, 1: Positive)')
plt.ylabel('Count')
plt.show()

# Length by sentiment analysis
plt.figure(figsize=(10, 6))
sns.boxplot(data=df, x='label', y='word_count')
plt.title('Review Length by Sentiment')
plt.show()

🔍 Pattern Discovery:

• Perfect 50–50 split between positive and negative reviews
• Negative reviews tend to be slightly longer
• More variance in positive review lengths

Next Steps and Resources

Where to Go From Here

1. Experiment with different preprocessing techniques
2. Try advanced visualization methods

Pada era data-driven decision making, Exploratory Data Analysis (EDA) menjadi langkah fundamental yang menentukan keberhasilan proyek machine learning. Artikel ini menyajikan pengalaman komprehensif tim kami dalam mengeksplorasi dataset IMDB, menggabungkan teori dengan praktik, serta menghasilkan insights yang dapat diaplikasikan secara nyata.

Latar Belakang

EDA, yang dikembangkan oleh John Tukey sejak 1970-an, telah berevolusi menjadi metodologi yang krusial dalam data science. Pendekatan ini memungkinkan kita untuk:

• Memahami struktur dan karakteristik data secara mendalam
• Mengidentifikasi anomali dan pattern tersembunyi
• Memvalidasi asumsi untuk pemodelan
• Mengoptimalkan proses pengambilan keputusan

Analisis Eksploratif Dataset IMDB

1. Analisis Struktur Data & Identifikasi Pola

# Load dataset
df = pd.DataFrame(dataset)

# Basic information
print("Dimensi dataset:", df.shape)
print("\nInformasi dataset:")
print(df.info())

# Check missing values
print("\nMissing values:")
print(df.isnull().sum())

# Calculate text lengths
df['text_length'] = df['text'].apply(len)

Hasil analisis menunjukkan:

• Dataset terdiri dari 25.000 review film
• Setiap entry memiliki dua kolom utama: text (ulasan) dan label (sentimen)
• Tidak ditemukan missing values
• Label terdistribusi secara seimbang (50% positif, 50% negatif)

2. Analisis Statistik Mendalam

# Statistical analysis
print("\nStatistik deskriptif panjang teks:")
print(df['text_length'].describe())

# Word count analysis
df['word_count'] = df['text'].apply(lambda x: len(x.split()))
print("\nStatistik jumlah kata:")
print(df['word_count'].describe())

Temuan statistik utama:

1. Karakteristik Teks:

• Mean: 233.79 kata per review
• Median: 174 kata
• Range: 10–2470 kata
• Standar deviasi: 173.73 kata

1. Distribusi Label:

• 12,500 review positif (50%)
• 12,500 review negatif (50%

Visualisasi Data Komprehensif

1. Distribusi Panjang Teks

import matplotlib.pyplot as plt
import seaborn as sns

plt.figure(figsize=(10, 6))
sns.histplot(data=df, x='word_count', bins=50)
plt.title('Distribusi Panjang Review')
plt.xlabel('Jumlah Kata')
plt.ylabel('Frekuensi')
plt.show()

2. Analisis Sentimen

plt.figure(figsize=(8, 6))
sns.countplot(data=df, x='label')
plt.title('Distribusi Label Sentimen')
plt.xlabel('Label (0: Negatif, 1: Positif)')
plt.ylabel('Jumlah Review')
plt.show()

Interpretasi Hasil Analisis

1. Pattern dan Trend Utama

1. Distribusi Teks:

• Mayoritas review memiliki panjang 100–300 kata
• Terdapat outliers dengan panjang >1000 kata
• Distribusi right-skewed menunjukkan preferensi review pendek

1. Pattern Linguistik:

• Dominasi kata-kata terkait film (‘movie’, ‘film’)
• Penggunaan kata sentimen (‘good’, ‘great’, ‘bad’) signifikan
• Presence of informal language dan slang

2. Implikasi untuk Pengembangan Model

1. Preprocessing Requirements:

• Normalisasi panjang teks diperlukan
• Standardisasi format teks

1. Feature Engineering Opportunities:

• Ekstraksi fitur berbasis panjang teks
• Penggunaan word embeddings

1. Model Selection Considerations:

• Balance dataset mendukung berbagai jenis model
• Pertimbangan computational cost untuk long texts

Kesimpulan

Melalui EDA yang komprehensif pada dataset IMDB, kami telah:

1. Mengidentifikasi karakteristik kunci dataset
2. Menemukan patterns dan anomali penting
3. Mengembangkan strategi preprocessing yang tepat
4. Membuat rekomendasi konkret untuk pengembangan model

EDA ini memberikan fondasi solid untuk tahap pengembangan model selanjutnya, dengan pemahaman mendalam tentang karakteristik data dan potensial challenges yang mungkin dihadapi.

Link Collab :
https://colab.research.google.com/drive/1Bm0SD3ADrHRkdJhPyPwFWFGi1z3DGXOG?usp=sharing

Hallo pembaca! Dalam modul 2, kita belajar tentang konsep dasar neural network (NN) dan bagaimana jaringan ini memproses input untuk menghasilkan prediksi dengan menggunakan bobot (weights). Kita juga membangun dan mengimplementasikan Neural Network sederhana yang dapat menangani multiple inputs dan multiple outputs, serta memahami bagaimana bobot mempengaruhi hasil prediksi.

Awalnya, saya mulai dengan membuat prediksi menggunakan jaringan neural sederhana yang hanya memiliki satu input dan satu output. Saya menemukan bahwa mekanisme jaringan neural cukup mudah dipahami, yakni dengan mengalikan input dengan bobot yang telah ditentukan. Namun, seiring perkembangan, saya menyadari bahwa kompleksitas jaringan meningkat, terutama ketika jumlah datapoints yang diproses secara bersamaan bertambah. Hal ini memiliki pengaruh signifikan terhadap akurasi dan performa prediksi.

Berikut adalah variabel penting yang perlu diketahui dalam Neural Networks:

1. Input: Data awal yang dimasukkan ke jaringan neural.
2. Weights (Bobot): Parameter yang menentukan kontribusi setiap input terhadap output.
3. Prediction (Prediksi): Hasil akhir dari proses perhitungan dalam jaringan.

Salah satu hal menarik adalah bagaimana bobot dalam jaringan neural mempengaruhi hasil prediksi. Sebagai contoh, dengan menggunakan satu input dan satu bobot, saya bisa memprediksi sesuatu yang sederhana seperti jumlah jari kaki seseorang.

Penggunaan vektor dan operasi perkalian elementwise juga memperlihatkan kekuatan matematika dalam menangani tugas-tugas yang kompleks. Saya mempelajari bahwa perkalian bobot dengan input secara elementwise tidak hanya memengaruhi output secara langsung, tetapi juga memberikan wawasan tentang seberapa besar kontribusi setiap input terhadap hasil akhir. Hal ini mengajarkan saya pentingnya memilih bobot yang tepat, terutama dalam konteks multiple inputs dan outputs.

Pada akhirnya, saya memahami bahwa forward propagation adalah tahap yang penting dalam perjalanan jaringan neural untuk belajar. Meskipun prediksi awal mungkin belum sempurna, proses ini merupakan fondasi yang kuat sebelum jaringan neural diperbaiki melalui pembelajaran dan penyesuaian bobot.

Modul ini membuat saya lebih menghargai peran matematika dalam AI, sekaligus membuka wawasan saya tentang bagaimana kita dapat menggunakan NN untuk memecahkan berbagai masalah yang kompleks di berbagai bidang, mulai dari prediksi sederhana hingga analisis data besar yang lebih kompleks.

Intinya, modul ini membuka mata saya tentang betapa pentingnya tahap forward propagation dalam neural networks. Meski prediksi awal mungkin belum akurat, proses ini jadi dasar yang penting sebelum jaringan neural belajar dan memperbaiki bobotnya. Dengan memahami ini, saya jadi lebih menghargai bagaimana neural networks bisa diaplikasikan untuk memecahkan masalah kompleks, mulai dari prediksi sederhana sampai analisis data besar yang lebih rumit.

Part 1 :
Refleksi pertemuan ke-1 Mata kuliah pembelajaran mesin lanjut | by Kartikasofia | Aug, 2024 | Medium

Melalui sinergi antara data mining dan OLAP, analisis mendalam terhadap performa siswa telah mengeksplorasi lapisan tersembunyi yang mengubah paradigma dalam pendekatan edukatif. Part 2 dari penelitian ini memperlihatkan betapa esensialnya kolaborasi ini dalam mengungkap pola baru dan memberikan wawasan yang mencerahkan terkait faktor-faktor yang memengaruhi kinerja siswa.

Integrasi data mining dan OLAP pada data performa siswa telah membuka cakrawala baru dalam mengidentifikasi pola-pola data yang relevan. Beberapa metodologi seperti metode association, clustering, classification, dan forecasting memberikan wawasan yang signifikan:

• Metode association menyoroti bahwa persiapan ujian tidak selalu menjamin hasil terbaik; perlunya analisis lebih lanjut terhadap faktor-faktor yang mempengaruhi performa siswa saat melakukan persiapan.
• Metode clustering membuktikan bahwa beberapa kelompok siswa memerlukan strategi pembelajaran yang berbeda-beda untuk meningkatkan performa mereka.
• Melalui metode classification, teridentifikasi bahwa tingkat pendidikan orang tua berhubungan erat dengan tingkat kesulitan dalam pembelajaran siswa.
• Metode forecasting memberikan prediksi tentang cara meningkatkan nilai siswa di masa mendatang.

Kontribusi terhadap Bidang Penelitian:

• Penelitian ini memberikan kontribusi dalam memahami pentingnya integrasi antara data mining dan OLAP dalam konteks pendidikan.
• Mengidentifikasi pola baru dalam data performa siswa dapat membantu institusi pendidikan dalam menyusun strategi yang lebih efektif dalam meningkatkan performa siswa.

Institusi pendidikan dapat menggunakan hasil penelitian ini untuk merancang strategi yang lebih tepat guna meningkatkan performa siswa. Hal ini dapat menjadi acuan dalam mengoptimalkan pembelajaran dan strategi pendidikan di masa depan. Diperlukan perhatian lebih terhadap proses pengumpulan data primer untuk mendapatkan informasi yang lebih mendalam dan akurat. Evaluasi lebih lanjut diperlukan untuk memastikan kehandalan dan validitas hasil dari metode data mining yang digunakan.

Kritik terhadap Metodologi yang Digunakan:

• Perlu perhatian lebih terhadap proses pengumpulan data primer untuk memperoleh informasi yang lebih mendalam dan akurat.
• Evaluasi lebih lanjut diperlukan untuk memastikan kehandalan dan validitas hasil yang dihasilkan oleh metode data mining yang digunakan.

Keterbatasan Penelitian:

• Penelitian ini menggunakan data sekunder pada tahun 2018; penggunaan data aktual yang lebih baru bisa memberikan wawasan yang lebih aktual tentang performa siswa.
• Faktor-faktor lain di luar variabel yang dianalisis dalam penelitian ini mungkin juga berpengaruh terhadap performa siswa.

Saran dan Pemikiran untuk Pengembangan Selanjutnya:

• Disarankan untuk melakukan penelitian lebih lanjut dengan menggunakan data aktual dan lebih mendalam untuk memperoleh pemahaman yang lebih komprehensif tentang faktor-faktor yang memengaruhi performa siswa.
• Penting untuk mempertimbangkan faktor-faktor sosial, psikologis, dan lingkungan yang mungkin mempengaruhi hasil yang diperoleh.

Integrasi antara data mining dan OLAP memiliki dampak yang signifikan dalam memahami dan meningkatkan performa siswa. Penelitian ini memberikan wawasan baru tentang pentingnya analisis data performa siswa dalam meningkatkan strategi pendidikan. Dengan menggabungkan data mining dan OLAP, penelitian ini memberikan pandangan yang mendalam tentang bagaimana institusi pendidikan dapat meningkatkan strategi mereka untuk membantu siswa mencapai potensi maksimal mereka.

Sinergi antara data mining dan OLAP dalam konteks pendidikan telah membuka jendela menuju pemahaman yang lebih dalam tentang faktor-faktor yang memengaruhi performa siswa. Meskipun menawarkan wawasan yang berharga, penelitian ini menyoroti pentingnya pengembangan metodologi yang lebih kuat dan penggunaan data aktual untuk menangkap dinamika yang lebih tepat dalam meningkatkan pendidikan di masa depan. Keberlanjutan eksplorasi ini menjadi kunci dalam membentuk landasan edukatif yang lebih efektif dan inklusif.

https://www.researchgate.net/publication/346548036_INTEGRASI_DATA_MINING_DAN_ONLINE_ANALYTICAL_PROCESSING_OLAP_PADA_DATA_PERFORMA_SISWA

https://revou.co/kosakata/olap

Apa itu SQL Join?

Sebelum kita masuk ke dalam jenis-jenis join, mari kita pahami apa itu SQL Join. Join adalah operasi dalam SQL yang memungkinkan Anda menggabungkan data dari dua atau lebih tabel berdasarkan kolom-kolom tertentu. Ini memungkinkan Anda untuk menggabungkan data dari tabel yang berbeda sehingga Anda dapat melakukan analisis yang lebih komprehensif.

Jenis-Jenis SQL Join

Ada beberapa jenis SQL Join yang umum digunakan, tetapi dalam artikel ini, kita akan fokus pada tiga yang paling populer:

1. INNER JOIN: Ini adalah jenis join paling umum. INNER JOIN menggabungkan baris dari dua tabel berdasarkan nilai yang cocok dalam kolom yang ditentukan. Hasilnya adalah tabel yang hanya berisi baris dengan nilai yang cocok di kedua tabel.
2. LEFT JOIN: LEFT JOIN menggabungkan semua baris dari tabel kiri (tabel pertama yang Anda tentukan) dan baris yang cocok dari tabel kanan (tabel kedua). Jika tidak ada nilai cocok di tabel kanan, kolom tabel kanan akan diisi dengan NULL.
3. RIGHT JOIN: RIGHT JOIN mirip dengan LEFT JOIN, tetapi sebaliknya. Ini menggabungkan semua baris dari tabel kanan dan baris yang cocok dari tabel kiri. Jika tidak ada nilai cocok di tabel kiri, kolom tabel kiri akan diisi dengan NULL.

Contoh Inner Join :

Gunakan = https://www.db-book.com/university-lab-dir/sqljs.html

Kita ingin menggabungkan informasi mata kuliah dan instruktur yang mengajarkannya. Kita dapat menggunakan inner join dengan kondisi bahwa nilai kolom course_id pada tabel teaches sama dengan nilai kolom course_id pada tabel course, dan nilai kolom ID pada tabel teaches sama dengan nilai kolom ID pada tabel instructor.

#step

lakukan inner join antara tabel course dan teaches berdasarkan nilai kolom course_id di kedua tabel.

# INNER JOIN teaches ON course.course_id = teaches.course_id;

— Kemudian, dilakukan inner join lagi antara tabel teaches dan instructor berdasarkan nilai kolom ID yang sama di kedua tabel.

# INNER JOIN instructor ON teaches.ID = instructor.ID;

Contoh Left Join :

SELECT instructor.name, department.dept_name FROM department LEFT JOIN instructor ON instructor.dept_name = department.dept_name;

LEFT JOIN pada query tersebut digunakan karena kita ingin mempertahankan semua baris yang ada di tabel parent yaitu department, bahkan jika tidak ada nilai yang cocok di tabel instructor. Artinya, jika ada department yang tidak memiliki instruktur yang terkait, record tersebut tetap akan ditampilkan dalam hasil query dengan nilai NULL untuk kolom-kolom instruktur… tapi rupanya table department (parent) terhadap instructor tidak ada NULL value, artinya table department tidak ada yang tidak memiliki instructor

tapi rupanya table department (parent) terhadap instructor tidak ada NULL value, artinya table department tidak ada yang tidak memiliki instructor

Contoh RIGHT JOIN :

kebalikan dari Left Join, kalo table parent adalah department (kiri) maka table instructor (kanan) yang akan di pertahankan, in case ada data instructor yang tidak memiliki department makan tetep akan muncul bersama department bernilai NULL, namun saya tidak bisa memunculkan nya, ada error merah ini, sepertinya tidak support di sqljs.html :

Full Join :
Ketika menggunakan FULL JOIN, semua row atau record dari kedua tabel (instructor dan department) akan ditampilkan dalam hasil query, bahkan jika tidak ada nilai yang cocok di tabel lainnya. jika ada departemen yang tidak memiliki instruktur terdaftar dan instruktur yang tidak terdaftar ke dalam departemen tertentu, kedua record tersebut tetap akan ditampilkan dalam hasil query dengan nilai NULL untuk kolom yang kosong. dan rupanya sqljs.html tidak support juga hehe.

Teruslah berlatih, eksperimen dengan data Anda sendiri, dan jadilah ahli dalam seni menggabungkan data

[PART 1] https://medium.com/@rifamartin/system-basis-data-persiapan-awal-89239616ee78
[PART 2] https://medium.com/@nabilaisha622/mengenal-lebih-jauh-mengenai-query-select-pada-basis-data-acabac63c404
[PART 3] https://medium.com/@rifamartin/cara-menggunakan-order-by-pada-sql-mengurutkan-data-siapapun-bisa-lakukan-60e09ae76a84
[PART 4] https://medium.com/@nabilaisha622/melakukan-seleksi-baris-pada-database-dengan-menggunakan-query-where-fa26d2855194

Mau urut-urutan data jadi rapi?Tenang saja, karena dengan ORDER BY pada SQL, semua jadi akan lebih mudah! Siapa saja yang menggunakan database pasti pernah mengalami kebingungan saat ingin mengurutkan data. Tetapi, jangan khawatir! Dalam artikel ini, kamu bisa belajar cara menggunakan ORDER BY pada SQL.

Jangan lupa temen-temen pastikan xampp kamu running ya di bagian apache dan Mysql, aku tahu laptop kamu udah berdebu jarang di pake, panasin yuk! buka senjatamu xampp dan dbeaver . semakin sering di buka semakin banyak data semakin jago nantinya hehe.

ORDER BY adalah sebuah perintah dalam bahasa SQL yang digunakan untuk mengurutkan hasil output data dari sebuah tabel secara ascending (naik) atau descending (turun) berdasarkan satu atau lebih kolom tertentu.

ORDER BY ASC:
ORDER BY ASC:

Kolom-kolom yang bisa diurutkan menggunakan ORDER BY dalam SQL tidak hanya terbatas pada kolom numerik atau alfanumerik saja, tetapi juga kolom-kolom lain seperti tanggal, waktu, atau objek lainnya di dalam basis data.

berikut sample query nya :

SELECT nim FROM <nama_table> ORDER BY <target_column> ASC; --terkecil ke terbesar
SELECT nim FROM <nama_table> ORDER BY <target_column> DSC; --terbesar ke terkecil

Sebelum kita bermain dengan query order by, tentunya kita perlu punya data yang perlu di order, disini saya memiliki table mahasiswa terdiri dari 47 record data.

saya akan melakukan order based on column nim

SELECT nim FROM uph.mahasiswa ORDER BY nim ASC;

hasilnya, data terurut dari nim terkecil sampai ke paling besar dan sebaliknya jika menggunakan DSC (descending)

mari kita coba urutkan berdasarkan alphabet menggunakan column jurusan:

select jurusan from mahasiswa order by jurusan asc;

maka data akan terurut berdasarkan alphabet, karena database mahasiswa hanya memilikin 3 jurusan secara ASC(ascending) akan terutus menjadi Sistem informasi, teknik elektro, teknik informatika begitupun sebaliknya bila menggunakan DSC (descending)

kita bisa menggunakan lebih dari satu column untuk untuk melakukan ordering data, seperti ini :

select nama,jurusan from mahasiswa order by jurusan,nama asc;

Dengan contoh query di atas, data akan diurutkan terlebih dahulu berdasarkan jurusan (secara ascending), kemudian baru diurutkan lagi setiap jurusan yang sama berdasarkan nama (secara ascending).

Order by itu penting banget buat kita urutkan data berdasarkan kolom tertentu. Dengan nge-order data, kita bisa lebih mudah melihat dan analisis data yang udah di-query. Jadi, jangan lupa buat ngerti cara pakai order by ya. Semoga artikel ini bisa membantu lebih paham tentang order by.

Addition Materi Part 3 :
1. String Operations adalah operasi SQL untuk memanipulasi nilai string dalam tabel, seperti menggabungkan, mengganti, memotong, atau mengubah huruf besar/kecil.

- CONCAT() — Untuk menggabungkan dua atau lebih nilai string menjadi satu nilai string.
— REPLACE() — Untuk mengganti setiap kemunculan nilai string tertentu dalam string dengan nilai string lain.
— SUBSTRING() — Untuk memotong atau mengekstrak nilai string tertentu dari sebuah string.
— UPPER() dan LOWER() — Untuk mengubah nilai string menjadi huruf besar atau kecil.

SELECT CONCAT(nama, ' - ', nim) AS nama_lengkap FROM mahasiswa;
 2. Set Operations adalah operasi SQL untuk membandingkan dan menggabungkan data dari dua tabel atau lebih. Contohnya menggabungkan data dengan UNION, mencari nilai yang sama dengan INTERSECT, dan mengambil nilai unik dengan EXCEPT. 3. Null Values adalah nilai-nilai yang tidak diketahui dalam tabel. Untuk menangani nilai null, dapat menggunakan operasi IS NULL untuk memeriksa apakah nilai null atau IS NOT NULL untuk memeriksa nilai bukan null. Juga dapat menggunakan COALESCE() untuk menentukan nilai default ketika null.

2. Set Operations adalah operasi SQL untuk membandingkan dan menggabungkan data dari dua tabel atau lebih. Contohnya menggabungkan data dengan UNION, mencari nilai yang sama dengan INTERSECT, dan mengambil nilai unik dengan EXCEPT.

SELECT nama, fakultas FROM mahasiswa
UNION
SELECT nama, fakultas FROM dosen;

3. Null Values adalah nilai-nilai yang tidak diketahui dalam tabel. Untuk menangani nilai null, dapat menggunakan operasi IS NULL untuk memeriksa apakah nilai null atau IS NOT NULL untuk memeriksa nilai bukan null. Juga dapat menggunakan COALESCE() untuk menentukan nilai default ketika null.

sekian teman-teman, jangan lupa tunggu artikel berikutnya ya…

[PART 1] https://medium.com/@rifamartin/system-basis-data-persiapan-awal-89239616ee78
[PART 2] https://medium.com/@nabilaisha622/mengenal-lebih-jauh-mengenai-query-select-pada-basis-data-acabac63c404

Hey Nakama!, Kali ini kita akan ngobrolin soal System Basis Data nih. Apa sih System Basis Data itu? Gampang banget, System Basis Data itu sebenernya gabungan dari alat, teknik, dan software yang membantu kita untuk memanage data yang kita punya secara efisien. Mulai dari mengumpulkan data, mengolah data, sampe menyimpan data dengan baik, semua bisa dilakukan dengan System Basis Data. Jadi, jangan takut untuk explore dunia System Basis Data ya! oh iya please di notes ya only untuk windows user.

Berikut tools yang kita perlukan :
- XAMMP (Cross-platform, Apache, MySQL, PHP, dan Perl)
- Beekeper Studio Community Edition/ Dbeaver (DBMS tools/ database management Software)

1. installation XAMPP:

setelah itu langsung cuss ke folder installed nya, lalu cari xampp-control.application -> send to dekstop, untuk memudahkan kita start/stop config application dari shorcout control xampp yang nantinya kita gunakan

Klik start pada Apache dan Mysql :

Setelah Success Start :

Setelah Apache dan Mysql Success Started, maka bisa kita pastikan dengan cara akses DBMS web tools phpMyAdmin di browser “http://localhost/phpmyadmin/”

Cheers! udah beres untuk step awal install XAMPP (Apache, MySQL)

2. installation DBMS Tools:

Btw di sini aku pake dbms tools nya Dbeaver ya gengs! kalian bebas mau pake yang mana saja asalkan itu open source, tapi jika dompet kalian tebal boleh beli yang berbayar ya, mari sejahterakan developer dengan dompetmu!.

untuk download application nya, kalian bisa akses di https://dbeaver.io/download/
lalu pilih sesuai os kalian, disini saya pake windows dan jangan lupa pilih yang community ya (The community is sometimes synonymous with open source)

Cuss, kita lanjut ke proses installation Dbeaver tersayang kita hehe

Disini kalian next next aja gengs ikuti default set up dan tunggu proses installation selesai bisa sambil ngopi santai.

Berikut tampilan awal dari Dbeaver kita gengs, kalian langsung pilih new connection ya, untuk new connection nya sudah aku kasih tanda, nantinya akan muncul popup pilihan database type, kita pilih MariaDB gengs

Sekedar Informasi tambahan dari popup tersebut menandakan ada banyak loh type database MariaDb,Oracle,Postgredd dll pasti mereka memiliki sejarah nya sendiri, yuk ekplore nanti!

Di Field Password kalian isi kosong aja ya, karena by default ketika kita melakukan initiating dari step awal kita tidak melakukan proses configuring user password

Setelah itu biasanya Dbeaver akan menginfokan Driver tambahan apa yang perlu di install

Setelah itu, kalian pilih open Script SQL untuk menjadi tempat kalian berkomunikasi dengan Database menggunal bahasa SQL dan coba ketikan show databases;

Untuk membuat database baru kalian cukup klik kanan Databases -> Create New Database

Aku mebuat database uphdb dan melakukan open SQL editor di database uphdb dan malakukan pembuatan table menggunakan SQL

CREATE TABLE mahasiswa (
  id INT(11) NOT NULL AUTO_INCREMENT,
  nama VARCHAR(50) NOT NULL,
  nim VARCHAR(20) NOT NULL,
  jurusan VARCHAR(50) NOT NULL,
  fakultas VARCHAR(50) NOT NULL,
  alamat VARCHAR(100) NOT NULL,
  PRIMA

Dan setelah itu kita bisa melakukan show table untuk melihat table apa saja di dalem database uphdb

show tables

Dan akhirnya proses set up kita selesai, setelah step installation selesai nantinya di next chapter tulisan ini, kita akan mempelajari bagaimana komunikasi dengan database menggunakan bahasa SQL

next chapter :
https://medium.com/@nabilaisha622/mengenal-lebih-jauh-mengenai-query-select-pada-basis-data-acabac63c404

stay hungry and foolish for the new knowledge

Thanks all!

CQRS, kepanjangan dari Segregasi Command Query Responsibility, berasal dari CQS (Command Query Separation) yang diperkenalkan oleh Bertrand Meyer dalam Konstruksi Perangkat Lunak Berorientasi Objek. Meyer menyatakan bahwa setiap metode harus berupa kueri atau perintah(Command).

Perbedaan antara CQS dan CQRS adalah setiap object CQRS dibagi dalam dua objek: satu untuk QUERY satu untuk PERINTAH (command)

Perintah didefinisikan sebagai metode yang mengubah STATUS. Sebaliknya, kueri hanya mengembalikan NILAI.

Skema berikut menunjukkan implementasi dasar dari pola CQRS di dalam aplikasi. Semua pesan dikirim melalui perintah dan event. Mari kita lihat lebih dekat

contoh penerapa pola CQRS(Command Query Responsibility)

Kita dapat dengan jelas melihat pemisahan antara bagian penulisan dan yang membaca: pengguna melakukan modifikasi pada halamannya, menghasilkan perintah yang dieksekusi. Setelah perintah ini ditangani sepenuhnya, sebuah event dikirim untuk memberi sinyal ada suatu modifikasi.

baiklah, dibawah ini adalah penampakan project yang ingin saya dokumentasikan API nya menggunakan swagger,

Yang perlu kita lakukan adalah, kita cukup menambahkan 2 despendencies di dalam file pom.xml setelah itu lakukan mvn clean install/enable auto import untuk melakukan download despendencies

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.6.0</version>
    <scope>compile</scope>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.6.1</version>
</dependency>

Setelah itu kita menambahkan anotation @EnableSwagger2, kedalam file spring boot aplication kita, disitu saya memberikan nama WmbBackendApplication.java

Jalankan project backend kita lalu akses kedalam browser dengan link :

http://localhost:{Sesuaikan dengan port kalian}/swagger-ui.html

seperti inilah penampakan swagger documentasion API kita guys :D

selamat mencoba …