Cách xây dựng mô hình deep learning để dự đoán khả năng giữ chân nhân viên bằng Keras và TensorFlow

Keras là một API mạng thần kinh được viết bằng Python. Nó chạy trên TensorFlow , CNTK hoặc Theano . Đây là phần trừu tượng ở mức độ cao của các khung học sâu này và do đó làm cho việc thử nghiệm nhanh hơn và dễ dàng hơn. Keras là module , nghĩa là việc triển khai diễn ra liền mạch vì các nhà phát triển có thể nhanh chóng mở rộng mô hình bằng cách thêm module .

---

TensorFlow là một thư viện phần mềm open-souce dành cho học máy. Nó hoạt động hiệu quả với tính toán liên quan đến mảng; vì vậy đó là một lựa chọn tuyệt vời cho mô hình bạn sẽ xây dựng trong hướng dẫn này. Hơn nữa, TensorFlow cho phép thực thi mã trên CPU hoặc GPU, đây là một tính năng hữu ích, đặc biệt khi bạn đang làm việc với một tập dữ liệu lớn.

Trong hướng dẫn này, bạn sẽ xây dựng một mô hình học sâu dự đoán xác suất nhân viên rời bỏ công ty. Giữ chân những nhân viên giỏi nhất là một yếu tố quan trọng đối với hầu hết các tổ chức. Để xây dựng mô hình của bạn , bạn sẽ sử dụng bộ dữ liệu này có sẵn tại Kaggle , có các tính năng đo lường sự hài lòng của nhân viên trong một công ty. Để tạo mô hình này, bạn sẽ sử dụng lớp tuần tự Keras để xây dựng các lớp khác nhau cho mô hình.

Yêu cầu

Trước khi bắt đầu hướng dẫn này, bạn cần những thứ sau:

• Môi trường phát triển Anaconda trên máy của bạn.
• Cài đặt Notebook Jupyter . Anaconda sẽ cài đặt Jupyter Notebook cho bạn trong quá trình cài đặt. Bạn cũng có thể làm theo hướng dẫn này để biết hướng dẫn về cách chuyển và sử dụng Jupyter Notebook.
• Làm quen với Học máy .

Bước 1 - Xử lý trước dữ liệu

Xử lý trước dữ liệu là cần thiết để chuẩn bị dữ liệu theo cách mà mô hình học sâu có thể chấp nhận. Nếu có các biến phân loại trong dữ liệu , bạn phải chuyển đổi chúng thành số vì thuật toán chỉ chấp nhận các số liệu. Một biến phân loại đại diện cho dữ liệu định lượng được biểu thị bằng tên. Trong bước này, bạn sẽ tải vào tập dữ liệu của bạn bằng cách sử dụng pandas , đây là một thư viện Python thao tác dữ liệu.

Trước khi bắt đầu xử lý trước dữ liệu, bạn sẽ kích hoạt môi trường của bạn và đảm bảo bạn đã cài đặt tất cả các gói cần thiết cho máy của bạn . Sẽ rất thuận lợi khi sử dụng conda để cài đặt keras và tensorflow vì nó sẽ xử lý việc cài đặt bất kỳ phụ thuộc cần thiết nào cho các gói này và đảm bảo chúng tương thích với keras và tensorflow . Theo cách này, sử dụng phân phối Anaconda Python là một lựa chọn tốt cho các dự án liên quan đến khoa học dữ liệu.

Di chuyển vào môi trường bạn đã tạo trong hướng dẫn tiên quyết:

conda activate my_env 

Chạy lệnh sau để cài đặt keras và tensorflow :

conda install tensorflow keras 

Bây giờ, hãy mở Jupyter Notebook để bắt đầu. Notebook Jupyter được mở bằng lệnh lệnh sau trên terminal của bạn:

jupyter notebook 

Lưu ý: Nếu bạn đang làm việc từ một server từ xa, bạn cần sử dụng tunnel SSH để truy cập sổ ghi chép của bạn . Vui lòng truy cập lại bước 2 của hướng dẫn yêu cầu để biết chi tiết về hướng dẫn cài đặt tunnel SSH. Bạn có thể sử dụng lệnh sau từ máy local của bạn để khởi tạo tunnel SSH:

ssh -L 8888:localhost:8888 your_username@your_server_ip 

Sau khi truy cập Jupyter Notebook, hãy nhấp vào file anaconda3 , sau đó nhấp vào Mới ở đầu màn hình và chọn Python 3 để tải sổ ghi chép mới.

Bây giờ, bạn sẽ nhập các module cần thiết cho dự án và sau đó tải tập dữ liệu vào một ô sổ ghi chép. Bạn sẽ tải trong module pandas để thao tác dữ liệu và numpy để chuyển đổi dữ liệu thành các mảng numpy . Bạn cũng sẽ chuyển đổi tất cả các cột có định dạng chuỗi thành các giá trị số để máy tính của bạn xử lý.

Chèn mã sau vào một ô sổ ghi chép và sau đó bấm Chạy :

import pandas as pd import numpy as np df = pd.read_csv("https://raw.githubusercontent.com/mwitiderrick/kerasDO/master/HR_comma_sep.csv") 

Bạn đã nhập numpy và pandas . Sau đó, bạn đã sử dụng pandas để tải vào tập dữ liệu cho mô hình.

Bạn có thể xem qua tập dữ liệu mà bạn đang làm việc bằng cách sử dụng head() . Đây là một chức năng hữu ích từ pandas cho phép bạn xem năm bản ghi đầu tiên của khung dữ liệu . Thêm mã sau vào một ô sổ ghi chép và sau đó chạy nó:

df.head() 

Đến đây bạn sẽ tiến hành chuyển đổi các cột phân loại thành số. Bạn làm điều này bằng cách chuyển đổi chúng thành các biến giả . Các biến giả thường là các biến số một và số không biểu thị sự hiện diện hoặc không có của một đối tượng phân loại. Trong tình huống này, bạn cũng tránh được bẫy biến giả bằng cách thả hình nộm đầu tiên.

Lưu ý: Bẫy biến giả là tình huống trong đó hai hoặc nhiều biến có tương quan cao. Điều này dẫn đến mô hình của bạn hoạt động kém. Do đó, bạn bỏ một biến giả để luôn duy trì với N-1 biến giả. Bất kỳ biến giả nào cũng có thể bị loại bỏ vì không được ưu tiên miễn là bạn vẫn sử dụng N-1 biến giả. Một ví dụ về điều này là nếu bạn có một lựa chọn bật / tắt. Khi bạn tạo biến giả, bạn sẽ nhận được hai cột: một cột on và một cột off . Bạn có thể bỏ một trong các cột vì nếu lựa chọn không bật, thì nó sẽ tắt.

Chèn mã này vào ô sổ ghi chép tiếp theo và thực thi nó:

feats = ['department','salary'] df_final = pd.get_dummies(df,columns=feats,drop_first=True) 

feats = ['department','salary'] xác định hai cột mà bạn muốn tạo biến giả. pd.get_dummies(df,columns=feats,drop_first=True) sẽ tạo các biến số mà mô hình giữ chân nhân viên của bạn yêu cầu. Nó thực hiện điều này bằng cách chuyển đổi các feats mà bạn xác định từ các biến phân loại sang số.

Bạn đã tải tập dữ liệu và chuyển đổi các cột lương và phòng ban sang định dạng mà mô hình học sâu keras có thể chấp nhận. Trong bước tiếp theo, bạn sẽ chia tập dữ liệu thành tập huấn luyện và thử nghiệm.

Bước 2 - Tách tập dữ liệu đào tạo và kiểm tra của bạn

Bạn sẽ sử dụng scikit-learn để chia tập dữ liệu của bạn thành tập huấn luyện và tập thử nghiệm. Điều này là cần thiết để bạn có thể sử dụng một phần dữ liệu nhân viên để đào tạo mô hình và một phần dữ liệu đó để kiểm tra hiệu suất của nó. Tách tập dữ liệu theo cách này là một thực tế phổ biến khi xây dựng mô hình học sâu.

Điều quan trọng là phải triển khai phần tách này trong tập dữ liệu để mô hình bạn xây dựng không có quyền truy cập vào dữ liệu thử nghiệm trong quá trình đào tạo. Điều này đảm bảo mô hình chỉ học từ dữ liệu đào tạo và sau đó bạn có thể kiểm tra hiệu suất của nó bằng dữ liệu thử nghiệm. Nếu bạn cho mô hình của bạn tiếp xúc với dữ liệu thử nghiệm trong quá trình đào tạo thì nó sẽ ghi nhớ các kết quả mong đợi. Do đó, nó sẽ không đưa ra dự đoán chính xác về dữ liệu mà nó chưa nhìn thấy.

Bạn sẽ bắt đầu bằng lệnh module train_test_split từ gói scikit-learn . Đây là module sẽ cung cấp chức năng phân tách. Chèn mã này vào ô sổ ghi chép tiếp theo và chạy:

from sklearn.model_selection import train_test_split 

Với module train_test_split được nhập, bạn sẽ sử dụng cột left trong tập dữ liệu của bạn để dự đoán liệu một nhân viên có rời công ty hay không. Do đó, điều cần thiết là mô hình học sâu của bạn không tiếp xúc với cột này. Chèn phần sau vào một ô để thả cột left :

X = df_final.drop(['left'],axis=1).values y = df_final['left'].values 

Mô hình học sâu của bạn mong đợi nhận được dữ liệu dưới dạng mảng. Do đó, bạn sử dụng numpy để chuyển đổi dữ liệu thành mảng numpy với thuộc tính .values .

Đến đây bạn đã sẵn sàng chuyển đổi tập dữ liệu thành tập thử nghiệm và đào tạo. Bạn sẽ sử dụng 70% dữ liệu để đào tạo và 30% để kiểm tra. Tỷ lệ đào tạo nhiều hơn tỷ lệ thử nghiệm vì bạn cần sử dụng hầu hết dữ liệu cho quá trình đào tạo. Nếu muốn, bạn cũng có thể thử nghiệm với tỷ lệ 80% cho tập huấn luyện và 20% cho tập thử nghiệm.

Bây giờ, hãy thêm mã này vào ô tiếp theo và chạy để chia dữ liệu đào tạo và thử nghiệm của bạn theo tỷ lệ được chỉ định:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) 

Đến đây bạn đã chuyển đổi dữ liệu vào các loại mà Keras hy vọng nó sẽ được trong ( numpy mảng), và dữ liệu là chia thành một huấn luyện và thử nghiệm cài đặt . Bạn sẽ chuyển dữ liệu này vào mô hình keras ở phần sau của hướng dẫn. Trước đó, bạn cần phải chuyển đổi dữ liệu mà bạn sẽ hoàn thành trong bước tiếp theo.

Bước 3 - Chuyển đổi dữ liệu

Khi xây dựng các mô hình học sâu, thông thường, cách thực hành tốt là mở rộng tập dữ liệu để làm cho việc tính toán hiệu quả hơn. Trong bước này, bạn sẽ chia tỷ lệ dữ liệu bằng cách sử dụng StandardScaler ; điều này sẽ đảm bảo các giá trị tập dữ liệu có giá trị trung bình bằng 0 và một biến đơn vị. Điều này biến tập dữ liệu thành được phân phối bình thường. Bạn sẽ sử dụng scikit-learn StandardScaler để chia tỷ lệ các tính năng trong cùng một phạm vi. Điều này sẽ biến đổi các giá trị để có giá trị trung bình là 0 và độ lệch chuẩn là 1. Bước này rất quan trọng vì bạn đang so sánh các đối tượng địa lý có các phép đo khác nhau; vì vậy nó thường được yêu cầu trong học máy.

Để chia tỷ lệ tập huấn luyện và tập kiểm tra, hãy thêm mã này vào ô sổ ghi chép và chạy nó:

from sklearn.preprocessing import StandardScaler sc = StandardScaler() X_train = sc.fit_transform(X_train) X_test = sc.transform(X_test) 

Tại đây, bạn bắt đầu bằng lệnh StandardScaler và gọi một version của nó. Sau đó, bạn sử dụng phương thức fit_transform của nó để mở rộng tập huấn luyện và thử nghiệm.

Bạn đã chia tỷ lệ tất cả các tính năng tập dữ liệu của bạn để nằm trong cùng một phạm vi. Bạn có thể bắt đầu xây dựng mạng nơ-ron nhân tạo trong bước tiếp theo.

Bước 4 - Xây dựng mạng nơ ron nhân tạo

Đến đây bạn sẽ sử dụng keras để xây dựng mô hình học sâu. Để thực hiện việc này, bạn sẽ nhập các keras , theo mặc định, sẽ sử dụng tensorflow làm backend . Từ keras , sau đó bạn sẽ nhập module Sequential để khởi tạo mạng nơ-ron nhân tạo . Mạng nơ-ron nhân tạo là một mô hình tính toán được xây dựng dựa trên cảm hứng từ hoạt động của bộ não con người. Bạn cũng sẽ nhập module Dense module này sẽ thêm các lớp vào mô hình học sâu của bạn.

Khi xây dựng một mô hình học sâu, bạn thường chỉ định ba loại lớp:

• Lớp đầu vào là lớp mà bạn sẽ chuyển các tính năng của tập dữ liệu của bạn . Không có tính toán nào xảy ra trong lớp này. Nó dùng để chuyển các tính năng đến các lớp ẩn.
• Các lớp ẩn thường là các lớp nằm giữa lớp đầu vào và lớp kết quả — và có thể có nhiều hơn một. Các lớp này thực hiện các phép tính và chuyển thông tin đến lớp kết quả .
• Lớp kết quả đại diện cho lớp của mạng nơ-ron sẽ cung cấp cho bạn kết quả sau khi đào tạo mô hình của bạn. Nó chịu trách nhiệm tạo ra các biến kết quả .

Để nhập module Keras , Sequential và Dense , hãy chạy mã sau trong ô sổ ghi chép của bạn:

import keras from keras.models import Sequential from keras.layers import Dense 

Bạn sẽ sử dụng Sequential để khởi tạo một chồng lớp tuyến tính. Vì đây là một vấn đề phân loại , bạn sẽ tạo một biến phân loại. Bài toán phân loại là một công việc mà bạn đã gắn nhãn dữ liệu và muốn đưa ra một số dự đoán dựa trên dữ liệu được gắn nhãn. Thêm mã này vào sổ ghi chép của bạn để tạo một biến phân loại:

classifier = Sequential() 

Bạn đã sử dụng Sequential để khởi tạo trình phân loại.

Đến đây bạn có thể bắt đầu thêm các lớp vào mạng của bạn . Chạy mã này trong ô tiếp theo của bạn:

classifier.add(Dense(9, kernel_initializer = "uniform",activation = "relu", input_dim=18)) 

Bạn thêm các lớp bằng cách sử dụng hàm .add() trên trình phân loại của bạn và chỉ định một số tham số:

• Tham số đầu tiên là số lượng nút mà mạng của bạn nên có. Kết nối giữa các node khác nhau là thứ tạo thành mạng nơ-ron. Một trong những chiến lược để xác định số lượng nút là lấy giá trị trung bình của các node trong lớp đầu vào và lớp kết quả .

• Tham số thứ hai là kernel_initializer. Khi bạn phù hợp với mô hình học sâu của bạn , trọng số sẽ được khởi tạo thành các số gần bằng 0, nhưng không phải bằng không. Để làm điều này, bạn sử dụng trình khởi tạo phân phối đồng nhất. kernel_initializer là hàm khởi tạo các trọng số.

• Tham số thứ ba là chức năng activation . Mô hình học sâu của bạn sẽ học thông qua chức năng này. Thường có các hàm kích hoạt tuyến tính và phi tuyến tính. Bạn sử dụng chức năng kích hoạt relu vì nó khái quát tốt trên dữ liệu . Các hàm tuyến tính không tốt cho những vấn đề như thế này vì chúng tạo thành một đường thẳng.

• Tham số cuối cùng là input_dim , đại diện cho số lượng tính năng trong tập dữ liệu .

Đến đây bạn sẽ thêm lớp kết quả sẽ cung cấp cho bạn các dự đoán:

classifier.add(Dense(1, kernel_initializer = "uniform",activation = "sigmoid")) 

Lớp kết quả nhận các tham số sau:

• Số lượng các node kết quả . Bạn mong đợi nhận được một kết quả : nếu một nhân viên rời công ty. Do đó bạn chỉ định một nút kết quả .

• Đối với kernel_initializer bạn sử dụng chức năng kích hoạt sigmoid để có thể có xác suất nhân viên nghỉ việc. Trong trường hợp bạn xử lý nhiều hơn hai danh mục, bạn sẽ sử dụng chức năng kích hoạt softmax , là một biến thể của chức năng kích hoạt sigmoid .

Tiếp theo, bạn sẽ áp dụng một gradient descent cho mạng nơ-ron. Đây là một chiến lược tối ưu hóa có tác dụng giảm thiểu sai sót trong quá trình đào tạo. Gradient descent là cách các trọng số được chỉ định ngẫu nhiên trong mạng nơ-ron được điều chỉnh bằng cách giảm hàm chi phí , là thước đo mức độ hoạt động của mạng nơ-ron dựa trên kết quả mong đợi từ nó.

Mục đích của gradient descent là để có được điểm mà lỗi ít nhất. Điều này được thực hiện bằng cách tìm nơi hàm chi phí ở mức tối thiểu, được gọi là mức tối thiểu local . Trong giảm dần độ dốc, bạn phân biệt để tìm độ dốc tại một điểm cụ thể và tìm hiểu xem độ dốc là âm hay dương — bạn đang giảm dần đến mức tối thiểu của hàm chi phí. Có một số loại chiến lược tối ưu hóa, nhưng bạn sẽ sử dụng một loại chiến lược phổ biến được gọi là adam trong hướng dẫn này.

Thêm mã này vào ô sổ ghi chép của bạn và chạy nó:

classifier.compile(optimizer= "adam",loss = "binary_crossentropy",metrics = ["accuracy"]) 

Việc áp dụng gradient descent được thực hiện thông qua hàm compile có các tham số sau:

• optimizer là phần dốc xuống.
• loss là một chức năng mà bạn sẽ sử dụng trong gradient descent. Vì đây là vấn đề phân loại binary nên bạn sử dụng hàm loss binary_crossentropy .
• Tham số cuối cùng là metric mà bạn sẽ sử dụng để đánh giá mô hình của bạn . Trong trường hợp này, bạn muốn đánh giá nó dựa trên độ chính xác của nó khi đưa ra dự đoán.

Bạn đã sẵn sàng để lắp bộ phân loại vào tập dữ liệu của bạn . Keras thực hiện điều này thông qua phương thức .fit() . Để thực hiện việc này, hãy chèn mã sau vào sổ ghi chép của bạn và chạy mã đó để phù hợp với mô hình với tập dữ liệu :

classifier.fit(X_train, y_train, batch_size = 10, epochs = 1) 

Phương thức .fit() nhận một vài tham số:

• Tham số đầu tiên là tập huấn luyện với các tính năng.

• Tham số thứ hai là cột mà bạn đang đưa ra dự đoán.

• Kích batch_size đại diện cho số lượng mẫu sẽ đi qua mạng nơ-ron ở mỗi vòng huấn luyện.

• epochs đại diện cho số lần tập dữ liệu sẽ được chuyển qua mạng nơron. Thời gian chạy mô hình của bạn càng nhiều kỷ nguyên, điều này cũng mang lại cho bạn kết quả tốt hơn.

Bạn đã tạo mô hình học sâu, biên dịch và trang bị nó vào tập dữ liệu của bạn . Bạn đã sẵn sàng đưa ra một số dự đoán bằng cách sử dụng mô hình học sâu. Trong bước tiếp theo, bạn sẽ bắt đầu đưa ra dự đoán với tập dữ liệu mà mô hình chưa nhìn thấy.

Bước 5 - Chạy dự đoán trên bộ thử nghiệm

Để bắt đầu đưa ra dự đoán, bạn sẽ sử dụng tập dữ liệu thử nghiệm trong mô hình mà bạn đã tạo. Keras cho phép bạn đưa ra dự đoán bằng cách sử dụng hàm .predict() .

Chèn mã sau vào ô sổ ghi chép tiếp theo để bắt đầu đưa ra dự đoán:

y_pred = classifier.predict(X_test) 

Vì bạn đã đào tạo bộ phân loại với bộ đào tạo, mã này sẽ sử dụng việc học được từ quá trình đào tạo để đưa ra các dự đoán trên bộ kiểm tra. Điều này sẽ cung cấp cho bạn khả năng một nhân viên nghỉ việc. Bạn sẽ làm việc với xác suất từ 50% trở lên cho thấy khả năng nhân viên rời công ty là rất cao.

Nhập dòng mã sau vào ô sổ ghi chép của bạn để đặt ngưỡng này:

y_pred = (y_pred > 0.5) 

Bạn đã tạo dự đoán bằng phương pháp dự đoán và đặt ngưỡng để xác định xem một nhân viên có khả năng rời đi hay không. Để đánh giá mức độ hoạt động của mô hình đối với các dự đoán, tiếp theo bạn sẽ sử dụng ma trận nhầm lẫn .

Bước 6 - Kiểm tra Ma trận nhầm lẫn

Trong bước này, bạn sẽ sử dụng ma trận nhầm lẫn để kiểm tra số lượng các dự đoán đúng và sai. Ma trận nhầm lẫn, còn gọi là ma trận lỗi, là một ma trận vuông báo cáo số lượng dương tính đúng (tp), dương tính sai (fp), phủ định đúng (tn) và phủ định sai (fn) của một bộ phân loại.

• Một kết quả tích cực thực sự là một kết quả trong đó mô hình dự đoán chính xác lớp tích cực ( còn gọi là độ nhạy hoặc sự thu hồi).
• Một tiêu cực thực sự là một kết quả mà mô hình dự đoán chính xác lớp tiêu cực.
• Một kết quả dương tính giả là một kết quả trong đó mô hình dự đoán không chính xác lớp tích cực.
• Âm tính giả là kết quả trong đó mô hình dự đoán không chính xác lớp tiêu cực.

Để làm điều này, bạn sẽ sử dụng một ma trận nhầm lẫn mà scikit-learn cung cấp.

Chèn mã này vào ô sổ ghi chép tiếp theo để nhập ma trận nhầm lẫn scikit-learn :

from sklearn.metrics import confusion_matrix cm = confusion_matrix(y_test, y_pred) cm 

Kết quả ma trận nhầm lẫn nghĩa là mô hình học sâu của bạn đã đưa ra 3305 + 375 dự đoán đúng và 106 + 714 dự đoán sai. Bạn có thể tính độ chính xác với: (3305 + 375) / 4500 . Tổng số quan sát trong tập dữ liệu là 4500. Điều này mang lại cho bạn độ chính xác là 81,7%. Đây là tỷ lệ chính xác rất tốt vì bạn có thể đạt được ít nhất 81% dự đoán chính xác từ mô hình của bạn .

Output
array([[3305,  106],        [ 714,  375]]) 

Bạn đã đánh giá mô hình của bạn bằng cách sử dụng ma trận nhầm lẫn. Tiếp theo, bạn sẽ thực hiện một dự đoán duy nhất bằng cách sử dụng mô hình mà bạn đã phát triển.

Bước 7 - Đưa ra một dự đoán duy nhất

Trong bước này, bạn sẽ đưa ra một dự đoán duy nhất với thông tin chi tiết của một nhân viên với mô hình của bạn. Bạn sẽ đạt được điều này bằng cách dự đoán xác suất một nhân viên rời công ty. Bạn sẽ chuyển các tính năng của nhân viên này sang phương pháp predict . Như bạn đã làm trước đó, bạn cũng sẽ chia tỷ lệ các tính năng và chuyển đổi chúng thành một mảng numpy .

Để chuyển các tính năng của nhân viên, hãy chạy mã sau trong một ô:

new_pred = classifier.predict(sc.transform(np.array([[0.26,0.7 ,3., 238., 6., 0.,0.,0.,0., 0.,0.,0.,0.,0.,1.,0., 0.,1.]]))) 

Các tính năng này đại diện cho các tính năng của một nhân viên. Như trong tập dữ liệu ở bước 1, các tính năng này thể hiện: mức độ hài lòng, đánh giá cuối cùng, số lượng dự án, v.v. Như bạn đã làm ở bước 3, bạn phải chuyển đổi các tính năng theo cách mà mô hình học sâu có thể chấp nhận.

Thêm ngưỡng 50% với mã sau:

new_pred = (new_pred > 0.5) new_pred 

Ngưỡng này cho biết xác suất nhân viên sẽ rời công ty là trên 50%.

Bạn có thể thấy trong kết quả của bạn rằng nhân viên sẽ không rời công ty:

Output
array([[False]]) 

Bạn có thể quyết định đặt ngưỡng thấp hơn hoặc cao hơn cho mô hình của bạn . Ví dụ: bạn có thể đặt ngưỡng là 60%:

new_pred = (new_pred > 0.6) new_pred 

Ngưỡng mới này vẫn cho thấy rằng nhân viên sẽ không rời công ty:

Output
array([[False]]) 

Trong bước này, bạn đã thấy cách thực hiện một dự đoán duy nhất dựa trên các tính năng của một nhân viên. Trong bước tiếp theo, bạn sẽ làm việc để cải thiện độ chính xác của mô hình của bạn.

Bước 8 - Cải thiện độ chính xác của mô hình

Nếu bạn đào tạo mô hình của bạn nhiều lần, bạn sẽ tiếp tục nhận được các kết quả khác nhau. Độ chính xác cho mỗi khóa đào tạo có một phương sai cao. Để giải quyết vấn đề này, bạn sẽ sử dụng xác thực chéo K-lần . Thông thường, K được đặt thành 10. Trong kỹ thuật này, người mẫu được huấn luyện trên 9 lần gấp đầu tiên và thử nghiệm ở lần gấp cuối cùng. Lặp lại này tiếp tục cho đến khi tất cả các nếp gấp đã được sử dụng. Mỗi lần lặp lại cho độ chính xác của riêng nó. Độ chính xác của mô hình trở thành giá trị trung bình của tất cả các độ chính xác này.

keras cho phép bạn triển khai xác thực chéo K-lần thông qua shell bọc KerasClassifier . Shell bọc này là từ xác thực chéo scikit-learn . Bạn sẽ bắt đầu bằng lệnh hàm xác nhận chéo cross_val_score và KerasClassifier . Để thực hiện việc này, hãy chèn và chạy mã sau trong ô sổ ghi chép của bạn:

from keras.wrappers.scikit_learn import KerasClassifier from sklearn.model_selection import cross_val_score 

Để tạo hàm mà bạn sẽ chuyển đến KerasClassifier , hãy thêm mã này vào ô tiếp theo:

def make_classifier():     classifier = Sequential()     classifier.add(Dense(9, kernel_initializer = "uniform", activation = "relu", input_dim=18))     classifier.add(Dense(1, kernel_initializer = "uniform", activation = "sigmoid"))     classifier.compile(optimizer= "adam",loss = "binary_crossentropy",metrics = ["accuracy"])     return classifier 

Tại đây, bạn tạo một hàm mà bạn sẽ chuyển cho KerasClassifier — hàm là một trong những đối số mà bộ phân loại mong đợi. Hàm là một shell bọc của thiết kế mạng nơ-ron mà bạn đã sử dụng trước đó. Các tham số được truyền vào cũng tương tự như các tham số được sử dụng trước đó trong hướng dẫn. Trong hàm, trước tiên bạn khởi tạo trình phân loại bằng Sequential() , sau đó bạn sử dụng Dense để thêm lớp đầu vào và kết quả . Cuối cùng, bạn biên dịch bộ phân loại và gửi lại nó.

Để chuyển hàm bạn đã tạo vào KerasClassifier , hãy thêm dòng mã này vào sổ tay của bạn:

classifier = KerasClassifier(build_fn = make_classifier, batch_size=10, nb_epoch=1) 

KerasClassifier nhận ba đối số:

• build_fn : hàm với thiết kế mạng nơron
• batch_size : số lượng mẫu được chuyển qua mạng trong mỗi lần lặp
• nb_epoch : số kỷ nguyên mạng sẽ chạy

Tiếp theo, bạn áp dụng xác nhận chéo bằng cross_val_score của Scikit- cross_val_score . Thêm mã sau vào ô sổ ghi chép của bạn và chạy nó:

accuracies = cross_val_score(estimator = classifier,X = X_train,y = y_train,cv = 10,n_jobs = -1) 

Hàm này sẽ cung cấp cho bạn mười độ chính xác vì bạn đã chỉ định số lần gấp là 10. Do đó, bạn gán nó cho biến độ chính xác và sau đó sử dụng nó để tính độ chính xác trung bình. Nó có các đối số sau:

• estimator : trình phân loại mà bạn vừa xác định
• X : các tính năng của tập huấn luyện
• y : giá trị được dự đoán trong tập huấn luyện
• cv : số lần gấp
• n_jobs : số lượng CPU sẽ sử dụng (chỉ định nó là -1 sẽ sử dụng tất cả các CPU có sẵn)

Đến đây bạn đã áp dụng xác nhận chéo, bạn có thể tính giá trị trung bình và phương sai của độ chính xác. Để làm điều này, hãy chèn mã sau vào sổ tay của bạn:

mean = accuracies.mean() mean 

Trong kết quả của bạn, bạn sẽ thấy rằng giá trị trung bình là 83%:

Output
0.8343617910685696 

Để tính toán phương sai của độ chính xác, hãy thêm mã này vào ô sổ ghi chép tiếp theo:

variance = accuracies.var() variance 

Bạn thấy rằng phương sai là 0,00109. Vì phương sai rất thấp, nghĩa là mô hình của bạn đang hoạt động rất tốt.

Output
0.0010935021002275425 

Bạn đã cải thiện độ chính xác của mô hình bằng cách sử dụng xác thực chéo K-Fold. Trong bước tiếp theo, bạn sẽ giải quyết vấn đề trang bị quá nhiều.

Bước 9 - Thêm quy định bỏ học để chống lại tình trạng quá phù hợp

Các mô hình dự đoán dễ gặp sự cố được gọi là trang bị quá mức . Đây là một kịch bản trong đó mô hình ghi nhớ các kết quả trong tập huấn luyện và không thể tổng quát hóa trên dữ liệu mà nó chưa thấy. Thông thường, bạn quan sát thấy trang bị quá mức khi bạn có một sự khác biệt rất cao về độ chính xác. Để giúp chống lại việc lắp quá nhiều trong mô hình của bạn, bạn sẽ thêm một lớp vào mô hình của bạn .

Trong mạng nơ-ron, quy định bỏ trang là kỹ thuật chống lại việc trang bị quá mức bằng cách thêm một lớp Dropout trong mạng nơ-ron của bạn. Nó có một tham số rate cho biết số lượng tế bào thần kinh sẽ ngừng hoạt động ở mỗi lần lặp. Quá trình vô hiệu hóa neruron thường là ngẫu nhiên. Trong trường hợp này, bạn chỉ định 0,1 là tỷ lệ nghĩa là 1% tế bào thần kinh sẽ ngừng hoạt động trong quá trình đào tạo. Thiết kế mạng được giữ nguyên.

Để thêm lớp Dropout của bạn, hãy thêm mã sau vào ô tiếp theo:

from keras.layers import Dropout  classifier = Sequential() classifier.add(Dense(9, kernel_initializer = "uniform", activation = "relu", input_dim=18)) classifier.add(Dropout(rate = 0.1)) classifier.add(Dense(1, kernel_initializer = "uniform", activation = "sigmoid")) classifier.compile(optimizer= "adam",loss = "binary_crossentropy",metrics = ["accuracy"]) 

Bạn đã thêm một lớp Dropout giữa lớp đầu vào và kết quả . Đặt tỷ lệ bỏ cuộc là 0,1 nghĩa là trong quá trình đào tạo, 15 tế bào thần kinh sẽ ngừng hoạt động để bộ phân loại không quá trang bị trên group đào tạo. Sau khi thêm Dropout và các lớp kết quả bạn sau đó biên soạn phân loại như bạn đã làm trước đó.

Bạn đã cố gắng chống lại sự vừa vặn quá mức trong bước này với lớp Dropout . Tiếp theo, bạn sẽ tiếp tục cải thiện mô hình bằng cách điều chỉnh các thông số bạn đã sử dụng khi tạo mô hình.

Bước 10 - Điều chỉnh siêu tham số

Tìm kiếm theo lưới là một kỹ thuật mà bạn có thể sử dụng để thử nghiệm với các thông số mô hình khác nhau nhằm thu được những thông số cung cấp cho bạn độ chính xác tốt nhất. Kỹ thuật này thực hiện điều này bằng cách thử các tham số khác nhau và trả về những tham số cho kết quả tốt nhất. Bạn sẽ sử dụng tìm kiếm lưới để tìm kiếm các thông số tốt nhất cho mô hình học sâu của bạn . Điều này sẽ giúp cải thiện độ chính xác của mô hình. scikit-learn cung cấp chức năng GridSearchCV để kích hoạt chức năng này. Đến đây bạn sẽ tiến hành sửa đổi hàm make_classifier để thử các tham số khác nhau.

Thêm mã này vào sổ tay của bạn để sửa đổi hàm make_classifier để bạn có thể kiểm tra các chức năng trình tối ưu hóa khác nhau:

from sklearn.model_selection import GridSearchCV def make_classifier(optimizer):     classifier = Sequential()     classifier.add(Dense(9, kernel_initializer = "uniform", activation = "relu", input_dim=18))     classifier.add(Dense(1, kernel_initializer = "uniform", activation = "sigmoid"))     classifier.compile(optimizer= optimizer,loss = "binary_crossentropy",metrics = ["accuracy"])     return classifier 

Bạn đã bắt đầu bằng lệnh GridSearchCV . Sau đó, bạn đã áp dụng các thay đổi đối với hàm make_classifier để bạn có thể thử các trình tối ưu hóa khác nhau. Bạn đã khởi tạo bộ phân loại, thêm lớp đầu vào và kết quả , sau đó biên dịch bộ phân loại. Cuối cùng, bạn đã trả lại trình phân loại để bạn có thể sử dụng nó.

Giống như trong bước 4, chèn dòng mã này để xác định bộ phân loại:

classifier = KerasClassifier(build_fn = make_classifier) 

Bạn đã xác định bộ phân loại bằng KerasClassifier , bộ này mong đợi một hàm thông qua tham số build_fn . Bạn đã gọi KerasClassifier và chuyển hàm make_classifier mà bạn đã tạo trước đó.

Đến đây bạn sẽ tiến hành cài đặt một số thông số mà bạn muốn thử nghiệm. Nhập mã này vào một ô và chạy:

params = {     'batch_size':[20,35],     'epochs':[2,3],     'optimizer':['adam','rmsprop'] } 

Ở đây bạn đã thêm các kích thước lô khác nhau, số kỷ nguyên và các loại chức năng của trình tối ưu hóa khác nhau.

Đối với một tập dữ liệu nhỏ như của bạn, kích thước lô từ 20–35 là tốt. Đối với các tập dữ liệu lớn, điều quan trọng là phải thử nghiệm với các kích thước lô lớn hơn. Sử dụng các con số thấp cho số kỷ nguyên đảm bảo bạn nhận được kết quả trong một khoảng thời gian ngắn. Tuy nhiên, bạn có thể thử nghiệm với những con số lớn hơn sẽ mất một lúc để hoàn thành tùy thuộc vào tốc độ xử lý của server của bạn. Các rmsprop tối ưu hóa adam và rmsprop từ keras là một lựa chọn tốt cho loại mạng nơ-ron này.

Đến đây bạn sẽ sử dụng các tham số khác nhau mà bạn đã xác định để tìm kiếm các tham số tốt nhất bằng cách sử dụng hàm GridSearchCV . Nhập mã này vào ô tiếp theo và chạy nó:

grid_search = GridSearchCV(estimator=classifier,                            param_grid=params,                            scoring="accuracy",                            cv=2) 

Chức năng tìm kiếm lưới mong đợi các tham số sau:

• estimator : bộ phân loại mà bạn đang sử dụng.
• param_grid : tập hợp các tham số mà bạn sẽ kiểm tra.
• scoring : số liệu bạn đang sử dụng.
• cv : số lần gấp bạn sẽ thử nghiệm.

Tiếp theo, bạn điều grid_search này với tập dữ liệu đào tạo của bạn :

grid_search = grid_search.fit(X_train,y_train) 

Đầu ra của bạn sẽ tương tự như sau, đợi một lát để hoàn thành:

Output
Epoch 1/2 5249/5249 [==============================] - 1s 228us/step - loss: 0.5958 - acc: 0.7645 Epoch 2/2 5249/5249 [==============================] - 0s 82us/step - loss: 0.3962 - acc: 0.8510 Epoch 1/2 5250/5250 [==============================] - 1s 222us/step - loss: 0.5935 - acc: 0.7596 Epoch 2/2 5250/5250 [==============================] - 0s 85us/step - loss: 0.4080 - acc: 0.8029 Epoch 1/2 5249/5249 [==============================] - 1s 214us/step - loss: 0.5929 - acc: 0.7676 Epoch 2/2 5249/5249 [==============================] - 0s 82us/step - loss: 0.4261 - acc: 0.7864 

Thêm mã sau vào ô sổ tay để có được các tham số tốt nhất từ tìm kiếm này bằng cách sử dụng thuộc tính best_params_ :

best_param = grid_search.best_params_ best_accuracy = grid_search.best_score_ 

Đến đây bạn có thể kiểm tra các thông số tốt nhất cho mô hình của bạn bằng mã sau:

best_param 

Đầu ra của bạn cho thấy rằng kích thước lô tốt nhất là 20 , số kỷ nguyên tốt nhất là 2 và trình tối ưu hóa adam là tốt nhất cho mô hình của bạn:

Output
{'batch_size': 20, 'epochs': 2, 'optimizer': 'adam'} 

Bạn có thể kiểm tra độ chính xác tốt nhất cho mô hình của bạn . Số best_accuracy number thể hiện độ chính xác cao nhất mà bạn nhận được từ các tham số tốt nhất sau khi chạy tìm kiếm lưới:

best_accuracy 

Đầu ra của bạn sẽ tương tự như sau:

Output
0.8533193637489285 

Bạn đã sử dụng GridSearch để tìm ra các thông số tốt nhất cho bộ phân loại của bạn . Bạn đã thấy rằng batch_size tốt nhất là 20, trình optimizer tốt nhất là trình tối ưu hóa adam và số kỷ nguyên tốt nhất là 2. Bạn cũng đã có được độ chính xác tốt nhất cho trình phân loại của bạn là 85%. Bạn đã xây dựng một mô hình giữ chân nhân viên có thể dự đoán nhân viên ở lại hay rời đi với độ chính xác lên đến 85%.

Kết luận

Trong hướng dẫn này, bạn đã sử dụng Keras để xây dựng một mạng nơ-ron nhân tạo dự đoán xác suất một nhân viên rời công ty. Bạn đã kết hợp kiến thức trước đây của bạn về học máy bằng cách sử dụng scikit-learn để đạt được điều này. Để cải thiện hơn nữa mô hình của bạn , bạn có thể thử các chức năng kích hoạt hoặc chức năng tối ưu hóa khác nhau từ keras . Bạn cũng có thể thử nghiệm với một số nếp gấp khác nhau hoặc thậm chí xây dựng một mô hình với một tập dữ liệu khác.

Đối với các hướng dẫn khác trong lĩnh vực học máy hoặc sử dụng TensorFlow, bạn có thể thử xây dựng mạng thần kinh để nhận dạng các chữ số viết tay hoặc các hướng dẫn học máy DigitalOcean khác.

---

---

Các tin liên quan