Lấy kỷ nguyên trong python

Hello tuần mới anh em Mì AI. Hôm nay chúng ta cùng nhau đi tìm hiểu Keras Callbacks – trợ thủ đắc lực khi train model nhé

Trước khi bắt đầu mình cũng xin nói trước là đây là series dành cho các bạn newbie bất đầu thôi. Còn với các bạn làm lâu rồi thì có lẽ khái niệm này đã khá quen thuộc rồi nên các bạn góp ý thêm cho mình nhé

Rồi bây giờ continue nha

Phần 1 – Keras Callback là cái chi?

Nhiều khi train model bị overfit, model kém chất lượng mà chúng ta không biết chính xác khi nào cần train, khi nào nên save lại weights… Đó là lúc chúng ta cần đến callback function. Tìm hiểu nhé

Theo như tài liệu chính chủ của Keras thì

A callback is a set of functions to be applied at given stages of the training procedure. You can use callbacks to get a view on internal states and statistics of the model during training.

Như vậy giải nghĩa ra thì Callback là một số hàm (hàm), chúng ta sẽ chạy các hàm này ở bước định trước nhất của quá trình đào tạo để xem, lưu lại các trạng thái và thông số của mô hình trong quá trình đào tạo

Chắc chắn sự bùng nổ phải không các bạn? . Các bạn sử dụng các cuộc gọi lại để có thể đưa vào quá trình đào tạo của các mô hình, ví dụ

• Dừng quá trình huấn luyện khi mô hình đạt được kết quả chính xác/mất mát nhất định, được gọi là Dừng sớm (Dừng sớm)
• Lưu lại trọng lượng (hoặc kiểu) của mô hình tại một thời điểm nào đó (gọi là điểm kiểm tra) khi bạn chọn đó là một bộ trọng lượng tốt
• Điều chỉnh tốc độ học (LR) của mô hình theo số kỷ nguyên đã đào tạo. Ví dụ lúc đầu có thể để LR cao, sau đó giảm dần…

Còn nhiều hàm gọi lại nữa, nhưng mình chỉ đi 03 hàm thông tin ứng dụng bên trên, các bạn có thể tự tìm hiểu thêm ở tài liệu gốc của Keras nhé.

Phần 2 – Tìm hiểu Early Stop Callback

Nói một cách rút gọn là Early Stop Callback dùng để dừng quá trình đào tạo sớm, sau khi thông số chúng ta quan sát được (có thể là độ chính xác xác thực hoặc mất giá trị xác thực) không “kháng lên” sau một vài kỷ nguyên

Đây cũng là một kỹ thuật hay được sử dụng để tránh Overfit (OF). Không phải cứ train nhiều epoch là tốt, chúng ta train nhiều quá mà không thấy val_loss giảm nữa hay val_acc tăng nữa mà vẫn tiếp tục train thì sẽ dẫn đến khả năng OF

Bạn nào chưa biết OF là gì thì có thể google thêm. Đại khái là khi mô hình đó khớp quá dữ liệu train, tạo acc train và mất train rất tốt nhưng kết quả xác thực thì ngược lại, ngày càng nhiều (và tệ cũng không “khá lên”)

Đó là khi chúng ta nên áp dụng Early Stop Callback

tf.keras.callbacks.EarlyStopping( monitor="val_loss", min_delta=0, mode="auto", restore_best_weights=False, )

Giải thích các tham số của EarlyStopping

• màn hình. Chúng ta sẽ quan sát tham số gì? . mất mát, val_accuracy,…
• min_delta. mức thay đổi tối thiểu để tham số quan sát ở trên được xem đã là “kháng lên”. Nếu để min_delta=0 thì chỉ cần thay đổi tích cực dù nhỏ nhất còn được gọi là “kháng lên” rồi. Còn nếu để min_delta=0. 5 không có giới hạn thì tham số phải thay đổi tích cực một lượng 0. 5 thì mới được coi là có “khá lên”. This number default is 0 nhé
• nhẫn nại (default = 0). wire is integer (gọi là N). Model will stop train if the number of quan sát không “kháng lên” sau N epochs
• chế độ. is the view mode. Nếu để là “min” thì tham số quan sát càng giảm “khá” (ví dụ mất mát), nếu để là “max” thì tham số quan sát càng tăng “khá” (ví dụ độ chính xác). Nếu để “auto” là ngon lành nhất, chế độ sẽ tự động chuyển thành min hoặc max tùy theo tham số của chúng ta là loss hay precision
• restore_best_weights. Tham số này quy định lỗi mô hình có khôi phục lại trọng lượng tốt nhất khi dừng lại hay không? . ”. Lúc này nếu ta để restore_best_weights=True thì mô hình sẽ khôi phục lại trọng số ở epoch 50 xong mới dừng, còn ngược lại thì nó sẽ giữ nguyên trọng số ở bước 53

Ví dụ chúng ta đào tạo người mẫu và muốn rằng sau 5 epoch mà giảm không giảm nữa thì dừng lại và lấy tạ tốt nhất để lưu ra file người mẫu. Ta sẽ ghi nguồn như sau

import tensorflow as tf import numpy as np # Thiết lập hàm call back Early Stopping callback = tf.keras.callbacks.EarlyStopping(monitor='loss', patience=5, restore_best_weights=True) # Tạo lập model model = tf.keras.models.Sequential([tf.keras.layers.Dense(512)]) model.compile(tf.keras.optimizers.SGD(), loss='mse') # Sinh dữ liệu fake để train thử X = np.arange(100).reshape(5, 20).astype(float) y = np.zeros(5) # Train model 10 epochs, batch_sizes = 1 history = model.fit( X, y , epochs=10, batch_size=1, callbacks=[callback]) # In history ra xem train mấy epochs print("Số epoch đã train = ", len(history.history['loss']))

And we are results

5/5 [==============================] - 0s 37ms/sample - loss: 543.4534 Epoch 2/10 5/5 [==============================] - 0s 766us/sample - loss: 52498.2139 Epoch 3/10 5/5 [==============================] - 0s 982us/sample - loss: 1131009.8172 Epoch 4/10 5/5 [==============================] - 0s 934us/sample - loss: 1418184.8703 Epoch 5/10 5/5 [==============================] - 0s 697us/sample - loss: 129574012.1000 Epoch 6/10 5/5 [==============================] - 0s 3ms/sample - loss: 179616147.2000 Số epoch đã train = 6

Chỉ có 06 epoch được đào tạo và mô hình đã dừng lại do mất mát không giảm nữa. Thực ra bài này loss tăng vê lờ luôn anh em. Thử nghiệm để anh em hiểu như nào là Early Stop thôi mà

Anh em có thể tham khảo rõ hơn qua đồ thị sau

Phần 3 – Checkpoint Keras Callbacks

With checkpoint callbacks thì khá đơn giản, nó chỉ đơn giản là làm nhiệm vụ lưu lại bộ trọng số tốt nhất cho chúng ta. Chúng ta quan tâm thứ 02 ở đây

• Thứ nhất, hư nào là tạ tốt? . Mất mát thì càng thấp càng tốt, độ chính xác thì càng cao càng tốt
• Thứ hai, checkpoint callback sẽ được gọi thực thi khi nào? . Khi một kỷ nguyên kết thúc, nó sẽ kiểm tra xem bộ trọng lượng hiện tại có được gọi là “tốt nhất” không?

Nào, cùng xem cái hàm Checkpoint mặt mũi nó ra sao nào

tf.keras.callbacks.ModelCheckpoint( filepath, monitor="val_loss", verbose=0, save_best_only=False, save_weights_only=False, mode="auto", save_freq="epoch" )

Tham số của các cuộc gọi lại máy ảnh này như sau

• đường dẫn tập tin. Đường dẫn lưu file weights/model
• màn hình. tham số quan sát, tương tự như ở trên Early Stop
• save_best_only. Nếu đúng thì mô hình chỉ lưu lại một điểm kiểm tra tốt nhất và ngược lại. This we should be true
• save_weights_only. If to is True, callback will only save back weights, not save back architecture model, but reverse back then will save all the architecture model in filepath. Các bạn tùy ý sử dụng nhé
• chế độ. Tương tự như ở EarlyStop, các bạn kéo lên xem nha
• save_freq. Nếu nói là “kỷ nguyên” thì mô hình sẽ kiểm tra tham số quan sát sau mỗi kỷ nguyên để từ đó đánh giá xem trọng số hiện tại có “tốt nhất” (để lưu lại) hay không?

Ví dụ một chút cho dễ hiểu nhé. Bây giờ chúng ta có bài toán dự đoán xem một người có bị tiểu đường hay không dựa vào các tham số đo lường được của người đó. Mình dùng dữ liệu từ Kaggle (https. //www. kaggle. com/uciml/pima-indians-diabetes-database) nhé

from keras.models import Sequential from keras.layers import Dense from keras.callbacks import ModelCheckpoint import numpy as np # Load dữ liệu dataset = np.loadtxt("pima-indians-diabetes.data.txt", delimiter=",") # Chia ra input X và output y X = dataset[:,0:8] Y = dataset[:,8] # Tạo model model = Sequential() model.add(Dense(32, input_dim=8, activation='relu')) model.add(Dense(16, activation='relu')) model.add(Dense(1, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # Tạo callback filepath="checkpoint.hdf5" callback = ModelCheckpoint(filepath, monitor='val_accuracy', verbose=1, save_best_only=True, mode='auto') # Train model model.fit(X, Y, validation_split=0.2, epochs=100, batch_size=8, callbacks=[callback])

Và sau khi train 100 epochs thì chúng ta sẽ thấy xuất hiện một file checkpoint. hdf5 in the current directory. Đó chính là tập tin lưu lại trọng lượng tốt nhất của chúng ta. Và nếu quan sát đăng nhập ra, các bạn sẽ thấy

Epoch 00096: val_accuracy did not improve from 0.74675 Epoch 97/100 614/614 [==============================] - 0s 112us/step - loss: 0.4925 - accuracy: 0.7655 - val_loss: 0.6825 - val_accuracy: 0.6948 Epoch 00097: val_accuracy did not improve from 0.74675 Epoch 98/100 614/614 [==============================] - 0s 107us/step - loss: 0.5555 - accuracy: 0.7508 - val_loss: 0.8247 - val_accuracy: 0.6558 Epoch 00098: val_accuracy did not improve from 0.74675 Epoch 99/100 614/614 [==============================] - 0s 112us/step - loss: 0.5101 - accuracy: 0.7573 - val_loss: 0.7197 - val_accuracy: 0.6948 Epoch 00099: val_accuracy did not improve from 0.74675 Epoch 100/100 614/614 [==============================] - 0s 110us/step - loss: 0.4815 - accuracy: 0.7687 - val_loss: 0.6195 - val_accuracy: 0.7273 Epoch 00100: val_accuracy did not improve from 0.74675

Như vậy val_accuracy tốt nhất là 0. 74675 and has been archive back. Chúng ta cũng có thể bổ sung các thông số như. epoch, loss value, precision in name file check point nhé. Ví dụ

filepath="checkpoint-{epoch}-{val_accuracy}.hdf5"

Rồi, như vậy có thể luyện 100 hay 1000 kỷ nguyên đi chăng nữa thì tạ tốt nhất luôn được lưu lại cho chúng ta. Yên tâm nhé

Phần 4 – Callback máy ảnh của LearningRateScheduler

Callbacks cái món này thì đơn giản lắm luôn, nó chỉ có nhiệm vụ điều chỉnh Learning Rate (LR) cho quá trình đào tạo. Bạn nào chưa biết LR là gì thì đọc ở đây nhé

Cấu trúc của món này khá đơn giản

Trong đó lịch biểu là tên hàm sẽ trả về LR

Ví dụ chính chủ của Keras luôn

import tensorflow as tf import numpy as np tf.enable_eager_execution() # Định nghĩa hàm trả về LR def scheduler(epoch, lr): # Nếu dưới 5 epoch if epoch < 5: # Trả về lr return float(lr) else: # Còn không thì trả về return float(lr * tf.math.exp(-0.1)) # Định nghĩa model model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)]) model.compile(tf.keras.optimizers.SGD(), loss='mse') print("Learning rate ban đầu = ", round(model.optimizer.lr.numpy(), 5)) # Train model và xem learning rate callback = tf.keras.callbacks.LearningRateScheduler(scheduler) X = np.arange(100).reshape(5, 20).astype(float) y = np.zeros(5) history = model.fit( X, y , epochs=8, callbacks=[callback], verbose=1) print("Learning rate sau khi train xong 8 epochs = ", round(model.optimizer.lr.numpy(), 5))

And results here

tf.keras.callbacks.EarlyStopping( monitor="val_loss", min_delta=0, mode="auto", restore_best_weights=False, )

Do đó, chúng ta đã biết sự thay đổi của LR qua quá trình đào tạo. Ý đối ở đây là lúc đầu tàu mới thì ta cần LR lớn để nhanh chóng tìm đến điểm cực tiểu, nhưng khi đã gần điểm cực tiểu rồi thì ta cần giảm LR để nhanh chóng dừng lại tránh “đi quá” điểm cực tiểu cần

Vậy là mình đã cùng các bạn đi qua vài chức năng gọi lại máy ảnh thông dụng trong mô hình tàu hỏa. Các bạn hãy ứng dụng vào thực tế để rèn luyện người mẫu tốt hơn và nhanh hơn nhé