ĐẠI HỌC QUỐC GIA THÀNH PHỐ HỒ CHÍ MINH

TRƯỜNG ĐẠI HỌC CÔNG NGHỆ THÔNG TIN

KHOA KHOA HỌC VÀ KỸ THUẬT THÔNG TIN
🙣🙣✶🙡🙢

BÁO CÁO ĐỒ ÁN

HOME CREDIT – CREDIT RISK MODEL STABILITY

Lớp: CS116.O21
GVHD: Nguyễn Vũ Anh Khoa
Sinh viên thực hiện: Hoàng Quý Mùi – 21521147
Sơn Men Kâl – 21522178
Trần Trọng Nhân – 21522924
Lê Đại Trình – 22521536

Thành phố Hồ Chí Minh, tháng 6 năm 2024

MỤC LỤC
I. GIỚI THIỆU ......................................................................................................................... 1
1.1. Giới thiệu bài toán ......................................................................................................................1
1.2. Cách đánh giá .............................................................................................................................1
1.3. Mô tả bộ dữ liệu ..........................................................................................................................2
II. CÁC PHƯƠNG PHÁP LIÊN QUAN.................................................................................. 3
2.1. Tạo lớp Pipeline cho tiền xử lý ..................................................................................................3
2.2. Tạo lớp để tổng hợp các hàm chức năng ..................................................................................3
2.3. Tạo hàm đọc 1 file đồng thời tiền xử lý ....................................................................................3
2.4. Tạo hàm đọc nhiều file đồng thời tiền xử lý.............................................................................3
2.5. Tạo hàm xử lý các đặc trưng .....................................................................................................4
2.6. Tạo hàm Dataframe thành Pandas Dataframe với các cột phân loại....................................4
2.7. Tạo hàm tối ưu hóa bộ nhớ cho Dataframe .............................................................................4
III. PHƯƠNG PHÁP THỰC HIỆN ........................................................................................ 5
3.1. Khởi tạo dictionary lưu trữ các bộ dataframe.........................................................................5
3.2. Data preprocessing and Feautures engineering ......................................................................5
3.2.1. Bộ huấn luyện .......................................................................................................................................5
3.2.2. Bộ kiểm thử ..........................................................................................................................................7
3.3. Gộp bộ huấn luyện và bộ kiểm thử ...........................................................................................7
3.4. Tạo mô hình VotingModel và huấn luyện mô hình.................................................................8
IV. PHÂN TÍCH VÀ THẢO LUẬN KẾT QUẢ ....................................................................... 9
V. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN ............................................................................ 9
VI. PHÂN CHIA CÔNG VIỆC .............................................................................................. 10
Lập trình Python cho Máy học - CS116.O21

I. GIỚI THIỆU
1.1. Giới thiệu bài toán

Trong lĩnh vực tài chính tiêu dùng, thiếu lịch sử tín dụng có thể do nhiều lý do như tuổi trẻ
hoặc ưa thích dùng tiền mặt, khiến nhiều người bị từ chối vay. Nhà cung cấp tài chính cần
xác định khả năng trả nợ của khách hàng, và dữ liệu đóng vai trò quan trọng trong việc này.
Khoa học dữ liệu có thể giúp dự đoán khả năng trả nợ tốt hơn, làm cho các khoản vay dễ tiếp
cận hơn.

Hiện tại, các nhà cung cấp dùng thống kê và học máy để dự đoán rủi ro cho vay, nhưng hành
vi khách hàng thay đổi liên tục, đòi hỏi cập nhật thường xuyên bảng điểm, tốn nhiều thời
gian. Sự ổn định của bảng điểm là rất quan trọng để tránh cấp vay cho khách hàng không đủ
điều kiện. Home Credit, thành lập năm 1997, là nhà cung cấp tài chính tiêu dùng quốc tế, tập
trung vào vay có trách nhiệm cho những người ít hoặc không có lịch sử tín dụng. Cuộc thi
trên Kaggle nhằm cải thiện dự đoán rủi ro tín dụng, giúp chấp nhận nhiều đơn vay hơn và cải
thiện cuộc sống của những người thiếu lịch sử tín dụng.

1.2. Cách đánh giá

Trong cuộc thi "Home Credit - Credit Risk Model Stability" trên Kaggle, cách đánh giá các
mô hình dự đoán rủi ro tín dụng được thực hiện thông qua các bước cụ thể và sử dụng các
tiêu chí sau:
1. Điểm số ROC AUC: ROC AUC đo lường khả năng phân biệt khách hàng có khả năng
trả nợ và không trả nợ, với điểm số từ 0 đến 1 (1 là hoàn hảo, 0.5 là ngẫu nhiên).
2. Sự ổn định của mô hình: Mô hình phải duy trì hiệu suất qua các tập dữ liệu khác nhau
theo thời gian hoặc nhóm khách hàng khác nhau.
3. Quy trình đánh giá chéo (Cross-Validation): Đảm bảo mô hình không bị overfitting
bằng cách huấn luyện và kiểm tra trên các phần khác nhau của tập dữ liệu.
4. Xử lý dữ liệu thiếu và ngoại lệ: Mô hình phải dự đoán chính xác dù dữ liệu không đầy
đủ hoặc có giá trị bất thường.
5. Hiệu quả thực tế: Đánh giá dựa trên khả năng triển khai, tính khả dụng và duy trì hiệu
suất cao trong thực tế.
Thông qua các tiêu chí đánh giá trên, cuộc thi nhằm tìm ra những mô hình không chỉ chính
xác mà còn ổn định và khả thi trong việc ứng dụng thực tế, giúp các nhà cung cấp tài chính
tiêu dùng có thể chấp nhận nhiều đơn vay hơn và mở rộng sự bao gồm tài chính.
1.3. Các đặc trưng quan trọng
Trong bài toán "Home Credit - Credit Risk Model Stability," việc khai thác và phân tích các
thuộc tính/đặc trưng của dữ liệu là rất quan trọng để xây dựng các mô hình dự đoán rủi ro tín
dụng hiệu quả. Dưới đây là một số nhóm thuộc tính chính.

1. Thông tin cá nhân của khách hàng:

• Tuổi: Phân tích phân phối tuổi của khách hàng, xem xét ảnh hưởng của tuổi đến
khả năng trả nợ.
• Giới tính: Kiểm tra tỷ lệ nam/nữ trong tập dữ liệu và phân tích sự khác biệt về
hành vi tín dụng giữa các giới tính.
• Tình trạng hôn nhân: Đánh giá mối quan hệ giữa tình trạng hôn nhân và rủi ro tín
dụng.
2. Thông tin kinh tế và việc làm:

1
Lập trình Python cho Máy học - CS116.O21

• Thu nhập hàng năm: Phân tích phân phối thu nhập, xem xét ảnh hưởng của mức
thu nhập đến khả năng trả nợ.
• Nghề nghiệp: Phân loại nghề nghiệp và đánh giá mức độ rủi ro của các nhóm
nghề nghiệp khác nhau.
• Thời gian làm việc: Xem xét thời gian làm việc tại công ty hiện tại và mối quan
hệ với khả năng trả nợ.
3. Lịch sử tín dụng:
• Số lượng khoản vay trước đó: Kiểm tra xem khách hàng đã từng vay bao nhiêu
lần và khả năng trả nợ của họ trong quá khứ.
• Tình trạng các khoản vay trước: Phân tích tình trạng của các khoản vay trước (đã
trả xong, đang trả, quá hạn) và ảnh hưởng của chúng đến rủi ro tín dụng hiện tại.
• Mức dư nợ hiện tại: Đánh giá mức dư nợ hiện tại và khả năng trả nợ.
4. Thông tin tài sản:
• Giá trị tài sản: Phân tích giá trị tài sản của khách hàng và mối quan hệ với khả
năng trả nợ.
• Loại tài sản: Phân loại các loại tài sản và đánh giá rủi ro tín dụng dựa trên loại tài
sản mà khách hàng sở hữu.
5. Thông tin khác:
• Số lượng người phụ thuộc: Phân tích số lượng người phụ thuộc trong gia đình và
ảnh hưởng của nó đến khả năng trả nợ.
• Mục đích vay vốn: Đánh giá các mục đích vay vốn khác nhau và mức độ rủi ro
tương ứng.

2
Lập trình Python cho Máy học - CS116.O21

II. CÁC PHƯƠNG PHÁP LIÊN QUAN

2.1. Tạo lớp Pipeline cho tiền xử lý
Lớp Pipeline sẽ gồm các phương thức sau:
• set_table_dtypes(df): chuyển đổi kiểu dữ liệu dựa trên các điều kiện nhất định.
- Đầu vào là một dataframe
- Hàm trả về DataFrame với các kiểu dữ liệu đã được chuyển đổi.
• handle_dates(df): xử lý các cột ngày tháng trong Dataframe
- Đầu vào là một dataframe
- Hàm trả về DataFrame đã được sửa đổi.
• fileter_col(df): lọc ra các cột dựa trên điều kiện nhất định
- Đầu vào là một dataframe
- Hàm trả về DataFrame đã được lọc.
2.2. Tạo lớp để tổng hợp các hàm chức năng
Lớp tổng hợp hàm chức năng gồm các phương thức sau:
• num_expr(df): trích xuất các đặc trưng số
- Đầu vào là một dataframe
- Hàm trả về danh sách các biểu thức gồm giá trị lớn nhất, cuối cùng, trung bình
• date_expr(df): trích xuất các đặc trưng liên quan đến ngày tháng
- Đầu vào là một dataframe
- Hàm trả về danh sách các biểu thức gồm giá trị lớn nhất, cuối cùng, trung bình
• str_expr(df): trích xuất các đặc trưng chuỗi
- Đầu vào là một dataframe
- Hàm trả về danh sách các biểu thức gồm giá trị lớn nhất, cuối cùng
• other_expr(df): trích xuất các đặc trưng chuỗi
- Đầu vào là một dataframe
- Hàm trả về danh sách các biểu thức gồm giá trị lớn nhất, cuối cùng
• count_expr(df): trích xuất các đặc trưng chuỗi
- Đầu vào là một dataframe.
- Hàm trả về danh sách các biểu thức gồm giá trị lớn nhất, cuối cùng
• get_exprs(df)): tập hợp tất cả các biểu thức từ các phương thức trước để có danh sách
toàn diện các biểu thức trích xuất đặc trưng
- Đầu vào là một dataframe.
- Hàm trả về danh sách hợp nhất các biểu thức cho tất cả các loại đặc trưng.

2.3. Tạo hàm đọc 1 file đồng thời tiền xử lý

• read_file(path, depth=None)
- Đầu vào là đường dẫn tới tệp Parquet, một tham số tùy chọn chỉ độ sâu của
việc tập hợp đặc trưng (mặc định là None).
- Hàm trả về một dataframe đã được xử lý.
2.4. Tạo hàm đọc nhiều file đồng thời tiền xử lý
• read_files(regex_path, depth=None)
- Đầu vào là đường dẫn tới các tệp, một tham số tùy chọn chỉ độ sâu của việc
tập hợp đặc trưng (mặc định là None).
- Hàm trả về một dataframe đã được xử lý.

3
Lập trình Python cho Máy học - CS116.O21

2.5. Tạo hàm xử lý các đặc trưng

• feature_eng(df_base, depth_0, depth_1, depth_2): thêm các tính năng liên quan đến
ngày và nối dữ liệu bổ sung dựa trên case_id.
- Tham số đầu vào gồm:
▪ df_base: một dataframe
▪ depth_0, depth_1, depth_2: độ sâu của df_base
- Hàm trả về dataframe đã được xử lý
2.6. Tạo hàm Dataframe thành Pandas Dataframe với các cột phân loại
• to_pandas(df_data, cat_cols=None): chuyển đổi DataFrame từ Polars sang Pandas và
chuyển đổi các cột chỉ định sang kiểu dữ liệu phân loại nếu cần thiết.
- Đầu vào là một dataframe, danh sách cột cần đổi thành kiểu phân loại (mặc
định là None).
- Hàm trả về một dataframe đã được xử lý.
2.7. Tạo hàm tối ưu hóa bộ nhớ cho Dataframe
• reduce_mem_usage(df): tối ưu hóa việc sử dụng bộ nhớ của DataFrame bằng cách
điều chỉnh các kiểu dữ liệu của các cột của nó
- Đầu vào: một dataframe
- Hàm trả về dataframe đã được tối ưu hóa

4
Lập trình Python cho Máy học - CS116.O21

III. PHƯƠNG PHÁP THỰC HIỆN

3.1. Khởi tạo dictionary lưu trữ các bộ dataframe
Đầu tiên, định nghĩa ROOT là đường dẫn tới thư mục gốc, TRAIN_DIR là đường dẫn tới thư
mục cho dữ liệu huấn luyện, TEST_DIR là đường dẫn tới thư mục cho dữ liệu kiểm thử.
ROOT = Path("/kaggle/input/home-credit-credit-risk-model-stability")
TRAIN_DIR = ROOT / "parquet_files" / "train"
TEST_DIR = ROOT / "parquet_files" / "test"

Tạo một dictionary data_store_train để lưu trữ như sau:

data_store_train = {
"df_base": read_file(TRAIN_DIR / "train_base.parquet"),
"depth_0": [
read_file(TRAIN_DIR / "train_static_cb_0.parquet"),
read_files(TRAIN_DIR / "train_static_0_*.parquet"),
],
"depth_1": [
read_files(TRAIN_DIR / "train_applprev_1_*.parquet", 1),
read_file(TRAIN_DIR / "train_tax_registry_a_1.parquet", 1),
read_file(TRAIN_DIR / "train_tax_registry_b_1.parquet", 1),
read_file(TRAIN_DIR / "train_tax_registry_c_1.parquet", 1),
read_files(TRAIN_DIR / "train_credit_bureau_a_1_*.parquet", 1),
read_file(TRAIN_DIR / "train_credit_bureau_b_1.parquet", 1),
read_file(TRAIN_DIR / "train_other_1.parquet", 1),
read_file(TRAIN_DIR / "train_person_1.parquet", 1),
read_file(TRAIN_DIR / "train_deposit_1.parquet", 1),
read_file(TRAIN_DIR / "train_debitcard_1.parquet", 1),
],
"depth_2": [
read_file(TRAIN_DIR / "train_credit_bureau_b_2.parquet", 2),
]
}

Tương tự cho các file test bằng cách đổi ‘train’ thành ‘test’.

3.2. Data preprocessing and Feautures engineering

3.2.1. Bộ huấn luyện

• Áp dụng hàm feature_eng() để xử lý các đặc trưng ở dữ liệu huấn luyện được lưu trữ
trong từ điển data_store bằng cách:
df_train = feature_eng(**data_store_train)

• Áp dụng bộ lọc cột bằng cách sử dụng phương pháp filter_cols từ lớp Pipeline vào
DataFrame df_train bằng cách sử dụng phương pháp pipe.
df_train = df_train.pipe(Pipeline.filter_cols)

• Chuyển đổi DataFrame df_train sang DataFrame Pandas và lấy tên các cột phân loại.

5
Lập trình Python cho Máy học - CS116.O21

df_train, cat_cols = to_pandas(df_train)

• Giảm dung lượng bộ nhớ của DataFrame df_train bằng cách sử dụng hàm
reduce_mem_usage để tối ưu hóa việc sử dụng bộ nhớ.
df_train = reduce_mem_usage(df_train)

• Chọn các cột số (loại trừ các cột phân loại) từ DataFrame và lưu tên của chúng vào
biến nums.
nums = df_train.select_dtypes(exclude=’category’).columns

• Nhập các hàm combinations và permutations từ module itertools.

from itertools import combinations, permutations

• Tạo DataFrame nans_df để xác định các giá trị thiếu trong các cột số.
nans_df = df_train[nums].isna()

• Khởi tạo một từ điển trống để lưu trữ các cột số được nhóm lại dựa trên số lượng giá
trị thiếu.
nans_groups = {}

• Lặp qua từng cột số (col) và tính toán số lượng giá trị thiếu cho mỗi cột. Sau đó,
nhóm các cột dựa trên số lượng giá trị thiếu trong từ điển nans_groups.
for col in nums:
cur_group = nans_df[col].sum()
try:
nans_groups[cur_group].append(col)
except:
nans_groups[cur_group]=[col]

• Tạo hàm reduce_group(grps) nhằm giảm số lượng cột trong mỗi nhóm bằng cách
chọn cột có số lượng giá trị duy nhất cao nhất.
- Đầu vào: danh sách các nhóm, mỗi nhóm được đại diện bởi một danh sách tên
cột.
- Hàm trả về danh sách các cột được chọn trong mỗi nhóm.

• Tạo hàm group_columns_by_correlation(matrix, threshold=0.8) nhằm nhóm các cột

dựa trên giá trị tương quan của chúng.
- Đầu vào:
▪ matrix: DataFrame đại diện cho tập dữ liệu.
▪ threshold: Giá trị ngưỡng cho tương quan. Các cột có giá trị tương
quan lớn hơn hoặc bằng ngưỡng này sẽ được nhóm lại với nhau. Mặc
định là 0.8.
- Hàm trả về danh sách các nhóm cột mà mỗi nhóm chứa các cột có giá trị
tương quan trên ngưỡng đã chỉ định.

• Xử lý giá trị bị khuyết và loại bỏ cột dựa trên độ tương quan

- uses = []: Khởi tạo danh sách trống uses để lưu trữ danh sách cuối cùng các
cột được chọn.

6
Lập trình Python cho Máy học - CS116.O21

- for k, v in nans_groups.items(): Lặp qua từ điển nans_groups với k là khóa (số

lượng giá trị thiếu) và v là danh sách tên các cột có số lượng giá trị thiếu đó.
- Đối với Các Nhóm Có Nhiều Hơn Một Cột:
▪ if len(v) > 1: Kiểm tra nếu nhóm chứa nhiều hơn một cột.
▪ Vs = nans_groups[k]: Gán danh sách các cột v cho Vs.
▪ grps = group_columns_by_correlation(df_train[Vs], threshold=0.8):
Nhóm các cột trong Vs dựa trên tương quan của chúng bằng ngưỡng
0.8.
▪ use = reduce_group(grps): Giảm các nhóm bằng cách chọn các cột có
số lượng giá trị duy nhất cao nhất bằng hàm reduce_group.
▪ uses = uses + use: Thêm các cột được chọn vào danh sách uses.
- Đối với Các Nhóm Có Một Cột:
▪ else: Nếu nhóm chỉ chứa một cột,
▪ uses = uses + v: Thêm trực tiếp cột vào danh sách uses.
3.2.2. Bộ kiểm thử
• Áp dụng hàm feature_eng() để xử lý các đặc trưng ở dữ liệu huấn luyện được lưu trữ
trong từ điển data_store bằng cách:
df_test = feature_eng(**data_store_test)

• Chọn các cột trong df_test khớp với các cột trong df_train, ngoại trừ cột "target".
Điều này đảm bảo rằng tập kiểm tra có các tính năng giống như tập huấn luyện.
df_test = df_test.select([col for col in df_train.columns if col != "target"])

• Chuyển đổi DataFrame df_train sang DataFrame Pandas và lấy tên các cột phân loại.
df_test, cat_cols = to_pandas(df_test)

• Giảm dung lượng bộ nhớ của DataFrame df_train bằng cách sử dụng hàm
reduce_mem_usage để tối ưu hóa việc sử dụng bộ nhớ.
df_test = reduce_mem_usage(df_test)

3.3. Gộp bộ huấn luyện và bộ kiểm thử

• Thêm cột ‘target’ vào bộ huấn luyện với các giá trị = 0
df_train['target'] = 0

• Thêm cột ‘target’ vào bộ kiểm thử với các giá trị = 1
df_test['target'] = 1

• Gộp bộ huấn luyện và bộ kiểm thử dọc theo các hàng và tối ưu hóa bộ nhớ
df_train = pd.concat([df_train, df_test])
df_train = reduce_mem_usage(df_train)

• Lấy cột ‘target’ và xóa các cột không cần thiết

y = df_train["target"]
df_train= df_train.drop(columns=["target", "case_id", "WEEK_NUM"])

7
Lập trình Python cho Máy học - CS116.O21

• Sử dụng joblib để lưu các bộ dữ liệu (df_train), mục tiêu (y) và bộ kiểm tra (df_test)
vào tệp có tên data.pkl
joblib.dump((df_train,y,df_test),'data.pkl')

3.4. Tạo mô hình VotingModel và huấn luyện mô hình

• Tạo một lớp VotingModel(BaseEstimator, RegressorMixin): tổng hợp tùy chỉnh sử
dụng phương pháp bỏ phiếu để tổng hợp dự đoán từ nhiều mô hình con gồm các
phương thức.
- __init__(self, estimators): Hàm khởi tạo này nhận vào một danh sách các mô
hình đã được huấn luyện (estimators) và gán nó cho thuộc tính self.estimators.
- fit(self, X, y=None): trả về đối tượng self.
- predict(self, X): Phương thức này thực hiện dự đoán bằng cách áp dụng tất cả
các mô hình con lên dữ liệu đầu vào X và lấy trung bình dự đoán của các mô
hình này. Kết quả là một mảng các giá trị dự đoán trung bình.
- predict_proba(self, X): Phương thức này thực hiện dự đoán xác suất bằng cách
áp dụng tất cả các mô hình con lên dữ liệu đầu vào X và lấy trung bình xác
suất dự đoán của các mô hình này. Kết quả là một mảng các xác suất dự đoán
trung bình.

class VotingModel(BaseEstimator, RegressorMixin):

def __init__(self, estimators):
super().__init__()
self.estimators = estimators

def fit(self, X, y=None):

return self

def predict(self, X):

y_preds = [estimator.predict(X) for estimator in self.estimators]
return np.mean(y_preds, axis=0)

def predict_proba(self, X):

y_preds = [estimator.predict_proba(X) for estimator in self.estimators]
return np.mean(y_preds, axis=0)

• Huấn luyện và lưu trữ mô hình đã huấn luyện vào một danh sách rỗng (sử dụng
LGBMClassifier())
fitted_models_lgb=[]
model = lgb.LGBMClassifier()
model.fit(df_train,y)
fitted_models_lgb.append(model)

• Dự đoán kết quả và lưu vào file submission.csv

8
Lập trình Python cho Máy học - CS116.O21

df_test = df_test.drop(columns=["WEEK_NUM",'target'])
df_test = df_test.set_index("case_id")

y_pred = pd.Series(model.predict_proba(df_test)[:,1], index=df_test.index)

condition=y_pred<0.98
df_subm = pd.read_csv("/kaggle/working/sub.csv")
df_subm = df_subm.set_index("case_id")

df_subm.loc[condition, 'score'] = (df_subm.loc[condition, 'score'] - 0.073).clip(0)

df_subm.to_csv("submission.csv")

IV. PHÂN TÍCH VÀ THẢO LUẬN KẾT QUẢ

Sau khi có file submission.csv, nhóm đã nộp kết quả và có được kết quả như hình:

Hình IV.1. Kết quả cuối cùng trên Kaggle

V. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN

9
Lập trình Python cho Máy học - CS116.O21

VI. PHÂN CHIA CÔNG VIỆC

10