การจำแนกประเภทไบนารีของ TensorFlow: ตัวอย่างตัวแยกประเภทเชิงเส้น

โดย: เอเวลิน คลาร์ก เอเวลิน คลาร์ก
Hours วันที่อัพเดท

สองอย่างที่พบบ่อยที่สุด การเรียนรู้ภายใต้การดูแล งานคือการถดถอยเชิงเส้นและลักษณนามเชิงเส้น การถดถอยเชิงเส้นทำนายค่าในขณะที่ตัวแยกประเภทเชิงเส้นทำนายคลาส บทช่วยสอนนี้เน้นไปที่ตัวแยกประเภทเชิงเส้น

ลักษณนามเชิงเส้นคืออะไร?

A ลักษณนามเชิงเส้น ใน Machine Learning เป็นวิธีการค้นหาคลาสของออบเจ็กต์ตามคุณลักษณะในการจำแนกประเภททางสถิติ ทำให้การตัดสินใจจำแนกประเภทขึ้นอยู่กับค่าของการรวมเชิงเส้นของคุณลักษณะของวัตถุ ตัวแยกประเภทเชิงเส้นใช้ในปัญหาเชิงปฏิบัติ เช่น การจำแนกเอกสาร และปัญหาที่มีตัวแปรหลายตัว

ปัญหาการจำแนกประเภทคิดเป็นประมาณ 80 เปอร์เซ็นต์ของงานแมชชีนเลิร์นนิง การจำแนกประเภทมีจุดมุ่งหมายเพื่อทำนายความน่าจะเป็นของแต่ละชั้นเรียนโดยพิจารณาจากชุดข้อมูลนำเข้า ป้ายกำกับ (เช่น ตัวแปรตาม) เป็นค่าที่ไม่ต่อเนื่อง เรียกว่าคลาส

  1. หากป้ายกำกับมีเพียงสองคลาส อัลกอริธึมการเรียนรู้จะเป็น Binary Classifier
  2. ตัวแยกประเภทหลายคลาสจะจัดการป้ายกำกับที่มีคลาสมากกว่าสองชั้น

ตัวอย่างเช่น ปัญหาการจำแนกประเภทแบบไบนารีทั่วไปคือการทำนายความเป็นไปได้ที่ลูกค้าจะซื้อสินค้าซ้ำ การทำนายประเภทของสัตว์ที่แสดงในภาพเป็นปัญหาการจำแนกประเภทแบบหลายคลาส เนื่องจากมีสัตว์มากกว่าสองสายพันธุ์

ส่วนทางทฤษฎีของบทช่วยสอนนี้เน้นที่คลาสไบนารีเป็นหลัก คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับฟังก์ชันเอาต์พุตแบบหลายคลาสในบทช่วยสอนในอนาคต

ตัวแยกประเภทไบนารีทำงานอย่างไร

คุณได้เรียนรู้ในบทช่วยสอนก่อนหน้านี้ว่าฟังก์ชันประกอบด้วยตัวแปรสองประเภท ตัวแปรตามและชุดคุณลักษณะ (ตัวแปรอิสระ) ในการถดถอยเชิงเส้น ตัวแปรตามคือจำนวนจริงที่ไม่มีช่วง วัตถุประสงค์หลักคือการทำนายค่าของมันโดยการลดความคลาดเคลื่อนกำลังสองเฉลี่ยให้เหลือน้อยที่สุด

สำหรับ TensorFlow Binary Classifier ป้ายกำกับสามารถมีค่าจำนวนเต็มที่เป็นไปได้สองค่า ในกรณีส่วนใหญ่ จะเป็น [0,1] หรือ [1,2] ตัวอย่างเช่น วัตถุประสงค์คือเพื่อคาดการณ์ว่าลูกค้าจะซื้อผลิตภัณฑ์หรือไม่ ป้ายกำกับถูกกำหนดดังนี้:

  • Y = 1 (ลูกค้าซื้อสินค้า)
  • Y = 0 (ลูกค้าไม่ได้ซื้อสินค้า)

โมเดลนี้ใช้ฟีเจอร์ X เพื่อจัดประเภทลูกค้าแต่ละรายในกลุ่มที่มีแนวโน้มมากที่สุดที่เขาเป็นสมาชิก กล่าวคือ ผู้ที่อาจเป็นผู้ซื้อหรือไม่

ความน่าจะเป็นของความสำเร็จจะถูกคำนวณด้วย การถดถอยโลจิสติก- อัลกอริทึมจะคำนวณความน่าจะเป็นตามคุณลักษณะ X และคาดการณ์ความสำเร็จเมื่อความน่าจะเป็นนี้สูงกว่า 50 เปอร์เซ็นต์ อย่างเป็นทางการมากขึ้น ความน่าจะเป็นจะถูกคำนวณตามที่แสดงในตัวอย่างการจำแนกประเภทไบนารี TensorFlow ด้านล่าง:

ตัวอย่างการจำแนกไบนารี

โดยที่ 0 คือเซตของน้ำหนัก คุณลักษณะ และ b อคติ

ฟังก์ชั่นสามารถแบ่งออกเป็นสองส่วน:

  • โมเดลเชิงเส้น
  • ฟังก์ชันลอจิสติกส์

โมเดลเชิงเส้น

คุณคุ้นเคยกับวิธีคำนวณน้ำหนักอยู่แล้ว น้ำหนักคำนวณโดยใช้ผลิตภัณฑ์ดอท:ดอทโปรดักส์ Y เป็นฟังก์ชันเชิงเส้นของจุดสนใจ x ทั้งหมดi- ถ้าแบบจำลองไม่มีคุณลักษณะ การทำนายจะเท่ากับอคติ ข

น้ำหนักระบุทิศทางของความสัมพันธ์ระหว่างคุณลักษณะ xi และป้ายกำกับ y ความสัมพันธ์เชิงบวกเพิ่มความน่าจะเป็นของคลาสเชิงบวก ในขณะที่ความสัมพันธ์เชิงลบทำให้ความน่าจะเป็นเข้าใกล้ 0 มากขึ้น (นั่นคือ คลาสเชิงลบ)

โมเดลเชิงเส้นส่งคืนเฉพาะจำนวนจริงเท่านั้น ซึ่งไม่สอดคล้องกับการวัดความน่าจะเป็นของช่วง [0,1] จำเป็นต้องใช้ฟังก์ชันลอจิสติกเพื่อแปลงเอาต์พุตของโมเดลเชิงเส้นให้มีความน่าจะเป็น

ฟังก์ชันลอจิสติก

ฟังก์ชันลอจิสติกหรือฟังก์ชันซิกมอยด์จะมีรูปทรง S และเอาต์พุตของฟังก์ชันนี้จะอยู่ระหว่าง 0 ถึง 1 เสมอ

ตัวอย่างฟังก์ชันลอจิสติก

ตัวอย่างฟังก์ชันลอจิสติก
ตัวอย่างฟังก์ชันลอจิสติก

มันง่ายที่จะแทนที่เอาต์พุตของการถดถอยเชิงเส้นลงในฟังก์ชันซิกมอยด์ ผลลัพธ์ที่ได้คือตัวเลขใหม่ที่มีความน่าจะเป็นระหว่าง 0 ถึง 1

ตัวแยกประเภทสามารถเปลี่ยนความน่าจะเป็นเป็นคลาสได้

  • ค่าระหว่าง 0 ถึง 0.49 จะกลายเป็นคลาส 0
  • ค่าระหว่าง 0.5 ถึง 1 จะกลายเป็นคลาส 1

จะวัดประสิทธิภาพของ Linear Classifier ได้อย่างไร

ความถูกต้อง

ประสิทธิภาพโดยรวมของตัวแยกประเภทวัดด้วยเมตริกความแม่นยำ ความแม่นยำจะรวบรวมค่าที่ถูกต้องทั้งหมดหารด้วยจำนวนการสังเกตทั้งหมด ตัวอย่างเช่น ค่าความแม่นยำ 80 เปอร์เซ็นต์ หมายความว่าแบบจำลองนั้นถูกต้องในกรณี 80 เปอร์เซ็นต์

เมตริกความแม่นยำ
วัดประสิทธิภาพของตัวแยกประเภทเชิงเส้นโดยใช้เมตริกความแม่นยำ

คุณสามารถสังเกตเห็นข้อบกพร่องด้วยเมตริกนี้ โดยเฉพาะอย่างยิ่งสำหรับคลาสที่ไม่สมดุล ชุดข้อมูลที่ไม่สมดุลจะเกิดขึ้นเมื่อจำนวนการสังเกตต่อกลุ่มไม่เท่ากัน สมมติว่าคุณพยายามจำแนกเหตุการณ์ที่เกิดขึ้นไม่บ่อยด้วยฟังก์ชันลอจิสติกส์ ลองนึกภาพว่าตัวจำแนกพยายามประมาณการเสียชีวิตของผู้ป่วยที่เกิดจากการเจ็บป่วย ในข้อมูล ผู้ป่วย 5 เปอร์เซ็นต์เสียชีวิต คุณสามารถฝึกตัวจำแนกให้ทำนายจำนวนผู้เสียชีวิตและใช้เมตริกความแม่นยำเพื่อประเมินประสิทธิภาพ หากตัวจำแนกทำนายการเสียชีวิต 0 รายสำหรับชุดข้อมูลทั้งหมด ก็จะถูกต้องใน 95 เปอร์เซ็นต์ของกรณี

เมทริกซ์ความสับสน

วิธีที่ดีกว่าในการประเมินประสิทธิภาพของตัวแยกประเภทคือการดูเมทริกซ์ความสับสน

เมทริกซ์ความสับสน
วัดประสิทธิภาพของ Linear Classifier โดยใช้ Confusion matrix

เหตุการณ์ เมทริกซ์ความสับสน แสดงความแม่นยำของตัวจำแนกประเภทโดยเปรียบเทียบคลาสจริงและคลาสที่คาดการณ์ไว้ตามที่แสดงในตัวอย่างตัวจำแนกประเภทเชิงเส้นด้านบน เมทริกซ์ความสับสนแบบไบนารีประกอบด้วยสี่เหลี่ยม:

  • TP: ค่าบวกจริง: ค่าที่คาดการณ์ไว้ทำนายอย่างถูกต้องว่าเป็นบวกจริง
  • FP: ค่าที่ทำนายไว้ทำนายค่าบวกจริงไม่ถูกต้อง กล่าวคือ ค่าลบที่ทำนายว่าเป็นบวก
  • FN: ค่าลบที่เป็นเท็จ: ค่าบวกที่คาดการณ์ว่าเป็นค่าลบ
  • TN: ค่าลบจริง: ค่าที่คาดการณ์ไว้ถูกทำนายอย่างถูกต้องว่าเป็นค่าลบจริง

จากเมทริกซ์ความสับสน ง่ายต่อการเปรียบเทียบคลาสจริงกับคลาสที่ทำนาย

บทความที่เกี่ยวข้อง

ความแม่นยำและความไว

เมทริกซ์ความสับสนให้ข้อมูลเชิงลึกที่ดีเกี่ยวกับผลบวกเชิงบวกและผลบวกลวง ในบางกรณี ควรมีการวัดที่กระชับกว่านี้จะดีกว่า

ความแม่นยำ

เมตริกความแม่นยำแสดงความแม่นยำของคลาสที่เป็นบวก โดยจะวัดว่าการทำนายคลาสเชิงบวกมีความเป็นไปได้เพียงใด

ความแม่นยำ

คะแนนสูงสุดคือ 1 เมื่อตัวแยกประเภทจำแนกค่าบวกทั้งหมดได้อย่างสมบูรณ์แบบ ความแม่นยำเพียงอย่างเดียวไม่ได้มีประโยชน์มากนักเพราะจะมองข้ามระดับเชิงลบ โดยปกติแล้วตัวชี้วัดจะจับคู่กับตัวชี้วัดการเรียกคืน การเรียกคืนเรียกอีกอย่างว่าความไวหรืออัตราบวกที่แท้จริง

ความไว

ความไวจะคำนวณอัตราส่วนของคลาสที่เป็นบวกที่ตรวจพบอย่างถูกต้อง ตัวชี้วัดนี้แสดงให้เห็นว่าแบบจำลองนั้นดีเพียงใดในการรับรู้คลาสที่เป็นบวก

ความไว

ตัวแยกประเภทเชิงเส้นพร้อม TensorFlow

สำหรับบทช่วยสอนนี้ เราจะใช้ชุดข้อมูลการสำรวจสำมะโนประชากร วัตถุประสงค์คือเพื่อใช้ตัวแปรในชุดข้อมูลการสำรวจสำมะโนประชากรเพื่อคาดการณ์ระดับรายได้ โปรดทราบว่ารายได้เป็นตัวแปรไบนารี่

  • ที่มีค่า 1 ถ้ารายได้ > 50k
  • 0 ถ้ารายได้ < 50k

ตัวแปรนี้คือป้ายกำกับของคุณ

ชุดข้อมูลนี้ประกอบด้วยตัวแปรหมวดหมู่ 8 รายการ:

  • ที่ทำงาน
  • การศึกษา
  • สมรส
  • อาชีพ
  • ความสัมพันธ์
  • แข่ง
  • เพศ
  • พื้นเมือง_ประเทศ

นอกจากนี้ ยังมีตัวแปรต่อเนื่องอีก 6 ตัวแปร ได้แก่

  • อายุ
  • Fnlwgt
  • การศึกษา_num
  • ทุน_กำไร
  • เงินทุน_ขาดทุน
  • ชั่วโมง_สัปดาห์

จากตัวอย่างการจัดประเภท TensorFlow นี้ คุณจะเข้าใจวิธีฝึกตัวแยกประเภท TensorFlow เชิงเส้นด้วยตัวประมาณค่า TensorFlow และวิธีการปรับปรุงตัววัดความแม่นยำ

เราจะดำเนินการดังนี้:

  • ขั้นตอนที่ 1) นำเข้าข้อมูล
  • ขั้นตอนที่ 2) การแปลงข้อมูล
  • ขั้นตอนที่ 3) ฝึกอบรมลักษณนาม
  • ขั้นตอนที่ 4) ปรับปรุงโมเดล
  • ขั้นตอนที่ 5) ไฮเปอร์พารามิเตอร์: Lasso & Ridge

ขั้นตอนที่ 1) นำเข้าข้อมูล

คุณต้องนำเข้าไลบรารีที่ใช้ระหว่างบทช่วยสอนก่อน

import tensorflow as tf
import pandas as pd

ขั้นตอนต่อไปคือการนำเข้าข้อมูลจากไฟล์เก็บถาวรของ UCI และกำหนดชื่อคอลัมน์ คุณจะใช้ COLUMNS เพื่อตั้งชื่อคอลัมน์ในกรอบข้อมูลแพนด้า

โปรดทราบว่าคุณจะฝึกลักษณนามโดยใช้ Pandas dataframe

## Define path data
COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital',
           'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss',
           'hours_week', 'native_country', 'label']
PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data"
PATH_test = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.test"

ข้อมูลที่จัดเก็บออนไลน์จะถูกแบ่งระหว่างชุดรถไฟและชุดทดสอบแล้ว

df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False)
df_test = pd.read_csv(PATH_test,skiprows = 1, skipinitialspace=True, names = COLUMNS, index_col=False)

ชุดรถไฟประกอบด้วยการสังเกต 32,561 ครั้ง และชุดทดสอบ 16,281 ครั้ง

print(df_train.shape, df_test.shape)
print(df_train.dtypes)
(32561, 15) (16281, 15)
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label             object
dtype: object

Tensorflow ต้องใช้ค่าบูลีนในการฝึกตัวจำแนกประเภท คุณต้องแปลงค่าจากสตริงเป็นจำนวนเต็ม ป้ายกำกับจะถูกจัดเก็บเป็นอ็อบเจ็กต์ อย่างไรก็ตาม คุณต้องแปลงป้ายกำกับเป็นค่าตัวเลข โค้ดด้านล่างจะสร้างพจนานุกรมที่มีค่าที่จะแปลงและวนซ้ำผ่านรายการคอลัมน์ โปรดทราบว่าคุณต้องดำเนินการนี้สองครั้ง ครั้งหนึ่งสำหรับการทดสอบการฝึก อีกครั้งสำหรับชุดการทดสอบ

label = {'<=50K': 0,'>50K': 1}
df_train.label = [label[item] for item in df_train.label]
label_t = {'<=50K.': 0,'>50K.': 1}
df_test.label = [label_t[item] for item in df_test.label]

ในข้อมูลรถไฟมีรายได้ 24,720 รายต่ำกว่า 50 และ 7841 ข้างต้น อัตราส่วนเกือบจะเท่ากันสำหรับชุดทดสอบ โปรดดูบทช่วยสอนนี้ใน Facets เพื่อดูข้อมูลเพิ่มเติม

print(df_train["label"].value_counts())
### The model will be correct in atleast 70% of the case
print(df_test["label"].value_counts())
## Unbalanced label
print(df_train.dtypes)
0    24720
1     7841
Name: label, dtype: int64
0    12435
1     3846
Name: label, dtype: int64
age                int64
workclass         object
fnlwgt             int64
education         object
education_num      int64
marital           object
occupation        object
relationship      object
race              object
sex               object
capital_gain       int64
capital_loss       int64
hours_week         int64
native_country    object
label              int64
dtype: object

ขั้นตอนที่ 2) การแปลงข้อมูล

จำเป็นต้องมีขั้นตอนไม่กี่ขั้นตอนก่อนที่คุณจะฝึกตัวแยกประเภทเชิงเส้นด้วย Tensorflow คุณต้องเตรียมคุณสมบัติที่จะรวมไว้ในโมเดล ในการถดถอยของเกณฑ์มาตรฐาน คุณจะใช้ข้อมูลเดิมโดยไม่ต้องใช้การแปลงใดๆ

เครื่องมือประมาณค่าจำเป็นต้องมีรายการคุณลักษณะเพื่อฝึกโมเดล ดังนั้น ข้อมูลของคอลัมน์จึงต้องถูกแปลงเป็นเมตริกซ์

แนวปฏิบัติที่ดีคือการกำหนดรายการคุณลักษณะสองรายการตามประเภทของคุณลักษณะเหล่านั้น แล้วส่งต่อไปใน Feature_columns ของตัวประมาณค่า

คุณจะเริ่มต้นด้วยการแปลงฟีเจอร์ต่อเนื่อง จากนั้นกำหนดบัคเก็ตด้วยข้อมูลที่เป็นหมวดหมู่

คุณสมบัติของชุดข้อมูลมีสองรูปแบบ:

  • จำนวนเต็ม
  • วัตถุ

แต่ละคุณลักษณะจะแสดงรายการอยู่ในตัวแปรสองตัวถัดไปตามประเภท

## Add features to the bucket: 
### Define continuous list
CONTI_FEATURES  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week']
### Define the categorical list
CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country']

คุณลักษณะคอลัมน์ประกอบด้วยวัตถุ numeric_column เพื่อช่วยในการแปลงตัวแปรต่อเนื่องเป็นเมตริกซ์ ในโค้ดด้านล่าง คุณจะแปลงตัวแปรทั้งหมดจาก CONTI_FEATURES เป็นเทนเซอร์ที่มีค่าตัวเลข นี่เป็นภาคบังคับในการสร้างแบบจำลอง ตัวแปรอิสระทั้งหมดจำเป็นต้องแปลงเป็นเทนเซอร์ประเภทที่เหมาะสม

ด้านล่างเราจะเขียนโค้ดเพื่อให้คุณเห็นว่าเกิดอะไรขึ้นเบื้องหลังฟีเจอร์_คอลัมน์.ตัวเลข_คอลัมน์ เราจะพิมพ์ค่าที่แปลงแล้วตามอายุ โดยมีจุดประสงค์เพื่ออธิบาย ดังนั้นจึงไม่จำเป็นต้องเข้าใจโค้ดหลาม คุณสามารถดูเอกสารอย่างเป็นทางการเพื่อทำความเข้าใจรหัสได้

def print_transformation(feature = "age", continuous = True, size = 2): 
    #X = fc.numeric_column(feature)
    ## Create feature name
    feature_names = [
    feature]

    ## Create dict with the data
    d = dict(zip(feature_names, [df_train[feature]]))

    ## Convert age
    if continuous == True:
        c = tf.feature_column.numeric_column(feature)
        feature_columns = [c]
    else: 
        c = tf.feature_column.categorical_column_with_hash_bucket(feature, hash_bucket_size=size) 
        c_indicator = tf.feature_column.indicator_column(c)
        feature_columns = [c_indicator]
    
## Use input_layer to print the value
    input_layer = tf.feature_column.input_layer(
        features=d,
        feature_columns=feature_columns
        )
    ## Create lookup table
    zero = tf.constant(0, dtype=tf.float32)
    where = tf.not_equal(input_layer, zero)
    ## Return lookup tble
    indices = tf.where(where)
    values = tf.gather_nd(input_layer, indices)
    ## Initiate graph
    sess = tf.Session()
    ## Print value
    print(sess.run(input_layer))
print_transformation(feature = "age", continuous = True) 
[[39.]
 [50.]
 [38.]
 ...
 [58.]
 [22.]
 [52.]]

ค่าจะเหมือนกับใน df_train ทุกประการ

continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]

ตามเอกสารของ TensorFlow มีวิธีต่างๆ ในการแปลงข้อมูลหมวดหมู่ หากทราบรายการคำศัพท์ของคุณลักษณะและมีค่าไม่มากนัก คุณสามารถสร้างคอลัมน์หมวดหมู่ด้วย categorical_column_with_vocabulary_list ได้ มันจะกำหนด ID ให้กับรายการคำศัพท์ที่ไม่ซ้ำทั้งหมด

ตัวอย่างเช่น หากสถานะตัวแปรมีค่าที่แตกต่างกันสามค่า:

  • สามี
  • ภรรยา
  • เดียว

จากนั้นจะมีการระบุ ID สามรายการ เช่น สามีจะมีบัตรประจำตัว 1 ภรรยามีบัตรประจำตัว 2 เป็นต้น

เพื่อจุดประสงค์ในการอธิบาย คุณสามารถใช้โค้ดนี้เพื่อแปลงตัวแปรออบเจ็กต์เป็นคอลัมน์หมวดหมู่ใน TensorFlow

ฟีเจอร์เพศสามารถมีค่าได้เพียง 2 ค่าเท่านั้น: ชายหรือหญิง เมื่อเราจะแปลงฟีเจอร์เพศ Tensorflow จะสร้างคอลัมน์ใหม่ 1 คอลัมน์ คอลัมน์หนึ่งสำหรับชายและอีกคอลัมน์หนึ่งสำหรับหญิง หากเพศเท่ากับชาย คอลัมน์ใหม่ชายจะเท่ากับ 0 และหญิงจะเท่ากับ XNUMX ตัวอย่างนี้แสดงอยู่ในตารางด้านล่าง:

แถว เพศ หลังการเปลี่ยนแปลง ชาย หญิง
1 ชาย => 1 0
2 ชาย => 1 0
3 หญิง => 0 1

ในเทนเซอร์โฟลว์:

print_transformation(feature = "sex", continuous = False, size = 2)
[[1. 0.]
 [1. 0.]
 [1. 0.]
 ...
 [0. 1.]
 [1. 0.]
 [0. 1.]]

relationship = tf.feature_column.categorical_column_with_vocabulary_list(
    'relationship', [
        'Husband', 'Not-in-family', 'Wife', 'Own-child', 'Unmarried',
        'Other-relative'])

ด้านล่างเราได้เพิ่ม Python รหัสเพื่อพิมพ์การเข้ารหัส ขอย้ำอีกครั้งว่าคุณไม่จำเป็นต้องเข้าใจโค้ด จุดประสงค์คือการเห็นการเปลี่ยนแปลง

อย่างไรก็ตาม วิธีที่เร็วกว่าในการแปลงข้อมูลคือการใช้วิธีการ categorical_column_with_hash_bucket การเปลี่ยนแปลงตัวแปรสตริงในเมทริกซ์แบบกระจายจะมีประโยชน์ เมทริกซ์กระจัดกระจายเป็นเมทริกซ์ที่มีศูนย์เป็นส่วนใหญ่ วิธีการดูแลทุกอย่าง คุณจะต้องระบุจำนวนที่เก็บข้อมูลและคอลัมน์หลักเท่านั้น จำนวนที่เก็บข้อมูลคือจำนวนกลุ่มสูงสุดที่ Tensorflow สามารถสร้างได้ คอลัมน์หลักเป็นเพียงชื่อของคอลัมน์ที่จะแปลง

ในโค้ดด้านล่างนี้ คุณสร้างการวนซ้ำเหนือฟีเจอร์ตามหมวดหมู่ทั้งหมด

categorical_features = [tf.feature_column.categorical_column_with_hash_bucket(k, hash_bucket_size=1000) for k in CATE_FEATURES]

ขั้นตอนที่ 3) ฝึกอบรมลักษณนาม

ปัจจุบัน TensorFlow มีตัวประมาณค่าสำหรับการถดถอยเชิงเส้นและการจำแนกเชิงเส้น

  • การถดถอยเชิงเส้น: LinearRegressor
  • การจำแนกเชิงเส้น: LinearClassifier

ไวยากรณ์ของตัวแยกประเภทเชิงเส้นจะเหมือนกับในบทช่วยสอน การถดถอยเชิงเส้น ยกเว้นหนึ่งอาร์กิวเมนต์ n_class คุณต้องกำหนดคอลัมน์คุณลักษณะ ไดเร็กทอรีโมเดล และเปรียบเทียบกับตัวถดถอยเชิงเส้น คุณมีการกำหนดจำนวนชั้นเรียน สำหรับการถดถอยโลจิท จำนวนของคลาสจะเท่ากับ 2

แบบจำลองจะคำนวณน้ำหนักของคอลัมน์ที่มีอยู่ใน Continue_features และ categorical_features

model = tf.estimator.LinearClassifier(
    n_classes = 2,
    model_dir="ongoing/train", 
    feature_columns=categorical_features+ continuous_features)

เอาท์พุต

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x181f24c898>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

เมื่อกำหนดลักษณนามแล้ว คุณสามารถสร้างฟังก์ชันอินพุตได้ วิธีการนี้เหมือนกับในบทช่วยสอนการถดถอยเชิงเส้น ที่นี่ คุณใช้ขนาดแบตช์ 128 และสับเปลี่ยนข้อมูล

FEATURES = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country']
LABEL= 'label'
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

คุณสร้างฟังก์ชันด้วยอาร์กิวเมนต์ที่ตัวประมาณค่าเชิงเส้นต้องการ เช่น จำนวนยุค จำนวนแบตช์ และสับเปลี่ยนชุดข้อมูลหรือบันทึก เนื่องจากคุณใช้ นุ่น ในการส่งข้อมูลไปยังโมเดล คุณต้องกำหนดตัวแปร X เป็นเฟรมข้อมูลแพนด้า โปรดทราบว่าคุณวนซ้ำข้อมูลทั้งหมดที่จัดเก็บไว้ในฟีเจอร์

มาฝึกโมเดลด้วย object model.train กันดีกว่า คุณใช้ฟังก์ชันที่กำหนดไว้ก่อนหน้านี้เพื่อป้อนโมเดลด้วยค่าที่เหมาะสม โปรดทราบว่าคุณตั้งค่าขนาดแบทช์เป็น 128 และจำนวนยุคเป็นไม่มี หุ่นจำลองจะได้รับการฝึกฝนมากกว่าพันก้าว

model.train(input_fn=get_input_fn(df_train, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

									 
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow: Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 65.8282
INFO:tensorflow:loss = 52583.64, step = 101 (1.528 sec)
INFO:tensorflow:global_step/sec: 118.386
INFO:tensorflow:loss = 25203.816, step = 201 (0.837 sec)
INFO:tensorflow:global_step/sec: 110.542
INFO:tensorflow:loss = 54924.312, step = 301 (0.905 sec)
INFO:tensorflow:global_step/sec: 199.03
INFO:tensorflow:loss = 68509.31, step = 401 (0.502 sec)
INFO:tensorflow:global_step/sec: 167.488
INFO:tensorflow:loss = 9151.754, step = 501 (0.599 sec)
INFO:tensorflow:global_step/sec: 220.155
INFO:tensorflow:loss = 34576.06, step = 601 (0.453 sec)
INFO:tensorflow:global_step/sec: 199.016
INFO:tensorflow:loss = 36047.117, step = 701 (0.503 sec)
INFO:tensorflow:global_step/sec: 197.531
INFO:tensorflow:loss = 22608.148, step = 801 (0.505 sec)
INFO:tensorflow:global_step/sec: 208.479
INFO:tensorflow:loss = 22201.918, step = 901 (0.479 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train/model.ckpt.
INFO:tensorflow:Loss for final step: 5444.363.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181f223630>

โปรดทราบว่าการสูญเสียลดลงในเวลาต่อมาในช่วง 100 ขั้นตอนสุดท้าย เช่น จาก 901 เป็น 1000

การสูญเสียครั้งสุดท้ายหลังจากการวนซ้ำหนึ่งพันครั้งคือ 5444 คุณสามารถประมาณแบบจำลองของคุณบนชุดทดสอบและดูประสิทธิภาพได้ ในการประเมินประสิทธิภาพของโมเดลของคุณ คุณต้องใช้การประเมินออบเจ็กต์ คุณป้อนโมเดลด้วยชุดทดสอบและตั้งค่าจำนวนยุคเป็น 1 กล่าวคือ ข้อมูลจะถูกส่งไปยังโมเดลเพียงครั้งเดียว

model.evaluate(input_fn=get_input_fn(df_test, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:22
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:23
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7615626, accuracy_baseline = 0.76377374, auc = 0.63300294, auc_precision_recall = 0.50891197, average_loss = 47.12155, global_step = 1000, label/mean = 0.23622628, loss = 5993.6406, precision = 0.49401596, prediction/mean = 0.18454961, recall = 0.38637546

{'accuracy': 0.7615626,
 'accuracy_baseline': 0.76377374,
 'auc': 0.63300294,
 'auc_precision_recall': 0.50891197,
 'average_loss': 47.12155,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 5993.6406,
 'precision': 0.49401596,
 'prediction/mean': 0.18454961,
 'recall': 0.38637546}

TensorFlow ส่งคืนหน่วยวัดทั้งหมดที่คุณเรียนรู้ในส่วนทางทฤษฎี ไม่ต้องสงสัยเลยว่าความแม่นยำมีมากเนื่องจากฉลากไม่สมดุล จริงๆ แล้ว โมเดลทำงานได้ดีกว่าการเดาแบบสุ่มเล็กน้อย ลองนึกภาพแบบจำลองทำนายทุกครัวเรือนที่มีรายได้ต่ำกว่า 50 จากนั้นแบบจำลองจะมีความแม่นยำ 70 เปอร์เซ็นต์ จากการวิเคราะห์อย่างใกล้ชิด คุณจะเห็นการคาดการณ์และการเรียกคืนข้อมูลได้ค่อนข้างต่ำ

ขั้นตอนที่ 4) ปรับปรุงโมเดล

เมื่อคุณมีแบบจำลองเกณฑ์มาตรฐานแล้ว คุณสามารถลองปรับปรุงได้ ซึ่งก็คือเพิ่มความแม่นยำ ในบทช่วยสอนก่อนหน้านี้ คุณได้เรียนรู้วิธีปรับปรุงพลังการทำนายด้วยคำศัพท์เชิงโต้ตอบ ในบทช่วยสอนนี้ คุณจะทบทวนแนวคิดนี้อีกครั้งโดยเพิ่มคำศัพท์พหุนามลงในการถดถอย

การถดถอยพหุนามเป็นเครื่องมือสำคัญเมื่อข้อมูลไม่เชิงเส้น มีสองวิธีในการจับภาพความไม่เชิงเส้นในข้อมูล

  • เพิ่มพจน์พหุนาม
  • รวมตัวแปรต่อเนื่องให้เป็นตัวแปรหมวดหมู่

ศัพท์พหุนาม

จากภาพด้านล่าง คุณจะเห็นว่าการถดถอยพหุนามคืออะไร เป็นสมการที่มีตัวแปร X ที่มีกำลังต่างกัน การถดถอยพหุนามขั้นที่สองมีตัวแปรสองตัวคือ X และ X กำลังสอง ระดับที่สามมีตัวแปรสามตัวคือ X, X2และ X3

การถดถอยพหุนาม
การถดถอยพหุนามคืออะไร

ด้านล่างนี้ เราสร้างกราฟที่มีตัวแปรสองตัว ได้แก่ X และ Y เห็นได้ชัดว่าความสัมพันธ์ไม่เป็นเส้นตรง หากเราเพิ่มการถดถอยเชิงเส้น เราจะเห็นว่าโมเดลไม่สามารถจับรูปแบบได้ (ภาพซ้าย)

ทีนี้ ดูภาพซ้ายจากภาพด้านล่าง เราได้บวก 5 เทอมเข้ากับการถดถอย (นั่นคือ y=x+x2+x3+x4+x5- ตอนนี้โมเดลจับรูปแบบได้ดีขึ้นมาก นี่คือพลังของการถดถอยพหุนาม

การถดถอยพหุนาม

กลับไปที่ตัวอย่างของเรากัน อายุไม่สัมพันธ์กับรายได้เป็นเส้นตรง อายุยังน้อยอาจมีรายได้คงที่เกือบเป็นศูนย์เพราะเด็กหรือเยาวชนไม่ได้ทำงาน จากนั้นจะเข้าสู่วัยทำงานที่เพิ่มขึ้นและลดลงในช่วงเกษียณอายุ โดยทั่วไปจะเป็นรูปทรง Inversed-U วิธีหนึ่งในการจับรูปแบบนี้คือการเพิ่มกำลังสองให้กับการถดถอย

มาดูกันว่ามันจะเพิ่มความแม่นยำหรือไม่

คุณต้องเพิ่มคุณลักษณะใหม่นี้ลงในชุดข้อมูลและในรายการคุณลักษณะต่อเนื่อง

คุณเพิ่มตัวแปรใหม่ในชุดข้อมูลการฝึกฝนและการทดสอบ ดังนั้นจึงสะดวกกว่าในการเขียนฟังก์ชัน

def square_var(df_t, df_te, var_name = 'age'):
    df_t['new'] = df_t[var_name].pow(2) 
    df_te['new'] = df_te[var_name].pow(2) 
    return df_t, df_te

ฟังก์ชันมี 3 อาร์กิวเมนต์:

  • df_t: กำหนดชุดการฝึก
  • df_te: กำหนดชุดทดสอบ
  • var_name = 'age': กำหนดตัวแปรที่จะแปลง

คุณสามารถใช้อ็อบเจ็กต์ pow(2) เพื่อยกกำลังสองของอายุของตัวแปรได้ โปรดทราบว่าตัวแปรใหม่มีชื่อว่า 'ใหม่'

เมื่อเขียนฟังก์ชัน square_var แล้ว คุณสามารถสร้างชุดข้อมูลใหม่ได้

df_train_new, df_test_new = square_var(df_train, df_test, var_name = 'age')

อย่างที่คุณเห็น ชุดข้อมูลใหม่มีคุณลักษณะเพิ่มเติมอีกหนึ่งอย่าง

print(df_train_new.shape, df_test_new.shape)			
(32561, 16) (16281, 16)

ตัวแปรสี่เหลี่ยมเรียกว่าตัวแปรใหม่ในชุดข้อมูล คุณต้องเพิ่มลงในรายการคุณสมบัติต่อเนื่อง

CONTI_FEATURES_NEW  = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week', 'new']
continuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]

หมายเหตุ ว่าคุณเปลี่ยนไดเร็กทอรีของกราฟ คุณไม่สามารถฝึกโมเดลที่แตกต่างกันในไดเร็กทอรีเดียวกันได้ หมายความว่าคุณต้องเปลี่ยนเส้นทางของอาร์กิวเมนต์ model_dir หากคุณไม่ทำ TensorFlow จะทำให้เกิดข้อผิดพลาด

model_1 = tf.estimator.LinearClassifier(
    model_dir="ongoing/train1", 
    feature_columns=categorical_features+ continuous_features_new)

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': 
<tensorflow.python.training.server_lib.ClusterSpec object at 0x1820f04b70>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
FEATURES_NEW = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'new']
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES_NEW}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

เมื่อตัวแยกประเภทได้รับการออกแบบด้วยชุดข้อมูลใหม่แล้ว คุณก็สามารถฝึกและประเมินโมเดลได้

model_1.train(input_fn=get_input_fn(df_train, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train1/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 81.487
INFO:tensorflow:loss = 70077.66, step = 101 (1.228 sec)
INFO:tensorflow:global_step/sec: 111.169
INFO:tensorflow:loss = 49522.082, step = 201 (0.899 sec)
INFO:tensorflow:global_step/sec: 128.91
INFO:tensorflow:loss = 107120.57, step = 301 (0.776 sec)
INFO:tensorflow:global_step/sec: 132.546
INFO:tensorflow:loss = 12814.152, step = 401 (0.755 sec)
INFO:tensorflow:global_step/sec: 162.194
INFO:tensorflow:loss = 19573.898, step = 501 (0.617 sec)
INFO:tensorflow:global_step/sec: 204.852
INFO:tensorflow:loss = 26381.986, step = 601 (0.488 sec)
INFO:tensorflow:global_step/sec: 188.923
INFO:tensorflow:loss = 23417.719, step = 701 (0.529 sec)
INFO:tensorflow:global_step/sec: 192.041
INFO:tensorflow:loss = 23946.049, step = 801 (0.521 sec)
INFO:tensorflow:global_step/sec: 197.025
INFO:tensorflow:loss = 3309.5786, step = 901 (0.507 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train1/model.ckpt.
INFO:tensorflow:Loss for final step: 28861.898.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1820f04c88>

model_1.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:37
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:39
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.7944229, accuracy_baseline = 0.76377374, auc = 0.6093755, auc_precision_recall = 0.54885805, average_loss = 111.0046, global_step = 1000, label/mean = 0.23622628, loss = 14119.265, precision = 0.6682401, prediction/mean = 0.09116262, recall = 0.2576703

{'accuracy': 0.7944229,
 'accuracy_baseline': 0.76377374,
 'auc': 0.6093755,
 'auc_precision_recall': 0.54885805,
 'average_loss': 111.0046,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 14119.265,
 'precision': 0.6682401,
 'prediction/mean': 0.09116262,
 'recall': 0.2576703}

ตัวแปรกำลังสองปรับปรุงความแม่นยำจาก 0.76 เป็น 0.79 มาดูกันว่าคุณสามารถทำได้ดีกว่านี้หรือไม่โดยการรวมการเก็บข้อมูลและการโต้ตอบเข้าด้วยกัน

การเก็บข้อมูลและการโต้ตอบ

อย่างที่คุณเห็นก่อนหน้านี้ ตัวแยกประเภทเชิงเส้นไม่สามารถจับรูปแบบรายได้ตามวัยได้อย่างถูกต้อง นั่นเป็นเพราะมันเรียนรู้น้ำหนักเดียวสำหรับแต่ละคุณสมบัติ เพื่อให้ตัวแยกประเภทง่ายขึ้น สิ่งหนึ่งที่คุณสามารถทำได้คือรวมฟีเจอร์นี้ไว้ การเก็บข้อมูลจะแปลงฟีเจอร์ตัวเลขเป็นหลายๆ ฟีเจอร์ตามช่วงที่ฟีเจอร์นั้นอยู่ และฟีเจอร์ใหม่แต่ละฟีเจอร์จะบ่งบอกว่าอายุของบุคคลนั้นอยู่ในช่วงนั้นหรือไม่

ด้วยฟีเจอร์ใหม่เหล่านี้ โมเดลเชิงเส้นสามารถบันทึกความสัมพันธ์โดยการเรียนรู้น้ำหนักที่แตกต่างกันสำหรับแต่ละบัคเก็ต

ใน TensorFlow ทำได้ด้วย bucketized_column คุณต้องเพิ่มช่วงของค่าในขอบเขต

age = tf.feature_column.numeric_column('age')
age_buckets = tf.feature_column.bucketized_column(
    age, boundaries=[18, 25, 30, 35, 40, 45, 50, 55, 60, 65])

คุณรู้อยู่แล้วว่าอายุไม่เป็นเชิงเส้นกับรายได้ อีกวิธีหนึ่งในการปรับปรุงโมเดลคือผ่านการโต้ตอบ ในคำพูดของ TensorFlow มันเป็นการข้ามคุณสมบัติ การข้ามคุณลักษณะเป็นวิธีหนึ่งในการสร้างคุณลักษณะใหม่ที่เป็นการผสมผสานระหว่างคุณลักษณะที่มีอยู่ ซึ่งจะมีประโยชน์สำหรับตัวแยกประเภทเชิงเส้นที่ไม่สามารถจำลองการโต้ตอบระหว่างคุณลักษณะต่างๆ ได้

คุณสามารถแจกแจงอายุด้วยฟีเจอร์อื่นๆ เช่น การศึกษา คือบางกลุ่มมีแนวโน้มมีรายได้สูง บางกลุ่มต่ำ (ลองนึกถึงนักศึกษาปริญญาเอก)

education_x_occupation = [tf.feature_column.crossed_column(
    ['education', 'occupation'], hash_bucket_size=1000)]
age_buckets_x_education_x_occupation = [tf.feature_column.crossed_column(
    [age_buckets, 'education', 'occupation'], hash_bucket_size=1000)]

หากต้องการสร้างคอลัมน์คุณลักษณะแบบไขว้ คุณต้องใช้ crossed_column กับตัวแปรที่จะข้ามในวงเล็บ hash_bucket_size ระบุความเป็นไปได้ในการข้ามสูงสุด หากต้องการสร้างการโต้ตอบระหว่างตัวแปร (ต้องมีตัวแปรอย่างน้อย 1000 ตัวที่เป็นหมวดหมู่) คุณสามารถใช้ tf.feature_column.crossed_column หากต้องการใช้ออบเจ็กต์นี้ คุณจะต้องเพิ่มตัวแปรที่จะโต้ตอบในวงเล็บเหลี่ยมและอาร์กิวเมนต์ที่สอง ซึ่งก็คือขนาดบัคเก็ต ขนาดที่เก็บข้อมูลคือจำนวนกลุ่มสูงสุดที่เป็นไปได้ภายในตัวแปร ที่นี่คุณตั้งค่าไว้ที่ XNUMX เนื่องจากคุณไม่ทราบจำนวนกลุ่มที่แน่นอน

ต้องเพิ่ม age_buckets ยกกำลังสองก่อนจึงจะเพิ่มลงในคอลัมน์ฟีเจอร์ได้ คุณยังเพิ่มคุณลักษณะใหม่ให้กับคอลัมน์คุณลักษณะและเตรียมตัวประมาณค่า

base_columns = [
    age_buckets,
]

model_imp = tf.estimator.LinearClassifier(
    model_dir="ongoing/train3", 
    feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation)

เอาท์พุต

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1823021be0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

FEATURES_imp = ['age','workclass', 'education', 'education_num', 'marital',
                'occupation', 'relationship', 'race', 'sex', 'native_country', 'new']

def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES_imp}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

คุณพร้อมที่จะประมาณการโมเดลใหม่และดูว่าจะปรับปรุงความแม่นยำหรือไม่

model_imp.train(input_fn=get_input_fn(df_train_new, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

									  
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train3/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 94.969
INFO:tensorflow:loss = 50.334488, step = 101 (1.054 sec)
INFO:tensorflow:global_step/sec: 242.342
INFO:tensorflow:loss = 56.153225, step = 201 (0.414 sec)
INFO:tensorflow:global_step/sec: 213.686
INFO:tensorflow:loss = 45.792007, step = 301 (0.470 sec)
INFO:tensorflow:global_step/sec: 174.084
INFO:tensorflow:loss = 37.485672, step = 401 (0.572 sec)
INFO:tensorflow:global_step/sec: 191.78
INFO:tensorflow:loss = 56.48449, step = 501 (0.524 sec)
INFO:tensorflow:global_step/sec: 163.436
INFO:tensorflow:loss = 32.528934, step = 601 (0.612 sec)
INFO:tensorflow:global_step/sec: 164.347
INFO:tensorflow:loss = 37.438057, step = 701 (0.607 sec)
INFO:tensorflow:global_step/sec: 154.274
INFO:tensorflow:loss = 61.1075, step = 801 (0.647 sec)
INFO:tensorflow:global_step/sec: 189.14
INFO:tensorflow:loss = 44.69645, step = 901 (0.531 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train3/model.ckpt.
INFO:tensorflow:Loss for final step: 44.18133.

<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x1823021cf8>

model_imp.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

									  
INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:28:52
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:28:54
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.8358209, accuracy_baseline = 0.76377374, auc = 0.88401634, auc_precision_recall = 0.69599575, average_loss = 0.35122654, global_step = 1000, label/mean = 0.23622628, loss = 44.67437, precision = 0.68986726, prediction/mean = 0.23320661, recall = 0.55408216


{'accuracy': 0.8358209,
 'accuracy_baseline': 0.76377374,
 'auc': 0.88401634,
 'auc_precision_recall': 0.69599575,
 'average_loss': 0.35122654,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.67437,
 'precision': 0.68986726,
 'prediction/mean': 0.23320661,
 'recall': 0.55408216}

ระดับความแม่นยำใหม่คือ 83.58 เปอร์เซ็นต์ สูงกว่ารุ่นก่อนถึงสี่เปอร์เซ็นต์

สุดท้ายนี้ คุณสามารถเพิ่มเงื่อนไขการทำให้เป็นมาตรฐานเพื่อป้องกันไม่ให้มีการติดตั้งมากเกินไป

ขั้นตอนที่ 5) ไฮเปอร์พารามิเตอร์: Lasso & Ridge

โมเดลของคุณสามารถทนทุกข์ทรมานจาก ฟิตเกินไป or เหมาะสม.

  • การติดตั้งมากเกินไป: โมเดลไม่สามารถสรุปการคาดการณ์กับข้อมูลใหม่ได้
  • Underfitting: โมเดลไม่สามารถจับรูปแบบของข้อมูลได้ กล่าวคือ การถดถอยเชิงเส้นเมื่อข้อมูลไม่เป็นเชิงเส้น

เมื่อแบบจำลองมีพารามิเตอร์จำนวนมากและมีข้อมูลค่อนข้างน้อย จะทำให้คาดการณ์ได้ไม่ดี ลองนึกภาพ กลุ่มหนึ่งมีเพียงสามข้อสังเกตเท่านั้น โมเดลจะคำนวณน้ำหนักให้กับกลุ่มนี้ น้ำหนักจะใช้ในการทำนาย หากการสังเกตชุดการทดสอบสำหรับกลุ่มนี้แตกต่างไปจากชุดการฝึกโดยสิ้นเชิง แบบจำลองก็จะทำการทำนายที่ผิด ระหว่างประเมินด้วยชุดฝึกมีความแม่นยำดีแต่ไม่ดีกับชุดทดสอบเพราะน้ำหนักที่คำนวณไว้ไม่ใช่น้ำหนักจริงที่จะสรุปแบบทั่วไป ในกรณีนี้ จะไม่มีการคาดการณ์ที่สมเหตุสมผลกับข้อมูลที่มองไม่เห็น

เพื่อป้องกันการติดตั้งเกิน การปรับให้เป็นมาตรฐานช่วยให้คุณควบคุมความซับซ้อนดังกล่าวได้ และทำให้สามารถสรุปผลได้ทั่วไปมากขึ้น มีเทคนิคการปรับให้เป็นมาตรฐานสองแบบ:

  • L1: บ่วงบาศ
  • L2: ริดจ์

ใน TensorFlow คุณสามารถเพิ่มไฮเปอร์พารามิเตอร์ทั้งสองนี้ในเครื่องมือเพิ่มประสิทธิภาพได้ ตัวอย่างเช่น ยิ่งไฮเปอร์พารามิเตอร์ L2 สูง น้ำหนักก็มีแนวโน้มที่จะต่ำมากและใกล้กับศูนย์ เส้นพอดีจะเรียบมาก ในขณะที่ L2 ใกล้ศูนย์แสดงว่าน้ำหนักใกล้เคียงกับการถดถอยเชิงเส้นปกติ

คุณสามารถลองใช้ค่าต่างๆ ของไฮเปอร์พารามิเตอร์ได้ด้วยตัวเอง และดูว่าคุณสามารถเพิ่มระดับความแม่นยำได้หรือไม่

หมายเหตุ หากคุณเปลี่ยนไฮเปอร์พารามิเตอร์ คุณต้องลบโฟลเดอร์ performing/train4 มิฉะนั้น โมเดลจะเริ่มต้นด้วยโมเดลที่ได้รับการฝึกก่อนหน้านี้

มาดูกันว่าแม่นแค่ไหนกับกระแสโฆษณา

model_regu = tf.estimator.LinearClassifier(
    model_dir="ongoing/train4", feature_columns=categorical_features+base_columns+education_x_occupation+age_buckets_x_education_x_occupation,
    optimizer=tf.train.FtrlOptimizer(
        learning_rate=0.1,
        l1_regularization_strength=0.9,
        l2_regularization_strength=5))

OUTUT

INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'ongoing/train4', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820d9c128>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

model_regu.train(input_fn=get_input_fn(df_train_new, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

OUTUT

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Saving checkpoints for 1 into ongoing/train4/model.ckpt.
INFO:tensorflow:loss = 88.722855, step = 1
INFO:tensorflow:global_step/sec: 77.4165
INFO:tensorflow:loss = 50.38778, step = 101 (1.294 sec)
INFO:tensorflow:global_step/sec: 187.889
INFO:tensorflow:loss = 55.38014, step = 201 (0.535 sec)
INFO:tensorflow:global_step/sec: 201.895
INFO:tensorflow:loss = 46.806694, step = 301 (0.491 sec)
INFO:tensorflow:global_step/sec: 217.992
INFO:tensorflow:loss = 38.68271, step = 401 (0.460 sec)
INFO:tensorflow:global_step/sec: 193.676
INFO:tensorflow:loss = 56.99398, step = 501 (0.516 sec)
INFO:tensorflow:global_step/sec: 202.195
INFO:tensorflow:loss = 33.263622, step = 601 (0.497 sec)
INFO:tensorflow:global_step/sec: 216.756
INFO:tensorflow:loss = 37.7902, step = 701 (0.459 sec)
INFO:tensorflow:global_step/sec: 240.215
INFO:tensorflow:loss = 61.732605, step = 801 (0.416 sec)
INFO:tensorflow:global_step/sec: 220.336
INFO:tensorflow:loss = 46.938225, step = 901 (0.456 sec)
INFO:tensorflow:Saving checkpoints for 1000 into ongoing/train4/model.ckpt.
INFO:tensorflow:Loss for final step: 43.4942.


<tensorflow.python.estimator.canned.linear.LinearClassifier at 0x181ff39e48>

model_regu.evaluate(input_fn=get_input_fn(df_test_new, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

เอาท์พุต

INFO:tensorflow:Calling model_fn.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
WARNING:tensorflow:Trapezoidal rule is known to produce incorrect PR-AUCs; please switch to "careful_interpolation" instead.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-06-02-08:29:07
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from ongoing/train4/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [100/1000]
INFO:tensorflow:Finished evaluation at 2018-06-02-08:29:09
INFO:tensorflow:Saving dict for global step 1000: accuracy = 0.83833915, accuracy_baseline = 0.76377374, auc = 0.8869794, auc_precision_recall = 0.7014905, average_loss = 0.34691378, global_step = 1000, label/mean = 0.23622628, loss = 44.12581, precision = 0.69720596, prediction/mean = 0.23662092, recall = 0.5579823





{'accuracy': 0.83833915,
 'accuracy_baseline': 0.76377374,
 'auc': 0.8869794,
 'auc_precision_recall': 0.7014905,
 'average_loss': 0.34691378,
 'global_step': 1000,
 'label/mean': 0.23622628,
 'loss': 44.12581,
 'precision': 0.69720596,
 'prediction/mean': 0.23662092,
 'recall': 0.5579823}

ด้วยไฮเปอร์พารามิเตอร์นี้ คุณจะเพิ่มเมตริกความแม่นยำได้เล็กน้อย ในบทช่วยสอนถัดไป คุณจะได้เรียนรู้วิธีปรับปรุงตัวแยกประเภทเชิงเส้นโดยใช้วิธีเคอร์เนล

สรุป

หากต้องการฝึกโมเดล คุณต้อง:

  • กำหนดคุณสมบัติ: ตัวแปรอิสระ: X
  • กำหนดป้ายกำกับ: ตัวแปรตาม: y
  • สร้างชุดรถไฟ/ชุดทดสอบ
  • กำหนดน้ำหนักเริ่มต้น
  • กำหนดฟังก์ชันการสูญเสีย: MSE
  • ปรับโมเดลให้เหมาะสม: การไล่ระดับลง
  • กำหนด:
    • อัตราการเรียนรู้
    • จำนวนยุค
    • ขนาดแบทช์
    • จำนวนชั้นเรียน

ในบทช่วยสอนนี้ คุณได้เรียนรู้วิธีใช้ API ระดับสูงสำหรับตัวแยกประเภทการถดถอยเชิงเส้น คุณต้องกำหนด:

  1. คอลัมน์คุณลักษณะ หากต่อเนื่อง: tf.feature_column.numeric_column() คุณสามารถเติมรายการด้วยความเข้าใจรายการหลาม
  2. ตัวประมาณค่า: tf.estimator.LinearClassifier(feature_columns, model_dir, n_classes = 2)
  3. ฟังก์ชันในการนำเข้าข้อมูล ขนาดแบตช์ และยุค: input_fn()

หลังจากนั้นคุณก็พร้อมที่จะฝึกฝน ประเมิน และทำนายด้วย train() ประเมิน() และทำนาย()

หากต้องการปรับปรุงประสิทธิภาพของโมเดล คุณสามารถ:

  • ใช้การถดถอยพหุนาม
  • คำโต้ตอบ: tf.feature_column.crossed_column
  • เพิ่มพารามิเตอร์การทำให้เป็นมาตรฐาน

ที่คุณอาจชอบ: