GSP631

Ringkasan

TensorFlow adalah library machine learning (ML) open source yang canggih dan portabel, yang dikembangkan oleh Google dan dapat digunakan dengan set data yang sangat besar. Di lab ini, Anda akan membuat dan melatih model computer vision untuk mengenali berbagai item pakaian menggunakan TensorFlow Vertex AI Workbench.

Pengantar TensorFlow

TensorFlow menyediakan framework komputasi untuk membangun model ML. TensorFlow menyediakan berbagai toolkit yang memungkinkan Anda membuat model di tingkat abstraksi yang Anda inginkan. Di lab ini, Anda akan menggunakan tf.keras, API tingkat tinggi untuk membangun dan melatih jaringan neural guna mengklasifikasi gambar di TensorFlow.

Jaringan neural

Jaringan neural adalah model yang terinspirasi oleh otak manusia. Jaringan ini tersusun atas banyak lapisan, dengan setidaknya satu di antaranya tersembunyi, yang terdiri dari unit atau neuron sederhana yang terhubung dan diikuti oleh sejumlah nonlinearitas.

Sebuah node di jaringan neural biasanya membutuhkan beberapa nilai input dan menghasilkan satu nilai output. Neuron ini menerapkan fungsi aktivasi (transformasi nonlinear) ke sejumlah nilai input yang tertimbang untuk menghitung nilai output-nya.

Untuk mendapatkan informasi selengkapnya tentang jaringan neural, lihat Jaringan Neural: Struktur.

Tujuan

Di lab ini, Anda akan mempelajari cara:

• Mendesain, mengompilasi, melatih, dan mengevaluasi model Tensorflow
• Menyimpan dan memuat model
• Menulis callback Anda sendiri untuk menyesuaikan perilaku selama pelatihan
• Menyelesaikan serangkaian latihan untuk memandu Anda bereksperimen dengan berbagai lapisan jaringan

Penyiapan dan persyaratan

Sebelum mengklik tombol Mulai Lab

Baca petunjuk ini. Lab memiliki timer dan Anda tidak dapat menjedanya. Timer, yang dimulai saat Anda mengklik Start Lab, akan menampilkan durasi ketersediaan resource Google Cloud untuk Anda.

Lab praktik ini dapat Anda gunakan untuk melakukan sendiri aktivitas lab di lingkungan cloud sungguhan, bukan di lingkungan demo atau simulasi. Untuk mengakses lab ini, Anda akan diberi kredensial baru yang bersifat sementara dan dapat digunakan untuk login serta mengakses Google Cloud selama durasi lab.

Untuk menyelesaikan lab ini, Anda memerlukan:

• Akses ke browser internet standar (disarankan browser Chrome).

Catatan: Gunakan jendela Samaran atau browser pribadi untuk menjalankan lab ini. Hal ini akan mencegah konflik antara akun pribadi Anda dan akun Siswa yang dapat menyebabkan tagihan ekstra pada akun pribadi Anda.

• Waktu untuk menyelesaikan lab. Ingat, setelah dimulai, lab tidak dapat dijeda.

Catatan: Jika Anda sudah memiliki project atau akun pribadi Google Cloud, jangan menggunakannya untuk lab ini agar terhindar dari tagihan ekstra pada akun Anda.

Tugas 1. Membuka notebook di Vertex AI Workbench

1. Di Konsol Google Cloud, pada Navigation menu (), klik Vertex AI > Workbench.

2. Cari instance lalu klik tombol Open JupyterLab.

Antarmuka JupyterLab untuk instance Workbench Anda akan terbuka di tab browser baru.

Menginstal TensorFlow dan paket tambahan

1. Dari menu Launcher, di bagian Other, pilih Terminal.

2. Periksa apakah lingkungan Python Anda sudah dikonfigurasi. Salin dan tempel perintah berikut di terminal.

python --version

Contoh output:

Python 3.10.14

3. Jalankan perintah berikut untuk menginstal paket TensorFlow.

pip3 install tensorflow

4. Untuk mengupgrade pip3, jalankan perintah berikut di terminal.

pip3 install --upgrade pip

Pylint adalah alat yang memeriksa error dalam kode Python, serta menandai masalah sintaksis dan gaya dalam kode sumber Python Anda.

5. Jalankan perintah berikut untuk menginstal paket pylint.

pip install -U pylint --user

6. Instal paket yang diperlukan untuk lab ini dalam file requirements.txt:

pip install -r requirements.txt

Lingkungan Anda berhasil disiapkan.

Tugas 2. Membuat notebook baru dan mengimpor library

1. Klik ikon + di sebelah kiri Workbench untuk membuka Launcher baru.

2. Dari menu Launcher, di bagian Notebook, pilih Python3.

Anda akan melihat notebook Jupyter baru. Untuk mendapatkan informasi selengkapnya tentang cara menggunakan notebook Jupyter, lihat dokumentasi Notebook Jupyter.

3. Impor dan konfigurasikan logging dan google-cloud-logging untuk Cloud Logging. Pada sel pertama, tambahkan kode berikut:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging cloud_logger = logging.getLogger('cloudLogger') cloud_logger.setLevel(logging.INFO) cloud_logger.addHandler(CloudLoggingHandler(cloud_logging.Client())) cloud_logger.addHandler(logging.StreamHandler())

4. Impor tensorflow untuk melatih dan mengevaluasi model. Namai sebagai tf untuk memudahkan. Tambahkan kode berikut ke sel pertama.

# Import TensorFlow import tensorflow as tf

5. Impor numpy guna mengurai data untuk tujuan proses debug. Namai sebagai np untuk memudahkan. Tambahkan kode berikut ke sel pertama.

# Import numpy import numpy as np

6. Tambahkan kode berikut ke sel pertama untuk mengimpor tensorflow_datasets guna mengintegrasikan set data. TensorFlow Datasets adalah sekumpulan set data yang siap digunakan dengan TensorFlow.

Untuk mempelajari lebih lanjut cara menggunakannya, lihat panduan dan daftar set data. # Import tensorflow_datasets import tensorflow_datasets as tfds

7. Untuk menjalankan sel ini, klik tombol Run atau tekan Shift + Enter.

8. Simpan notebook. Klik File > Save. Namai filenya sebagai model.ipynb, lalu klik OK.

Tugas 3. Memuat dan melakukan prapemrosesan set data

Tentang set data

Anda akan melatih jaringan neural untuk mengklasifikasi gambar pakaian dari sebuah set data yang disebut Fashion MNIST.

Set data ini berisi 70.000 item pakaian dari 10 kategori berbeda. Gambar menunjukkan setiap potong pakaian dalam resolusi rendah (28x28 piksel), seperti terlihat di sini:

Di lab ini, 60.000 gambar akan digunakan untuk melatih jaringan dan 10.000 gambar akan digunakan untuk mengevaluasi seberapa akurat jaringan tersebut belajar mengklasifikasi gambar.

Data Fashion MNIST tersedia di set data tensorflow(tfds).

Memuat set data

Untuk memuat data Fashion MNIST, Anda akan menggunakan fungsi tfds.load().

1. Tambahkan kode berikut ke sel kedua di notebook:

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True)

Dalam kode di atas, tetapkan argumen split untuk menentukan bagian set data yang akan dimuat. Tetapkan as_supervised ke True untuk memastikan bahwa tf.data.Dataset yang dimuat memiliki struktur 2-tuple (input, label).

ds_train dan ds_test merupakan jenis tf.data.Dataset. ds_train memiliki 60.000 gambar yang akan digunakan untuk melatih model. ds_test memiliki 10.000 gambar yang akan digunakan untuk mengevaluasi model.

Untuk membaca lebih lanjut tfds.load() dan argumennya, lihat panduan.

Seperti apa tampilan nilai tersebut?

2. Selanjutnya, tambahkan pernyataan print untuk melihat nilai minimum dan maksimum gambar pelatihan untuk item 0. Tambahkan kode berikut ke sel kedua:

# Values before normalization image_batch, labels_batch = next(iter(ds_train)) print("Before normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Prapemrosesan Data

1. Ukuran tumpukan adalah istilah yang digunakan dalam machine learning dan mengacu pada jumlah contoh pelatihan yang digunakan dalam satu iterasi. Tetapkan nilai ini ke 32.

Tetapkan ukuran tumpukan dengan menambahkan kode berikut ke model.ipynb:

# Define batch size BATCH_SIZE = 32

2. Saat melatih jaringan neural, karena berbagai alasan, akan lebih mudah jika Anda menskalakan nilai piksel ke rentang antara 0 dan 1. Proses ini disebut 'normalisasi'. Karena nilai piksel untuk set data Fashion MNIST berada dalam rentang [0, 255], Anda harus membagi nilai piksel tersebut dengan 255,0 untuk menormalisasi gambar.

Kode yang ditampilkan di bawah menggunakan fungsi map() pada tf.data.Dataset untuk menerapkan normalisasi ke gambar di ds_train dan ds_test. Karena nilai pikselnya berjenis tf.uint8, fungsi tf.cast digunakan untuk mengonversi nilai tersebut ke tf.float32, lalu membaginya dengan 255.0. Set data ini juga dikonversi menjadi beberapa batch dengan memanggil metode batch() dengan BATCH_SIZE sebagai argumennya.

Baca lebih lanjut semua metode yang tersedia untuk tf.data.Dataset di sini.

Tambahkan kode berikut ke bagian akhir file:

# Normalize and batch process the dataset ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE)

3. Tambahkan lagi pernyataan print untuk nilai minimum dan maksimum sebuah gambar di set data pelatihan:

Tambahkan kode berikut ke bagian akhir file:

# Examine the min and max values of the batch after normalization image_batch, labels_batch = next(iter(ds_train)) print("After normalization ->", np.min(image_batch[0]), np.max(image_batch[0]))

Tugas 4. Mendesain, mengompilasi, dan melatih model

Di bagian ini, Anda akan mendesain model menggunakan TensorFlow.

1. Tambahkan kode berikut ke file:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

Lihat berbagai jenis lapisan dan parameter yang digunakan dalam arsitektur model ini:

• Sequential: Menentukan URUTAN lapisan di jaringan neural.

• Flatten: Bentuk gambar (28x28), artinya nilai berbentuk matriks persegi. Lapisan flatten mengambil matriks persegi tersebut dan mengubahnya menjadi vektor satu dimensi.

• Dense: Menambahkan lapisan neuron.

Setiap lapisan neuron memerlukan fungsi aktivasi untuk menentukan apakah neuron perlu diaktifkan atau tidak. Dari banyak opsi yang tersedia, lab ini menggunakan fungsi berikut:

• Relu secara efektif berarti jika X>0 menampilkan X, sebaliknya menampilkan 0. Fungsi ini meneruskan nilai 0 atau yang lebih besar ke lapisan berikutnya dalam jaringan.
• Softmax mengambil serangkaian nilai, dan secara efektif memilih nilai terbesar agar Anda tidak perlu mengurutkan untuk menemukan nilai yang paling besar. Misalnya, jika output lapisan terakhir adalah [0.1, 0.1, 0.05, 0.1, 9.5, 0.1, 0.05, 0.05, 0.05], softmax akan menampilkan [0,0,0,0,1,0,0,0,0].

Mengompilasi dan melatih model

Di bagian ini, pertama-tama Anda akan mengompilasi model dengan fungsi pengoptimal dan kerugian. Selanjutnya, Anda akan melatih model tersebut berdasarkan data dan label pelatihan Anda.

Tujuannya adalah agar model mencari tahu hubungan antara data pelatihan dan labelnya. Setelah pelatihan selesai, model Anda harus melihat gambar pakaian yang baru yang menyerupai data pelatihan Anda dan membuat prediksi tentang kelas yang mencakup pakaian tersebut.

Pengoptimal merupakan satu dari dua argumen yang diperlukan untuk mengompilasi model tf.keras. Optimizer (pengoptimal) adalah algoritma yang memodifikasi atribut jaringan neural, seperti bobot dan kecepatan pembelajaran. Algoritma ini membantu mengurangi kerugian dan meningkatkan akurasi.

Baca lebih lanjut berbagai jenis pengoptimal yang ada di tf.keras, di sini.

Loss (kerugian) menunjukkan performa model dengan angka. Makin baik performa model, makin kecil angka kerugian yang ditampilkan. Begitu pula sebaliknya.

Baca lebih lanjut berbagai jenis fungsi kerugian yang ada di tf.keras di sini.

Perhatikan parameter metrics=. Parameter ini memungkinkan TensorFlow melaporkan akurasi pelatihan setelah setiap epoch dengan memeriksa hasil yang diprediksi berdasarkan jawaban yang diketahui (label). Parameter ini pada dasarnya melaporkan seberapa efektif jalannya pelatihan.

Klik di sini untuk mendapatkan informasi selengkapnya tentang berbagai jenis metrik yang tersedia di `tf.keras`

Model.fit akan melatih model untuk sejumlah epoch yang sudah ditetapkan.

1. Tambahkan kode berikut ke file:

# Compile the model model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5)

Klik Check my progress untuk memverifikasi tujuan. Membuat model machine learning

Menjalankan kode

1. Jalankan sel kedua dengan mengklik tombol Run atau menekan Shift + Enter.

Saat sel notebook dijalankan, Anda akan melihat kerugian dan akurasi dilaporkan setelah setiap epoch (atau pass) pelatihan. Perhatikan bahwa dengan makin bertambahnya epoch (atau pass), akurasi meningkat:

Contoh output (nilai Anda mungkin sedikit berbeda, abaikan pesan peringatan):

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846

Untuk output # Values before normalization, terlihat bahwa nilai minimum dan maksimum berada dalam rentang [0, 255]. Setelah normalisasi, Anda dapat melihat semua nilai berada dalam rentang [0, 1].

Seiring berjalannya pelatihan, kerugian menurun dan akurasi meningkat.

Setelah model selesai dilatih, nilai akurasi akan terlihat di ujung epoch terakhir. Nilai tersebut mungkin mendekati 0.8846 seperti di atas (akurasi Anda mungkin berbeda).

Hal ini menunjukkan bahwa jaringan neural tersebut 89% akurat dalam mengklasifikasi data pelatihan. Dengan kata lain, pada 89% kesempatan, jaringan neural ini berhasil menemukan kecocokan pola antara gambar dan label. Tidak istimewa, tetapi juga tidak buruk mengingat pelatihan hanya dijalankan sebanyak lima epoch pada jaringan neural yang kecil.

Tugas 5. Mengevaluasi performa model pada data yang belum dilihat

Namun, bagaimana performa model saat dijalankan pada data yang belum dilihatnya?

Set pengujian dapat membantu menjawab pertanyaan ini. Panggil model.evaluate, teruskan kedua set pengujian, dan model akan melaporkan kerugian untuk setiap set.

Evaluasi set pengujian:

1. Tambahkan kode berikut ke sel ketiga di notebook:

cloud_logger.info(model.evaluate(ds_test))

2. Jalankan sel dengan mengklik tombol Run atau menekan Shift + Enter.

Jika men-scroll hingga ke bagian bawah output, Anda dapat melihat hasil evaluasi di baris terakhir.

Before normalization -> 0 227 After normalization -> 0.0 1.0 Epoch 1/5 1875/1875 [==============================] - 12s 6ms/step - loss: 0.5264 - sparse_categorical_accuracy: 0.8175 Epoch 2/5 1875/1875 [==============================] - 6s 3ms/step - loss: 0.3977 - sparse_categorical_accuracy: 0.8580 Epoch 3/5 1875/1875 [==============================] - 5s 3ms/step - loss: 0.3585 - sparse_categorical_accuracy: 0.8701 Epoch 4/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3329 - sparse_categorical_accuracy: 0.8784 Epoch 5/5 1875/1875 [==============================] - 5s 2ms/step - loss: 0.3151 - sparse_categorical_accuracy: 0.8846 313/313 [==============================] - 1s 4ms/step - loss: 0.3653 - sparse_categorical_accuracy: 0.8708 INFO:cloudLogger:[0.36530008912086487, 0.8708000183105469]

Model ini melaporkan akurasi .8708 pada set pengujian (ds_test) yang berarti akurasinya sekitar 87%. (Nilai Anda mungkin sedikit berbeda).

Sesuai dugaan, saat dijalankan pada data yang belum diketahui, model tersebut kurang akurat dibandingkan ketika dijalankan pada data yang telah digunakan untuk melatihnya.

Sembari menggunakan TensorFlow lebih lanjut, Anda akan mempelajari cara meningkatkan akurasi ini.

Klik Check my progress untuk memverifikasi tujuan. Menggunakan model

Tugas 6. Menyimpan dan memuat model

Progres model dapat disimpan selama dan setelah pelatihan. Artinya, model dapat melanjutkan dari posisi terakhir saat pelatihan dihentikan sehingga Anda dapat menghindari waktu pelatihan yang lama. Dengan menyimpan model, Anda dapat membagikannya dan orang lain dapat mencipta ulang hasil kerja Anda. Untuk latihan pertama ini, Anda akan menambahkan kode yang diperlukan untuk menyimpan dan memuat model.

Keseluruhan model dapat disimpan dalam dua format file berbeda, yaitu SavedModel dan Keras. Format TensorFlow SavedModel merupakan format file default di TF2.x. Namun, model dapat disimpan dalam format Keras. Anda akan mempelajari lebih lanjut cara menyimpan model dalam kedua format file ini.

1. Tambahkan kode berikut ke sel keempat di notebook:

# Save the entire model as a Keras model using .keras format model.save('saved_model.keras') # Load the model using custom_objects to handle the custom activation function new_model = tf.keras.models.load_model('saved_model.keras', custom_objects={'softmax_v2': tf.keras.activations.softmax}) # Summary of loaded SavedModel new_model.summary() # Save the entire model to a keras file. model.save('my_model.keras') # Recreate the exact same model, including its weights and the optimizer new_model_keras = tf.keras.models.load_model('my_model.keras', custom_objects={'softmax_v2': tf.keras.activations.softmax}) # Summary of loaded keras model new_model_keras.summary()

Kode di atas menunjukkan cara menyimpan model dalam dua format berbeda dan memuat kembali model yang tersimpan. Anda dapat memilih format apa pun sesuai dengan kasus penggunaan Anda. Baca lebih lanjut fungsionalitas ini di Dokumentasi TensorFlow untuk "Menyimpan dan memuat model".

2. Jalankan sel dengan mengklik tombol Run atau menekan Shift + Enter.

Di bagian akhir output, Anda akan melihat dua set ringkasan model. Set pertama menunjukkan ringkasan setelah model disimpan dalam format SavedModel. Set kedua menunjukkan ringkasan setelah model disimpan dalam format h5.

Anda dapat melihat bahwa kedua ringkasan model tersebut identik karena kita pada dasarnya menyimpan model yang sama dalam dua format berbeda.

Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________ Model: "sequential" _________________________________________________________________ Layer (type) Output Shape Param # ================================================================= flatten (Flatten) (None, 784) 0 dense (Dense) (None, 64) 50240 dense_1 (Dense) (None, 10) 650 ================================================================= Total params: 50,890 Trainable params: 50,890 Non-trainable params: 0 _________________________________________________________________

Klik Check my progress untuk memverifikasi tujuan. Menyimpan dan Memuat Model

Tugas 7. Mempelajari callback

Sebelumnya, saat melatih model, Anda telah melihat bahwa, seiring berlangsungnya pelatihan, kerugian model berkurang dan akurasinya meningkat. Setelah mencapai akurasi dan kerugian pelatihan yang diinginkan, Anda mungkin masih perlu menunggu sebentar lagi hingga pelatihan selesai.

Anda mungkin berpikir, "Bukankah lebih baik jika pelatihan dapat dihentikan saat model mencapai nilai akurasi yang diinginkan?"

Misalnya, jika akurasi 95% dirasa cukup, dan model dapat mencapainya setelah 3 epoch pelatihan, mengapa harus menunggu hingga selesainya beberapa epoch lagi?

Jawabannya adalah: Callback!

Callback adalah alat yang efektif untuk menyesuaikan perilaku model Keras selama pelatihan, evaluasi, atau inferensi. Anda dapat menetapkan callback untuk menghentikan pelatihan segera setelah model mencapai akurasi yang diinginkan pada set pelatihan.

Coba kode berikut untuk melihat apa yang terjadi jika Anda menetapkan callback untuk menghentikan pelatihan saat akurasi mencapai 84%:

1. Buka Launcher, lalu pilih Python3 untuk membuat notebook Jupyter baru.

2. Simpan file itu sebagai callback_model.ipynb.

3. Tempel kode berikut ke sel pertama callback_model.ipynb:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging exp_logger = logging.getLogger('expLogger') exp_logger.setLevel(logging.INFO) exp_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="callback")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define Callback class myCallback(tf.keras.callbacks.Callback): def on_epoch_end(self, epoch, logs={}): if(logs.get('sparse_categorical_accuracy')>0.84): exp_logger.info("\nReached 84% accuracy so cancelling training!") self.model.stop_training = True callbacks = myCallback() # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5, callbacks=[callbacks])

4. Tekan Ctrl + S atau buka File > Save Notebook untuk menyimpan perubahan.

5. Jalankan kode dengan mengklik tombol Run atau menekan Shift + Enter.

Lihat bahwa pelatihan dibatalkan setelah beberapa epoch.

Klik Check my progress untuk memverifikasi tujuan. Mempelajari Callback

Tugas 8. Bereksperimen dengan model

Di bagian ini, Anda akan bereksperimen dengan berbagai lapisan jaringan.

Latihan 1

Dalam Latihan ini, Anda akan mempelajari lapisan yang ada di model Anda. Apa yang terjadi saat Anda mengubah jumlah neuron?

1. Buka Launcher, lalu pilih Python3 untuk membuat notebook Jupyter baru.

2. Simpan file itu sebagai updated_model.ipynb.

3. Tempel kode berikut ke sel pertama updated_model.ipynb:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) ds_test = ds_test.map(lambda x, y: (tf.cast(x, tf.float32)/255.0, y)).batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info)

4. Lakukan eksperimen dengan berbagai nilai untuk lapisan padat.

Buka bagian # Define the model, lalu ubah 64 menjadi 128 neuron:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(128, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

4. Tekan Ctrl + S atau buka File > Save Notebook untuk menyimpan perubahan.

5. Jalankan kode dengan mengklik tombol Run atau menekan Shift + Enter.

Apa saja hasil yang Anda peroleh untuk kerugian, waktu pelatihan, dll.? Kira-kira apa penyebabnya?

Saat jumlah neuron ditingkatkan menjadi 128, Anda harus melakukan lebih banyak penghitungan. Hal ini akan memperlambat proses pelatihan. Dalam kasus ini, peningkatan tersebut berdampak positif karena model menjadi lebih akurat. Namun, tidak selalu 'makin banyak, makin baik'. Anda dapat mencapai titik penurunan hasil dengan sangat cepat.

Klik Check my progress untuk memverifikasi tujuan. Latihan 1

Latihan 2

Pertimbangkan efek lapisan tambahan dalam jaringan. Apa yang akan terjadi jika Anda menambahkan lapisan tambahan antara kedua lapisan padat itu?

1. Di updated_model.ipynb, tambahkan lapisan di bagian # Define the model.

Ganti definisi model Anda dengan kode berikut:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Tekan Ctrl + S atau buka File > Save Notebook untuk menyimpan perubahan.

3. Jalankan kode dengan mengklik tombol Run atau menekan Shift + Enter.

Jawaban: Tidak ada dampak yang signifikan -- karena data ini relatif sederhana. Untuk data yang jauh lebih kompleks, lapisan tambahan kerap diperlukan.

Klik Check my progress untuk memverifikasi tujuan. Latihan 2

Latihan 3

Sebelum melatih model, Anda telah menormalisasi nilai piksel ke rentang [0, 1]. Apa dampak dari menghapus normalisasi sehingga nilai tersebut berada dalam rentang [0, 255] seperti aslinya dalam set data?

1. Cobalah! Di # Define, load and configure data, hapus fungsi map baik yang diterapkan ke set data pelatihan maupun pengujian.

# Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Tambahkan kode ini di bagian akhir sel untuk mencetak nilai maksimum gambar pertama di batch 0. Tanpa normalisasi, nilai maksimum akan berada dalam rentang [0, 255].

# Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

3. Model updated_model.ipynb akhir Anda akan terlihat seperti ini:

# Import and configure logging import logging import google.cloud.logging as cloud_logging from google.cloud.logging.handlers import CloudLoggingHandler from google.cloud.logging_v2.handlers import setup_logging up_logger = logging.getLogger('upLogger') up_logger.setLevel(logging.INFO) up_logger.addHandler(CloudLoggingHandler(cloud_logging.Client(), name="updated")) # Import tensorflow_datasets import tensorflow_datasets as tfds # Import numpy import numpy as np # Import TensorFlow import tensorflow as tf # Define, load and configure data (ds_train, ds_test), info = tfds.load('fashion_mnist', split=['train', 'test'], with_info=True, as_supervised=True) # Define batch size BATCH_SIZE = 32 # Normalizing and batch processing of data ds_train = ds_train.batch(BATCH_SIZE) ds_test = ds_test.batch(BATCH_SIZE) # Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)]) # Compile data model.compile(optimizer = tf.keras.optimizers.Adam(), loss = tf.keras.losses.SparseCategoricalCrossentropy(), metrics=[tf.keras.metrics.SparseCategoricalAccuracy()]) model.fit(ds_train, epochs=5) # Logs model summary model.summary(print_fn=up_logger.info) # Print out max value to see the changes image_batch, labels_batch = next(iter(ds_train)) t_image_batch, t_labels_batch = next(iter(ds_test)) up_logger.info("training images max " + str(np.max(image_batch[0]))) up_logger.info("test images max " + str(np.max(t_image_batch[0])))

4. Tekan Ctrl + S atau buka File > Save Notebook untuk menyimpan perubahan.

5. Jalankan kode dengan mengklik tombol Run atau menekan Shift + Enter.

Output yang diharapkan untuk # Print out max value to see the changes

INFO:upLogger:training images max 255 INFO:upLogger:test images max 255

Setelah menyelesaikan sejumlah epoch, Anda dapat melihat perbedaan akurasi tanpa normalisasi.

Kira-kira apa penyebab perubahan akurasi tersebut?

Temukan jawabannya di sini di Stack Overflow.

Klik Check my progress untuk memverifikasi tujuan. Latihan 3

Latihan 4

Apa yang terjadi jika Anda menghapus lapisan Flatten(), dan mengapa?

Silakan mencobanya:

1. Di bagian # Define the model, hapus tf.keras.layers.Flatten():

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Simpan dan jalankan sel di updated_model.ipynb.

Anda mendapatkan error terkait bentuk data tersebut. Hal ini sudah diperkirakan.

Detail error tersebut mungkin tidak tampak jelas untuk saat ini, tetapi hal itu memperkuat prinsip utama bahwa lapisan pertama dalam jaringan Anda harus memiliki bentuk yang sama dengan data Anda. Saat ini, gambar input memiliki bentuk 28x28, dan 28 lapisan dari 28 neuron tidaklah memungkinkan. Oleh karena itu, akan lebih masuk akal untuk meratakan 28x28 itu menjadi 784x1.

Alih-alih menulis semua kode untuk menangani hal itu sendiri, Anda dapat menambahkan lapisan Flatten() di awal. Ketika dimuat ke dalam model, array tersebut akan otomatis diratakan untuk Anda.

Latihan 5

Perhatikan lapisan (output) terakhir. Mengapa ada 10 neuron di lapisan terakhir? Apa yang terjadi jika jumlah neuron tidak 10?

Cari tahu dengan melatih jaringan menggunakan 5 neuron.

1. Ganti bagian # Define the model dengan kode berikut untuk mengurungkan perubahan yang Anda buat di bagian sebelumnya:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(10, activation=tf.nn.softmax)])

2. Ubah jumlah neuron di lapisan terakhir dari 10 menjadi 5:

# Define the model model = tf.keras.models.Sequential([tf.keras.layers.Flatten(), tf.keras.layers.Dense(64, activation=tf.nn.relu), tf.keras.layers.Dense(5, activation=tf.nn.softmax)])

3. Simpan dan jalankan sel di updated_model.ipynb.

Apa yang terjadi: Anda mendapatkan error begitu model menemukan nilai yang tidak diharapkan.

Prinsip utama lainnya -- jumlah neuron di lapisan terakhir harus sama dengan jumlah kelas yang Anda klasifikasi. Dalam kasus ini, jumlah tersebut adalah digit 0-9, jadi ada 10 kelas. Oleh karena itu, lapisan terakhir Anda juga harus memiliki 10 neuron.

Selamat!

Selamat! Di lab ini, Anda telah mempelajari cara mendesain, mengompilasi, melatih, dan mengevaluasi model Tensorflow. Anda juga telah mempelajari cara menyimpan dan memuat model serta menulis callback Anda sendiri untuk menyesuaikan perilaku selama pelatihan. Anda juga telah menyelesaikan serangkaian latihan untuk memandu Anda bereksperimen dengan berbagai lapisan di jaringan.

Langkah berikutnya/pelajari lebih lanjut

• Lihat semua hal yang perlu diketahui di Kursus Singkat Machine Learning.
• Lakukan eksperimen di halaman Cobalah! untuk mendapatkan gambaran apa saja yang dapat Anda lakukan dengan computer vision.
• Lihat dokumentasi Vertex AI untuk mempelajari machine learning sebagai bagian dari Vertex AI.
• Hal-hal menarik terkait AI. Lihat Bereksperimen dengan Google.
• Pelajari lebih lanjut TensorFlow.

Sertifikasi dan pelatihan Google Cloud

...membantu Anda mengoptimalkan teknologi Google Cloud. Kelas kami mencakup keterampilan teknis dan praktik terbaik untuk membantu Anda memahami dengan cepat dan melanjutkan proses pembelajaran. Kami menawarkan pelatihan tingkat dasar hingga lanjutan dengan opsi on demand, live, dan virtual untuk menyesuaikan dengan jadwal Anda yang sibuk. Sertifikasi membantu Anda memvalidasi dan membuktikan keterampilan serta keahlian Anda dalam teknologi Google Cloud.

Manual Terakhir Diperbarui 12 September 2024

Lab Terakhir Diuji 12 September 2024

Hak cipta 2025 Google LLC Semua hak dilindungi undang-undang. Google dan logo Google adalah merek dagang dari Google LLC. Semua nama perusahaan dan produk lain mungkin adalah merek dagang masing-masing perusahaan yang bersangkutan.