Binning còn được gọi là nhóm hoặc rời rạc hóa là một kỹ thuật xử lý trước dữ liệu phổ biến được sử dụng để nhóm các khoảng thời gian dữ liệu liên tục thành "thùng" hoặc "nhóm". Trong bài viết này, chúng ta sẽ thảo luận về 4 phương pháp để tạo các giá trị số bằng thư viện python Pandas
Ảnh của Pawel Czerwinski trên BaptMethods
Chúng tôi tạo dữ liệu tổng hợp sau đây cho mục đích minh họa
import pandas as pd # version 1.3.5
import numpy as npdef create_df[]: df = pd.DataFrame[{'score': np.random.randint[0,101,1000]}] return dfdf = create_df[]df.head[]
Dữ liệu bao gồm điểm học tập từ 0 đến 100 cho 1000 sinh viên. Nhiệm vụ là sắp xếp các điểm số thành các loại giá trị “A”, “B” và “C” trong đó “A” là điểm tốt nhất và “C” là điểm kém hơn
Hình ảnh của tác giả1. giữa & loc
Phương thức
df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
0 của Pandas trả về một vectơ boolean chứa True bất cứ nơi nào phần tử Sê-ri tương ứng nằm giữa các giá trị biên trái và phải[1]
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
Thông số
df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
1. ranh giới bên trái
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
2. ranh giới bên phải
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
3. Bao gồm ranh giới nào. Các giá trị được chấp nhận là {“cả hai”, “không”, “trái”, “phải”}
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
Cho phép phân loại điểm của học sinh thành các lớp dựa trên các khoảng thời gian sau
- A. [80, 100]
- B. [50, 80]
- C. [0, 50]
Trong đó dấu ngoặc vuông
df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
4 và dấu ngoặc tròn df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
5 cho biết giá trị ranh giới lần lượt là bao gồm và loại trừChúng tôi xác định
df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
6 nằm giữa các khoảng thời gian quan tâm và gán các giá trị df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
7 tương ứng cho nó. Đối với điểm “A” và “B”, chỉ bao gồm ranh giới bên phải do đó chúng tôi chuyển df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
2 cho tham số df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
3. Đối với cấp "C", cả hai ranh giới đều được bao gồm do đó chúng tôi đã chuyển df.grade.value_counts[]
0 cho tham số df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
3df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
Hình ảnh của tác giả
Đây là số học sinh trong mỗi thùng
df.grade.value_counts[]
Hình ảnh của tác giả
Phương pháp này yêu cầu một dòng mã mới cho mỗi thùng do đó nó chỉ phù hợp với các trường hợp có ít thùng
2. cắtGiá trị bin thành các khoảng rời rạc. Sử dụng cắt khi bạn cần phân đoạn và sắp xếp các giá trị dữ liệu vào các thùng. Hàm này cũng hữu ích để chuyển từ biến liên tục sang biến phân loại[2]
Các sinh viên được đánh dấu dựa trên cùng một khoảng thời gian như ví dụ trên. Đây là những thông số được sử dụng
df.grade.value_counts[]
2. Mảng đầu vào được binned. Phải là 1 chiềudf.grade.value_counts[]
3. Chuỗi vô hướng. Xác định các cạnh thùng cho phép chiều rộng không đồng nhấtdf.grade.value_counts[]
4. Chỉ định nhãn cho các thùng được trả lại. Phải có cùng chiều dài với các thùng kết quảdf.grade.value_counts[]
5. [bool] Khoảng đầu tiên có nên bao hàm bên trái hay không
bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
Chúng tôi tạo danh sách
df.grade.value_counts[]
3 chứa các giá trị ranh giới của các thùng và danh sách df.grade.value_counts[]
4 chứa các nhãn thùng tương ứngĐây là số học sinh trong mỗi thùng
df.grade.value_counts[]
Hình ảnh của tác giả
Kết quả giống với ví dụ đầu tiên
3. qcutChức năng rời rạc dựa trên lượng tử. Biến rời rạc thành các nhóm có kích thước bằng nhau dựa trên thứ hạng hoặc dựa trên lượng tử mẫu[3]
Trong các ví dụ trước, chúng tôi đã xác định khoảng cách điểm số cho từng lớp dẫn đến số lượng học sinh không đồng đều trong mỗi nhóm lớp. Trong ví dụ sau, chúng tôi cố gắng chia học sinh thành 3 nhóm lớp, mỗi nhóm có số học sinh [xấp xỉ] bằng nhau. Chúng tôi có 1000 học sinh nên mỗi thùng nên có khoảng 333 học sinh. Các học sinh được xếp hạng đầu tiên theo điểm số của họ và một phần ba học sinh trên cùng, giữa và dưới cùng được xếp vào các ô xếp hạng “A”, “B” và “C” tương ứng
Đây là các tham số đã được sử dụng trong ví dụ sau
df.grade.value_counts[]
2. Mảng đầu vào được binned. Phải là 1 chiềudf.grade.value_counts[]
9. Số lượng phân vị. 10 cho deciles, 4 cho tứ phân vị, v.v. Mảng lượng tử xen kẽ, e. g. [0,. 25,. 5,. 75, 1. ] cho phần tưdf.grade.value_counts[]
4. Chỉ định nhãn cho các thùng được trả lại. Phải có cùng chiều dài với các thùng kết quảbins = [0, 50, 80, 100]
1. [bool] Có trả lại [thùng, nhãn] hay không. Có thể hữu ích nếu các thùng được đưa ra dưới dạng vô hướng
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
df['grade'], cut_bin = pd.qcut[df['score'], q = 3, labels = ['C', 'B', 'A'], retbins = True]
df.head[]
Hình ảnh của tác giả
Vượt qua
bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
1 vì bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
3 trả về ranh giới thùngprint [cut_bin]
>> [ 0. 36. 68. 100.]
Các thùng có các khoảng sau
- C. [0, 36]
- B. [36, 68]
- A. [68, 100]
Chúng tôi có thể kiểm tra xem có bao nhiêu học sinh trong mỗi ngăn lớp bằng cách sử dụng
bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
4. Lý tưởng nhất là mỗi thùng nên có khoảng 333 học sinhdf.grade.value_counts[]
Hình ảnh của tác giả4. số lượng giá trị
Mặc dù gấu trúc
bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
5 thường được sử dụng để đếm số lượng giá trị duy nhất trong một chuỗi, nhưng nó cũng có thể được sử dụng để nhóm các giá trị vào các ngăn mở một nửa bằng cách sử dụng tham số df.grade.value_counts[]
3[4]df['score'].value_counts[bins = 3, sort = False]
Theo mặc định,
bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
5 sắp xếp chuỗi trả về theo thứ tự giá trị giảm dần. Đặt bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
8 thành bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
9 để sắp xếp chuỗi theo thứ tự tăng dần của chỉ mụcHình ảnh của tác giả
Chỉ số sê-ri đề cập đến phạm vi khoảng thời gian cho mỗi ngăn trong đó dấu ngoặc vuông
df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
4 và dấu ngoặc tròn df.loc[df['score'].between[0, 50, 'both'], 'grade'] = 'C'
df.loc[df['score'].between[50, 80, 'right'], 'grade'] = 'B'
df.loc[df['score'].between[80, 100, 'right'], 'grade'] = 'A'
5 cho biết giá trị ranh giới lần lượt là bao gồm và loại trừ. Các giá trị của chuỗi được trả về cho biết có bao nhiêu bản ghi trong mỗi ngănKhông giống như ví dụ về
df.grade.value_counts[]
2, số lượng bản ghi trong mỗi ngăn không nhất thiết phải giống nhau [xấp xỉ]. bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
5 không chỉ định số lượng hồ sơ bằng nhau vào mỗi ngăn điểm, thay vào đó nó chia phạm vi điểm thành 3 phần bằng nhau dựa trên điểm tối đa và tối thiểu. Điểm số có giá trị tối thiểu là 0 và giá trị tối đa là 100, do đó mỗi phần trong số 3 phần đều xấp xỉ trong phạm vi 33. 33. Điều này cũng giải thích tại sao ranh giới của các thùng là bội số của 33. 33 ngoại trừ ranh giới thấp nhất bên tráiChúng tôi cũng có thể xác định ranh giới bin bằng cách chuyển vào danh sách các ranh giới
df['score'].value_counts[bins = [0,50,80,100], sort = False]
Hình ảnh của tác giả
Điều này cho chúng ta kết quả giống như ví dụ 1 và 2
Bản tóm tắtTrong bài viết này, chúng tôi đã kiểm tra cách phân loại các giá trị liên tục bằng cách sử dụng
df.grade.value_counts[]
4, df.grade.value_counts[]
5, df.grade.value_counts[]
2 và bins = [0, 50, 80, 100]
labels = ['C', 'B', 'A']
df['grade'] = pd.cut[x = df['score'], bins = bins, labels = labels, include_lowest = True]
5. Bạn có thể tìm thấy sổ tay Colab cho ví dụ trên tại đây