ฉันสงสัยว่าจะคำนวณความแม่นยำและมาตรการการเรียกคืนสำหรับการจำแนกประเภทหลายคลาสแบบหลายป้ายกำกับได้อย่างไรเช่นการจำแนกที่มีป้ายกำกับมากกว่าสองป้ายและแต่ละกรณีสามารถมีป้ายกำกับได้หลายป้าย

อีกเครื่องมือยอดนิยมสำหรับการวัดประสิทธิภาพของตัวจําแนกคือROC / AUC ; อันนี้ก็มีส่วนขยายหลายระดับ / หลายฉลาก: ดู [Hand 2001]

[Hand 2001]: การวางนัยทั่วไปอย่างง่ายของพื้นที่ใต้เส้นโค้ง ROC ไปสู่ปัญหาการจำแนกประเภทหลายชั้น

ต่อไปนี้คือบางส่วนของเธรดฟอรัม coursera เกี่ยวกับเมทริกซ์ความสับสนและการวัด / เรียกคืนความแม่นยำหลายระดับ

แนวคิดพื้นฐานคือการคำนวณความแม่นยำและการเรียกคืนคลาสทั้งหมดจากนั้นหาค่าเฉลี่ยเพื่อให้ได้การวัดจำนวนจริงเพียงครั้งเดียว

เมทริกซ์ความสับสนทำให้ง่ายต่อการคำนวณความแม่นยำและการเรียกคืนคลาส

ด้านล่างนี้เป็นคำอธิบายพื้นฐานเกี่ยวกับความสับสนของเมทริกซ์ที่คัดลอกมาจากชุดข้อความ:

เมทริกซ์ความสับสนเป็นวิธีการจำแนกบวกจริงลบจริงบวกเท็จและลบเท็จเมื่อมีมากกว่า 2 คลาส มันใช้สำหรับการคำนวณความแม่นยำและการเรียกคืนและดังนั้นคะแนน f1 สำหรับปัญหาหลายชั้น

ค่าจริงแสดงด้วยคอลัมน์ ค่าที่คาดการณ์จะแสดงโดยแถว

ตัวอย่าง:

ตัวอย่างการฝึกอบรม 10 ตัวอย่างที่จริง 8 ถูกจัดประเภท (ทำนาย) ไม่ถูกต้องเป็น 5
13 ตัวอย่างการฝึกอบรมที่จริง 4 ถูกจำแนกอย่างไม่ถูกต้องเป็น 9

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

cm =
     0 1 2 3 4 5 6 7 8 9 10
     1 298 2 1 0 1 1 3 3 1 1 0
     2 0 293 7 4 1 0 5 2 0 0
     3 1 3 263 0 8 0 0 3 3 2
     4 1 5 0 261 4 0 3 2 0 1
     5 0 0 10 0 254 3 0 10 2 1
     6 0 4 1 1 4 300 0 1 0 0
     7 1 3 2 0 0 0 264 0 7 1
     8 3 5 3 1 7 1 0 289 1 0
     9 0 1 3 13 1 0 11 1 289 0
    10 0 6 0 1 6 1 2 1 4 304

สำหรับคลาส x:

• จริงบวก: ตำแหน่งแนวทแยง, ซม. (x, x)

• เท็จบวก: ผลรวมของคอลัมน์ x (ไม่มีเส้นทแยงมุมหลัก), ผลรวม (ซม. (:, x)) - ซม. (x, x)

• False ลบ: ผลรวมของแถว x (ไม่มีเส้นทแยงมุมหลัก), ผลรวม (cm (x, :), 2) -cm (x, x)

คุณสามารถคำนวณความแม่นยำการเรียกคืนและคะแนน F1 ตามสูตรหลักสูตร

การหาค่าเฉลี่ยของคลาสทั้งหมด (ไม่ว่าจะมีหรือไม่มีน้ำหนัก) ให้ค่าสำหรับโมเดลทั้งหมด

สำหรับการจำแนกประเภทหลายฉลากคุณมีสองวิธีที่จะไปก่อนพิจารณาสิ่งต่อไปนี้

• $n$คือจำนวนตัวอย่าง
• $Y_i$คือการกำหนดป้ายกำกับความจริงภาคพื้นของตัวอย่าง ..$i^{th}$
• $x_i$เป็นตัวอย่างเช่น$i^{th}$
• $h(x_i)$เป็นป้ายที่คาดการณ์ไว้สำหรับตัวอย่างเช่น$i^{th}$

ตัวอย่างตาม

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

• ความแม่นยำ = , อัตราส่วนของจำนวนคำทำนายที่ถูกต้อง ตัวเศษจะหาจำนวนป้ายกำกับในเวกเตอร์ที่คาดการณ์ว่ามีความจริงร่วมกับความจริงภาคพื้นดินและอัตราส่วนคำนวณจำนวนป้ายกำกับจริงที่คาดการณ์จำนวนจริงในความจริงภาคพื้นดิน$\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|h(x_{i})|}$
• เรียกคืน , อัตราส่วนของจำนวนป้ายกำกับที่แท้จริงที่คาดการณ์ไว้ ตัวเศษจะหาจำนวนป้ายกำกับในเวกเตอร์ที่คาดการณ์ว่ามีความจริงร่วมกับความจริงภาคพื้นดิน (ดังที่แสดงไว้ด้านบน) จากนั้นจะหาอัตราส่วนกับจำนวนป้ายกำกับที่แท้จริง$\frac{1}{n}\sum_{i=1}^{n}\frac{|Y_{i}\cap h(x_{i})|}{|Y_{i}|}$

มีตัวชี้วัดอื่น ๆ เช่นกัน

ฉลากตาม

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

วิธีที่ง่ายคือการนำเสนอแบบฟอร์มทั่วไป

นี่เป็นเพียงส่วนขยายของมาตรฐานเทียบเท่าหลายคลาส

• ค่าเฉลี่ยของแมโคร$\frac{1}{q}\sum_{j=1}^{q}B(TP_{j},FP_{j},TN_{j},FN_{j})$

• ไมโครเฉลี่ย$B(\sum_{j=1}^{q}TP_{j},\sum_{j=1}^{q}FP_{j},\sum_{j=1}^{q}TN_{j},\sum_{j=1}^{q}FN_{j})$

นี่คือคือจำนวนจริงบวก, บวกเท็จ, ลบจริงและลบเท็จตามลำดับสำหรับฉลากเท่านั้น j t $TP_{j},FP_{j},TN_{j},FN_{j}$$j^{th}$

ที่นี่ย่อมาจากเมตริกที่อิงกับความสับสน ในกรณีของคุณคุณจะต้องเสียบความแม่นยำมาตรฐานและสูตรการเรียกคืน สำหรับค่าเฉลี่ยของมาโครคุณต้องผ่านการนับต่อฉลากจากนั้นหาผลรวมสำหรับค่าเฉลี่ยขนาดเล็กคุณต้องนับค่าเฉลี่ยก่อนจากนั้นจึงใช้ฟังก์ชันเมตริกของคุณ$B$

คุณอาจจะสนใจที่จะมีลักษณะเป็นรหัสสำหรับตัวชี้วัด Mult-ฉลากที่นี่ซึ่งเป็นส่วนหนึ่งของแพคเกจmldrในR นอกจากนี้คุณอาจสนใจที่จะมองเข้าไปในห้องสมุด Java หลายป้ายมู่หลาน

นี่เป็นบทความที่ดีที่จะนำไปใช้ในการวัดต่างๆ: การทบทวนขั้นตอนวิธีการเรียนรู้แบบหลายฉลาก

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

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

และลิงค์นี้จะอธิบายวิธีการคำนวณ micro-f1 และ macro-f1 เพื่อประเมินตัวจําแนกโดยรวม

หวังว่าคุณจะพบว่ามีประโยชน์

ลิงก์นี้ช่วยฉัน .. https://www.youtube.com/watch?v=HBi-P5j0Kec ฉันหวังว่ามันจะช่วยคุณเช่นกัน

พูดการกระจายดังต่อไปนี้

    A   B   C   D
A   100 80  10  10
B   0    9   0   1
C   0    1   8   1
D   0    1   0   9

ความแม่นยำสำหรับ A จะเป็น

P (A) = 100/100 + 0 + 0 +0 = 100

P (B) = 9/9 + 80 + 1 + 1 = 9/91 psst ... โดยพื้นฐานแล้วให้ผลบวกที่แท้จริงของคลาสและหารด้วยข้อมูลคอลัมน์ข้ามแถว

เรียกคืนสำหรับจะเป็น

R (A) = 100 / 100+ 80 + 10 + 10 = 0.5

R (B) = 9 / 9+ 0 + 0 + 1 = 0.9

psst ... โดยพื้นฐานแล้วให้ผลบวกที่แท้จริงของคลาสและหารด้วยข้อมูลแถวข้ามคอลัมน์

เมื่อคุณได้รับค่าทั้งหมดแล้วให้หาค่าเฉลี่ยมาโคร

avg (P) = P (A) + P (B) + P (C) + P (D) / 4

avg (R) = R (A) + R (B) + R (C) + R (D) / 4

F1 = 2 * avg (P) * avg (R) / avg (P) + avg (R)

ตรวจสอบภาพนิ่งเหล่านี้จาก cs205.org ที่ Harvard เมื่อคุณไปที่หัวข้อการวัดความผิดพลาดจะมีการอภิปรายเกี่ยวกับความแม่นยำและการเรียกคืนในการตั้งค่าแบบหลายคลาส (เช่น One-vs-All หรือ One-vs-one) และเมทริกซ์ความสับสน เมทริกซ์ความสับสนเป็นสิ่งที่คุณต้องการจริงๆที่นี่

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

จาก Ozgur et al (2005) เป็นไปได้ที่จะเห็นว่าคุณควรคำนวณความแม่นยำและเรียกคืนตามนิพจน์ปกติ แต่แทนที่จะหาค่าเฉลี่ยจากอินสแตนซ์ N ทั้งหมดในชุดข้อมูลของคุณคุณควรใช้ N = [อินสแตนซ์ที่มีป้ายกำกับอย่างน้อยหนึ่งรายการ ชั้นเรียนที่มีปัญหามอบหมายให้]

นี่คือการอ้างอิงที่กล่าวถึง: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.10.10.8244&rep=rep1&type=pdf

วิธีเดียวกันกับที่คุณทำกับกรณีทั่วไปโดยมีชุด:

http://en.wikipedia.org/wiki/F1_score

http://en.wikipedia.org/wiki/Precision_and_recall

นี่คือฟังก์ชั่น Python ทั่วไปที่ทำอย่างนั้น:

def precision(y_true, y_pred):
    i = set(y_true).intersection(y_pred)
    len1 = len(y_pred)
    if len1 == 0:
        return 0
    else:
        return len(i) / len1


def recall(y_true, y_pred):
    i = set(y_true).intersection(y_pred)
    return len(i) / len(y_true)


def f1(y_true, y_pred):
    p = precision(y_true, y_pred)
    r = recall(y_true, y_pred)
    if p + r == 0:
        return 0
    else:
        return 2 * (p * r) / (p + r)


if __name__ == '__main__':
    print(f1(['A', 'B', 'C'], ['A', 'B']))