You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
ML-For-Beginners/translations/th/2-Regression/4-Logistic/README.md

38 KiB

การถดถอยโลจิสติกเพื่อทำนายหมวดหมู่

ภาพเปรียบเทียบการถดถอยเชิงเส้นและโลจิสติก

แบบทดสอบก่อนเรียน

บทเรียนนี้มีในภาษา R ด้วย!

บทนำ

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

ในบทเรียนนี้ คุณจะได้เรียนรู้:

  • ไลบรารีใหม่สำหรับการแสดงผลข้อมูล
  • เทคนิคสำหรับการถดถอยโลจิสติก

เพิ่มความเข้าใจเกี่ยวกับการทำงานกับการถดถอยประเภทนี้ใน โมดูลการเรียนรู้

ความรู้พื้นฐานที่ควรมี

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

เรามาสร้างโมเดลการถดถอยโลจิสติกเพื่อทำนายว่า ฟักทองที่กำหนดมีแนวโน้มที่จะมีสีอะไร (สีส้ม 🎃 หรือสีขาว 👻)

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

กำหนดคำถาม

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

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

เกี่ยวกับการถดถอยโลจิสติก

การถดถอยโลจิสติกแตกต่างจากการถดถอยเชิงเส้นที่คุณได้เรียนรู้มาก่อนหน้านี้ในหลาย ๆ ด้านที่สำคัญ

ML สำหรับผู้เริ่มต้น - ทำความเข้าใจการถดถอยโลจิสติกสำหรับการจัดหมวดหมู่ใน Machine Learning

🎥 คลิกที่ภาพด้านบนเพื่อดูวิดีโอสั้น ๆ เกี่ยวกับการถดถอยโลจิสติก

การจัดหมวดหมู่แบบทวิภาค

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

โมเดลการจัดหมวดหมู่ฟักทอง

อินโฟกราฟิกโดย Dasani Madipalli

การจัดหมวดหมู่อื่น ๆ

ยังมีการถดถอยโลจิสติกประเภทอื่น ๆ เช่น มัลติโนเมียลและออร์ดินัล:

  • มัลติโนเมียล ซึ่งเกี่ยวข้องกับการมีมากกว่าหนึ่งหมวดหมู่ - "สีส้ม สีขาว และลาย"
  • ออร์ดินัล ซึ่งเกี่ยวข้องกับหมวดหมู่ที่มีลำดับ เช่น ฟักทองที่เรียงตามขนาดที่มีจำนวนจำกัด (เล็ก, กลาง, ใหญ่, ใหญ่มาก)

มัลติโนเมียล vs ออร์ดินัล

ตัวแปรไม่จำเป็นต้องมีความสัมพันธ์กัน

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

คุณต้องการข้อมูลที่สะอาดและมากพอ

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

ML สำหรับผู้เริ่มต้น - การวิเคราะห์และเตรียมข้อมูลสำหรับการถดถอยโลจิสติก

🎥 คลิกที่ภาพด้านบนเพื่อดูวิดีโอสั้น ๆ เกี่ยวกับการเตรียมข้อมูลสำหรับการถดถอยเชิงเส้น

คิดเกี่ยวกับประเภทของข้อมูลที่เหมาะสมกับการถดถอยโลจิสติก

แบบฝึกหัด - ทำความสะอาดข้อมูล

ก่อนอื่น ทำความสะอาดข้อมูลเล็กน้อยโดยลบค่าที่เป็น null และเลือกเฉพาะบางคอลัมน์:

  1. เพิ่มโค้ดต่อไปนี้:

    
    columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
    pumpkins = full_pumpkins.loc[:, columns_to_select]
    
    pumpkins.dropna(inplace=True)
    

    คุณสามารถดู dataframe ใหม่ของคุณได้เสมอ:

    pumpkins.info
    

การแสดงผล - แผนภูมิหมวดหมู่

ตอนนี้คุณได้โหลด สมุดบันทึกเริ่มต้น พร้อมข้อมูลฟักทองอีกครั้งและทำความสะอาดเพื่อรักษาชุดข้อมูลที่มีตัวแปรบางตัว รวมถึง Color ลองแสดง dataframe ในสมุดบันทึกโดยใช้ไลบรารีที่แตกต่าง: Seaborn ซึ่งสร้างขึ้นบน Matplotlib ที่เราใช้ก่อนหน้านี้

Seaborn มีวิธีที่น่าสนใจในการแสดงผลข้อมูลของคุณ ตัวอย่างเช่น คุณสามารถเปรียบเทียบการกระจายของข้อมูลสำหรับแต่ละ Variety และ Color ในแผนภูมิหมวดหมู่

  1. สร้างแผนภูมิแบบนี้โดยใช้ฟังก์ชัน catplot กับข้อมูลฟักทอง pumpkins และระบุการจับคู่สีสำหรับแต่ละหมวดหมู่ของฟักทอง (สีส้มหรือสีขาว):

    import seaborn as sns
    
    palette = {
    'ORANGE': 'orange',
    'WHITE': 'wheat',
    }
    
    sns.catplot(
    data=pumpkins, y="Variety", hue="Color", kind="count",
    palette=palette, 
    )
    

    กริดของข้อมูลที่แสดงผล

    โดยการสังเกตข้อมูล คุณสามารถเห็นได้ว่าข้อมูล Color เกี่ยวข้องกับ Variety อย่างไร

    จากแผนภูมิหมวดหมู่นี้ คุณสามารถจินตนาการถึงการสำรวจที่น่าสนใจอะไรบ้าง?

การเตรียมข้อมูล: การเข้ารหัสฟีเจอร์และป้ายกำกับ

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

สำหรับการเข้ารหัสฟีเจอร์ มีตัวเข้ารหัสหลักสองประเภท:

  1. ตัวเข้ารหัสแบบลำดับ: เหมาะสำหรับตัวแปรลำดับ ซึ่งเป็นตัวแปรหมวดหมู่ที่ข้อมูลของพวกมันมีลำดับเชิงตรรกะ เช่น คอลัมน์ Item Size ในชุดข้อมูลของเรา มันสร้างการจับคู่ที่แต่ละหมวดหมู่แสดงด้วยตัวเลขซึ่งเป็นลำดับของหมวดหมู่ในคอลัมน์

    from sklearn.preprocessing import OrdinalEncoder
    
    item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
    ordinal_features = ['Item Size']
    ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
    
  2. ตัวเข้ารหัสหมวดหมู่: เหมาะสำหรับตัวแปรที่ไม่มีลำดับ ซึ่งเป็นตัวแปรหมวดหมู่ที่ข้อมูลของพวกมันไม่มีลำดับเชิงตรรกะ เช่น ฟีเจอร์ทั้งหมดที่แตกต่างจาก Item Size ในชุดข้อมูลของเรา มันเป็นการเข้ารหัสแบบ one-hot ซึ่งหมายความว่าแต่ละหมวดหมู่แสดงด้วยคอลัมน์ไบนารี: ตัวแปรที่เข้ารหัสจะเท่ากับ 1 หากฟักทองเป็นของ Variety นั้น และ 0 หากไม่ใช่

    from sklearn.preprocessing import OneHotEncoder
    
    categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
    categorical_encoder = OneHotEncoder(sparse_output=False)
    

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

    from sklearn.compose import ColumnTransformer
    
    ct = ColumnTransformer(transformers=[
        ('ord', ordinal_encoder, ordinal_features),
        ('cat', categorical_encoder, categorical_features)
        ])
    
    ct.set_output(transform='pandas')
    encoded_features = ct.fit_transform(pumpkins)

ในทางกลับกัน สำหรับการเข้ารหัสป้ายกำกับ เราใช้คลาส LabelEncoder ของ scikit-learn ซึ่งเป็นคลาสยูทิลิตี้ที่ช่วยทำให้ป้ายกำกับเป็นปกติ โดยที่ป้ายกำกับมีค่าเฉพาะระหว่าง 0 และ n_classes-1 (ที่นี่คือ 0 และ 1)

    from sklearn.preprocessing import LabelEncoder

    label_encoder = LabelEncoder()
    encoded_label = label_encoder.fit_transform(pumpkins['Color'])

เมื่อเราเข้ารหัสฟีเจอร์และป้ายกำกับแล้ว เราสามารถรวมพวกมันเข้าด้วยกันใน dataframe ใหม่ encoded_pumpkins

    encoded_pumpkins = encoded_features.assign(Color=encoded_label)

ข้อดีของการใช้ตัวเข้ารหัสแบบลำดับสำหรับคอลัมน์ Item Size คืออะไร?

วิเคราะห์ความสัมพันธ์ระหว่างตัวแปร

ตอนนี้เราได้เตรียมข้อมูลของเราแล้ว เราสามารถวิเคราะห์ความสัมพันธ์ระหว่างฟีเจอร์และป้ายกำกับเพื่อให้เข้าใจว่าโมเดลจะสามารถทำนายป้ายกำกับได้ดีเพียงใดจากฟีเจอร์ วิธีที่ดีที่สุดในการทำการวิเคราะห์ประเภทนี้คือการแสดงผลข้อมูล เราจะใช้ฟังก์ชัน catplot ของ Seaborn อีกครั้งเพื่อแสดงความสัมพันธ์ระหว่าง Item Size, Variety และ Color ในแผนภูมิหมวดหมู่ เพื่อแสดงผลข้อมูลได้ดียิ่งขึ้น เราจะใช้คอลัมน์ Item Size ที่เข้ารหัสและคอลัมน์ Variety ที่ไม่ได้เข้ารหัส

    palette = {
    'ORANGE': 'orange',
    'WHITE': 'wheat',
    }
    pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']

    g = sns.catplot(
        data=pumpkins,
        x="Item Size", y="Color", row='Variety',
        kind="box", orient="h",
        sharex=False, margin_titles=True,
        height=1.8, aspect=4, palette=palette,
    )
    g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
    g.set_titles(row_template="{row_name}")

แผนภูมิหมวดหมู่ของข้อมูลที่แสดงผล

ใช้แผนภูมิแบบฝูง

เนื่องจาก Color เป็นหมวดหมู่แบบทวิภาค (สีขาวหรือไม่ใช่) มันต้องการ 'วิธีการเฉพาะ specialized approach ในการแสดงผล' ยังมีวิธีอื่น ๆ ในการแสดงความสัมพันธ์ของหมวดหมู่นี้กับตัวแปรอื่น ๆ

คุณสามารถแสดงตัวแปรเคียงข้างกันด้วยแผนภูมิ Seaborn

  1. ลองใช้แผนภูมิแบบ 'swarm' เพื่อแสดงการกระจายของค่า:

    palette = {
    0: 'orange',
    1: 'wheat'
    }
    sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
    

    แผนภูมิแบบฝูงของข้อมูลที่แสดงผล

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

🧮 คณิตศาสตร์เบื้องหลัง

การถดถอยโลจิสติกอาศัยแนวคิดของ 'ความน่าจะเป็นสูงสุด' โดยใช้ ฟังก์ชันซิกมอยด์ ฟังก์ชันซิกมอยด์บนกราฟมีลักษณะเหมือนรูปตัว 'S' มันรับค่าและแมปไปยังค่าระหว่าง 0 และ 1 เส้นโค้งของมันยังเรียกว่า 'เส้นโค้งโลจิสติก' สูตรของมันมีลักษณะดังนี้:

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

โดยที่จุดกึ่งกลางของซิกมอยด์อยู่ที่จุด 0 ของ x, L คือค่ามากสุดของเส้นโค้ง และ k คือความชันของเส้นโค้ง หากผลลัพธ์ของฟังก์ชันมากกว่า 0.5 ป้ายกำกับจะถูกกำหนดให้เป็นคลาส '1' ของตัวเลือกแบบทวิภาค หากไม่ใช่ จะถูกจัดเป็น '0'

สร้างโมเดลของคุณ

การสร้างโมเดลเพื่อค้นหาการจัดหมวดหมู่แบบทวิภาคนั้นง่ายอย่างน่าประหลาดใจใน Scikit-learn

ML สำหรับผู้เริ่มต้น - การถดถอยโลจิสติกสำหรับการจัดหมวดหมู่ข้อมูล

🎥 คลิกที่ภาพด้านบนเพื่อดูวิดีโอสั้น ๆ เกี่ยวกับการสร้างโมเดลการถดถอยเชิงเส้น

  1. เลือกตัวแปรที่คุณต้องการใช้ในโมเดลการจัดหมวดหมู่ของคุณและแบ่งชุดข้อมูลการฝึกอบรมและการทดสอบโดยเรียกใช้ train_test_split():

    from sklearn.model_selection import train_test_split
    
    X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
    y = encoded_pumpkins['Color']
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    
    
  2. ตอนนี้คุณสามารถฝึกโมเดลของคุณได้โดยเรียกใช้ fit() พร้อมข้อมูลการฝึกอบรมของคุณ และพิมพ์ผลลัพธ์ออกมา:

    from sklearn.metrics import f1_score, classification_report 
    from sklearn.linear_model import LogisticRegression
    
    model = LogisticRegression()
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)
    
    print(classification_report(y_test, predictions))
    print('Predicted labels: ', predictions)
    print('F1-score: ', f1_score(y_test, predictions))
    

    ดูคะแนนของโมเดลของคุณ มันไม่ได้แย่เลยเมื่อพิจารณาว่าคุณมีข้อมูลเพียงประมาณ 1000 แถว:

                       precision    recall  f1-score   support
    
                    0       0.94      0.98      0.96       166
                    1       0.85      0.67      0.75        33
    
        accuracy                                0.92       199
        macro avg           0.89      0.82      0.85       199
        weighted avg        0.92      0.92      0.92       199
    
        Predicted labels:  [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
        0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
        1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
        0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
        0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
        0 0 0 1 0 0 0 0 0 0 0 0 1 1]
        F1-score:  0.7457627118644068
    

เข้าใจได้ดีขึ้นด้วยเมทริกซ์ความสับสน

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

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

  1. ในการใช้เมทริกซ์ความสับสน ให้เรียกใช้ confusion_matrix():

    from sklearn.metrics import confusion_matrix
    confusion_matrix(y_test, predictions)
    

    ดูเมทริกซ์ความสับสนของโมเดลของคุณ:

    array([[162,   4],
           [ 11,  22]])
    

ใน Scikit-learn เมทริกซ์ความสับสนมีแถว (แกน 0) เป็นป้ายกำกับจริง และคอลัมน์ (แกน 1) เป็นป้ายกำกับที่ทำนาย

0 1
0 TN FP
1 FN TP

เกิดอะไรขึ้นที่นี่? สมมติว่าโมเดลของเราถูกขอให้จัดหมวดหมู่ฟักทองระหว่างสองหมวดหมู่แบบทวิภาค คือ หมวดหมู่ 'สีขาว' และหมวดหมู่ 'ไม่ใช ความสัมพันธ์ระหว่าง Confusion Matrix กับ Precision และ Recall คืออะไร? จำไว้ว่า Classification Report ที่แสดงไว้ข้างต้นแสดงค่า Precision (0.85) และ Recall (0.67)

Precision = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461

Recall = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666

ถาม: จาก Confusion Matrix โมเดลทำงานเป็นอย่างไร? ตอบ: ไม่เลวเลย; มีจำนวน True Negatives ที่ดี แต่ก็มี False Negatives อยู่บ้าง

มาทบทวนคำศัพท์ที่เราเคยเห็นก่อนหน้านี้โดยใช้การแมป TP/TN และ FP/FN จาก Confusion Matrix:

🎓 Precision: TP/(TP + FP) สัดส่วนของตัวอย่างที่เกี่ยวข้องในตัวอย่างที่ถูกดึงมา (เช่น ฉลากที่ถูกระบุได้ดี)

🎓 Recall: TP/(TP + FN) สัดส่วนของตัวอย่างที่เกี่ยวข้องที่ถูกดึงมา ไม่ว่าจะระบุได้ดีหรือไม่

🎓 f1-score: (2 * precision * recall)/(precision + recall) ค่าเฉลี่ยแบบถ่วงน้ำหนักระหว่าง Precision และ Recall โดยค่าที่ดีที่สุดคือ 1 และแย่ที่สุดคือ 0

🎓 Support: จำนวนครั้งที่ฉลากแต่ละตัวถูกดึงมา

🎓 Accuracy: (TP + TN)/(TP + TN + FP + FN) เปอร์เซ็นต์ของฉลากที่ถูกทำนายได้อย่างถูกต้องในตัวอย่าง

🎓 Macro Avg: การคำนวณค่าเฉลี่ยแบบไม่ถ่วงน้ำหนักสำหรับแต่ละฉลาก โดยไม่คำนึงถึงความไม่สมดุลของฉลาก

🎓 Weighted Avg: การคำนวณค่าเฉลี่ยสำหรับแต่ละฉลาก โดยคำนึงถึงความไม่สมดุลของฉลากด้วยการถ่วงน้ำหนักตาม Support (จำนวนตัวอย่างจริงสำหรับแต่ละฉลาก)

คุณคิดว่าคุณควรดู Metric ใดหากคุณต้องการลดจำนวน False Negatives ของโมเดล?

การแสดงผล ROC Curve ของโมเดลนี้

ML for beginners - การวิเคราะห์ประสิทธิภาพ Logistic Regression ด้วย ROC Curves

🎥 คลิกที่ภาพด้านบนเพื่อดูวิดีโอสั้นเกี่ยวกับ ROC Curves

มาทำการแสดงผลอีกครั้งเพื่อดู 'ROC' Curve:

from sklearn.metrics import roc_curve, roc_auc_score
import matplotlib
import matplotlib.pyplot as plt
%matplotlib inline

y_scores = model.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])

fig = plt.figure(figsize=(6, 6))
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()

ใช้ Matplotlib เพื่อแสดงผล Receiving Operating Characteristic หรือ ROC ROC Curves มักถูกใช้เพื่อดูผลลัพธ์ของตัวจำแนกในแง่ของ True Positives เทียบกับ False Positives "ROC Curves มักมีแกน Y เป็น True Positive Rate และแกน X เป็น False Positive Rate" ดังนั้น ความชันของกราฟและพื้นที่ระหว่างเส้นกลางกับกราฟจึงสำคัญ: คุณต้องการกราฟที่พุ่งขึ้นและข้ามเส้นอย่างรวดเร็ว ในกรณีของเรา มี False Positives ในช่วงเริ่มต้น และจากนั้นกราฟก็พุ่งขึ้นและข้ามเส้นได้อย่างเหมาะสม:

ROC

สุดท้าย ใช้ roc_auc_score API ของ Scikit-learn เพื่อคำนวณ 'Area Under the Curve' (AUC) จริง:

auc = roc_auc_score(y_test,y_scores[:,1])
print(auc)

ผลลัพธ์คือ 0.9749908725812341 เนื่องจาก AUC มีค่าตั้งแต่ 0 ถึง 1 คุณต้องการคะแนนที่สูง เพราะโมเดลที่ทำนายได้ถูกต้อง 100% จะมี AUC เท่ากับ 1; ในกรณีนี้ โมเดลถือว่า ดีมาก

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


🚀ความท้าทาย

ยังมีอีกมากมายเกี่ยวกับ Logistic Regression ที่ต้องเรียนรู้! แต่วิธีที่ดีที่สุดในการเรียนรู้คือการทดลอง ค้นหาชุดข้อมูลที่เหมาะสมกับการวิเคราะห์ประเภทนี้และสร้างโมเดลด้วยชุดข้อมูลนั้น คุณได้เรียนรู้อะไร? เคล็ดลับ: ลองดู Kaggle สำหรับชุดข้อมูลที่น่าสนใจ

แบบทดสอบหลังการบรรยาย

ทบทวนและศึกษาด้วยตนเอง

อ่านหน้าแรก ๆ ของ เอกสารนี้จาก Stanford เกี่ยวกับการใช้งาน Logistic Regression ในทางปฏิบัติ ลองคิดถึงงานที่เหมาะสมกับการใช้ Regression ประเภทต่าง ๆ ที่เราได้ศึกษาไปจนถึงตอนนี้ งานประเภทใดที่เหมาะสมที่สุด?

งานที่ได้รับมอบหมาย

ลองทำ Regression นี้อีกครั้ง


ข้อจำกัดความรับผิดชอบ:
เอกสารนี้ได้รับการแปลโดยใช้บริการแปลภาษา AI Co-op Translator แม้ว่าเราจะพยายามให้การแปลมีความถูกต้องมากที่สุด แต่โปรดทราบว่าการแปลโดยอัตโนมัติอาจมีข้อผิดพลาดหรือความไม่ถูกต้อง เอกสารต้นฉบับในภาษาดั้งเดิมควรถือเป็นแหล่งข้อมูลที่เชื่อถือได้ สำหรับข้อมูลที่สำคัญ ขอแนะนำให้ใช้บริการแปลภาษามืออาชีพ เราไม่รับผิดชอบต่อความเข้าใจผิดหรือการตีความที่ผิดพลาดซึ่งเกิดจากการใช้การแปลนี้