Geekly articles weekly

Ulasan keras untuk TensorFlow



Terjemahan panduan ikhtisar dari Tensorflow.org. Panduan ini akan memberi Anda dasar-dasar untuk memulai dengan Keras. Membaca membutuhkan waktu 10 menit.

Impor tf.keras


tf.keras adalah implementasi dari spesifikasi TensorFlow Keras API. Ini adalah API tingkat tinggi untuk model pengembangan dan pelatihan yang mencakup dukungan kelas satu untuk fungsionalitas spesifik TensorFlow seperti eksekusi yang cepat , jaringan pipa tf.data , dan Estimator . tf.keras mempermudah penggunaan TensorFlow tanpa mengorbankan fleksibilitas dan kinerja.

Untuk memulai, impor tf.keras sebagai bagian dari pengaturan TensorFlow Anda:

 from __future__ import absolute_import, division, print_function, unicode_literals import tensorflow as tf from tensorflow import keras

tf.keras dapat menjalankan kode Keras-kompatibel apa pun, tetapi perlu diingat:

  • Versi tf.keras dalam rilis TensorFlow terbaru mungkin berbeda dari versi keras terbaru di PyPI. Lihat tf.keras.__version__ .
  • Saat Anda menyimpan bobot model, tf.keras melakukan ini secara default dalam format pos pemeriksaan. Lewati save_format='h5' untuk menggunakan HDF5 (atau tambahkan ekstensi .h5 ke .h5 file).

Bangun model yang sederhana


Model berurutan


Di Keras, Anda mengumpulkan lapisan untuk membangun model . Model adalah grafik layer (biasanya). Jenis model yang paling umum adalah lapisan tumpukan: tf.keras.Sequential . Model yang sama.

Kami membangun jaringan yang sepenuhnya terhubung sederhana (mis., Multilayer perceptron):

 from tensorflow.keras import layers model = tf.keras.Sequential() #       64 : model.add(layers.Dense(64, activation='relu')) #   : model.add(layers.Dense(64, activation='relu')) #   softmax  10 : model.add(layers.Dense(10, activation='softmax'))

Kustomisasi layer


Banyak varietas lapisan tf.keras.layers . Sebagian besar dari mereka menggunakan konstruktor argumen umum:

  • activation : Mengatur fungsi aktivasi untuk layer. Parameter ini menentukan nama fungsi bawaan atau objek yang dipanggil. Parameter tidak memiliki nilai default.
  • kernel_initializer dan bias_initializer : Skema inisialisasi yang membuat bobot lapisan (inti dan shift). Parameter ini bisa berupa nama atau objek yang dipanggil. "Glorot uniform" default adalah "Glorot uniform" .
  • kernel_regularizer dan bias_regularizer : Skema bias_regularizer ditambahkan ke bobot layer (core dan shift), seperti regularisasi L1 atau L2. Secara default, regularisasi tidak diatur.

Contoh instance dari lapisan `tf.keras.layers.Dense` menggunakan argumen konstruktor:

 #    : layers.Dense(64, activation='sigmoid') # : layers.Dense(64, activation=tf.keras.activations.sigmoid) #     L1   0.01    : layers.Dense(64, kernel_regularizer=tf.keras.regularizers.l1(0.01)) #     L2   0.01    : layers.Dense(64, bias_regularizer=tf.keras.regularizers.l2(0.01)) #        : layers.Dense(64, kernel_initializer='orthogonal') #        2.0: layers.Dense(64, bias_initializer=tf.keras.initializers.Constant(2.0))

Pelatihan dan penilaian


Pengaturan pelatihan


Setelah model dibangun, konfigurasikan proses pembelajaran dengan memanggil metode compile :

 model = tf.keras.Sequential([ #     64   : layers.Dense(64, activation='relu', input_shape=(32,)), #  : layers.Dense(64, activation='relu'), #   softmax  10 : layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='categorical_crossentropy', metrics=['accuracy'])

tf.keras.Model.compile menerima tiga argumen penting:

  • optimizer : Objek ini mendefinisikan prosedur pelatihan. Lewati instance optimizer dari modul tf.keras.optimizers , seperti tf.keras.optimizers.Adam atau tf.keras.optimizers.SGD . Jika Anda hanya ingin menggunakan opsi default, Anda juga dapat menentukan pengoptimal dengan kata kunci seperti 'adam' atau 'sgd' .
  • loss : Ini adalah fungsi yang diminimalkan dalam proses pembelajaran. Di antara variasi umum adalah kesalahan standar ( mse ), categorical_crossentropy , binary_crossentropy . Fungsi kerugian ditentukan berdasarkan nama atau dengan melewatkan objek yang dipanggil dari modul tf.keras.losses .
  • metrics : Digunakan untuk memantau pelatihan. Ini adalah nama string atau objek yang dipanggil dari modul tf.keras.metrics .
  • Selain itu, untuk memastikan bahwa model dilatih dan dievaluasi dengan penuh semangat, periksa apakah Anda memberikan parameter run_eagerly=True ke kompiler

Selanjutnya, kita akan melihat beberapa contoh konfigurasi model untuk pelatihan:

 #       . model.compile(optimizer=tf.keras.optimizers.Adam(0.01), loss='mse', # mean squared error metrics=['mae']) # mean absolute error #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.01), loss=tf.keras.losses.CategoricalCrossentropy(), metrics=[tf.keras.metrics.CategoricalAccuracy()])

Belajar dari NumPy Data


Untuk kumpulan data yang lebih kecil, gunakan array memori NumPy untuk melatih dan mengevaluasi model. Model ini "terlatih" tentang data pelatihan menggunakan metode `fit`:

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.fit(data, labels, epochs=10, batch_size=32)

tf.keras.Model.fit mengambil tiga argumen penting:

  • epochs : Belajar dipecah menjadi * zaman *. Era adalah satu iterasi atas semua data input (ini dilakukan dalam batch kecil).
  • batch_size : Saat mentransmisikan data NumPy, model memecah data menjadi blok yang lebih kecil (batch) dan beralih ke blok ini selama pelatihan. Angka ini menunjukkan ukuran setiap blok data. Ingat bahwa blok terakhir mungkin lebih kecil jika jumlah total catatan tidak dibagi dengan ukuran kumpulan.
  • validation_data : Saat membuat prototipe model, Anda ingin melacak kinerjanya dengan mudah pada data validasi. Melewati tuple input data dan label dengan argumen ini memungkinkan model untuk menampilkan nilai-nilai dari fungsi yang hilang dan metrik dalam mode output untuk data yang dikirim pada akhir setiap era.

Berikut ini contoh menggunakan validation_data :

 import numpy as np data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) val_data = np.random.random((100, 32)) val_labels = np.random.random((100, 10)) model.fit(data, labels, epochs=10, batch_size=32, validation_data=(val_data, val_labels))

Pelatihan menggunakan dataset tf.data


Gunakan API Kumpulan Data untuk skala database besar atau pelatihan di beberapa perangkat. Lewati instance dari `tf.data.Dataset` ke metode fit :

 #    : dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.fit(dataset, epochs=10)

Karena Dataset menyediakan data dalam batch, kode ini tidak memerlukan argumen batch_size .

Kumpulan data juga dapat digunakan untuk memvalidasi:

 dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) val_dataset = tf.data.Dataset.from_tensor_slices((val_data, val_labels)) val_dataset = val_dataset.batch(32) model.fit(dataset, epochs=10, validation_data=val_dataset)

Penilaian dan prediksi


Metode tf.keras.Model.evaluate dan tf.keras.Model.predict dapat menggunakan data NumPy dan tf.data.Dataset .

Ini adalah bagaimana Anda dapat memperkirakan kerugian dalam mode keluaran dan metrik untuk data yang disediakan:

 #   Numpy data = np.random.random((1000, 32)) labels = np.random.random((1000, 10)) model.evaluate(data, labels, batch_size=32) #   dataset = tf.data.Dataset.from_tensor_slices((data, labels)) dataset = dataset.batch(32) model.evaluate(dataset)

Dan di sini adalah bagaimana memprediksi output level terakhir dalam mode output untuk data yang disediakan dalam bentuk array NumPy:

Membangun model yang kompleks


API Fungsional


Model tf.keras.Sequential adalah tumpukan lapisan sederhana yang Anda tidak dapat membayangkan model yang sewenang-wenang. Gunakan API fungsional Keras untuk membangun topologi model yang kompleks, seperti:

  • Model Input Berganda
  • Model dengan banyak keluaran,
  • Model dengan lapisan umum (lapisan yang sama disebut beberapa kali),
  • Model dengan aliran data yang tidak konsisten (mis., Hubungan residual).

Membangun model dengan API fungsional berfungsi sebagai berikut:

  1. Contoh layer dapat dipanggil dan mengembalikan tensor.
  2. Input dan output tensor digunakan untuk menentukan instance dari tf.keras.Model
  3. Model ini dilatih seperti model `Sequential`.

Contoh berikut menggunakan API fungsional untuk membangun jaringan yang sederhana dan terhubung sepenuhnya:

 inputs = tf.keras.Input(shape=(32,)) #    #        . x = layers.Dense(64, activation='relu')(inputs) x = layers.Dense(64, activation='relu')(x) predictions = layers.Dense(10, activation='softmax')(x)

Buat instance model dengan input dan output ini.

 model = tf.keras.Model(inputs=inputs, outputs=predictions) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5  model.fit(data, labels, batch_size=32, epochs=5)

Model Subklasifikasi


Buat model yang sepenuhnya dapat disesuaikan menggunakan subclassing tf.keras.Model dan tf.keras.Model distribusi langsung Anda sendiri. Buat layer dalam metode __init__ dan atur sebagai atribut dari instance kelas. Tetapkan propagasi langsung dalam metode call .

Subkelas model sangat berguna ketika eksekusi yang diinginkan diaktifkan, karena memungkinkan Anda untuk menulis distribusi langsung secara imperatif.

Catatan: jika Anda ingin model Anda selalu dieksekusi secara imperatif, Anda dapat mengatur dynamic=True ketika Anda memanggil super constructor.
Poin kunci: Gunakan API yang benar untuk bekerja. Meskipun subklas model memberikan fleksibilitas, Anda harus membayarnya dengan kompleksitas yang lebih besar dan potensi kesalahan kustom yang lebih besar. Jika memungkinkan, pilih API fungsional.
Contoh berikut menunjukkan model tf.keras.Model subclass menggunakan distribusi langsung kustom, yang tidak diharuskan imperatif:

 class MyModel(tf.keras.Model): def __init__(self, num_classes=10): super(MyModel, self).__init__(name='my_model') self.num_classes = num_classes #    . self.dense_1 = layers.Dense(32, activation='relu') self.dense_2 = layers.Dense(num_classes, activation='sigmoid') def call(self, inputs): #     , #      ( `__init__`). x = self.dense_1(inputs) return self.dense_2(x)

Buat instance dari kelas model baru:

 model = MyModel(num_classes=10) #     . model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

Lapisan khusus


Buat layer kustom dengan tf.keras.layers.Layer dan mengimplementasikan metode berikut:

  • __init__ : Secara opsional tentukan sublayers yang akan digunakan dalam lapisan ini.
  • * build : Buat layer weight. Tambahkan bobot menggunakan metode add_weight
  • call : Tentukan distribusi langsung.
  • Secara opsional, layer dapat diserialisasi dengan menerapkan metode get_config dan metode from_config .

Di bawah ini adalah contoh dari lapisan pengguna yang mengalikan matriks ( matmul ) diumpankan ke input dengan matriks kernel:

 class MyLayer(layers.Layer): def __init__(self, output_dim, **kwargs): self.output_dim = output_dim super(MyLayer, self).__init__(**kwargs) def build(self, input_shape): #       . self.kernel = self.add_weight(name='kernel', shape=(input_shape[1], self.output_dim), initializer='uniform', trainable=True) def call(self, inputs): return tf.matmul(inputs, self.kernel) def get_config(self): base_config = super(MyLayer, self).get_config() base_config['output_dim'] = self.output_dim return base_config @classmethod def from_config(cls, config): return cls(**config)

Buat model menggunakan lapisan khusus Anda:

 model = tf.keras.Sequential([ MyLayer(10), layers.Activation('softmax')]) #      model.compile(optimizer=tf.keras.optimizers.RMSprop(0.001), loss='categorical_crossentropy', metrics=['accuracy']) #   5 . model.fit(data, labels, batch_size=32, epochs=5)

Kolbeki


Kolbek adalah objek yang ditransfer ke model untuk menyesuaikan dan memperluas perilakunya selama pelatihan. Anda dapat menulis panggilan balik sendiri atau menggunakan tf.keras.callbacks yang meliputi:

tf.keras.callbacks.ModelCheckpoint : Menyimpan breakpoints model secara berkala.
tf.keras.callbacks.LearningRateScheduler : Secara dinamis mengubah langkah pembelajaran.
tf.keras.callbacks.EarlyStopping : Menghentikan pelatihan saat hasil validasi berhenti membaik.
tf.keras.callbacks.TensorBoard: Memantau Penggunaan Model Perilaku
Papan tarik

Untuk menggunakan tf.keras.callbacks.Callback , berikan kepada metode model fit :

 callbacks = [ #    `val_loss`     2  tf.keras.callbacks.EarlyStopping(patience=2, monitor='val_loss'), #   TensorBoard   `./logs` directory tf.keras.callbacks.TensorBoard(log_dir='./logs') ] model.fit(data, labels, batch_size=32, epochs=5, callbacks=callbacks, validation_data=(val_data, val_labels))

Menyimpan dan Memulihkan


Hanya menyimpan nilai bobot


Simpan dan muat bobot model menggunakan tf.keras.Model.save_weights :

 model = tf.keras.Sequential([ layers.Dense(64, activation='relu', input_shape=(32,)), layers.Dense(10, activation='softmax')]) model.compile(optimizer=tf.keras.optimizers.Adam(0.001), loss='categorical_crossentropy', metrics=['accuracy']) 

 #     TensorFlow Checkpoint model.save_weights('./weights/my_model') #    #        . model.load_weights('./weights/my_model')

Secara default, bobot model disimpan dalam format pos pemeriksaan TensorFlow. Berat juga dapat disimpan dalam format Keras HDF5 (nilai default untuk implementasi universal Keras):

 #     HDF5 model.save_weights('my_model.h5', save_format='h5') #    model.load_weights('my_model.h5')

Menyimpan hanya konfigurasi model


Konfigurasi model dapat disimpan - ini membuat serialisasi arsitektur model tanpa bobot. Konfigurasi yang disimpan dapat memulihkan dan menginisialisasi model yang sama, bahkan tanpa kode yang menentukan model aslinya. Keras mendukung format serialisasi JSON dan YAML:

 #     JSON json_string = model.to_json() json_string 

 import json import pprint pprint.pprint(json.loads(json_string))

Memulihkan model (diinisialisasi ulang) dari JSON:

 fresh_model = tf.keras.models.model_from_json(json_string)

Serializing model ke YAML memerlukan instalasi `pyyaml` sebelum mengimpor TensorFlow :

 yaml_string = model.to_yaml() print(yaml_string)

Memulihkan model dari YAML:

 fresh_model = tf.keras.models.model_from_yaml(yaml_string)

Catatan: model subclass tidak berseri, karena arsitekturnya ditentukan oleh kode Python di tubuh metode `call`.

Menyimpan seluruh model dalam satu file


Seluruh model dapat disimpan ke file yang berisi nilai bobot, konfigurasi model, dan bahkan konfigurasi pengoptimal. Ini akan memungkinkan Anda untuk mengatur breakpoint model dan melanjutkan pelatihan nanti dari posisi yang persis sama bahkan tanpa akses ke kode sumber.

 #    model = tf.keras.Sequential([ layers.Dense(10, activation='softmax', input_shape=(32,)), layers.Dense(10, activation='softmax') ]) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.fit(data, labels, batch_size=32, epochs=5) #      HDF5 model.save('my_model.h5') #         . model = tf.keras.models.load_model('my_model.h5')

Eksekusi yang bersemangat


Eksekusi yang cepat adalah lingkungan pemrograman yang sangat penting yang segera menjalankan operasi. Ini tidak diperlukan untuk Keras, tetapi didukung oleh tf.keras dan berguna untuk memeriksa program dan debugging Anda.

Semua model pembangunan API `tf.keras` kompatibel dengan eksekusi yang cepat. Meskipun `Sequential` dan API fungsional dapat digunakan, eksekusi yang cepat sangat berguna ketika mensubklasifikasikan model dan membangun lapisan khusus - API ini mengharuskan Anda untuk menulis distribusi langsung dalam bentuk kode (alih-alih API yang membuat model dengan merakit lapisan yang ada).

Distribusi


Banyak GPU


model tf.keras dapat dijalankan pada banyak GPU menggunakan tf.distribute.Strategy . API ini menyediakan pembelajaran terdistribusi di beberapa GPU dengan sedikit atau tanpa perubahan kode yang ada.

Saat ini, tf.distribute.MirroredStrategy satu tf.distribute.MirroredStrategy satunya strategi distribusi yang didukung. MirroredStrategy mereplikasi grafik dengan
pembelajaran sinkron menggunakan semua-mengurangi pada satu mesin. Untuk menggunakan ` distribute.Strategy , .scope() instalasi pengoptimal, desain, dan kompilasi model .scope() Strategy .scope() `, lalu latih model tersebut.

Contoh berikut mendistribusikan tf.keras.Model antara beberapa GPU pada mesin yang sama.

Pertama, kami mendefinisikan model dalam area strategi terdistribusi:

 strategy = tf.distribute.MirroredStrategy() with strategy.scope(): model = tf.keras.Sequential() model.add(layers.Dense(16, activation='relu', input_shape=(10,))) model.add(layers.Dense(1, activation='sigmoid')) optimizer = tf.keras.optimizers.SGD(0.2) model.compile(loss='binary_crossentropy', optimizer=optimizer) model.summary()

Kemudian kami melatih model pada data seperti biasa:

 x = np.random.random((1024, 10)) y = np.random.randint(2, size=(1024, 1)) x = tf.cast(x, tf.float32) dataset = tf.data.Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=1024).batch(32) model.fit(dataset, epochs=1)

Setelah verifikasi, terjemahan juga akan muncul di Tensorflow.org. Jika Anda ingin berpartisipasi dalam terjemahan dokumentasi situs web Tensorflow.org ke dalam bahasa Rusia, silakan hubungi secara pribadi atau komentar. Setiap koreksi atau komentar sangat dihargai.

Source: https://habr.com/ru/post/id482126/

More articles:


All Articles