Hướng dẫn searching in python
Nội dung chính Show
Giới thiệuTrong hướng dẫn này, chúng ta sẽ nói về một thuật toán tối ưu hóa (hoặc tự động hóa) rất mạnh mẽ, tức là Thuật toán Tìm kiếm Lưới. Nó được sử dụng phổ biến nhất để điều chỉnh siêu tham số trong các mô hình học máy. Chúng ta sẽ tìm hiểu cách triển khai nó bằng Python, cũng như áp dụng nó trong một ứng dụng thực tế để xem nó có thể giúp chúng ta chọn các tham số tốt nhất cho mô hình của mình và cải thiện độ chính xác của nó như thế nào. Vì vậy, chúng ta hãy bắt đầu. Điều kiện tiên quyếtĐể làm theo hướng dẫn này, bạn phải có hiểu biết cơ bản về Python hoặc một số ngôn ngữ lập trình khác. Việc bạn có một số kiến thức cơ bản về máy học được ưu tiên, nhưng không cần thiết. Ngoài ra, bài viết này thân thiện với người mới bắt đầu và có thể được theo dõi bởi bất kỳ ai. Cài đặtĐể xem qua hướng dẫn, bạn cần cài đặt các thư viện / khung công tác sau trong hệ thống của mình:
Tất cả chúng đều khá đơn giản để cài đặt – bạn có thể nhấp vào từng cái để truy cập trang web tương ứng của chúng, nơi cung cấp hướng dẫn cài đặt chi tiết. Nói chung, các gói có thể được cài đặt bằng pip: $ pip install numpy pandas tensorflow keras scikit-learn Nếu bạn gặp phải bất kỳ vấn đề nào, vui lòng tham khảo tài liệu chính thức từ mỗi gói. Tìm kiếm Grid là gì?Tìm kiếm theo lưới về cơ bản là một thuật toán tối ưu hóa cho phép bạn chọn các tham số tốt nhất cho vấn đề tối ưu hóa của mình từ danh sách các tùy chọn tham số mà bạn cung cấp, do đó tự động hóa phương pháp ‘thử và sai’. Mặc dù nó có thể được áp dụng cho nhiều bài toán tối ưu hóa, nhưng nó được biết đến phổ biến nhất với việc sử dụng trong học máy để có được các tham số mà tại đó mô hình cho độ chính xác tốt nhất. Giả sử rằng mô hình của bạn lấy ba tham số dưới đây làm đầu vào:
Nếu đối với mỗi đầu vào tham số, chúng tôi muốn thử hai tùy chọn (như đã đề cập trong dấu ngoặc vuông ở trên), thì tổng cộng là 23= 8 kết hợp khác nhau (ví dụ: một kết hợp có thể là [2,5,10]). Làm điều này theo cách thủ công sẽ rất đau đầu. Bây giờ hãy tưởng tượng nếu chúng ta có 10 tham số đầu vào khác nhau và chúng ta muốn thử 5 giá trị có thể có cho mỗi tham số. Nó sẽ yêu cầu nhập thủ công từ phía chúng tôi mỗi khi chúng tôi muốn thay đổi giá trị tham số, chạy lại mã và theo dõi kết quả cho tất cả các kết hợp tham số. Grid Search tự động hóa quá trình đó, vì nó chỉ đơn giản là lấy các giá trị có thể có cho mỗi tham số và chạy mã để thử tất cả các kết hợp có thể có, xuất ra kết quả cho mỗi kết hợp, cũng như xuất ra kết hợp mang lại độ chính xác tốt nhất. Hữu ích, không? Triển khai Tìm kiếm LướiĐược rồi, nói đủ rồi. Cho phép áp dụng Tìm kiếm theo lưới trên một ứng dụng thực tế. Thảo luận về phần Học máy và Tiền xử lý dữ liệu không nằm trong phạm vi của hướng dẫn này, vì vậy chúng tôi chỉ đơn giản là chạy mã của nó và nói chuyên sâu về phần mà Grid Search đi kèm. Hãy bắt đầu! Chúng tôi sẽ sử dụng tập dữ liệu về bệnh tiểu đường ở Ấn Độ Pima chứa thông tin về việc bệnh nhân có bị tiểu đường hay không dựa trên các thuộc tính khác nhau như nồng độ glucozơ trong máu, huyết áp, v.v. Sử dụng Pandas read_csv() bạn có thể nhập trực tiếp tập dữ liệu từ một tài nguyên trực tuyến. Tập lệnh sau nhập các thư viện bắt buộc: from sklearn.model_selection import GridSearchCV, KFold from keras.models import Sequential from keras.layers import Dense, Dropout from keras.wrappers.scikit_learn import KerasClassifier from keras.optimizers import Adam import sys import pandas as pd import numpy as np Tập lệnh sau nhập tập dữ liệu và đặt tiêu đề cột cho tập dữ liệu. columns = ['num_pregnant', 'glucose_concentration', 'blood_pressure', 'skin_thickness',
'serum_insulin', 'BMI', 'pedigree_function', 'age', 'class']
data_path = "https://raw.githubusercontent.com/mkhalid1/Machine-Learning-Projects-Python-/master/Grid%20Search/pima-indians-diabetes.csv"
df = pd.read_csv(data_path, names=columns)
Hãy xem 5 hàng đầu tiên của tập dữ liệu: df.head() Output: Như bạn có thể thấy, 5 hàng này đều là nhãn để mô tả từng cột (thực tế có 9 trong số đó), vì vậy chúng không có tác dụng gì đối với chúng ta. Chúng tôi sẽ bắt đầu bằng cách xóa các hàng không phải dữ liệu này và sau đó thay thế tất cả NaNs với 0: # Remove first 9 non-data rows
df = df.iloc[9:]
# Replace NaN (Not a Number) values with 0 in each column
for col in columns:
df[col].replace(0, np.NaN, inplace=True)
df.dropna(inplace=True) # Drop all rows with missing values
dataset = df.values # Convert dataframe to numpy array
Tập lệnh sau đây chia dữ liệu thành các tập hợp tính năng và nhãn, đồng thời áp dụng tỷ lệ tiêu chuẩn trên tập dữ liệu: X = dataset[:,0:8] Y = dataset[:, 8].astype(int) # Normalize the data using sklearn StandardScaler from sklearn.preprocessing import StandardScaler scaler = StandardScaler().fit(X) # Transform and display the training data X_standardized = scaler.transform(X) data = pd.DataFrame(X_standardized) Học sâu thực tế cho thị giác máy tính với PythonKhi nhìn xuống cốc cà phê của mình, bạn sẽ không ngạc nhiên chút nào về vật thể trước mặt. Bạn đã có thể làm… Hãy dùng thử Phương pháp sau tạo ra mô hình học sâu đơn giản của chúng tôi: def create_model(learn_rate, dropout_rate):
# Create model
model = Sequential()
model.add(Dense(8, input_dim=8, kernel_initializer="normal", activation='relu'))
model.add(Dropout(dropout_rate))
model.add(Dense(4, input_dim=8, kernel_initializer="normal", activation='relu'))
model.add(Dropout(dropout_rate))
model.add(Dense(1, activation='sigmoid'))
# Compile the model
adam = Adam(lr=learn_rate)
model.compile(loss="binary_crossentropy", optimizer=adam, metrics=['accuracy'])
return model
Đây là tất cả mã mà bạn cần chạy để tải tập dữ liệu, xử lý trước và tạo mô hình học máy của bạn. Vì chúng tôi chỉ quan tâm đến việc xem chức năng của Grid Search, tôi đã không thực hiện phân tách đào tạo / kiểm tra và chúng tôi sẽ điều chỉnh mô hình trên toàn bộ tập dữ liệu. Trong phần tiếp theo, chúng ta sẽ bắt đầu xem Grid Search giúp cuộc sống của chúng ta dễ dàng hơn bằng cách tối ưu hóa các tham số của chúng ta như thế nào. Đào tạo Mô hình mà không cần Tìm kiếm LướiTrong đoạn mã dưới đây, chúng tôi sẽ tạo một mô hình bằng cách sử dụng các giá trị tham số mà chúng tôi đã quyết định một cách ngẫu nhiên hoặc dựa trên trực giác của chúng tôi và xem mô hình của chúng tôi hoạt động như thế nào: # Declare parameter values dropout_rate = 0.1 epochs = 1 batch_size = 20 learn_rate = 0.001 # Create the model object by calling the create_model function we created above model = create_model(learn_rate, dropout_rate) # Fit the model onto the training data model.fit(X_standardized, Y, batch_size=batch_size, epochs=epochs, verbose=1) Output: Epoch 1/1 130/130 [==============================] - 0s 2ms/step - loss: 0.6934 - accuracy: 0.6000 Độ chính xác mà chúng tôi nhận được, như bạn có thể thấy bên dưới, là 60.00%. Đây là mức khá thấp, nhưng không có gì phải lo lắng! Chúng tôi vẫn có Tìm kiếm theo lưới để thử và tiết kiệm trong ngày. Vì vậy, hay thực hiện ngay bây giơ. Tối ưu hóa Siêu tham số bằng Grid SearchNếu bạn không sử dụng Grid Search, bạn có thể gọi trực tiếp fit() trên mô hình mà chúng ta đã tạo ở trên. Tuy nhiên, để sử dụng Grid Search, chúng ta cần chuyển một số tham số vào create_model(). Hơn nữa, chúng ta cần khai báo lưới của chúng ta với các tùy chọn khác nhau mà chúng ta muốn thử cho mỗi tham số. Hãy làm điều đó theo từng phần. Đầu tiên chúng tôi sửa đổi create_model() để chấp nhận các tham số từ hàm gọi: def create_model(learn_rate, dropout_rate):
# Create model
model = Sequential()
model.add(Dense(8, input_dim=8, kernel_initializer="normal", activation='relu'))
model.add(Dropout(dropout_rate))
model.add(Dense(4, input_dim=8, kernel_initializer="normal", activation='relu'))
model.add(Dropout(dropout_rate))
model.add(Dense(1, activation='sigmoid'))
# Compile the model
adam = Adam(lr=learn_rate)
model.compile(loss="binary_crossentropy", optimizer=adam, metrics=['accuracy'])
return model
# Create the model
model = KerasClassifier(build_fn=create_model, verbose=1)
Bây giờ, chúng tôi đã sẵn sàng triển khai thuật toán Tìm kiếm theo lưới của mình và phù hợp với tập dữ liệu trên đó: # Define the parameters that you wish to use in your Grid Search along
# with the list of values that you wish to try out
learn_rate = [0.001, 0.02, 0.2]
dropout_rate = [0.0, 0.2, 0.4]
batch_size = [10, 20, 30]
epochs = [1, 5, 10]
seed = 42
# Make a dictionary of the grid search parameters
param_grid = dict(learn_rate=learn_rate, dropout_rate=dropout_rate, batch_size=batch_size, epochs=epochs )
# Build and fit the GridSearchCV
grid = GridSearchCV(estimator=model, param_grid=param_grid,
cv=KFold(random_state=seed), verbose=10)
grid_results = grid.fit(X_standardized, Y)
# Summarize the results in a readable format
print("Best: {0}, using {1}".format(grid_results.best_score_, grid_results.best_params_))
means = grid_results.cv_results_['mean_test_score']
stds = grid_results.cv_results_['std_test_score']
params = grid_results.cv_results_['params']
for mean, stdev, param in zip(means, stds, params):
print('{0} ({1}) with: {2}'.format(mean, stdev, param))
Output: Best: 0.7959183612648322, using {'batch_size': 10, 'dropout_rate': 0.2, 'epochs': 10, 'learn_rate': 0.02}
Trong đầu ra, chúng ta có thể thấy nó cung cấp cho chúng ta sự kết hợp tham số mang lại độ chính xác tốt nhất. Có thể nói rằng Grid Search khá dễ thực hiện bằng Python và tiết kiệm cho chúng tôi rất nhiều thời gian, về mặt sức lao động của con người. Bạn chỉ có thể liệt kê tất cả các tham số bạn muốn điều chỉnh, khai báo các giá trị sẽ được kiểm tra, chạy mã của bạn và quên nó đi. Không cần thêm đầu vào từ phía bạn. Sau khi tìm thấy kết hợp thông số tốt nhất, bạn có thể chỉ cần sử dụng kết hợp đó cho mô hình cuối cùng của mình. Sự kết luậnTóm lại, chúng tôi đã tìm hiểu Grid Search là gì, cách nó có thể giúp chúng tôi tối ưu hóa mô hình của mình và những lợi ích mà nó mang lại như tự động hóa. Hơn nữa, chúng tôi đã học cách triển khai nó trong một vài dòng mã bằng Ngôn ngữ Python. Để xem hiệu quả của nó, chúng tôi cũng đã đào tạo mô hình Học máy có và không thực hiện Tìm kiếm theo lưới và độ chính xác cao hơn 19% với Tìm kiếm theo lưới. |
