การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder
ผู้เรียนจะเปลี่ยนกลุ่มแบบมีลำดับให้เป็นจำนวนเต็ม และกลุ่มแบบไม่มีลำดับให้เป็นเวกเตอร์วันฮอต พร้อมจัดการกลุ่มที่ไม่รู้จักขณะอนุมาน
การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder เป็นบทเรียน Machine Learning Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Machine Learning Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดจึงต้องมีการเข้ารหัสข้อมูลเชิงหมวดหมู่
แบบจำลองการเรียนรู้ของเครื่องทำงานกับ ตัวเลข ไม่ใช่สตริง คอลัมน์ที่มีค่าอย่าง 'red', 'green', 'blue' ไม่สามารถป้อนเข้าสู่ตัวประมาณค่าของ scikit-learn ได้โดยตรง คุณต้องแปลงหมวดหมู่ให้เป็นตัวแทนเชิงตัวเลขก่อนการฝึก การเลือกวิธีเข้ารหัสมีความสำคัญอย่างมาก เพราะ การเข้ารหัสที่ไม่เหมาะสมอาจสร้างความสัมพันธ์เชิงลำดับที่ไม่มีอยู่จริง หรือทำให้จำนวนมิติเพิ่มขึ้นอย่างมาก บทเรียนนี้ครอบคลุมตัวเข้ารหัสสำคัญสองชนิด ได้แก่ OrdinalEncoder สำหรับหมวดหมู่ที่มีลำดับ และ OneHotEncoder สำหรับหมวดหมู่ที่ไม่มีลำดับ
import pandas as pd
df = pd.DataFrame({
'size': ['small', 'medium', 'large', 'medium'],
'color': ['red', 'blue', 'green', 'red'],
'price': [10.5, 20.0, 15.0, 18.5]
})
print(df.dtypes)
# size and color are 'object' (string) — must be encoded before modellingหมวดหมู่แบบมีลำดับเทียบกับแบบนามบัญญัติ
ตัวแปรเชิงหมวดหมู่ไม่ได้มีลักษณะเหมือนกันทั้งหมด หมวดหมู่แบบมีลำดับ มีลำดับที่มีความหมาย: เล็ก < กลาง < ใหญ่ หรือ แย่ < พอใช้ < ดี < ยอดเยี่ยม ส่วน หมวดหมู่แบบนามบัญญัติ ไม่มีลำดับในตัวเอง: แดง, น้ำเงิน, เขียว เป็นเพียงป้ายกำกับ การเลือกวิธีเข้ารหัสผิดจะสร้างความสัมพันธ์เท็จ ตัวอย่างเช่น การเข้ารหัสสีที่ไม่มีลำดับเป็นจำนวนเต็ม 0, 1, 2 จะบอกแบบจำลองว่าสีน้ำเงิน (1) อยู่ระหว่างสีแดง (0) และสีเขียว (2) ซึ่งไม่มีความหมาย ต้องระบุเสมอว่าตัวแปรเป็นแบบมีลำดับหรือนามบัญญัติก่อนทำการเข้ารหัส
# Ordinal: clear ordering
ordinal_example = ['low', 'medium', 'high', 'very high']
# Nominal: no meaningful ordering
nominal_example = ['cat', 'dog', 'bird']
# Wrong approach for nominal: integer encoding implies order
# 0=cat, 1=dog, 2=bird -- model thinks dog is between cat and bird
# Correct approach for nominal: one-hot encoding
# cat -> [1, 0, 0]
# dog -> [0, 1, 0]
# bird -> [0, 0, 1]OrdinalEncoder: การแมปลำดับเป็นจำนวนเต็ม
OrdinalEncoder จะแมปแต่ละหมวดหมู่เป็นจำนวนเต็มตามลำดับที่กำหนด คุณระบุพารามิเตอร์ categories เป็นรายการของรายการย่อย โดยตำแหน่งจะเป็นตัวกำหนดจำนวนเต็มที่ได้รับ หากไม่ระบุลำดับ scikit-learn จะกำหนดจำนวนเต็มตามลำดับตัวอักษร ซึ่งอาจสอดคล้องหรือไม่สอดคล้องกับลำดับที่แท้จริงก็ได้ ต้องระบุลำดับของหมวดหมู่อย่างชัดเจนเสมอ สำหรับตัวแปรแบบมีลำดับ เพื่อให้แบบจำลองเรียนรู้ความสัมพันธ์ระหว่างค่าได้อย่างถูกต้อง
from sklearn.preprocessing import OrdinalEncoder
import numpy as np
X = np.array([['low'], ['high'], ['medium'], ['low'], ['high']])
# Specify order explicitly: low=0, medium=1, high=2
enc = OrdinalEncoder(categories=[['low', 'medium', 'high']])
X_encoded = enc.fit_transform(X)
print('Ordinal encoded:', X_encoded.flatten())
# [0. 2. 1. 0. 2.]OneHotEncoder: ตัวแปรจำลองสำหรับข้อมูลแบบนามบัญญัติ
OneHotEncoder จะสร้างคอลัมน์ไบนารีหนึ่งคอลัมน์ต่อหนึ่งหมวดหมู่ สำหรับคุณลักษณะ สี ที่มีค่า แดง, เขียว, น้ำเงิน จะได้สามคอลัมน์ ได้แก่ color_red, color_green, color_blue โดยในแต่ละแถวจะมีค่าเป็น 1 เพียงคอลัมน์เดียว และคอลัมน์ที่เหลือเป็น 0 วิธีนี้ช่วยหลีกเลี่ยงการสื่อถึงลำดับใด ๆ ข้อแลกเปลี่ยนคือจำนวนมิติ คุณลักษณะที่มีค่าไม่ซ้ำกัน 100 ค่าจะสร้างคอลัมน์ใหม่ 100 คอลัมน์ โดยค่าเริ่มต้น OneHotEncoder ของ scikit-learn จะตัดหมวดหมู่หนึ่งหมวดออก (การเข้ารหัสตัวแปรจำลอง) เพื่อหลีกเลี่ยงภาวะพหุสหสัมพันธ์เชิงเส้นอย่างสมบูรณ์ในแบบจำลองเชิงเส้น
from sklearn.preprocessing import OneHotEncoder
import numpy as np
X = np.array([['red'], ['green'], ['blue'], ['red']])
enc = OneHotEncoder(sparse_output=False) # dense output for readability
X_ohe = enc.fit_transform(X)
print('Categories:', enc.categories_)
print('One-hot encoded:\n', X_ohe)
# [[0. 0. 1.]
# [0. 1. 0.]
# [1. 0. 0.]
# [0. 0. 1.]]การตัดหมวดหมู่ออกหนึ่งหมวด: การเข้ารหัสตัวแปรจำลอง
เมื่อใช้ OneHotEncoder กับแบบจำลองเชิงเส้น การเก็บไว้ทั้ง K คอลัมน์สำหรับตัวแปรที่มี K หมวดหมู่จะทำให้เกิด ภาวะพหุสหสัมพันธ์เชิงเส้นอย่างสมบูรณ์ เพราะผลรวมของคอลัมน์มีค่าเป็น 1 ดังนั้นคอลัมน์ใดคอลัมน์หนึ่งจึงเป็นการผสมเชิงเส้นของคอลัมน์อื่น ๆ ได้ ทำให้เมทริกซ์การออกแบบเป็นเอกฐาน (ไม่สามารถหาเมทริกซ์ผกผันได้) การตั้งค่า drop='first' จะตัดหมวดหมู่แรกออก เหลือ K-1 คอลัมน์ที่อธิบายตัวแปรได้ครบถ้วนโดยไม่มีความซ้ำซ้อน สำหรับแบบจำลองที่อาศัยต้นไม้ การเก็บไว้ทั้ง K คอลัมน์ไม่มีผลเสีย และบางครั้งอาจให้ผลดีกว่าเล็กน้อย ดังนั้นคุณจึงใช้ drop=None ได้
from sklearn.preprocessing import OneHotEncoder
import numpy as np
X = np.array([['red'], ['green'], ['blue'], ['red']])
# Drop first category to avoid multicollinearity
enc = OneHotEncoder(drop='first', sparse_output=False)
X_ohe = enc.fit_transform(X)
print('Categories kept (first dropped):', enc.get_feature_names_out())
print('Encoded:\n', X_ohe)
# Only 2 columns instead of 3การจัดการหมวดหมู่ที่ไม่รู้จักขณะอนุมาน
ความท้าทายในโลกจริงคือ ในขณะอนุมานอาจพบหมวดหมู่ที่ไม่เคยปรากฏในข้อมูลฝึก โดยค่าเริ่มต้น OrdinalEncoder และ OneHotEncoder จะแสดงข้อผิดพลาดเมื่อพบหมวดหมู่ที่ไม่รู้จัก ให้ตั้งค่า handle_unknown='ignore' ใน OneHotEncoder เพื่อสร้างแถวที่มีค่าเป็นศูนย์ทั้งหมดสำหรับค่าที่ไม่รู้จัก (แบบจำลองจะทำนายโดยไม่ใช้คุณลักษณะนั้น) สำหรับ OrdinalEncoder ให้ตั้งค่า handle_unknown='use_encoded_value' พร้อมกับ unknown_value=-1 เพื่อระบุค่าที่ไม่รู้จักอย่างชัดเจน
from sklearn.preprocessing import OneHotEncoder
import numpy as np
# Training data: only red and blue seen
X_train = np.array([['red'], ['blue'], ['red']])
X_test = np.array([['green']]) # Unseen at training time
enc = OneHotEncoder(handle_unknown='ignore', sparse_output=False)
enc.fit(X_train)
X_test_enc = enc.transform(X_test)
print('Unknown category encodes as all zeros:', X_test_enc)
# [[0. 0.]] -- no error, unknown silently encoded as zerosการเข้ารหัสเป้าหมายสำหรับคุณลักษณะที่มีจำนวนค่ามาก
เมื่อคุณลักษณะเชิงหมวดหมู่มีค่าที่ไม่ซ้ำกันหลายร้อยหรือหลายพันค่า (เช่น รหัสไปรษณีย์หรือรหัสสินค้า) การเข้ารหัสแบบวันฮอตจะสร้างเมทริกซ์ขนาดใหญ่จนจัดการได้ยาก การเข้ารหัสเป้าหมาย จะแทนที่แต่ละหมวดหมู่ด้วยค่าเฉลี่ยของตัวแปรเป้าหมายสำหรับหมวดหมู่นั้น วิธีนี้บีบอัดคุณลักษณะที่มีจำนวนค่ามากให้เหลือเพียงคอลัมน์เดียว ความเสี่ยงคือ การรั่วไหลของเป้าหมาย หากคุณเข้ารหัสโดยใช้ค่าเฉลี่ยที่คำนวณจากแถวเดียวกับที่ใช้ฝึก แบบจำลองจะจดจำรูปแบบแทนที่จะนำไปใช้กับข้อมูลใหม่ได้ดี ต้องใช้การเข้ารหัสเป้าหมายแบบแบ่งชุดย่อยข้ามชุดเสมอเพื่อป้องกันการรั่วไหล
import pandas as pd
import numpy as np
df = pd.DataFrame({
'city': ['NYC', 'LA', 'NYC', 'Chicago', 'LA', 'NYC'],
'churned': [1, 0, 1, 0, 1, 0]
})
# Simple (leaky) target encoding
target_mean = df.groupby('city')['churned'].mean()
df['city_encoded'] = df['city'].map(target_mean)
print(df[['city', 'city_encoded', 'churned']])
# Use cross-fold encoding in practice to avoid leakageการเข้ารหัสไบนารีสำหรับจำนวนค่าระดับปานกลาง
การเข้ารหัสไบนารี เป็นทางเลือกกึ่งกลางระหว่างการเข้ารหัสแบบมีลำดับและแบบวันฮอต รหัสจำนวนเต็มแต่ละค่าจะถูกแปลงเป็นรูปแบบไบนารี ทำให้ได้ log2(K) คอลัมน์แทนที่จะเป็น K คอลัมน์ ตัวอย่างเช่น หมวดหมู่ 8 หมวดต้องใช้คอลัมน์ไบนารีเพียง 3 คอลัมน์แทนคอลัมน์แบบวันฮอต 8 คอลัมน์ วิธีนี้ช่วยลดจำนวนมิติได้อย่างมากสำหรับคุณลักษณะที่มีหมวดหมู่ 10–100 ค่า ไลบรารี category_encoders มี BinaryEncoder ที่จัดการการแปลงนี้ด้วยส่วนติดต่อการเขียนโปรแกรมที่เข้ากันได้กับ scikit-learn
# Conceptual example: binary encoding manually
# Category -> Integer -> Binary columns
categories = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
for i, cat in enumerate(categories):
binary = format(i, '03b') # 3 bits for 8 categories
print(f'{cat} -> {i} -> {list(binary)}')
# A -> 0 -> [0, 0, 0]
# B -> 1 -> [0, 0, 1]
# ...
# H -> 7 -> [1, 1, 1]
# 8 categories need only 3 columns (vs 8 with one-hot)การใช้ตัวเข้ารหัสใน ColumnTransformer
ชุดข้อมูลจริงมักมีคอลัมน์ตัวเลข คอลัมน์แบบมีลำดับ และคอลัมน์แบบนามบัญญัติปะปนกัน ColumnTransformer จะใช้การแปลงที่แตกต่างกันกับคอลัมน์แต่ละกลุ่มแบบขนาน แล้วนำผลลัพธ์มาต่อกัน ให้ระบุคอลัมน์แบบมีลำดับด้วย OrdinalEncoder คอลัมน์แบบนามบัญญัติด้วย OneHotEncoder และคอลัมน์ตัวเลขด้วย StandardScaler ผลลัพธ์จะเป็นเมทริกซ์ตัวเลขเดียวที่สะอาดและพร้อมใช้กับตัวประมาณค่าของ scikit-learn ทุกชนิด นี่คือรูปแบบมาตรฐานสำหรับใช้งานจริง กับชุดข้อมูลที่มีชนิดข้อมูลผสมกัน
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OrdinalEncoder, OneHotEncoder, StandardScaler
preprocessor = ColumnTransformer([
('num', StandardScaler(), ['age', 'income']),
('ord', OrdinalEncoder(categories=[['low', 'medium', 'high']]), ['risk_level']),
('nom', OneHotEncoder(drop='first', sparse_output=False), ['city', 'product'])
])
# Result: numeric + ordinal encoded + one-hot columns in one matrixชื่อคุณลักษณะหลังการเข้ารหัส
หลังการเข้ารหัส เมทริกซ์คุณลักษณะของคุณจะมีคอลัมน์มากกว่า DataFrame เดิม และตัวแปลงของ scikit-learn จะติดตามชื่อใหม่เหล่านั้น เรียก get_feature_names_out() บน ColumnTransformer หรือ OneHotEncoder เพื่อดึงชื่อคุณลักษณะที่สร้างขึ้นมา สิ่งนี้จำเป็นต่อ การตีความแบบจำลอง เพราะการทราบว่าคอลัมน์แบบวันฮอตใดสอดคล้องกับหมวดหมู่เดิมใด ช่วยให้คุณตีความความสำคัญของคุณลักษณะจากป่าสุ่ม หรือค่าของ SHAP จากแบบจำลองการเพิ่มพูนตามการไล่ระดับได้อย่างถูกต้อง
from sklearn.preprocessing import OneHotEncoder
import numpy as np
X = np.array([['red', 'small'], ['blue', 'large'], ['green', 'medium']])
enc = OneHotEncoder(sparse_output=False)
enc.fit(X)
print('Feature names:', enc.get_feature_names_out(['color', 'size']))
# ['color_blue' 'color_green' 'color_red' 'size_large' 'size_medium' 'size_small']
X_enc = enc.transform(X)
print('Encoded shape:', X_enc.shape)กระบวนการเข้ารหัสแบบครบถ้วน: ตัวอย่างตั้งแต่ต้นจนจบ
ต่อไปนี้คือตัวอย่างกระบวนการที่มีการเข้ารหัสหลายรูปแบบอย่างครบถ้วน ColumnTransformer จัดการคอลัมน์สามชนิด ได้แก่ ปรับสเกลคุณลักษณะเชิงตัวเลข เข้ารหัสคุณลักษณะแบบมีลำดับเป็นจำนวนเต็มตามลำดับที่กำหนดอย่างชัดเจน และเปลี่ยนคุณลักษณะแบบนามบัญญัติให้เป็นคอลัมน์แบบวันฮอต จากนั้นกระบวนการจะได้รับการตรวจสอบไขว้ โดยฝึกการเข้ารหัสใหม่ภายในแต่ละชุดย่อยของ CV เพื่อป้องกันการรั่วไหล รูปแบบนี้ใช้ได้กับชุดข้อมูลทุกชนิด และพร้อมนำไปใช้งานจริงเมื่อฝึกด้วยชุดข้อมูลทั้งหมดแล้ว
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OrdinalEncoder, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
preprocessor = ColumnTransformer([
('num', StandardScaler(), ['age', 'income']),
('ord', OrdinalEncoder(categories=[['low', 'medium', 'high']]), ['risk']),
('ohe', OneHotEncoder(drop='first', handle_unknown='ignore'), ['city'])
])
pipeline = Pipeline([
('prep', preprocessor),
('clf', LogisticRegression(max_iter=500))
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='accuracy')
print('CV accuracy:', scores.mean().round(3))ตรวจสอบความเข้าใจอย่างรวดเร็ว
ทดสอบความเข้าใจแนวคิด Machine Learning with Python จากบทเรียนนี้
สรุปบทเรียน
ในบทเรียนนี้ คุณได้เรียนรู้ ความแตกต่างระหว่างหมวดหมู่แบบมีลำดับและแบบนามบัญญัติ และเหตุใดความแตกต่างนี้จึงกำหนดวิธีเข้ารหัส OrdinalEncoder สำหรับตัวแปรแบบมีลำดับ และ OneHotEncoder สำหรับตัวแปรแบบนามบัญญัติ รวมถึง วิธีจัดการหมวดหมู่ที่ไม่รู้จัก และการรวมตัวเข้ารหัสในกระบวนการ ColumnTransformer บทถัดไปเราจะสำรวจการรวมขั้นตอนการเตรียมข้อมูลทั้งหมดด้วย ColumnTransformer
เรียนรู้ Python ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 30
- บทเรียน
- 120
คำถามที่พบบ่อย
บทเรียน “การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Machine Learning Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder”
ผู้เรียนจะเปลี่ยนกลุ่มแบบมีลำดับให้เป็นจำนวนเต็ม และกลุ่มแบบไม่มีลำดับให้เป็นเวกเตอร์วันฮอต พร้อมจัดการกลุ่มที่ไม่รู้จักขณะอนุมาน คุณปฏิบัติ Machine Learning Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Machine Learning Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Machine Learning Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน
บทเรียน “การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Machine Learning Academy นี้ได้ไหม
ได้ บทเรียน Machine Learning Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การจัดการค่าที่หายไป: ลบ เติมค่า และทำเครื่องหมาย
- การปรับสเกลคุณลักษณะ: StandardScaler และ MinMaxScaler
- การเข้ารหัสตัวแปรเชิงกลุ่ม: OrdinalEncoder และ OneHotEncoder
- การรวมขั้นตอนด้วย ColumnTransformer