Keras là một API cấp cao, thường được sử dụng với thư viện Tensorflow và đã hạ thấp rào cản gia nhập đối với nhiều người cũng như dân chủ hóa việc tạo ra các mô hình và hệ thống Deep Learning
Khi mới bắt đầu, một API cấp cao trừu tượng hóa hầu hết các hoạt động bên trong sẽ giúp mọi người hiểu rõ về những điều cơ bản và xây dựng trực giác bắt đầu. Tuy nhiên, cuối cùng, các học viên tự nhiên muốn xây dựng một trực giác mạnh mẽ hơn về những gì xảy ra bên dưới mui xe để có được cái nhìn sâu sắc có thể hành động và hiểu sâu hơn về cách mô hình của họ học hỏi
Trong nhiều trường hợp, sẽ rất hữu ích khi xem xét quá trình học tập của Mạng lưới thần kinh sâu, kiểm tra cách nó dự đoán các giá trị trên mỗi giai đoạn học tập và lưu các giá trị
Các giá trị đã lưu này có thể được sử dụng để trực quan hóa các dự đoán, sử dụng các thư viện như Matplotlib hoặc Seaborn hoặc có thể được lưu trong nhật ký để phân tích thêm trong các hệ thống thông minh hoặc được phân tích đơn giản bởi con người. Chúng tôi thường trích xuất các đường cong học tập của một mô hình để hiểu rõ hơn về cách thức hoạt động của mô hình theo thời gian - nhưng các đường cong học tập phản ánh tổn thất trung bình theo thời gian và bạn không thể biết mô hình hoạt động như thế nào cho đến khi hoàn thành quá trình đào tạo
Keras có một tính năng tuyệt vời - gọi lại là các đoạn mã được gọi trong quá trình đào tạo và có thể được sử dụng để tùy chỉnh quy trình đào tạo. Thông thường, bạn sử dụng các lệnh gọi lại để lưu mô hình nếu nó hoạt động tốt, dừng đào tạo nếu nó quá phù hợp hoặc phản ứng hoặc ảnh hưởng đến các bước trong quy trình học tập.
Điều này làm cho lệnh gọi lại trở thành lựa chọn tự nhiên để chạy dự đoán trên từng đợt hoặc kỷ nguyên cũng như lưu kết quả và trong hướng dẫn này - chúng ta sẽ xem xét cách chạy dự đoán trên tập kiểm tra, trực quan hóa kết quả và lưu chúng dưới dạng
Ghi chú. Chúng ta sẽ xây dựng một mô hình Deep Learning đơn giản bằng cách sử dụng Keras trong các phần tiếp theo, nhưng sẽ không tập trung nhiều vào việc triển khai hoặc tập dữ liệu. Đây không phải là một hướng dẫn để xây dựng các mô hình hồi quy, nhưng một mô hình là cần thiết để thể hiện chính xác cách thức hoạt động của hàm gọi lại
Nếu bạn muốn đọc thêm về cách xây dựng các mô hình này và cách làm cho chúng có độ chính xác cao thay vì chỉ chính xác - hãy đọc Dự đoán giá nhà thực hành rộng rãi và chi tiết của chúng tôi - Học máy với Python
Xây dựng và đánh giá mô hình học sâu với Keras
Hãy xây dựng một mô hình Keras đơn giản cho mục đích minh họa. Chúng ta sẽ lướt qua phần này với sự tập trung và chú ý tối thiểu - đây không phải là hướng dẫn xây dựng mô hình hồi quy. Chúng ta sẽ làm việc với Bộ dữ liệu Nhà ở California, có được thông qua mô-đun
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Hãy tiếp tục và nhập các thư viện và phương thức tĩnh mà chúng ta sẽ sử dụng
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
Bây giờ, hãy tải tập dữ liệu vào, chia nó thành tập huấn luyện và kiểm tra [chúng ta sẽ chia tập xác thực sau] và trực quan hóa vị trí của các ngôi nhà để kiểm tra xem dữ liệu đã được tải chính xác chưa
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Hình như California. Vì dữ liệu được tải chính xác, chúng tôi có thể xác định mô hình Keras tuần tự đơn giản
checkpoint = keras.callbacks.ModelCheckpoint["california.h5", save_best_only=True]
model = keras.Sequential[[
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2", input_shape=[x_train.shape[1]]],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2"],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[1]
]]
model.compile[loss='mae',
optimizer=keras.optimizers.RMSprop[learning_rate=1e-2, decay=0.1],
metrics=['mae']]
history = model.fit[
x_train, y_train,
epochs=150,
batch_size=64,
validation_split=0.2,
callbacks=[checkpoint]
]
Ở đây, chúng ta có một MLP đơn giản, với một chút Dropout và Chuẩn hóa hàng loạt để chống lại việc trang bị quá mức, được tối ưu hóa bằng trình tối ưu hóa RMSprop và giảm Lỗi tuyệt đối trung bình. Chúng tôi đã trang bị mô hình cho 150 kỷ nguyên, với phân chia xác thực là
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
...
Epoch 150/150
387/387 [==============================] - 3s 7ms/step - loss: 0.6279 - mae: 0.5976 - val_loss: 0.6346 - val_mae: 0.6042
Chúng tôi có thể hình dung các đường cong học tập để có được một số hiểu biết cơ bản về quá trình đào tạo diễn ra như thế nào, nhưng nó không cho chúng tôi biết toàn bộ câu chuyện - đây chỉ là những phương tiện tổng hợp đối với các bộ đào tạo và xác nhận trong quá trình đào tạo
model_history = pd.DataFrame[history.history]
model_history['epoch'] = history.epoch
fig, ax = plt.subplots[1, figsize=[8,6]]
num_epochs = model_history.shape[0]
ax.plot[np.arange[0, num_epochs], model_history["mae"],
label="Training MAE"]
ax.plot[np.arange[0, num_epochs], model_history["val_mae"],
label="Validation MAE"]
ax.legend[]
plt.tight_layout[]
plt.show[]
Kết quả này trong
Và chúng ta có thể đánh giá mô hình của mình với
model.evaluate[x_test, y_test]
162/162 [==============================] - 0s 2ms/step - loss: 0.5695 - mae: 0.5451 - mape: 32.2959
Vì biến mục tiêu được đo bằng bội số của $100. 000, có nghĩa là mạng của chúng tôi bỏ lỡ giá lên tới khoảng 54 đô la. 000, là Sai số phần trăm tuyệt đối trung bình ~32%. Hầu hết các phương pháp Học máy truyền thống như Hồi quy rừng ngẫu nhiên, ngay cả sau khi tiền xử lý dữ liệu mở rộng hơn cho tập dữ liệu này đạt được khoảng 52 đô la. 000, với các siêu tham số được điều chỉnh - vì vậy đây thực sự là một kết quả khá tốt, mặc dù vậy, nó có thể được cải thiện với nhiều tiền xử lý hơn, điều chỉnh tốt hơn và các kiến trúc khác nhau
Vấn đề ở đây không phải là xây dựng một mô hình đặc biệt chính xác, nhưng chúng tôi đã chọn một tập dữ liệu mà mô hình sẽ không hội tụ rất nhanh, vì vậy chúng tôi có thể quan sát chuyển động của nó xung quanh các biến mục tiêu
Một cách minh họa hơn để đánh giá cách thức hoạt động của mô hình loại bỏ hoàn toàn Lỗi tuyệt đối trung bình tổng hợp và Lỗi tỷ lệ phần trăm tuyệt đối trung bình và chúng ta có thể vẽ biểu đồ phân tán của giá dự đoán so với giá thực tế. Nếu chúng bằng nhau - các điểm đánh dấu được vẽ sẽ đi theo quỹ đạo thẳng theo đường chéo. Để tham khảo và phạm vi - chúng ta cũng có thể vẽ một đường chéo và đánh giá mức độ gần của mỗi điểm đánh dấu với đường
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
Hãy xem hướng dẫn thực hành, thực tế của chúng tôi để học Git, với các phương pháp hay nhất, tiêu chuẩn được ngành chấp nhận và bao gồm bảng gian lận. Dừng các lệnh Git trên Google và thực sự tìm hiểu nó
Chạy mã này dẫn đến
Mạng định giá quá cao những ngôi nhà rẻ hơn và định giá thấp hơn những ngôi nhà đắt tiền hơn - và các ước tính có phạm vi khá rộng rãi [với một số dự đoán ở bên phải hoàn toàn nằm ngoài phạm vi - tuy nhiên, điều này xảy ra do chúng tôi chưa làm sạch tập dữ liệu và nhiều giá nhà bị giới hạn
Đây không phải là cái nhìn sâu sắc mà bạn có được từ các đường cong học tập và một mạng lưới có tác động ngược lại - định giá thấp những ngôi nhà rẻ hơn và định giá quá cao những ngôi nhà đắt tiền có thể có cùng MAE và MAPE nhưng hoạt động hoàn toàn khác
Điều chúng tôi cũng quan tâm là làm thế nào mô hình có được ở đây và những dự đoán này đã thay đổi như thế nào theo thời gian và quá trình học tập. Đây chỉ là điểm cuối của quá trình đào tạo và đã có một chút đào tạo liên quan để đạt được điều này
Hãy tiếp tục và viết một cuộc gọi lại tùy chỉnh để thêm vào danh sách các cuộc gọi lại trong quá trình đào tạo, cuộc gọi lại này sẽ chạy dự đoán trên tập kiểm tra trên mỗi kỷ nguyên, trực quan hóa các dự đoán và lưu chúng dưới dạng hình ảnh
Gọi lại Keras dự đoán tùy chỉnh với các ô
Giống như chúng ta đã sử dụng hàm gọi lại
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Tạo một cuộc gọi lại tùy chỉnh giúp mở rộng lớp
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Tùy thuộc vào thời điểm bạn muốn dự đoán bằng mô hình đào tạo của mình, bạn sẽ chọn phương pháp phù hợp. Một thước đo tốt về tiến trình của nó là một kỷ nguyên, vì vậy, vào cuối mỗi kỷ nguyên đào tạo, chúng tôi sẽ kiểm tra mô hình trên bộ thử nghiệm của mình
Chúng tôi cần một cách để cung cấp tập kiểm tra cho cuộc gọi lại, vì đây là dữ liệu ngoài. Cách dễ nhất để làm điều đó là xác định một hàm tạo chấp nhận tập kiểm tra và đánh giá mô hình hiện tại trên đó, mang lại cho bạn kết quả nhất quán
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
Cuộc gọi lại đơn giản này chấp nhận tập hợp nhà thử nghiệm và các biến mục tiêu có liên quan và tự đánh giá trên mỗi kỷ nguyên, in kết quả ra bàn điều khiển, ngay bên cạnh đầu ra Keras thông thường
Nếu chúng ta khởi tạo và thêm lệnh gọi lại này vào mô hình và
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Kết quả này trong
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
Thật tuyệt vời. Mô hình đang tự đánh giá trên từng kỷ nguyên, trên dữ liệu chúng tôi đã chuyển vào lệnh gọi lại. Bây giờ, hãy sửa đổi cuộc gọi lại để nó trực quan hóa các dự đoán thay vì in chúng ra đầu ra đã lộn xộn
Để đơn giản hóa mọi thứ, chúng tôi sẽ gọi lại để lưu hình ảnh vào một thư mục, để chúng tôi có thể ghép chúng lại với nhau thành video hoặc Gif sau này. Chúng tôi cũng sẽ bao gồm một
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Ở đây, chúng tôi tạo một hình Matplotlib trên mỗi kỷ nguyên và vẽ biểu đồ phân tán của giá dự đoán so với giá thực tế. Ngoài ra, chúng tôi đã thêm một đường tham chiếu chéo - các điểm đánh dấu biểu đồ phân tán của chúng tôi càng gần đường chéo thì các dự đoán của mô hình của chúng tôi càng chính xác
Sau đó, cốt truyện được lưu qua
X, y = fetch_california_housing[as_frame=True, return_X_y=True]
x_train, x_test, y_train, y_test = train_test_split[x, y]
plt.figure[figsize=[12, 8]]
sns.scatterplot[data=x, x='Longitude', y='Latitude', size=y, alpha=0.5, hue=y, palette='magma']
plt.show[]
Bây giờ, hãy sử dụng lại cuộc gọi lại tùy chỉnh này, cung cấp tên kiểu máy ngoài các bộ
checkpoint = keras.callbacks.ModelCheckpoint["california.h5", save_best_only=True]
model = keras.Sequential[[
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2", input_shape=[x_train.shape[1]]],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2"],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[1]
]]
model.compile[loss='mae',
optimizer=keras.optimizers.RMSprop[learning_rate=1e-2, decay=0.1],
metrics=['mae']]
history = model.fit[
x_train, y_train,
epochs=150,
batch_size=64,
validation_split=0.2,
callbacks=[checkpoint]
]
checkpoint = keras.callbacks.ModelCheckpoint["california.h5", save_best_only=True]
model = keras.Sequential[[
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2", input_shape=[x_train.shape[1]]],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2"],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[1]
]]
model.compile[loss='mae',
optimizer=keras.optimizers.RMSprop[learning_rate=1e-2, decay=0.1],
metrics=['mae']]
history = model.fit[
x_train, y_train,
epochs=150,
batch_size=64,
validation_split=0.2,
callbacks=[checkpoint]
]
checkpoint = keras.callbacks.ModelCheckpoint["california.h5", save_best_only=True]
model = keras.Sequential[[
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2", input_shape=[x_train.shape[1]]],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2"],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[1]
]]
model.compile[loss='mae',
optimizer=keras.optimizers.RMSprop[learning_rate=1e-2, decay=0.1],
metrics=['mae']]
history = model.fit[
x_train, y_train,
epochs=150,
batch_size=64,
validation_split=0.2,
callbacks=[checkpoint]
]
checkpoint = keras.callbacks.ModelCheckpoint["california.h5", save_best_only=True]
model = keras.Sequential[[
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2", input_shape=[x_train.shape[1]]],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[64, activation='relu', kernel_initializer='normal', kernel_regularizer="l2"],
keras.layers.Dropout[0.2],
keras.layers.BatchNormalization[],
keras.layers.Dense[1]
]]
model.compile[loss='mae',
optimizer=keras.optimizers.RMSprop[learning_rate=1e-2, decay=0.1],
metrics=['mae']]
history = model.fit[
x_train, y_train,
epochs=150,
batch_size=64,
validation_split=0.2,
callbacks=[checkpoint]
]
Giờ đây, bạn có thể sử dụng công cụ yêu thích của mình để ghép các hình ảnh lại với nhau thành video hoặc tệp Gif hoặc chỉ cần duyệt chúng theo cách thủ công. Đây là một Gif của mô hình chúng tôi đã xây dựng đào tạo về dữ liệu này
Phần kết luận
Trong hướng dẫn này, chúng tôi đã xây dựng một mô hình đơn giản để dự đoán giá nhà trong Bộ dữ liệu Nhà ở California với độ chính xác vừa phải. Sau đó, chúng tôi đã xem xét cách viết lệnh gọi lại Keras tùy chỉnh để kiểm tra hiệu suất của mô hình Deep Learning và trực quan hóa nó trong quá trình đào tạo, trên mỗi kỷ nguyên
Chúng tôi đã tiến hành lưu những hình ảnh này vào đĩa và tạo Gif từ chúng, giúp chúng tôi có một góc nhìn khác về quá trình đào tạo so với góc nhìn mà chúng tôi nhận được từ việc phân tích các đường cong học tập của một mô hình