Tensorflow

Sejarah Tensorflow

Diawali dengan terciptanya DistBelief (2011-2015) diciptakan oleh Google Brain (tim riset AI di Google). DistBelief dirancang untuk membangun deep neural networks skala besar dengan tujuan untuk meningkatkan produk Google, seperti Search, Photos, Speech Recognition, dan Translate. Masalah yang ditemukan pada DistBelief adalah sangat sulit untuk memodifikasi model, kurang fleksibel untuk eksperimen riset.

Tahun 2014 adalah ide merancang Tensorflow yang diharapkan dapat fleksibel untuk riset (research-friendly), kuat untuk produksi (production-ready), dan dapat beroperasi di berbagai perangkat (CPU, GPU, bahkan mobile). Tahun 2015 Tensorflow dibangun oleh Jeff Dean, Rajat Monga, Yuan Yu, Greg Corrado dan selain itu, ada puluhan engineer dan peneliti lain yang berkontribusi dalam membangun TensorFlow dari awal. Fun Fact! Jeff Dean adalah tokoh legendaris di Google, dia juga pencipta MapReduce dan BigTable — fondasi dari Google Search!.

Tepat tanggal 9 November 2015, Google merilis resmi Tensorflow sebagai open-source project di bawah lisensi Apache 2.0. Ini menjadi langkah besar dalam komunitas AI, karena membuka akses ke teknologi AI canggih.

Sejak dirilisnya TensorFlow sejak diluncurkan tahun 2015, sudah merilis banyak versi besar dan kecil.

Lebih detailnya untuk version release, dapat dilihat disini

Cara kerja Tensorflow

Gambar diatas menggambarkan aliran data dalam TensorFlow menggunakan bentuk grafik komputasi.

• proses "OPERASI" mewakili node di dalam graf TensorFlow. Setiap operasi bisa berupa perhitungan matematis seperti penjumlahan, perkalian, aktivasi neuron, dsb.
• proses "TENSOR" mewakili data berbentuk array multidimensi (seperti vektor, matriks, atau lebih kompleks lagi) yang mengalir di sepanjang edge (garis penghubung) dalam graf.
• Data masukan "DATA LATIH" seperti gambar, teks, angka, dll. Data ini masuk ke dalam graf untuk dilatih atau diuji.
• "MODEL" Bagian ini adalah hasil akhir dari serangkaian operasi yang diterapkan pada tensor. Model ini nantinya digunakan untuk membuat prediksi atau inferensi.
• Setelah data melalui semua operasi dan tensor-tensor diolah, TensorFlow mengeluarkan hasil akhir (seperti klasifikasi, prediksi nilai, dll).

Spesifikasi piranti untuk menjalankan Tensorflow

Untuk dapat menjalankan Tensorflow di perangkat minimum Intel Core i3 / AMD Ryzen 3 (atau lebih baru) dengan RAM 4 GB (disarankan 8 GB). Kemudian, Sistem Operasi adalah Windows 10 64-bit, Ubuntu 18.04+, MacOS 10.14+. Dan perlu menginstall Python minimal versi 3.8 setelah itu download dan install library pendukung seperti pip, virtualenv, dan tensorflow dari PyPI

INFO TAMBAHAN

• TensorFlow versi 2.11 ke atas hanya support Python 3.8–3.11 dan OS 64-bit (tidak support Windows 7/8/32-bit).
• Untuk Mac M1/M2/M3, TensorFlow juga ada versi khusus (pakai Metal acceleration), jadi tetap bisa cepat walau bukan NVIDIA.

Apa saja yang dapat dilakukan dengan Tensorflow ?

• Membuat komputer mengenali gambar, suara, teks, atau pola, seperti manusia belajar.
• memprediksi harga rumah, cuaca, saham, bahkan penyakit dari data.
• Membuat chatbot, deteksi wajah, penerjemah otomatis, pengenal tulisan tangan.
• TensorFlow mampu menangani data dalam jumlah sangat besar dengan cepat.
• Model yang dibuat bisa dipasang di server, web, smartphone, atau perangkat kecil (embedded device).
• TensorFlow banyak dipakai untuk penelitian mutakhir di bidang AI seperti deep learning, reinforcement learning, dan machine learning generatif.

Project

Proyek ini adalah identifikasi gambar atau foto bahasa isyarat statis dengan Tensorflow.
Dengan menggunakan dataset BISINDO yang berisi gambar dataset yang telah dibuat directory per huruf A hingga Z

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout
import json

train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=10,          # lebih kecil
    width_shift_range=0.1,
    height_shift_range=0.1,
    zoom_range=0.1,
    brightness_range=[0.9, 1.1],
    shear_range=0.1,
    horizontal_flip=True,
    fill_mode='nearest',
    validation_split=0.2
)

#Jika dari Google Drive
	  from google.colab import drive
drive.mount('/content/drive')

train_generator = train_datagen.flow_from_directory(
    '/content/drive/MyDrive/BISINDO/',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical',
    subset='training'
)

validation_generator = train_datagen.flow_from_directory(
    '/content/drive/MyDrive/BISINDO/',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical',
    subset='validation'
)

# Simpan class indices ke JSON
class_indices = train_generator.class_indices
with open('class_indices_2.json', 'w') as f:
    json.dump(class_indices, f)
print("Class indices saved.")

# Arsitektur model menggunakan MobileNetV2
base_model = MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights='imagenet')
base_model.trainable = False  # Freeze base model

model = Sequential([
    base_model,
    GlobalAveragePooling2D(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(train_generator.num_classes, activation='softmax')
])

# Compile model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
			  
# Training model
history = model.fit(
    train_generator,
    epochs=15,
    validation_data=validation_generator
)

# Evaluasi model
test_loss, test_accuracy = model.evaluate(validation_generator)
print(f"Validation Loss: {test_loss:.4f}")
print(f"Validation Accuracy: {test_accuracy:.4f}")


# Simpan model
model.save('bisindo_mobilenetv2_model_2.h5')
print("Model saved.")

Hasil Training Model

Epoch 1/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 36s 3s/step - accuracy: 0.0462 - loss: 3.8794 - val_accuracy: 0.1731 - val_loss: 3.0495
Epoch 2/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 36s 3s/step - accuracy: 0.1107 - loss: 3.1508 - val_accuracy: 0.2500 - val_loss: 3.0064
Epoch 3/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 24s 3s/step - accuracy: 0.1586 - loss: 2.9460 - val_accuracy: 0.2692 - val_loss: 2.8244
Epoch 4/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 41s 3s/step - accuracy: 0.2089 - loss: 2.7607 - val_accuracy: 0.3654 - val_loss: 2.6005
Epoch 5/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 26s 3s/step - accuracy: 0.2382 - loss: 2.6696 - val_accuracy: 0.4808 - val_loss: 2.3553
Epoch 6/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 27s 3s/step - accuracy: 0.2731 - loss: 2.4624 - val_accuracy: 0.3462 - val_loss: 2.3943
Epoch 7/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 25s 3s/step - accuracy: 0.3214 - loss: 2.2831 - val_accuracy: 0.5000 - val_loss: 2.2100
Epoch 8/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 25s 3s/step - accuracy: 0.3992 - loss: 2.0699 - val_accuracy: 0.5769 - val_loss: 1.9240
Epoch 9/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 25s 3s/step - accuracy: 0.3943 - loss: 1.9923 - val_accuracy: 0.7115 - val_loss: 1.7838
Epoch 10/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 38s 2s/step - accuracy: 0.4908 - loss: 1.7668 - val_accuracy: 0.6923 - val_loss: 1.6811
Epoch 11/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 25s 3s/step - accuracy: 0.5984 - loss: 1.4675 - val_accuracy: 0.6923 - val_loss: 1.4733
Epoch 12/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 25s 3s/step - accuracy: 0.6243 - loss: 1.4220 - val_accuracy: 0.7692 - val_loss: 1.2904
Epoch 13/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 26s 3s/step - accuracy: 0.6594 - loss: 1.2960 - val_accuracy: 0.7308 - val_loss: 1.3024
Epoch 14/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 40s 3s/step - accuracy: 0.6596 - loss: 1.2650 - val_accuracy: 0.8462 - val_loss: 1.1609
Epoch 15/15
9/9 ━━━━━━━━━━━━━━━━━━━━ 41s 3s/step - accuracy: 0.6791 - loss: 1.1946 - val_accuracy: 0.8269 - val_loss: 1.0926

Hasil Evaluasi Model

2/2 ━━━━━━━━━━━━━━━━━━━━ 5s 1s/step - accuracy: 0.8197 - loss: 1.1229
Validation Loss: 1.1125
Validation Accuracy: 0.8077

Pengujian

Import Library

import numpy as np
from tensorflow.keras.preprocessing import image
from tensorflow.keras.models import load_model
import tensorflow as tf
import json

Load Model .h5 yang telah di simpan

# Load model dan class indices
model = tf.keras.models.load_model('bisindo_mobilenetv2_model_2.h5')
with open('class_indices_2.json', 'r') as f:
    class_indices = json.load(f)

Mapping index label yang sudah di buat dalam JSON

# Balik mapping untuk dapatkan label dari index
idx_to_class = {v: k for k, v in class_indices.items()}

Load Gambar pengujian format jpg

# Load dan preprocess gambar
img_path = 'vvvv.jpg'
img = image.load_img(img_path, target_size=(224, 224))
img_array = image.img_to_array(img) / 255.0  # Normalisasi
img_array = np.expand_dims(img_array, axis=0)  # Tambah batch dimensi

Prediksi dan Hasil Pungujian

# Prediksi
pred = model.predict(img_array)
predicted_class = idx_to_class[np.argmax(pred)]
confidence = np.max(pred)

print(f"Predicted Class: {predicted_class} (Confidence: {confidence:.2f})")

---

#HASIL PENGUJIAN DENGAN INPUTAN SEBUAH GAMBAR STATIS vvvv.jpg
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 70ms/step
Predicted Class: V (Confidence: 0.18)
						 

File Uji

Tampilan pengujian di Google Collab

huruf A huruf V Gagal Identifikasi, diharapkan Q hasilnya B Ini terjadi karena posisi object tidak terbaca dengan baik, perlu penyesuaian kembali di augmentasi agar dapat membaca segala rotasi foto / gambar dengan baik

#download file
Dataset
Model H5
Class Indices JSON

Code Model
Code Pengujian

---

Additional Info:
Tensorflow dan Internet Of Things

TensorFlow, dikenal sebagai platform machine learning populer yang dikembangkan oleh Google, lalu kini dapat diadaptasi untuk IoT melalui versinya yang ringan, TensorFlow Lite. TensorFlow Lite dirancang khusus untuk memungkinkan model machine learning berjalan langsung di perangkat kecil seperti microcontroller, smart sensor, dan embedded system, yang umumnya memiliki keterbatasan memori dan daya komputasi.

Dengan TensorFlow Lite, kita bisa melatih model cerdas di komputer besar, lalu mengubahnya menjadi format yang lebih kecil dan efisien. Setelah dikonversi, model ini dapat dijalankan di device seperti ESP32, Raspberry Pi, bahkan smartphone, tanpa bergantung pada koneksi internet atau server eksternal. Beberapa kegunaan Tensorflow pada IoT ;

• Sensor IoT dapat mengenali pola cuaca.
• Kamera kecil dapat mendeteksi wajah atau gerakan.
• Mikrofon sederhana dapat memahami perintah suara.
• Alat kesehatan wearable bisa memonitor kondisi tubuh secara real-time.

TensorFlow untuk IoT bukan hanya tentang menghubungkan perangkat, tetapi juga memberdayakan mereka untuk berpikir, memahami, dan beradaptasi dengan lingkungan sekitarnya. Dengan kombinasi machine learning dan IoT, dunia kita menuju era baru: dunia di mana benda-benda di sekitar kita menjadi semakin pintar dan mandiri.

Berikut link repository terkait Tensorflow lite disini

---

Terima kasih telah membaca artikel tentang Tensorflow