Altair di Python Tutorial: Visualisasi Data

Kemampuan membuat plot yang mudah dipahami sekaligus canggih sangat penting untuk menjadi data scientist yang sukses. Membuat visualisasi adalah cara yang bagus untuk menceritakan kisah di balik data Anda. Visualisasi menyoroti hubungan dalam data dan mengungkap informasi yang terlihat oleh mata manusia yang tidak bisa disampaikan hanya dengan angka. Namun, tahukah Anda apa yang lebih baik daripada visualisasi biasa untuk analisis data? Visualisasi interaktif!

Sayangnya, bagi pemula, hal ini bisa terasa menakutkan. Python dan R sama-sama menyediakan beragam alat dan trik untuk membantu Anda. Dalam tutorial ini, kami akan memperkenalkan Anda pada Altair. Dengan Altair, Anda dapat membuat visualisasi yang bermakna, elegan, dan efektif hanya dengan beberapa baris kode dalam waktu singkat. Mari kita mulai!

Apa itu Altair?

Altair adalah library Python yang dirancang untuk visualisasi statistik. Library ini bersifat deklaratif (kita akan membahas definisi ini nanti). Altair berbasis pada Vega dan Vega-Lite, keduanya merupakan tata bahasa visualisasi yang memungkinkan Anda mendeskripsikan tampilan visual dan perilaku interaktif dari sebuah visualisasi dalam format JSON.

API Imperatif vs. Deklaratif

Seperti disebutkan sebelumnya, Python sudah memiliki sejumlah alat dan library hebat untuk visualisasi data, dan banyak yang mendukung visualisasi interaktif. Lalu, apa yang membuat Altair menonjol?

Jawabannya terletak pada sifat deklaratif-nya dibandingkan dengan API imperatif lainnya.

Dengan API imperatif, Anda harus berfokus pada 'bagaimana melakukan sesuatu' alih-alih 'apa yang ingin Anda lakukan'. Anda harus lebih memikirkan kode yang diperlukan untuk membuat visualisasi, serta menentukan langkah plotting secara manual—batas sumbu, ukuran, rotasi, legenda, dan sebagainya.

Sebagai data scientist, Altair memungkinkan Anda memusatkan waktu dan usaha pada data—memahami, menganalisis, dan memvisualisasikannya—alih-alih pada kode yang dibutuhkan. Artinya, Anda bisa mendefinisikan data dan keluaran yang ingin Anda lihat (seperti apa visualisasi akhirnya), dan Altair akan melakukan manipulasi yang diperlukan secara otomatis.

Instalasi

Dalam tutorial ini, kita akan menggunakan contoh dataset dari Vega datasets. Untuk memasang Altier bersama dengan Vega datasets, ketik perintah berikut di jendela konsol Anda:

$ pip install altair vega_datasets

Jika Anda menggunakan manajer paket conda, perintah yang setara adalah:

$ conda install -c conda-forge altair vega_datasets

Setelah itu, Anda bisa beralih ke Jupyter Notebook dan mengimpor Altair untuk memulai. Untuk mempelajari lebih lanjut tentang Jupyter notebook, pastikan untuk membaca Panduan Definitif Jupyter Notebook dari DataCamp.

Data

Sekarang kita telah memasang Altair beserta Vega dataset, saatnya memuat data. Mulailah dengan impor berikut:

import pandas as pd
import altair as alt

Mengapa mengimpor Pandas?

Karena data di Altair dibangun di sekitar Pandas DataFrame, ini berarti Anda dapat memanipulasi data di Altair dengan cara yang sama seperti Anda menangani DataFrame di Pandas.

Dan meskipun secara internal Altair menyimpan data dalam format Pandas DataFrame, ada beberapa cara untuk memasukkan data:

• sebagai Pandas DataFrame
• sebagai objek Data atau yang terkait (mis. UrlData, InlineData, NamedData)
• sebagai string URL yang mengarah ke file teks berformat JSON atau CSV
• sebagai objek yang mendukung geo_interface (mis., Geopandas GeoDataFrame, Shapely Geometries, Objek GeoJSON)

Movies Dataset

Dalam tutorial ini, kita akan bekerja dengan Movies Dataset dari Vega dataset. Dataset ini atau dataset serupa terkait film terkenal di komunitas data science, terutama dalam konteks Recommendation Engine. Namun, kita hanya akan melakukan analisis data menggunakan visualisasi dengan Altair.

Dataset ini memuat informasi terkait film seperti judul film, pendapatan kotor di Amerika dan seluruh dunia, beserta anggaran produksi, genre, rating dari IMDB dan Rotten Tomatoes. Kita tidak akan menggunakan semua kolom, melainkan hanya beberapa saja untuk mempelajari cara kerja Altair sebagai alat visualisasi.

Mari kita lanjutkan mengambil dataset dan melakukan beberapa analisis sederhana untuk memahaminya lebih baik.

# Importing the Vega Dataset
from vega_datasets import data as vega_data

movies_df = pd.read_json(vega_data.movies.url)

# Checking the type of data that we get
print("movies_df is of the type: ", type(movies_df))

print("movies_df: ", movies_df.shape)

movies_df is of the type:  <class 'pandas.core.frame.DataFrame'>
movies_df:  (3201, 16)

Seperti yang Anda lihat, movies_df adalah sebuah pandas DataFrame dan memiliki 3201 film (baris) dengan masing-masing 16 fitur (kolom). Mari kita lihat data di dalam dataframe.

movies_df.head(5)

Nilai kolomnya adalah:

movies_df.columns

Index(['Title', 'US_Gross', 'Worldwide_Gross', 'US_DVD_Sales',
       'Production_Budget', 'Release_Date', 'MPAA_Rating', 'Running_Time_min',
       'Distributor', 'Source', 'Major_Genre', 'Creative_Type', 'Director',
       'Rotten_Tomatoes_Rating', 'IMDB_Rating', 'IMDB_Votes'],
      dtype='object')

Sekarang kita akan menggunakan fungsi to_datetime di pandas untuk mengonversi kolom Release_Date menjadi tanggal sebenarnya lalu mengekstrak nilai 'year'-nya. Nanti kita akan menggunakan kolom baru ini dalam visualisasi.

def extract_year(value):
    return pd.to_datetime(value, format='%b %d %Y').year

movies_df["Year"] = movies_df["Release_Date"].apply(extract_year)

Jika sekarang Anda memeriksa nilai kolom, Anda akan melihat kolom baru bernama Year yang berisi nilai tahun untuk film terkait.

movies_df.columns

Index(['Title', 'US_Gross', 'Worldwide_Gross', 'US_DVD_Sales',
       'Production_Budget', 'Release_Date', 'MPAA_Rating', 'Running_Time_min',
       'Distributor', 'Source', 'Major_Genre', 'Creative_Type', 'Director',
       'Rotten_Tomatoes_Rating', 'IMDB_Rating', 'IMDB_Votes', 'Year'],
      dtype='object')

Sekarang, kita akan mulai membuat plot. Namun sebelum itu, jalankan potongan kode ini:

alt.renderers.enable('notebook')

RendererRegistry.enable('notebook')

Kode di atas memungkinkan Altair merender secara inline di Jupyter notebook, sehingga kita bisa melihat gambar yang kita buat. Jika Anda menemui masalah, lihat halaman pemecahan masalah Altair.

Pandangan pertama pada data, akan menarik untuk melihat hubungan antara seberapa banyak uang yang dihabiskan untuk membuat film (Production_Budget) dan seberapa banyak uang yang benar-benar dihasilkan film tersebut (Worldwide_Gross). Kita akan memplot nilai-nilai ini pada sumbu X dan Y.

Namun, dataset ini relatif besar—mengingat fokus kita adalah berlatih dengan Altair. Jadi, untuk sementara, kita akan bekerja dengan beberapa titik data saja. Mari lihat jumlah film pada tahun tertentu di dataset kita dan pilih satu tahun untuk difokuskan.

movies_df["Year"].value_counts()

2006    220
2005    210
2002    208
2004    192
2000    188
       ...
1943      1
2015      1
2027      1
2037      1
1928      1
Name: Year, Length: 91, dtype: int64

Mari kita fokus pada tahun 2000 dan buat dataframe baru movies_2000 yang hanya berisi data dari tahun ini. Seharusnya berisi 188 baris (film).

movies_2000 = movies_df[movies_df["Year"] == 2000]
movies_2000.shape

(188, 17)

Sekarang kita akan menuju visualisasi pertama. Mari selami sedikit lebih dalam format Altair untuk melakukannya.

Chart

Chart adalah objek fundamental di Altair, dan menerima satu argumen—sebuah dataframe. Cara kita mendefinisikan chart adalah sebagai berikut:

alt.Chart(DataFrame)

Namun, secara terpisah, chart tidak akan banyak berguna selain menentukan data yang ingin Anda gunakan—setelah itu Anda perlu menyatakan apa yang ingin dilakukan berikutnya dengan data tersebut. Di sinilah kita menggunakan mark.

Mark

Properti mark memungkinkan Anda menentukan bagaimana data direpresentasikan pada plot. Berikut adalah properti mark dasar yang disediakan Altair:

Untuk properti mark, kita ingin setiap nilai dalam dataFrame ditandai sebagai titik (lingkaran) pada plot. Maka kita tulis:

alt.Chart(DataFrame).mark_point()

Encoding

Setelah kita memiliki data dan cara representasinya—kita ingin menentukan di mana merepresentasikannya. Yaitu, mengatur posisi, ukuran, warna, dan sebagainya. Di sinilah kita menggunakan encoding. Jadi, kita punya:

alt.Chart(DataFrame).mark_point().encode()

Menggabungkan semuanya dan menambahkan detail untuk membuat visualisasi pertama kita:

alt.Chart(movies_2000).mark_point().encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross')
)

<vega.vegalite.VegaLite at 0x11709a1d0>

Keren, bukan? Kita tidak perlu banyak usaha—kita mengenal beberapa istilah dan menyusunnya. Sekarang, kita punya plot yang menampilkan jumlah yang dihabiskan vs. jumlah pendapatan kotor film pada tahun 2000 dalam dataset kita.

Mari buat grafik ini lebih menarik. Alih-alih semua titik diberi ukuran lingkaran yang sama, mari kita buat penanda sebesar (atau sekecil) US_Gross masing-masing. Untuk itu, kita perkenalkan fitur Size. Jadi, semakin besar ukuran lingkaran, semakin besar pula pendapatan box office AS. Kita juga beri warna pada penanda lingkaran, bukan hanya garis tepinya; untuk ini, kita tambahkan argumen pada properti mark_point().

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross')
)

<vega.vegalite.VegaLite at 0x117cce790>

Sekarang, kita memiliki plot yang menggambarkan anggaran tiap film hanya dalam empat baris. Apa yang kurang? WARNA!

Tapi kita tidak akan menambahkan warna acak begitu saja! Kita akan membuat grafik tetap menarik dengan menambahkan satu informasi lagi yang kita miliki di dataset, yaitu Major_Genre. Kita akan memberi setiap genre film warna masing-masing menggunakan fitur Color dan menambahkan transparansi dengan OpacityValue.

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7)
)

<vega.vegalite.VegaLite at 0x118e3ff50>

Ini sudah bagus, tapi belum cukup! Akan lebih keren jika kita bisa bergerak di sekitar plot dan juga melihat detail tentang film yang diwakili oleh titik data tersebut. Tooltip memungkinkan kita melakukan itu...

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title'),
               alt.Tooltip('Production_Budget'),
               alt.Tooltip('Worldwide_Gross'),
               alt.Tooltip('US_Gross')
              ]
)

<vega.vegalite.VegaLite at 0x118e3ff90>

Keren, bukan? Tapi tunggu, kita bisa lebih jauh lagi. Ingat mengapa kita ingin menggunakan Altair sejak awal? Agar kita bisa membuat visualisasi interaktif. Tooltip sudah memperkenalkan sedikit interaksi saat Anda mengarahkan kursor ke titik data. Namun, mari tambahkan fungsi interactive() sederhana ke yang sudah kita buat...

alt.Chart(movies_2000).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title'),
               alt.Tooltip('Production_Budget'),
               alt.Tooltip('Worldwide_Gross'),
               alt.Tooltip('US_Gross')
              ]
).interactive()

<vega.vegalite.VegaLite at 0x118e3c750>

Menambahkan potongan kode sederhana tersebut sudah memungkinkan Anda memperbesar area tertentu—mengatur nilai sumbu secara otomatis sehingga Anda bisa fokus pada area minat tertentu. Namun masih banyak fitur interaktif lanjutan yang bisa Anda tambahkan ke grafik. Mari coba salah satunya...

Kita akhirnya punya plot keren untuk memamerkan data. Mari masukkan semua titik data ke grafik kita. Tapi tunggu, bukankah terlalu banyak jika semua titik data dimasukkan ke satu visualisasi? Selain itu, kita tentu ingin memisahkannya berdasarkan nilai Year yang kita buat sebelumnya. Untuk melakukannya, kita akan menggunakan properti selection tingkat lanjut.

select_year = alt.selection_single(
    name='Select', fields=['Year'], init={'Year': 1928},
    bind=alt.binding_range(min=1928, max=2046, step=10)
)

alt.Chart(movies_df).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title:N'),
               alt.Tooltip('Production_Budget:Q'),
               alt.Tooltip('Worldwide_Gross:Q'),
               alt.Tooltip('US_Gross:Q')
              ]
).add_selection(select_year).transform_filter(select_year)

<vega.vegalite.VegaLite at 0x117cd4cd0>

Jadi, kita menggunakan properti add_selection untuk menambahkan select_year sebagai fitur pemilihan tunggal ke plot dan kemudian menerapkan transform_filter() untuk benar-benar menerapkan transformasi ke plot.

Apakah Anda memperhatikan tambahan baru lainnya pada kode? Huruf 'Q' dan 'N' pada Tooltip. Ini untuk menentukan tipe data: N-Nominal (data kategorikal), Q-Kuantitatif (data numerik), O-Ordinal (data berurutan), atau T-Temporal (titik waktu atau interval).

Periksa tahun tertua dan terbaru di dataset.

print("The oldest year is: ", movies_df["Year"].min())
print("The latest year is: ", movies_df["Year"].max())

The oldest year is:  1928
The latest year is:  2046

Seperti yang Anda lihat, saat Anda menggeser bilah 'Select_Year', tidak banyak film yang terwakili pada tahun 1928–1967. Dan tidak ada data film yang tercatat setelah 2018 dan tentu saja tidak sampai 2046. Kita bisa menggunakan properti binding_range() untuk menentukan rentang tahun dan juga langkah tahunnya.

Dalam proyek nyata, temuan seperti ini penting dan dapat mengarah pada kesalahan pada tahap pengumpulan data atau di suatu titik dalam prosesnya. Anda perlu menangani kesalahan secara efektif. Ini adalah langkah penting selama prapemrosesan data. Lihat Data Preparation with pandas untuk pengantar langkah-langkah penting ini.

Mari sesuaikan tahunnya, dan dengan ini, visualisasi final kita siap...

select_year = alt.selection_single(
    name='Select', fields=['Year'], init={'Year': 1968},
    bind=alt.binding_range(min=1968, max=2008, step=10)
)

alt.Chart(movies_df).mark_point(filled=True).encode(
    alt.X('Production_Budget'),
    alt.Y('Worldwide_Gross'),
    alt.Size('US_Gross'),
    alt.Color('Major_Genre'),
    alt.OpacityValue(0.7),
    tooltip = [alt.Tooltip('Title:N'),
               alt.Tooltip('Production_Budget:Q'),
               alt.Tooltip('Worldwide_Gross:Q'),
               alt.Tooltip('US_Gross:Q')
              ]
).add_selection(select_year).transform_filter(select_year)

<vega.vegalite.VegaLite at 0x1180cda10>

Dalam tutorial ini, Anda diperkenalkan dengan Altair. Anda melihat bagaimana, dengan beberapa baris kode, Anda bisa membuat plot yang indah dan interaktif yang membantu menceritakan kisah dalam data Anda dengan lebih efektif. Tutorial ini berharap dapat menunjukkan kekuatan dan potensi Altair. Untuk mempelajari lebih lanjut tentang Altair, kunjungi situs web resmi mereka.