Tutorial PySpark: Mulai Menggunakan PySpark

Apa itu PySpark?

PySpark adalah antarmuka untuk Apache Spark dalam Python. Dengan PySpark, Anda dapat menulis perintah mirip Python dan SQL untuk memanipulasi dan menganalisis data dalam lingkungan pemrosesan terdistribusi. Menggunakan PySpark, data scientist memanipulasi data, membangun pipeline machine learning, dan menyetel model.

Kebanyakan data scientist dan analis sudah akrab dengan Python dan menggunakannya untuk mengimplementasikan alur kerja machine learning. PySpark memungkinkan mereka bekerja dengan bahasa yang familier pada dataset terdistribusi berskala besar. Apache Spark juga dapat digunakan dengan bahasa pemrograman data science lain seperti R. Jika Anda tertarik mempelajarinya, kursus Introduction to Spark with sparklyr in R adalah tempat yang bagus untuk memulai.

RDD vs DataFrame di PySpark

PySpark memberi Anda dua cara untuk merepresentasikan data terdistribusi. Memahami mana yang digunakan adalah salah satu pertanyaan pertama yang dihadapi pengguna PySpark baru.

Untuk mayoritas pekerjaan — termasuk semua yang ada di tutorial ini — DataFrame adalah pilihan yang tepat. Optimizer kueri Catalyst milik Spark menulis ulang operasi DataFrame menjadi rencana eksekusi yang efisien secara otomatis, memberi Anda keuntungan kinerja yang harus Anda implementasikan sendiri jika menggunakan RDD. Gunakan RDD hanya ketika Anda memerlukan kontrol langsung atas partisi atau bekerja dengan data yang tidak cocok dengan skema tabel.

Mengapa Menggunakan PySpark?

PySpark adalah pilihan utama untuk memproses big data karena menggabungkan kemudahan Python dengan kekuatan komputasi terdistribusi Spark. Berikut perbandingannya dengan alternatif lain:

Alasan perusahaan memilih kerangka seperti PySpark adalah karena kecepatan pemrosesan big data yang sangat cepat. Ia lebih cepat daripada pustaka seperti Pandas dan Dask, dan dapat menangani data yang lebih besar daripada kerangka kerja tersebut. Jika Anda memiliki data berukuran petabyte untuk diproses, misalnya, Pandas dan Dask akan gagal tetapi PySpark akan dapat menanganinya dengan mudah.

Meskipun juga memungkinkan menulis kode Python di atas sistem terdistribusi seperti Hadoop, banyak organisasi memilih Spark dan menggunakan API PySpark karena lebih cepat dan dapat menangani data real-time. Dengan PySpark, Anda dapat menulis kode untuk mengumpulkan data dari sumber yang terus diperbarui, sementara data hanya dapat diproses dalam mode batch dengan Hadoop. 

Apache Flink adalah sistem pemrosesan terdistribusi yang memiliki API Python bernama PyFlink, dan sebenarnya lebih cepat daripada Spark dalam hal kinerja. Namun, Apache Spark sudah ada lebih lama dan memiliki dukungan komunitas yang lebih baik, sehingga lebih andal. 

PySpark juga menyediakan toleransi kesalahan: jika sebuah node gagal di tengah pekerjaan, Spark merekonstruksi data yang hilang menggunakan informasi garis keturunan RDD. Kerangka ini juga memiliki komputasi in-memory dan disimpan di random access memory (RAM). Ia dapat berjalan pada mesin yang tidak memiliki hard drive atau SSD terpasang.

Cara Menginstal PySpark

Berikut cara menginstal PySpark secara lokal atau di lingkungan cloud. 

Prasyarat

Sebelum memulai instalasi, pastikan Anda sudah memasang prasyarat berikut:

• Java 11 atau lebih baru (Java 17 direkomendasikan)
• Python 3.7 atau lebih baru
• Jupyter Notebook 

Catatan: Jika Anda menggunakan platform berbasis cloud seperti DataLab atau Databricks, Anda dapat melewati instalasi lokal karena PySpark sudah terpasang.

Menginstal PySpark

Buka file Python di Jupyter Notebook Anda dan jalankan baris kode berikut di sel pertama:

!pip install pyspark

Atau, Anda dapat mengikuti panduan instalasi PySpark end-to-end ini untuk memasang perangkat lunak di perangkat Anda.

Tutorial PySpark Machine Learning End-to-end

Sekarang PySpark sudah berjalan, kami akan menunjukkan cara menjalankan proyek segmentasi pelanggan end-to-end menggunakan pustaka ini. 

Segmentasi pelanggan adalah teknik pemasaran yang digunakan perusahaan untuk mengidentifikasi dan mengelompokkan pengguna yang menampilkan karakteristik serupa. Misalnya, jika Anda mengunjungi Starbucks hanya saat musim panas untuk membeli minuman dingin, Anda dapat disegmentasikan sebagai “pembeli musiman” dan dipikat dengan promosi khusus yang disusun untuk musim panas.

Data scientist biasanya membangun algoritma machine learning tanpa pengawasan, seperti pengelompokan K-Means atau pengelompokan hierarkis, untuk melakukan segmentasi pelanggan. Model-model ini sangat baik dalam mengidentifikasi pola serupa antar kelompok pengguna yang sering luput dari pengamatan manusia.

Dalam tutorial ini, kita akan menggunakan pengelompokan K-Means untuk melakukan segmentasi pelanggan pada dataset e-commerce.

Pada akhir tutorial ini, Anda akan akrab dengan konsep berikut:

• Membaca file CSV dengan PySpark

• Exploratory Data Analysis dengan PySpark

• Mengelompokkan dan mengurutkan data

• Melakukan operasi aritmetika

• Mengagregasi dataset

• Pra-pemrosesan Data dengan PySpark

• Bekerja dengan nilai datetime

• Konversi tipe

• Menggabungkan dua data frame

• Fungsi rank()

• Machine Learning dengan PySpark

• Membuat vektor fitur

• Menstandarkan data

• Membangun model pengelompokan K-Means

• Menginterpretasikan model

Langkah 1: Membuat SparkSession

SparkSession adalah titik masuk ke semua fungsionalitas di Spark, dan diperlukan jika Anda ingin membangun dataframe di PySpark. Jalankan baris kode berikut untuk menginisialisasi SparkSession: 

from pyspark.sql import SparkSession  # add this import


spark = (
    SparkSession.builder
    .appName("DataCamp PySpark Tutorial")
    .config("spark.memory.offHeap.enabled", "true")
    .config("spark.memory.offHeap.size", "10g")
    .getOrCreate()
)

Menggunakan kode di atas, kita membangun sesi Spark dan menetapkan nama untuk aplikasinya. Lalu, data di-cache di memori off-heap untuk menghindari penyimpanan langsung ke disk, dan jumlah memori ditentukan secara manual.

Langkah 2: Membuat DataFrame

Sekarang kita dapat membaca dataset. Anda dapat mengunduh dataset e-commerce contoh dari tutorial PySpark Read CSV kami atau menggunakan file CSV Anda sendiri:

df = spark.read.csv("datacamp_ecommerce.csv", header=True, escape='"', inferSchema=True)

Perhatikan bahwa kami mendefinisikan karakter escape untuk menghindari koma di file .csv saat parsing.

Mari lihat kepala DataFrame menggunakan fungsi show():

df.show(5,0)

DataFrame terdiri dari 8 variabel:

1. InvoiceNo: Pengidentifikasi unik setiap faktur pelanggan.

2. StockCode: Pengidentifikasi unik setiap item dalam stok.

3. Description: Item yang dibeli pelanggan.

4. Quantity: Jumlah setiap item yang dibeli pelanggan dalam satu faktur.

5. InvoiceDate: Tanggal pembelian.

6. UnitPrice: Harga satu unit setiap item.

7. CustomerID: Pengidentifikasi unik yang ditetapkan untuk setiap pengguna.

8. Country: Negara asal pembelian dilakukan.

Langkah 3: Analisis data eksploratif

Sekarang kita telah melihat variabel dalam dataset ini, mari lakukan beberapa analisis data eksploratif untuk lebih memahami titik data ini:

1. Mari mulai dengan menghitung jumlah baris dalam DataFrame:

df.count()  # Answer: 2,500

1. Berapa banyak pelanggan unik yang ada dalam DataFrame?

df.select('CustomerID').distinct().count() # Answer: 95

1. Negara mana yang paling banyak menjadi asal pembelian?

Untuk menemukan negara yang paling banyak melakukan pembelian, kita perlu menggunakan klausa groupBy() di PySpark:

from pyspark.sql.functions import *
from pyspark.sql.types import *

df.groupBy('Country').agg(countDistinct('CustomerID').alias('country_count')).show()

Tabel berikut akan dirender setelah menjalankan kode di atas:

Hampir semua pembelian di platform dilakukan dari United Kingdom, dan hanya sebagian kecil berasal dari negara seperti Jerman, Australia, dan Prancis. 

Perhatikan bahwa data pada tabel di atas tidak disajikan dalam urutan jumlah pembelian. Untuk mengurutkan tabel ini, kita dapat menyertakan klausa orderBy():

df.groupBy('Country').agg(countDistinct('CustomerID').alias('country_count')).orderBy(desc('country_count')).show()

Output yang ditampilkan sekarang diurutkan secara menurun:

1. Kapan pembelian paling baru dilakukan oleh pelanggan di platform e-commerce?

Untuk mengetahui kapan pembelian terbaru dilakukan di platform, kita perlu mengonversi kolom InvoiceDate ke format timestamp dan menggunakan fungsi max() di PySpark:

df = df.withColumn(
    "date",
    coalesce(
        to_timestamp(col("InvoiceDate"), "yy/MM/dd HH:mm"),
        to_timestamp(col("InvoiceDate"), "yyyy-MM-dd HH:mm:ss"),
        to_timestamp(col("InvoiceDate"))  # best-effort fallback
    )
)
df.select(max("date")).show()

Anda akan melihat tabel berikut muncul setelah menjalankan kode di atas:

1. Kapan pembelian paling awal dilakukan oleh pelanggan di platform e-commerce?

Mirip seperti di atas, fungsi min() dapat digunakan untuk menemukan tanggal dan waktu pembelian paling awal:

df.select(min("date")).show()

Perhatikan bahwa pembelian paling baru dan paling awal dilakukan pada hari yang sama, hanya berselang beberapa jam. Ini berarti dataset yang kita unduh hanya berisi informasi pembelian yang dilakukan pada satu hari.

Langkah 4: Pra-pemrosesan data

Sekarang kita telah menganalisis dataset dan memahami setiap titik data dengan lebih baik, kita perlu menyiapkan data untuk dimasukkan ke dalam algoritma machine learning.

Mari lihat kembali kepala data frame untuk memahami bagaimana pra-pemrosesan akan dilakukan:

df.show(5,0)

Dari dataset di atas, kita perlu membuat beberapa segmen pelanggan berdasarkan perilaku pembelian masing-masing pengguna. 

Variabel dalam dataset ini berada dalam format yang tidak mudah dimasukkan ke model segmentasi pelanggan. Fitur-fitur ini secara terpisah tidak banyak memberi tahu kita tentang perilaku pembelian pelanggan.

Karena itu, kita akan menggunakan variabel yang ada untuk menurunkan tiga fitur informatif baru - recency, frequency, dan monetary value (RFM).

RFM umum digunakan dalam pemasaran untuk mengevaluasi nilai klien berdasarkan:

1. Recency: Seberapa baru setiap pelanggan melakukan pembelian?
2. Frequency: Seberapa sering mereka membeli sesuatu?
3. Monetary Value: Berapa banyak uang yang mereka belanjakan rata-rata saat berbelanja?

Sekarang kita akan melakukan pra-pemrosesan data frame untuk membuat variabel di atas.

Recency

Pertama, mari hitung nilai recency - tanggal dan waktu terbaru pembelian yang dilakukan di platform. Ini dapat dicapai dalam dua langkah:

i) Menetapkan skor recency untuk setiap pelanggan

Kita akan mengurangkan setiap tanggal di data frame dari tanggal paling awal. Ini akan memberi tahu kita seberapa baru seorang pelanggan terlihat di data frame. Nilai 0 menunjukkan recency terendah, karena akan diberikan kepada orang yang terlihat melakukan pembelian pada tanggal paling awal.

df = df.withColumn("from_date", to_timestamp(lit("12/1/10 08:26"), "yy/MM/dd HH:mm"))
df2 = df.withColumn("recency", col("date").cast("long") - col("from_date").cast("long"))


w = Window.partitionBy("CustomerID").orderBy(desc("recency"))
df2 = df2.withColumn("rn", row_number().over(w)).filter(col("rn") == 1).drop("rn")

ii) Memilih pembelian paling baru

Satu pelanggan dapat melakukan beberapa pembelian pada waktu yang berbeda. Kita perlu memilih hanya waktu terakhir mereka terlihat membeli produk, karena ini menunjukkan kapan pembelian paling baru dilakukan: 

df2 = df2.join(df2.groupBy('CustomerID').agg(max('recency').alias('recency')),on='recency',how='leftsemi')

Mari lihat kepala data frame baru. Kini terdapat variabel bernama “recency” yang ditambahkan:

df2.show(5,0)

Cara yang lebih mudah untuk melihat semua variabel dalam sebuah DataFrame PySpark adalah menggunakan fungsi printSchema(). Ini setara dengan fungsi info() di Pandas:

df2.printSchema()

Output yang dirender akan terlihat seperti ini:

Frequency

Sekarang mari hitung nilai frequency - seberapa sering pelanggan membeli sesuatu di platform. Untuk melakukannya, kita hanya perlu melakukan group by setiap CustomerID dan menghitung jumlah item yang mereka beli. Untuk teknik pengelompokan yang lebih lanjut, lihat tutorial PySpark groupBy kami:

df_freq = df2.groupBy('CustomerID').agg(count('InvoiceDate').alias('frequency'))

Lihat kepala DataFrame baru yang baru saja kita buat:

df_freq.show(5,0)

Terdapat nilai frequency yang ditambahkan ke setiap pelanggan dalam DataFrame. DataFrame baru ini hanya memiliki dua kolom, dan kita perlu menggabungkannya dengan yang sebelumnya. Pelajari lebih lanjut tentang berbagai tipe join di tutorial PySpark Joins kami:

df3 = df2.join(df_freq,on='CustomerID',how='inner')

Mari cetak skema DataFrame ini:

df3.printSchema()

Monetary Value

Terakhir, mari hitung monetary value - total jumlah yang dibelanjakan oleh setiap pelanggan dalam DataFrame. Ada dua langkah untuk mencapainya:

i) Temukan total jumlah yang dibelanjakan di setiap pembelian:

Setiap CustomerID memiliki variabel Quantity dan UnitPrice untuk satu pembelian:

Untuk mendapatkan total jumlah yang dibelanjakan setiap pelanggan dalam satu pembelian, kita perlu mengalikan Quantity dengan UnitPrice:

m_val = df3.withColumn(
    "TotalAmount",
    col("Quantity").cast("double") * col("UnitPrice").cast("double")
)

ii) Temukan total jumlah yang dibelanjakan oleh setiap pelanggan:

Untuk menemukan total jumlah yang dibelanjakan oleh setiap pelanggan secara keseluruhan, kita hanya perlu melakukan group by kolom CustomerID dan menjumlahkan total jumlah yang dibelanjakan:

m_val = m_val.groupBy('CustomerID').agg(sum('TotalAmount').alias('monetary_value'))

Gabungkan DataFrame ini dengan semua variabel lainnya:

finaldf = m_val.join(df3,on='CustomerID',how='inner')

Sekarang kita telah membuat semua variabel yang diperlukan untuk membangun model, jalankan baris kode berikut untuk memilih hanya kolom yang dibutuhkan dan menghapus baris duplikat dari DataFrame:

finaldf = finaldf.select(['recency','frequency','monetary_value','CustomerID']).distinct()

Lihat kepala DataFrame final untuk memastikan bahwa pra-pemrosesan telah dilakukan dengan tepat:

Standarisasi

Sebelum membangun model segmentasi pelanggan, mari standarkan DataFrame untuk memastikan semua variabel berada pada skala yang serupa:

from pyspark.ml.feature import VectorAssembler, StandardScaler


assemble = VectorAssembler(
    inputCols=["recency", "frequency", "monetary_value"],
    outputCol="features"
)
assembled_data = assemble.transform(finaldf)


scale = StandardScaler(inputCol="features", outputCol="standardized")
data_scale = scale.fit(assembled_data)
data_scale_output = data_scale.transform(assembled_data)

Jalankan baris kode berikut untuk melihat seperti apa vektor fitur yang sudah distandarkan:

data_scale_output.select('standardized').show(2,truncate=False)

Inilah fitur berskala yang akan dimasukkan ke algoritma pengelompokan.

Jika Anda ingin mempelajari lebih lanjut tentang persiapan data dengan PySpark, ikuti kursus feature engineering ini di DataCamp.

Langkah 5: Membangun model machine learning

Sekarang kita telah menyelesaikan semua analisis dan persiapan data, mari bangun model pengelompokan K-Means. 

Algoritma akan dibuat menggunakan API machine learning PySpark.

i) Menentukan jumlah klaster yang digunakan

Saat membangun model pengelompokan K-Means, pertama-tama kita perlu menentukan jumlah klaster atau grup yang kita inginkan dari algoritma. Jika kita memutuskan tiga klaster, misalnya, maka kita akan memiliki tiga segmen pelanggan.

Teknik paling populer untuk memutuskan berapa banyak klaster yang digunakan dalam K-Means disebut “metode siku (elbow method).”

Ini dilakukan dengan menjalankan algoritma K-Means untuk rentang jumlah klaster dan memvisualisasikan hasil model untuk setiap klaster. Plot akan memiliki titik belok yang terlihat seperti siku, dan kita cukup memilih jumlah klaster pada titik tersebut.

Baca tutorial K-Means clustering DataCamp ini untuk mempelajari lebih lanjut cara kerja algoritma.

Mari jalankan baris kode berikut untuk membangun algoritma pengelompokan K-Means dari 2 hingga 10 klaster:

from pyspark.ml.clustering import KMeans
from pyspark.ml.evaluation import ClusteringEvaluator
import numpy as np

cost = np.zeros(10)

evaluator = ClusteringEvaluator(
    predictionCol="prediction",
    featuresCol="standardized",
    metricName="silhouette",
    distanceMeasure="squaredEuclidean"
)


ks = range(2, 10)
cost = np.zeros(len(ks))


for idx, k in enumerate(ks):
    km = KMeans(featuresCol="standardized", k=k)
    model = km.fit(data_scale_output)
    output = model.transform(data_scale_output)
    cost[idx] = model.summary.trainingCost   # WSSSE

Dengan kode di atas, kita telah berhasil membangun dan mengevaluasi model pengelompokan K-Means dengan 2 hingga 10 klaster. Hasilnya telah ditempatkan dalam sebuah array, dan sekarang dapat divisualisasikan dalam grafik garis:

import pandas as pd
import pylab as pl
df_cost = pd.DataFrame(cost)  # cost has 8 values, one per k in range(2, 10)
df_cost.columns = ["cost"]
new_col = range(2, 10)
df_cost.insert(0, 'cluster', new_col)
pl.plot(df_cost.cluster, df_cost.cost)
pl.xlabel('Number of Clusters')
pl.ylabel('Score')
pl.title('Elbow Curve')
pl.show()

Kode di atas akan merender grafik berikut:

ii) Membangun Model Pengelompokan K-Means

Dari plot di atas, kita dapat melihat ada titik belok yang terlihat seperti siku pada angka empat. Karena itu, kita akan melanjutkan membangun algoritma K-Means dengan empat klaster:

KMeans_algo=KMeans(featuresCol='standardized', k=4)
KMeans_fit=KMeans_algo.fit(data_scale_output)

iii) Membuat prediksi

Mari gunakan model yang kita buat untuk menetapkan klaster kepada setiap pelanggan dalam dataset:

preds=KMeans_fit.transform(data_scale_output)

preds.show(5,0)

Perhatikan bahwa ada kolom “prediction” dalam DataFrame ini yang memberi tahu kita klaster mana yang dimiliki setiap CustomerID:

Langkah 6: Analisis Klaster

Langkah terakhir dalam seluruh tutorial ini adalah menganalisis segmen pelanggan yang baru saja kita bangun.

Jalankan baris kode berikut untuk memvisualisasikan recency, frequency, dan monetary value dari setiap CustomerID dalam DataFrame:

import matplotlib.pyplot as plt
import seaborn as sns

df_viz = preds.select('recency','frequency','monetary_value','prediction')
df_viz = df_viz.toPandas()
avg_df = df_viz.groupby(['prediction'], as_index=False).mean()

rfm_columns = ['recency', 'frequency', 'monetary_value']

for metric in rfm_columns:
    sns.barplot(x='prediction', y=metric, data=avg_df)
    plt.show()

Kode di atas akan merender plot berikut:

Berikut gambaran karakteristik yang ditampilkan pelanggan di setiap klaster:

• Klaster 0: Pelanggan di segmen ini menunjukkan recency, frequency, dan monetary value yang rendah. Mereka jarang berbelanja di platform dan merupakan pelanggan berpotensi rendah yang kemungkinan akan berhenti bertransaksi dengan perusahaan e-commerce.
• Klaster 1: Pengguna di klaster ini menunjukkan recency tinggi tetapi belum terlihat banyak membelanjakan di platform. Mereka juga tidak sering mengunjungi situs. Ini mengindikasikan bahwa mereka mungkin pelanggan baru yang baru mulai bertransaksi dengan perusahaan.
• Klaster 2: Pelanggan di segmen ini menunjukkan recency dan frequency sedang serta banyak membelanjakan di platform. Ini mengindikasikan bahwa mereka cenderung membeli item bernilai tinggi atau melakukan pembelian dalam jumlah besar.
• Klaster 3: Segmen terakhir terdiri dari pengguna yang menunjukkan recency tinggi dan sering berbelanja di platform. Namun, mereka tidak banyak membelanjakan di platform, yang mungkin berarti mereka cenderung memilih item yang lebih murah pada setiap pembelian.

Untuk melampaui konsep pemodelan prediktif yang dibahas dalam kursus ini, Anda dapat mengikuti kursus Machine Learning with PySpark di DataCamp.

Belajar PySpark dari Nol: Langkah Berikutnya

Sekarang Anda telah menyelesaikan tutorial ini, berikut langkah berikutnya yang direkomendasikan berdasarkan tujuan Anda:

Jika Anda berhasil mengikuti seluruh tutorial PySpark ini, selamat! Anda kini telah berhasil menginstal PySpark di perangkat lokal, menganalisis dataset e-commerce, dan membangun algoritma machine learning menggunakan kerangka kerja ini.

Satu catatan dari analisis di atas adalah bahwa analisis dilakukan dengan 2.500 baris data e-commerce yang dikumpulkan pada satu hari. Hasil analisis ini dapat diperkokoh jika kita memiliki jumlah data yang lebih besar, karena teknik seperti pemodelan RFM biasanya diterapkan pada data historis selama berbulan-bulan.

Namun, Anda dapat mengambil prinsip yang dipelajari dalam artikel ini dan menerapkannya pada berbagai dataset yang lebih besar di ranah machine learning tanpa pengawasan.

Lihat lembar contekan ini oleh DataCamp untuk mempelajari lebih lanjut tentang sintaks PySpark dan modul-modulnya.

Terakhir, jika Anda ingin melampaui konsep yang dibahas dalam tutorial ini dan mempelajari dasar-dasar pemrograman dengan PySpark, Anda dapat mengikuti track pembelajaran Big Data with PySpark di DataCamp. Track ini berisi rangkaian kursus yang akan mengajarkan Anda melakukan hal berikut dengan PySpark:

• Manajemen Data, Analisis, dan Pra-pemrosesan
• Membangun dan Menyetel Pipeline Machine Learning
• Analisis Big Data 
• Feature Engineering 
• Membangun Recommendation Engine

Pikiran penutup

PySpark adalah alat yang tepat ketika data Anda melampaui kemampuan satu mesin. Proyek segmentasi pelanggan RFM dalam tutorial ini membahas seluruh alur: memuat data, analisis eksploratif, rekayasa fitur, dan ML. Ini adalah pola yang akan Anda gunakan kembali pada dataset yang jauh lebih besar di produksi.

Satu catatan jujur: contoh ini menggunakan 2.500 baris dari satu hari transaksi. PySpark menangani itu dengan nyaman. Keuntungan nyata dari pengaturan terdistribusi datang saat Anda bekerja dengan riwayat transaksi berbulan-bulan di jutaan peristiwa — saat itulah eksekusi in-memory dan toleransi kesalahan benar-benar berarti.

Untuk terus membangun, track Big Data with PySpark kami mencakup pipeline data engineering, recommendation engine, dan ML produksi dalam urutan terstruktur. Untuk tim, DataCamp for Business menawarkan jalur pembelajaran yang disesuaikan untuk peran data engineering. Ajukan demo untuk mempelajari lebih lanjut.