Tutorial TensorFlow untuk Pemula
Pendahuluan
Pernah bertanya-tanya bagaimana aplikasi bisa mengenali wajahmu di foto, atau bagaimana sistem rekomendasi Tokopedia tahu produk apa yang mungkin kamu suka? Di balik semua itu, ada teknologi bernama machine learning — dan salah satu tools paling populer untuk membangunnya adalah TensorFlow.
TensorFlow dibuat oleh Google dan dirilis ke publik pada 2015. Sejak saat itu, ia menjadi salah satu framework deep learning paling banyak digunakan di dunia. Kabar baiknya: kamu tidak perlu latar belakang matematika yang sangat dalam untuk mulai menggunakannya.
Di artikel ini, kita akan belajar dari nol — mulai dari instalasi, memahami konsep dasarnya, hingga membangun model klasifikasi gambar pertamamu. Jika kamu sudah familiar dengan variabel dan tipe data Python, kamu sudah punya bekal yang cukup untuk mengikuti tutorial ini.
Mengenal Apa Itu TensorFlow
Bayangkan kamu ingin mengajari seorang anak membedakan kucing dan anjing. Kamu tidak menjelaskan aturannya secara eksplisit — kamu cukup menunjukkan ribuan foto kucing dan anjing, lalu si anak belajar sendiri pola-polanya. Itulah cara kerja TensorFlow: ia membantu komputermu belajar dari data.
TensorFlow adalah open-source machine learning framework yang menyediakan alat-alat untuk:
- Mendefinisikan model matematika (neural network)
- Melatih model dengan data
- Mengoptimasi model agar semakin akurat
- Men-deploy model ke produksi (web, mobile, server)
Versi modern TensorFlow menggunakan Keras sebagai API tingkat tinggi — artinya kamu bisa membangun model kompleks hanya dengan beberapa baris kode tanpa perlu memikirkan operasi matematika tingkat rendah.
Instalasi dan Persiapan Lingkungan
Sebelum mulai, pastikan Python 3.8+ sudah terinstal di sistemmu. Gunakan virtual environment agar proyekmu tetap bersih dan terisolasi.
# Buat virtual environment agar instalasi paket tetap terpisah
python -m venv venv-tensorflow
# Aktifkan virtual environment — pilih sesuai sistem operasimu:
# Linux / macOS:
source venv-tensorflow/bin/activate
# Windows (Command Prompt):
venv-tensorflow\Scripts\activate.bat
# Windows (PowerShell):
venv-tensorflow\Scripts\Activate.ps1
# Upgrade pip agar proses instalasi lebih lancar
python -m pip install --upgrade pip
# Install TensorFlow
python -m pip install tensorflow
# Verifikasi instalasi dengan menampilkan versi TensorFlow
python -c "import tensorflow as tf; print(tf.__version__)"
# Output yang diharapkan:
# > 2.x.xJika output menampilkan versi seperti 2.15.0, berarti instalasi berhasil. Untuk bekerja dengan data dan visualisasi, install juga library berikut:
# Install library yang dibutuhkan untuk tutorial deep learning pemula
pip install numpy matplotlib scikit-learn
# Cek apakah semua library berhasil terpasang
python -c "import numpy, matplotlib, sklearn; print('Instalasi berhasil'); print('Semua library siap digunakan')"
# Output yang diharapkan:
# > Instalasi berhasil
# > Semua library siap digunakanKonsep Dasar TensorFlow: Tensor, Variable, dan Graph
Apa Itu Tensor?
Tensor adalah blok bangunan utama TensorFlow. Analoginya sederhana:
| Dimensi | Nama Biasa | Contoh |
|---|---|---|
| 0D | Skalar | 42 |
| 1D | Vektor/Array | [1, 2, 3] |
| 2D | Matriks/Tabel | [[1,2],[3,4]] |
| 3D+ | Tensor | Gambar RGB, video |
import tensorflow as tf
# Membuat tensor sederhana
skalar = tf.constant(42) # Tensor 0 dimensi
vektor = tf.constant([1.0, 2.0, 3.0]) # Tensor 1 dimensi
matriks = tf.constant([[1, 2], [3, 4]]) # Tensor 2 dimensi
# Menampilkan nilai dan bentuk (shape) tensor
print("Skalar:", skalar.numpy())
print("Shape vektor:", vektor.shape)
print("Shape matriks:", matriks.shape)
# Membuat dua vektor untuk operasi dasar
a = tf.constant([3.0, 6.0])
b = tf.constant([2.0, 3.0])
# Operasi matematika dasar pada tensor
print("Penjumlahan:", tf.add(a, b).numpy())
print("Perkalian:", tf.multiply(a, b).numpy())
print("Dot product:", tf.tensordot(a, b, axes=1).numpy())
# Output yang diharapkan:
# > Skalar: 42
# > Shape vektor: (3,)
# > Shape matriks: (2, 2)
# > Penjumlahan: [5. 9.]
# > Perkalian: [ 6. 18.]
# > Dot product: 24.0Variable vs Constant
tf.constant adalah nilai yang tidak berubah — cocok untuk data input. Sedangkan tf.Variable adalah nilai yang bisa diupdate selama pelatihan — digunakan untuk menyimpan bobot (weights) model.
import tensorflow as tf
# tf.constant: nilai tetap, tidak bisa diubah setelah dibuat
batas_atas = tf.constant(100)
print("Batas atas:", batas_atas.numpy())
# tf.Variable: nilai bisa diubah/update selama program berjalan
bobot = tf.Variable([0.5, 0.3, 0.2])
print("Bobot awal:", bobot.numpy())
# Update isi variable dengan nilai baru
bobot.assign([0.6, 0.25, 0.15])
print("Bobot setelah update:", bobot.numpy())
# Output yang diharapkan:
# > Batas atas: 100
# > Bobot awal: [0.5 0.3 0.2]
# > Bobot setelah update: [0.6 0.25 0.15]Konsep ini mirip dengan bagaimana kamu bekerja dengan struktur data graf — ada node (operasi) dan edge (aliran data) yang membentuk sebuah computation graph.
Contoh Kasus Nyata: Membangun Model Klasifikasi Gambar Sederhana
Kita akan membangun model untuk mengklasifikasikan gambar pakaian dari dataset Fashion MNIST — dataset yang berisi 70.000 gambar berukuran 28x28 piksel dalam 10 kategori (kaos, celana, sepatu, dll).
Bayangkan kamu sedang membangun fitur pencarian visual untuk marketplace seperti Tokopedia — di mana pengguna bisa upload foto pakaian dan sistem langsung mengenali kategorinya. Ini adalah langkah pertama menuju sistem seperti itu.
Langkah 1: Load dan Persiapkan Data
import tensorflow as tf
import matplotlib.pyplot as plt
# Memuat dataset Fashion MNIST
# Dataset ini berisi gambar pakaian berukuran 28x28 piksel
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()
# Daftar nama kelas untuk setiap label angka
nama_kelas = [
"T-shirt/top", "Trouser", "Pullover", "Dress", "Coat",
"Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"
]
# Menampilkan ukuran data training dan testing
print(f"Data training: {x_train.shape}")
print(f"Data testing: {x_test.shape}")
# Normalisasi piksel dari rentang 0-255 menjadi 0.0-1.0
# Ini membantu model belajar lebih stabil
x_train = x_train / 255.0
x_test = x_test / 255.0
# Menampilkan 8 contoh gambar dari data training
plt.figure(figsize=(10, 4))
for i in range(8):
plt.subplot(2, 4, i + 1) # Membuat grid 2 baris x 4 kolom
plt.imshow(x_train[i], cmap="gray") # Menampilkan gambar ke-i
plt.title(nama_kelas[y_train[i]]) # Menampilkan nama kelas
plt.axis("off") # Menyembunyikan sumbu
plt.tight_layout()
plt.show()
# Output yang diharapkan:
# > Data training: (60000, 28, 28)
# > Data testing: (10000, 28, 28)Langkah 2: Bangun Arsitektur Model
import tensorflow as tf
# Membuat model deep learning sederhana dengan Keras Sequential
model = tf.keras.Sequential([
# Flatten mengubah input gambar 28x28 menjadi 1 baris data (784 nilai)
tf.keras.layers.Flatten(input_shape=(28, 28)),
# Hidden layer dengan 128 neuron dan aktivasi ReLU
tf.keras.layers.Dense(128, activation='relu'),
# Dropout membantu mengurangi overfitting saat training
tf.keras.layers.Dropout(0.3),
# Output layer dengan 10 neuron untuk 10 kelas
tf.keras.layers.Dense(10, activation='softmax')
])
# Menampilkan ringkasan arsitektur model
model.summary()
# Menampilkan informasi singkat tambahan agar mudah dipahami pemula
print("Model berhasil dibuat.")
print("Jumlah layer:", len(model.layers))
# Output yang diharapkan:
# > Model berhasil dibuat.
# > Jumlah layer: 4Langkah 3: Compile dan Latih Model
import tensorflow as tf
from tensorflow import keras
# Muat dataset Fashion MNIST (gambar pakaian 28x28 piksel)
(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
# Normalisasi nilai piksel dari 0-255 menjadi 0-1 agar training lebih stabil
x_train = x_train / 255.0
x_test = x_test / 255.0
# Nama kelas untuk 10 kategori pakaian
nama_kelas = [
"T-shirt/top", "Trouser", "Pullover", "Dress", "Coat",
"Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"
]
# Buat model neural network sederhana
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)), # Ubah gambar 28x28 menjadi vektor 1 dimensi
keras.layers.Dense(128, activation='relu'), # Hidden layer dengan 128 neuron
keras.layers.Dropout(0.3), # Dropout untuk mengurangi overfitting
keras.layers.Dense(10, activation='softmax') # Output 10 kelas pakaian
])
# Compile model
model.compile(
optimizer='adam', # Optimizer untuk memperbarui bobot model
loss='sparse_categorical_crossentropy', # Loss untuk label integer (0-9)
metrics=['accuracy'] # Gunakan akurasi sebagai metrik evaluasi
)
# Latih model selama 10 epoch
history = model.fit(
x_train, y_train,
epochs=10,
validation_split=0.1, # 10% data training dipakai untuk validasi
verbose=1
)
# Evaluasi model dengan data test
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f"Akurasi data test: {test_acc:.4f}")
# Output yang diharapkan:
# > Epoch 1/10
# > ... - accuracy: 0.xx - loss: 0.xx - val_accuracy: 0.xx - val_loss: 0.xx
# > ...
# > Epoch 10/10
# > ... - accuracy: 0.xx - loss: 0.xx - val_accuracy: 0.xx - val_loss: 0.xx
# > Akurasi data test: 0.8xxxLangkah 4: Evaluasi dan Prediksi
import numpy as np
import tensorflow as tf
from tensorflow import keras
# Daftar nama kelas untuk dataset Fashion MNIST
nama_kelas = [
"T-shirt/top", "Trouser", "Pullover", "Dress", "Coat",
"Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot"
]
# Muat dataset Fashion MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.fashion_mnist.load_data()
# Normalisasi nilai piksel dari 0-255 menjadi 0-1 agar model lebih mudah belajar
x_train = x_train / 255.0
x_test = x_test / 255.0
# Buat model neural network sederhana
model = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28)), # Ubah gambar 28x28 menjadi vektor
keras.layers.Dense(128, activation="relu"), # Hidden layer
keras.layers.Dropout(0.3), # Dropout untuk mengurangi overfitting
keras.layers.Dense(10, activation="softmax") # Output 10 kelas
])
# Compile model sebelum training
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"]
)
# Latih model dengan beberapa epoch
model.fit(x_train, y_train, epochs=5, batch_size=32, verbose=0)
# Evaluasi model pada data test
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)
print(f"Akurasi pada data test: {test_acc:.2%}")
# Prediksi 5 gambar pertama dari data test
prediksi = model.predict(x_test[:5], verbose=0)
for i in range(5):
# Ambil indeks kelas dengan probabilitas tertinggi
kelas_prediksi = np.argmax(prediksi[i])
# Ambil nilai probabilitas (kepercayaan) dari prediksi tersebut
kepercayaan = prediksi[i][kelas_prediksi]
# Ambil label asli dari data test
label_asli = nama_kelas[y_test[i]]
print(
f"Gambar {i+1}: Prediksi = {nama_kelas[kelas_prediksi]} "
f"({kepercayaan:.1%}) | Asli = {label_asli}"
)
# Simpan model ke file
model.save("model_fashion.keras")
print("Model berhasil disimpan!")
# Output yang diharapkan:
# > Akurasi pada data test: 84.00%
# > Gambar 1: Prediksi = Ankle boot (98.7%) | Asli = Ankle boot
# > Gambar 2: Prediksi = Pullover (91.2%) | Asli = Pullover
# > Gambar 3: Prediksi = Trouser (99.1%) | Asli = Trouser
# > Gambar 4: Prediksi = Trouser (97.8%) | Asli = Trouser
# > Gambar 5: Prediksi = Shirt (65.4%) | Asli = Shirt
# > Model berhasil disimpan!Troubleshooting: Error yang Sering Muncul
ModuleNotFoundError: No module named ‘tensorflow’
Penyebab: TensorFlow belum terinstal di environment aktif, atau kamu menjalankan Python dari environment yang berbeda.
Solusi:
# Buat virtual environment jika belum ada
python -m venv .venv
# Aktifkan virtual environment sesuai sistem operasi:
# Linux/macOS:
source .venv/bin/activate
# Windows (Command Prompt):
.venv\Scripts\activate.bat
# Windows (PowerShell):
.venv\Scripts\Activate.ps1
# Upgrade pip agar proses install lebih lancar
python -m pip install --upgrade pip
# Install TensorFlow di environment yang sedang aktif
python -m pip install tensorflow
# Cek versi TensorFlow untuk memastikan instalasi berhasil
python -c "import tensorflow as tf; print(tf.__version__)"
# Output yang diharapkan:
# > 2.x.xValueError: Input 0 of layer is incompatible with the layer
Penyebab: Shape (ukuran dimensi) data input tidak sesuai dengan yang diharapkan oleh layer pertama model.
Solusi:
import tensorflow as tf
# Load dataset Fashion MNIST (gambar grayscale 28x28)
(x_train, y_train), _ = tf.keras.datasets.fashion_mnist.load_data()
# Cek shape data sebelum dimasukkan ke model
print("Shape input sebelum reshape:", x_train.shape) # Harus (N, 28, 28)
# Ubah nilai pixel dari 0-255 menjadi 0-1 agar model lebih mudah belajar
x_train = x_train / 255.0
# Tambahkan dimensi channel karena Conv2D butuh format (tinggi, lebar, channel)
# Fashion MNIST adalah gambar grayscale, jadi channel = 1
x_train = x_train.reshape(-1, 28, 28, 1)
# Cek shape data setelah reshape
print("Shape input sesudah reshape:", x_train.shape) # Harus (N, 28, 28, 1)
# Buat model CNN sederhana
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(32, (3, 3), activation="relu", input_shape=(28, 28, 1)),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(10, activation="softmax")
])
# Tampilkan shape input yang digunakan model
print("Input shape model:", model.input_shape)
# Output yang diharapkan:
# > Shape input sebelum reshape: (60000, 28, 28)
# > Shape input sesudah reshape: (60000, 28, 28, 1)
# > Input shape model: (None, 28, 28, 1)ResourceExhaustedError: OOM when allocating tensor (Out of Memory)
Penyebab: GPU atau RAM tidak cukup untuk menampung batch data dan model secara bersamaan.
Solusi:
import os
# Paksa TensorFlow menggunakan CPU saja
# Baris ini harus dijalankan SEBELUM import tensorflow
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
import tensorflow as tf
from tensorflow.keras.datasets import fashion_mnist
# Ambil dataset Fashion MNIST
(x_train, y_train), _ = fashion_mnist.load_data()
# Normalisasi nilai piksel dari 0-255 menjadi 0-1
x_train = x_train.astype("float32") / 255.0
# Buat model sederhana untuk klasifikasi gambar pakaian
model = tf.keras.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)), # Ubah gambar 28x28 jadi vektor
tf.keras.layers.Dense(128, activation="relu"), # Hidden layer
tf.keras.layers.Dense(10, activation="softmax") # Output 10 kelas pakaian
])
# Tentukan optimizer, loss, dan metrik evaluasi
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics=["accuracy"]
)
# Latih model dengan batch_size lebih kecil agar lebih ringan
history = model.fit(
x_train,
y_train,
epochs=3,
batch_size=16, # Coba lebih kecil dari default 32
verbose=1
)
# Tampilkan akurasi terakhir setelah training
print("Akurasi terakhir:", round(history.history["accuracy"][-1], 4))
# Output yang diharapkan:
# > Epoch 1/3
# > ... - accuracy: ...
# > Akurasi terakhir: 0.8xxxModel Overfitting: Akurasi Training Tinggi, Test Rendah
Penyebab: Model “menghafal” data training dan gagal generalisasi ke data baru. Sering terjadi ketika dataset kecil atau model terlalu kompleks.
Solusi:
import tensorflow as tf
# Contoh data: 60 gambar latih berukuran 28x28
# Di proyek asli, ganti ini dengan data Fashion MNIST
x_train = tf.random.uniform((60, 28, 28))
y_train = tf.random.uniform((60,), minval=0, maxval=10, dtype=tf.int32)
# Membuat model neural network sederhana
model = tf.keras.Sequential([
# Mengubah gambar 28x28 menjadi vektor 1 dimensi
tf.keras.layers.Flatten(input_shape=(28, 28)),
# Hidden layer pertama dengan 128 neuron
tf.keras.layers.Dense(128, activation='relu'),
# Hidden layer kedua dengan regularisasi L2 untuk mengurangi overfitting
tf.keras.layers.Dense(
64,
activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(0.001)
),
# Dropout: mematikan sebagian neuron saat training agar model lebih general
tf.keras.layers.Dropout(0.5),
# Output layer untuk 10 kelas
tf.keras.layers.Dense(10, activation='softmax')
])
# Menentukan cara model belajar
model.compile(
optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)
# Early Stopping: berhenti jika val_loss tidak membaik
early_stop = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
patience=3,
restore_best_weights=True
)
# Melatih model
history = model.fit(
x_train,
y_train,
epochs=10,
validation_split=0.1,
callbacks=[early_stop],
verbose=1
)
# Menampilkan hasil akhir training
print("Training selesai.")
print("Epoch terakhir:", len(history.history['loss']))
print("Akurasi terakhir:", round(history.history['accuracy'][-1], 4))
# Output yang diharapkan:
# > Muncul proses training per epoch dengan nilai loss, accuracy, val_loss, dan val_accuracy
# > Training selesai.
# > Epoch terakhir: [jumlah epoch yang dijalankan]
# > Akurasi terakhir: [nilai akurasi terakhir]Pertanyaan yang Sering Diajukan
Apa perbedaan TensorFlow dan PyTorch?
Keduanya adalah framework deep learning yang sangat populer. TensorFlow lebih dikenal di lingkungan produksi dan enterprise (terutama dengan TensorFlow Serving dan TensorFlow Lite untuk mobile), sedangkan PyTorch lebih disukai di dunia riset karena API-nya yang lebih intuitif. Untuk pemula, keduanya memiliki kurva belajar yang serupa — pilih salah satu dan kuasai dulu sepenuhnya.
Apakah TensorFlow membutuhkan GPU?
Tidak wajib, tetapi GPU sangat mempercepat proses pelatihan. CPU sudah cukup untuk eksperimen dan model kecil. Jika tidak punya GPU, kamu bisa gunakan Google Colab secara gratis — platform ini menyediakan GPU dan sudah pre-install TensorFlow, sehingga kamu bisa langsung coding tanpa setup apapun di komputermu.
Bagaimana cara menyimpan dan memuat model TensorFlow?
import numpy as np
import tensorflow as tf
# Buat model sederhana
model = tf.keras.Sequential([
tf.keras.layers.Dense(8, activation='relu', input_shape=(2,)),
tf.keras.layers.Dense(1, activation='sigmoid')
])
# Compile model agar siap digunakan
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
# Data latihan sederhana
X_train = np.array([
[0, 0],
[0, 1],
[1, 0],
[1, 1]
], dtype=np.float32)
y_train = np.array([0, 1, 1, 0], dtype=np.float32)
# Latih model sebentar
model.fit(X_train, y_train, epochs=10, verbose=0)
# Simpan model ke file
model.save('model_saya.keras')
# Muat model kembali dari file
model_loaded = tf.keras.models.load_model('model_saya.keras')
# Data baru untuk prediksi
data_baru = np.array([
[0, 1],
[1, 1]
], dtype=np.float32)
# Prediksi dengan model yang dimuat
hasil = model_loaded.predict(data_baru, verbose=0)
# Tampilkan hasil prediksi
print("Hasil prediksi:")
print(hasil)
# Output yang diharapkan:
# > Hasil prediksi:
# > [[0.xxx]
# > [0.xxx]]Apa itu epoch, batch, dan learning rate?
- Epoch: Satu kali model melihat seluruh dataset training. 10 epoch = model melihat data 10 kali.
- Batch size: Jumlah sampel yang diproses sekaligus sebelum bobot diupdate. Batch 32 berarti 32 gambar diproses per iterasi.
- Learning rate: Seberapa besar langkah update bobot setiap iterasi. Terlalu besar = tidak stabil, terlalu kecil = lambat belajar.
Berapa banyak data yang dibutuhkan untuk melatih model TensorFlow?
Tidak ada angka pasti — tergantung kompleksitas masalah. Untuk klasifikasi gambar sederhana, ribuan sampel per kelas sudah bisa menghasilkan model yang layak. Jika datamu sedikit, gunakan teknik transfer learning (memanfaatkan model yang sudah dilatih sebelumnya seperti MobileNet atau ResNet) untuk hasil yang jauh lebih baik dengan data yang terbatas.
Kesimpulan
Kita sudah menempuh perjalanan dari instalasi TensorFlow, memahami konsep tensor dan variable, hingga membangun model klasifikasi gambar Fashion MNIST dari nol. Kamu sekarang tahu cara mendefinisikan arsitektur model dengan Keras, melatihnya dengan data, mengevaluasi performa, dan bahkan menangani error-error umum yang sering muncul.
Langkah selanjutnya: coba eksperimen dengan menambah atau mengurangi layer, ubah jumlah neuron, atau coba dataset lain seperti CIFAR-10. Semakin banyak kamu bereksperimen, semakin dalam intuisimu tentang cara kerja model deep learning. Selamat belajar dan jangan pernah takut untuk mencoba — setiap error yang kamu temui adalah pelajaran berharga menuju keahlian yang sesungguhnya! Dunia AI sangat luas dan selalu ada hal menarik untuk dijelajahi bersama di KamusNgoding.