NumPy dan TensorFlow

TensorFlow mengubah cara kerjanya secara besar-besaran sejak versi 2.x: kode dieksekusi eager, artinya setiap operasi dihitung seketika — perilaku yang memang sudah biasa kita rasakan di NumPy. Objek dasarnya adalah tf.Tensor, dan jembatan dua arah antara tf.Tensor dengan ndarray menjadi sangat pendek. Pustaka ini juga tidak terpasang di lingkungan pengujian bab ini, sehingga aturannya sama dengan bab NumPy dan PyTorch: blok yang diuji hanya memakai NumPy, dan kode TensorFlow tampil sebagai ilustrasi # notest yang menuntut pip install tensorflow.

Persiapan data pelatihan justru seluruhnya domain NumPy: menyusun fitur, mengisi nilai kosong, menyeragamkan skala, lalu mengemas hasilnya dalam format file yang portabel. Itulah yang kita uji di sini.

Format Pertukaran Portabel: npy #

Sebelum data masuk ke kerangka kerja mana pun, ia harus bisa menyeberang antar sesi, mesin, dan bahasa tanpa kehilangan bentuk dan dtype. Format biner .npy milik NumPy menyimpan ketiganya sekaligus:

import os
import numpy as np

X = np.array([[40.0], [60.0], [80.0], [100.0]])
y = np.array([350.0, 500.0, 650.0, 800.0])
np.save("latihan.npy", X)
np.save("target.npy", y)
X_baru = np.load("latihan.npy")
print("identik ->", np.array_equal(X, X_baru))
print("File ada:", os.path.exists("latihan.npy"), os.path.exists("target.npy"))

Output yang Dihasilkan:

identik -> True
File ada: True True

Bedah singkat:

1. Baris 4-5: fitur X disengaja berbentuk 2-D (4, 1) — kontrak yang sama dengan yang dibahas pada bab NumPy dan scikit-learn; y tetap 1-D.
2. Baris 6-7 (np.save(...)): file .npy menyimpan array beserta dtype dan bentuknya dalam satu biner; tidak ada penguraian teks, tidak ada kehilangan presisi.
3. Baris 8-10 (np.load(...)): array yang dibaca kembali identik dengan yang disimpan — np.array_equal bernilai True.

Format ini adalah lingua franca de facto untuk memindahkan data antara NumPy, PyTorch, dan TensorFlow: setiap kerangka kerja punya pemuatnya sendiri, dan semuanya membaca .npy. Detail format dibahas penuh pada bab Menyimpan Array dengan npy dan Memuat Array dari npy.

Mengemas Dataset dalam Arsip npz #

Saat fitur dan target berjumlah banyak, dua file terpisah rawan terpisah juga versinya. np.savez mengemas beberapa array menjadi satu arsip .npz:

import numpy as np

rng = np.random.default_rng(42)
tinggi = rng.normal(165, 8, size=(6, 1)).astype(np.float32)
berat = (tinggi - 100).astype(np.float32)
np.savez("dataset.npz", X=tinggi, y=berat)
arsip = np.load("dataset.npz")
print(sorted(arsip.files))
print(arsip["X"].dtype, arsip["y"].dtype)
print(arsip["X"].ravel()[:3])

Output yang Dihasilkan:

['X', 'y']
float32 float32
[167.43774 156.68013 171.00362]

Mari kita bedah:

1. Baris 3-4 (default_rng(42)): data sintetis ber-seed agar output bab ini dapat direproduksi — kebiasaan yang sama dengan bab Reproducibility dan Random Seed.
2. Baris 5 (astype(np.float32)): dataset dikonversi ke float32 sebelum disimpan — ukuran file separuhnya, dan ini dtype yang paling lazim untuk pelatihan model.
3. Baris 6-8 (np.savez(...) / np.load(...)): arsip dibaca seperti dict; arsip.files memuat nama array, dan arsip["X"] mengembalikan ndarray lengkap dengan bentuk dan dtype aslinya.

Kontrak dtype dan Bentuk untuk Model #

Kerangka kerja deep learning menuntut bentuk yang konsisten: fitur 2-D (n_samples, n_features), target 1-D atau 2-D sesuai kebutuhan lapisan akhir. Pemeriksaan ringan berikut mencegah error yang muncul jauh di dalam pelatihan:

import numpy as np

X = np.array([[40, 60], [80, 100]])
y = np.array([350, 500])
print(X.shape, X.dtype, y.shape, y.dtype)
X32 = X.astype(np.float32)
print(X32.dtype)

Output yang Dihasilkan:

(2, 2) int64 (2,) int64
float32

Penjelasannya:

1. Baris 5 (print(...)): pemeriksaan satu baris membuka semua informasi kontrak — bentuk dan dtype kedua array.
2. Baris 6-7 (astype(np.float32)): nilai uang dan luas disimpan sebagai int64, sedangkan lapisan model bekerja dengan float; konversi eksplisit di sisi NumPy menghindari kejutan dtype di sisi TensorFlow.

Kode Integrasi (Ilustratif) #

Blok berikut memperlihatkan kedua arah konversi dan pemakaian array NumPy langsung di model.fit; ia tidak diuji karena memerlukan pustaka tensorflow yang terpasang:

# notest
import numpy as np
import tensorflow as tf  # perlu dipasang sendiri: pip install tensorflow

a = np.array([1.0, 2.0, 3.0])
t = tf.convert_to_tensor(a)   # ndarray -> tf.Tensor (eager)
kembali = t.numpy()           # tf.Tensor -> ndarray
X = np.load("dataset.npz")["X"]
y = np.load("dataset.npz")["y"]
model = tf.keras.Sequential([tf.keras.layers.Dense(1)])
model.compile(optimizer="sgd", loss="mse")
model.fit(X, y, epochs=5)     # array NumPy dipakai langsung

Baris demi baris:

1. Baris 6 (tf.convert_to_tensor(a)): dalam eager execution, hasilnya tf.Tensor yang nilainya bisa langsung dibaca; nilai elemennya sama dengan array asal.
2. Baris 7 (t.numpy()): setiap tf.Tensor eager menyediakan method .numpy() yang mengembalikan ndarray berisi nilai yang sama — jalur keluar resmi dari TensorFlow.
3. Baris 8-13: model.fit menerima array NumPy langsung — Keras membaginya menjadi batch internal; pemisahan batch, pengacakan, dan penghitungan gradien terjadi di dalam TensorFlow, sedangkan data tetap dibaca dari buffer NumPy kita.

Ringkasnya, pembagian kerjanya: NumPy bertanggung jawab sampai data tersimpan sebagai .npz dengan bentuk dan dtype yang benar; TensorFlow mengambil alih sejak fit(). Jika suatu hari pustaka belum terpasang di lingkungan pembaca, bungkus impor dengan try/except ImportError dan tampilkan pesan pemasangan — pola pemeriksaan ketersediaan yang juga berlaku untuk pustaka array lain.