Pengenalan Jupyter Notebook

Eksperimen deep learning berkembang melalui siklus berulang: muat data, coba parameter, amati hasil, lalu catat kesimpulan. Bekerja hanya dengan berkas skrip dan terminal membuat catatan serta hasil eksekusi berpencar, sulit ditelusuri kembali. Jupyter Notebook menyatukan kode, keluaran, grafik, dan catatan teks dalam satu dokumen interaktif — format yang menjadi standar de facto komunitas riset dan praktisi deep learning. Chapter ini memperkenalkan struktur berkas .ipynb, cara menjalankan server Jupyter, serta kernel yang menyimpan keadaan perhitungan antar sel. Pada akhirnya kita membuktikan bahwa sebuah notebook dapat dibuat dan dijalankan sepenuhnya dari terminal.

Apa itu Jupyter Notebook #

Jupyter Notebook adalah aplikasi web yang berjalan lokal: server kecil menyala di komputer Anda, lalu browser terhubung ke server tersebut melalui alamat localhost. Dokumen yang diedit bernama notebook — berkas berekstensi .ipynb yang sebenarnya adalah JSON berisi rangkaian sel. Setiap notebook terhubung ke sebuah kernel, yaitu proses interpreter Python yang tetap hidup selama notebook terbuka.

Karena kernel tetap hidup, variabel dari satu sel dapat dipakai oleh sel yang dijalankan setelahnya — notebook terasa seperti laboratorium hidup, bukan sekadar editor.

Memasang dan Menjalankan Jupyter #

Paket inti yang kita butuhkan bernama notebook. Pasang di dalam virtual environment proyek (lihat Chapter Virtual Environment) agar tidak mencemari interpreter lain:

python3 -m pip install notebook

Output yang Dihasilkan (mesin uji Course telah memiliki notebook, sehingga pip melaporkannya):

Requirement already satisfied: notebook in /home/z/.venv/lib/python3.12/site-packages (7.5.2)
Requirement already satisfied: jupyter-server<3,>=2.4.0 in /home/z/.venv/lib/python3.12/site-packages (from notebook) (2.17.0)

Pada venv yang masih kosong, pip mengunduh berkas tersebut alih-alih melaporkannya. Setelah terpasang, ada dua antarmuka pilihan: jupyter lab (JupyterLab, antarmuka lengkap dengan file manager) atau jupyter server (antarmuka notebook klasik). Kita gunakan yang kedua:

mkdir /tmp/latihan-jupyter && cd /tmp/latihan-jupyter
jupyter server

Output yang Dihasilkan (waktu log dan nilai token disingkat; token dibuat baru setiap kali server dinyalakan):

[I ... ServerApp] Serving notebooks from local directory: /tmp/latihan-jupyter
[I ... ServerApp] Jupyter Server 2.17.0 is running at:
[I ... ServerApp] http://localhost:8888/?token=...
[I ... ServerApp]     http://127.0.0.1:8888/?token=...
[I ... ServerApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).

Salin URL lengkap beserta token dari terminal Anda ke browser, buat notebook baru melalui tombol New, dan server siap dipakai. Tekan Ctrl-C dua kali untuk mematikan server beserta seluruh kernel.

Anatomi Berkas .ipynb #

Notebook adalah JSON biasa, sehingga kita dapat membuatnya secara programatik tanpa membuka browser. Skrip berikut membangun notebook kecil berisi satu sel Markdown dan dua sel kode:

import json

sel_markdown = {
    "cell_type": "markdown",
    "id": "pengantar",
    "metadata": {},
    "source": "# Latihan Notebook\n\nSel ini teks penjelasan; dua sel berikutnya berisi kode.",
}

sel_kode_1 = {
    "cell_type": "code",
    "id": "jumlah-array",
    "execution_count": None,
    "metadata": {},
    "outputs": [],
    "source": (
        "import numpy as np\n"
        "\n"
        "angka = np.arange(1, 11)\n"
        'print("angka       :", angka)\n'
        'print("total       :", int(angka.sum()))'
    ),
}

sel_kode_2 = {
    "cell_type": "code",
    "id": "fungsi-kuadrat",
    "execution_count": None,
    "metadata": {},
    "outputs": [],
    "source": (
        "def kuadrat(x):\n"
        "    return x * x\n"
        "\n"
        "hasil = [kuadrat(n) for n in range(1, 6)]\n"
        'print("kuadrat 1-5 :", hasil)'
    ),
}

notebook = {
    "cells": [sel_markdown, sel_kode_1, sel_kode_2],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3",
            "language": "python",
            "name": "python3",
        },
        "language_info": {"name": "python", "version": "3.12.15"},
    },
    "nbformat": 4,
    "nbformat_minor": 5,
}

with open("latihan.ipynb", "w", encoding="utf-8") as berkas:
    json.dump(notebook, berkas, indent=1, ensure_ascii=False)

print("Berkas latihan.ipynb dibuat dengan", len(notebook["cells"]), "sel")

Output yang Dihasilkan:

Berkas latihan.ipynb dibuat dengan 3 sel

Mari kita telaah kode di atas baris per baris:

1. Baris 1 (import json): karena .ipynb adalah JSON, modul standard library json sudah cukup untuk membuatnya — tanpa paket tambahan.
2. Baris 3-8 (sel_markdown): sel teks didefinisikan lewat dictionary dengan cell_type, id unik, dan source berisi teks Markdown. Tanda \n di dalam string mewakili baris baru.
3. Baris 10-21 (sel_kode_1): sel kode memiliki dua field tambahan — execution_count bernilai None karena sel belum pernah dijalankan, dan outputs yang masih kosong.
4. Baris 41-44 ("kernelspec"): metadata ini memberi tahu Jupyter kernel mana yang dipakai notebook, yaitu kernel python3 bawaan ipykernel.
5. Baris 49-50 (json.dump(...)): menulis seluruh struktur ke berkas latihan.ipynb dengan indentasi satu spasi agar mudah dibaca manusia.

Menjalankan Notebook dari Terminal #

Notebook yang baru dibuat belum berisi hasil eksekusi. Perintah jupyter nbconvert --execute menjalankan semua sel lewat kernel sungguhan, lalu menyimpan hasilnya kembali ke berkas yang sama — teknik yang dipakai untuk menguji notebook secara otomatis:

cd content/deep-learning/persiapan-lingkungan/pengenalan-jupyter-notebook
jupyter nbconvert --to notebook --execute --inplace latihan.ipynb

Output yang Dihasilkan:

[NbConvertApp] Converting notebook latihan.ipynb to notebook
[NbConvertApp] Writing 2064 bytes to latihan.ipynb

Setelah eksekusi, hasil setiap sel tersimpan di field outputs masing-masing sel kode. Skrip pembaca berikut mengekstrak keluaran tersebut kembali ke terminal:

import json

with open("latihan.ipynb", encoding="utf-8") as berkas:
    notebook = json.load(berkas)

for sel in notebook["cells"]:
    if sel["cell_type"] != "code":
        continue
    print("=== sel kode:", sel["id"], "===")
    for keluaran in sel["outputs"]:
        if keluaran["output_type"] == "stream":
            teks = keluaran.get("text", "")
            if isinstance(teks, list):
                teks = "".join(teks)
            print(teks, end="")

Output yang Dihasilkan:

=== sel kode: jumlah-array ===
angka       : [ 1  2  3  4  5  6  7  8  9 10]
total       : 55
=== sel kode: fungsi-kuadrat ===
kuadrat 1-5 : [1, 4, 9, 16, 25]

Mari kita telaah kode di atas baris per baris:

1. Baris 3-4 (json.load): membaca seluruh notebook menjadi struktur dictionary dan list Python, sama seperti membaca JSON biasa.
2. Baris 6-8 (if sel["cell_type"] != "code"): hanya sel kode yang memiliki outputs, sehingga sel Markdown dilewati dengan continue.
3. Baris 10 (output_type == "stream"): keluaran print() disimpan dengan tipe stream; tipe lain seperti error dan hasil ekspresi terakhir (execute_result) tidak dicetak skrip ini.
4. Baris 11-14 (isinstance(teks, list)): format .ipynb mengizinkan field text berupa string panjang atau daftar baris; "".join() menyatukan keduanya.

Sel, Kernel, dan Magic Command #

Kernel menyimpan state di memori: isi variabel ditentukan oleh urutan sel dijalankan, bukan urutan sel di layar. Menjalankan sel ketiga sebelum sel pertama yang mendefinisikan variabel adalah kesalahan klasik yang membuat hasil notebook tampak tidak konsisten. Biasakan menjalankan sel dari atas ke bawah, dan gunakan menu Restart & Run All saat hasil mulai meragukan.

Notebook juga menyediakan magic command — perintah khusus berawalan % yang hanya dikenali IPython/Jupyter, bukan Python murni. Magic sel %%time mengukur lama eksekusi satu sel dengan menambahkannya pada baris pertama sel berikut:

total = sum(range(1_000_000))
print(total)

Jupyter akan mencetak baris CPU times dan Wall time tepat di bawah hasil sel. Nilainya berbeda setiap eksekusi dan bergantung beban komputer, sehingga cocok untuk membandingkan dua pendekatan secara kasar, bukan sebagai angka mutlak. Magic satu baris seperti %time bekerja serupa untuk satu pernyataan.

Ringkasan #

Pada Chapter ini kita mengenal notebook sebagai dokumen JSON berisi sel kode dan sel Markdown yang dijalankan oleh kernel hidup, menjalankan server Jupyter dari terminal, serta membuktikan siklus penuh — membuat .ipynb secara programatik, mengeksekusinya dengan nbconvert, lalu membaca kembali hasilnya. Dengan Python, venv, dan Jupyter siap, komponen terakhir yang belum ada adalah framework deep learning itu sendiri. Chapter berikutnya memasang framework pertama kita: PyTorch.