Pengenalan TensorFlow

Kita sudah melatih neural network dari nol dengan NumPy dan menyusuri tensor dari sisi PyTorch pada section sebelumnya. Sekarang kita berkenalan dengan framework kedua yang menjadi fokus Course ini: TensorFlow, framework buatan tim Google Brain yang sejak 2015 tumbuh menjadi salah satu pilar deep learning di industri. TensorFlow menempuh jalur yang berbeda dari PyTorch — alih-alih menonjolkan kebebasan menulis kode Python, TensorFlow menonjolkan antarmuka deklaratif Keras serta ekosistem deployment yang matang. Chapter ini merunut sejarah singkatnya, memetakan posisi Keras 3 di dalam paket, membandingkan filosofinya dengan PyTorch, lalu menjalankan operasi tensor pertama kita pada TensorFlow 2.21. Seluruh contoh diuji nyata di mesin CPU Course ini.

Sejarah Singkat TensorFlow #

TensorFlow bermula dari DistBelief, sistem pelatihan model terdistribusi yang dibangun Google Brain sekitar 2011. Pada November 2015 Google membuka penerusnya sebagai proyek open source bernama TensorFlow, dan sejak itu perkembangannya terbagi menjadi dua era besar yang penting kita pahami:

Di era TensorFlow 1.x, kita harus membangun computational graph terlebih dahulu, lalu menjalankannya di dalam tf.Session. Model di-debug dengan kesulitan: nilai tensor tidak bisa dilihat begitu saja, dan pesan galat muncul jauh dari lokasi kesalahan. TensorFlow 2.0 yang rilis tahun 2019 mengubah arah ini — operasi dieksekusi segera secara eager layaknya kode Python biasa, sehingga bisa di-print dan di-inspeksi kapan saja. Sejak itulah cara kerja TensorFlow terasa dekat dengan intuisi yang kita bangun di section dasar Python dan NumPy.

Keras: API Tingkat Tinggi Resmi #

Sejak TensorFlow 2.0, Keras menjadi API tingkat tinggi resmi untuk membangun model. Sejak TensorFlow 2.16, tf.keras menunjuk ke Keras 3 — generasi terbaru yang juga dapat berjalan di atas backend JAX dan PyTorch, bukan hanya TensorFlow. Satu perintah pip install tensorflow di Chapter instalasi sudah memasang keduanya: mesin komputasi TensorFlow dan antarmuka model Keras 3. Selama section ini kita memakai API Keras 3 melalui tf.keras, misalnya tf.keras.layers.Dense, tf.keras.Model, model.compile, dan model.fit.

Diagram di atas melukiskan posisi Keras: layer dan model yang kita susun diterjemahkan Keras menjadi operasi tensor, lalu dijalankan runtime TensorFlow di perangkat keras yang tersedia. Posisi Keras sebagai lapisan antarmuka inilah yang membuat kode model kita kelihatan deklaratif dan ringkas dibanding implementasi NumPy murni pada section dasar neural network.

Ekosistem dan Siapa yang Memakainya #

TensorFlow lebih dari sekadar pustaka pelatihan; TensorFlow adalah keluarga perangkat untuk seluruh daur hidup model. Tabel berikut memetakan komponen yang paling sering disebut:

Karena ekosistem tersebut, TensorFlow banyak dipakai tim yang mengirim model ke produksi: layanan Google, perusahaan transportasi daring, layanan kesehatan, hingga manufaktur. Peneliti pun memakainya, tetapi porsi terbesar pengguna TensorFlow adalah insinyur yang butuh jalur mulus dari eksperimen sampai deployment.

Filosofi TensorFlow vs PyTorch #

Kedua framework menyelesaikan masalah yang sama — komputasi tensor dan gradien — dengan penekanan berbeda. Tabel berikut merangkum perbedaan filosofinya:

Perbandingan pada praktik nyata sudah kita jalankan dari sisi PyTorch pada Pengenalan PyTorch ; sepanjang section ini kita akan melihat padanan TensorFlow dari konsep yang sama. Panduan resmi API Keras tersedia di tensorflow.org/guide/keras dan keras.io .

Operasi Tensor Pertama #

Sekarang kita jalankan program TensorFlow pertama section ini. Skrip di bawah memeriksa versi, membuktikan eager execution aktif, lalu menghitung total belanja dan hasil kali matriks–vektor dengan angka kecil yang bisa kita hitung manual:

"""Uji pertama TensorFlow 2.21: versi, eager execution, dan operasi tensor."""

import os

os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"

import tensorflow as tf

print("Versi TensorFlow :", tf.__version__)
print("Versi Keras      :", tf.keras.__version__)
print("Eager execution  :", tf.executing_eagerly())

a = tf.constant(3.0)
b = tf.constant(4.0)
print("a + b            :", (a + b).numpy())
print("a * b - b        :", (a * b - b).numpy())

harga = tf.constant([2.0, 3.0, 5.0])
jumlah = tf.constant([10.0, 5.0, 2.0])
total = tf.reduce_sum(harga * jumlah)
print("Total belanja    :", total.numpy())

matriks = tf.constant([[1.0, 2.0],
                       [3.0, 4.0]])
vektor = tf.constant([10.0, 20.0])
print("Matriks @ vektor :", tf.linalg.matvec(matriks, vektor).numpy())

Output yang Dihasilkan:

Versi TensorFlow : 2.21.0
Versi Keras      : 3.15.1
Eager execution  : True
a + b            : 7.0
a * b - b        : 8.0
Total belanja    : 45.0
Matriks @ vektor : [ 50. 110.]

Mari kita telaah kode di atas baris per baris:

1. Baris 1-5 (os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"): mematikan log INFO dan WARNING TensorFlow sebelum modul dimuat — kebiasaan yang sudah kita sepakati pada Chapter Instalasi TensorFlow .
2. Baris 9-10 (cetak versi): tf.__version__ melaporkan 2.21.0 dan tf.keras.__version__ melaporkan 3.15.1 — bukti paket ini membawa Keras 3.
3. Baris 11 (tf.executing_eagerly()): mengembalikan True — setiap operasi dieksekusi seketika, tidak lagi ditunda sampai tf.Session dijalankan seperti era TensorFlow 1.x.
4. Baris 13-16 (a + b, a * b - b): tf.constant membuat tensor tetap; operasi aritmetika dievaluasi langsung dan .numpy() mengambil hasilnya sebagai angka Python/NumPy. Nilai 7.0 dan 8.0 tampil seketika di layar karena eager.
5. Baris 18-21 (total belanja): perkalian harga * jumlah berjalan per elemen menghasilkan [20, 15, 10], lalu tf.reduce_sum menjumlahkannya menjadi 45.0 — persis 2×10 + 3×5 + 5×2.
6. Baris 23-26 (tf.linalg.matvec): mengalikan matriks 2×2 dengan vektor: baris pertama 1×10 + 2×20 = 50, baris kedua 3×10 + 4×20 = 110, sehingga hasilnya [50, 110].

Ringkasan #

TensorFlow lahir dari Google Brain, melewati era graph yang kaku, lalu bertransformasi di TensorFlow 2.0 dengan eager execution dan Keras sebagai API resmi. Versi 2.21 yang kita pakai membawa Keras 3 multi-backend dengan ekosistem deployment yang luas — sisi yang melengkapi kebebasan riset PyTorch. Kita juga telah membuktikan eager execution lewat operasi pertama yang nilai-nilainya bisa diverifikasi hitungan tangan. Fondasi ini cukup untuk masuk lebih dalam: Chapter berikutnya membahas tf.constant, tf.Variable, operasi tensor, dan jembatan NumPy secara sistematis.