เหตุใด Rand ()% 6 จึงเอนเอียง

เมื่ออ่านวิธีใช้ std :: rand ฉันพบโค้ดนี้ในcppreference.com

int x = 7;
while(x > 6) 
    x = 1 + std::rand()/((RAND_MAX + 1u)/6);  // Note: 1+rand()%6 is biased

มีอะไรผิดปกติกับนิพจน์ด้านขวา? พยายามแล้วและทำงานได้อย่างสมบูรณ์

มีสองปัญหาrand() % 6( ปัญหา1+ไม่ส่งผลกระทบต่อปัญหาใด ๆ )

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

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

ในฐานะที่เป็นตัวอย่างมากแกล้งทำเป็นว่าผลิตค่าการกระจายอย่างสม่ำเสมอในช่วงrand() [0..6]ถ้าคุณดูที่เหลือสำหรับค่านั้นเมื่อrand()ส่งกลับค่าในช่วงที่เหลือผลิตกระจายผลในช่วง[0..5] [0..5]เมื่อrand()คืนค่า 6 ให้rand() % 6ส่งกลับ 0 เหมือนกับว่าrand()ได้ส่งกลับ 0 ดังนั้นคุณจะได้รับการแจกแจงที่มีค่า 0 เป็นสองเท่าของค่าอื่น ๆ

ประการที่สองคือปัญหาที่แท้จริงกับrand() % 6.

วิธีหลีกเลี่ยงปัญหานั้นคือการละทิ้งค่าที่จะทำให้เกิดรายการซ้ำที่ไม่สม่ำเสมอ คุณคำนวณผลคูณที่ใหญ่ที่สุดของ 6 ที่น้อยกว่าหรือเท่ากับRAND_MAXและเมื่อใดก็ตามที่rand()ส่งกลับค่าที่มากกว่าหรือเท่ากับจำนวนเต็มที่คุณปฏิเสธและเรียกว่า `rand () อีกครั้งตามต้องการหลาย ๆ ครั้ง

ดังนั้น:

int max = 6 * ((RAND_MAX + 1u) / 6)
int value = rand();
while (value >= max)
    value = rand();

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

มีความลึกที่ซ่อนอยู่ที่นี่:

1. การใช้ขนาดเล็กในu ถูกกำหนดให้เป็นประเภทและมักจะเป็นไปได้ที่ใหญ่ที่สุด พฤติกรรมของจะไม่ได้กำหนดไว้ในกรณีเช่นนี้เนื่องจากคุณมีประเภทมากเกินไป การเขียนแรงประเภทการแปลงเป็นเพื่อขัดขวางการล้นRAND_MAX + 1uRAND_MAXintintRAND_MAX + 1signed1uRAND_MAXunsigned

2. การใช้% 6 กระป๋อง ( แต่ในการดำเนินการทุกstd::randที่ผมเคยเห็น ไม่ได้ ) แนะนำอคติทางสถิติใด ๆ เพิ่มเติมเหนือกว่าทางเลือกที่นำเสนอ กรณีดังกล่าวที่% 6เป็นอันตรายคือกรณีที่ตัวสร้างตัวเลขมีที่ราบสหสัมพันธ์ในบิตลำดับต่ำเช่นการใช้งาน IBM ที่มีชื่อเสียง (ใน C) ของrandในฉันคิดว่าในปี 1970 ซึ่งพลิกบิตสูงและต่ำเป็น "a final เจริญรุ่งเรือง ". ข้อควรพิจารณาเพิ่มเติมคือ 6 มีขนาดเล็กมาก cf RAND_MAXดังนั้นจะมีเอฟเฟกต์น้อยที่สุดหากRAND_MAXไม่ใช่ผลคูณของ 6 ซึ่งอาจไม่ใช่

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

โค้ดตัวอย่างนี้แสดงให้เห็นว่าstd::randเป็นกรณีของ Balderdash ลัทธิการขนส่งสินค้าแบบดั้งเดิมที่ควรทำให้คิ้วของคุณยกขึ้นทุกครั้งที่คุณเห็น

มีปัญหาหลายประการที่นี่:

คนทำสัญญามักจะถือว่า - แม้แต่วิญญาณผู้เคราะห์ร้ายที่ไม่รู้จักอะไรดีกว่าและจะไม่คิดในแง่เหล่านี้อย่างชัดเจนนั่นคือrandตัวอย่างจากการแจกแจงสม่ำเสมอบนจำนวนเต็มใน 0, 1, 2, ... RAND_MAX, และการโทรแต่ละครั้งจะให้ตัวอย่างอิสระ

ปัญหาแรกคือสัญญาที่สมมติขึ้นซึ่งเป็นตัวอย่างแบบสุ่มที่เป็นอิสระในการโทรแต่ละครั้งไม่ใช่สิ่งที่เอกสารระบุไว้จริง ๆ และในทางปฏิบัติการนำไปใช้งานในอดีตล้มเหลวในการจัดหาแม้แต่สถานการณ์จำลองของความเป็นอิสระที่ชัดเจนที่สุด ตัวอย่างเช่น C99 §7.20.2.1 'The randfunction' กล่าวโดยไม่ต้องอธิบายรายละเอียด:

randฟังก์ชั่นคำนวณลำดับของจำนวนเต็มสุ่มหลอกในช่วง 0 RAND_MAXถึง

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

การใช้งานทางประวัติศาสตร์โดยทั่วไปใน C จะทำงานดังนี้:

static unsigned int seed = 1;

static void
srand(unsigned int s)
{
    seed = s;
}

static unsigned int
rand(void)
{
    seed = (seed*1103515245 + 12345) % ((unsigned long)RAND_MAX + 1);
    return (int)seed;
}

สิ่งนี้มีคุณสมบัติที่น่าเสียดายที่แม้ว่าตัวอย่างเดียวอาจมีการกระจายอย่างสม่ำเสมอภายใต้เมล็ดพันธุ์แบบสุ่มที่เหมือนกัน (ซึ่งขึ้นอยู่กับค่าเฉพาะของRAND_MAX) มันสลับระหว่างจำนวนเต็มคู่และจำนวนคี่ในการโทรติดต่อกัน - หลัง

int a = rand();
int b = rand();

นิพจน์(a & 1) ^ (b & 1)จะให้ 1 พร้อมความน่าจะเป็น 100% ซึ่งไม่ใช่กรณีสำหรับตัวอย่างสุ่มอิสระในการแจกแจงใด ๆ ที่รองรับบนจำนวนเต็มคู่และจำนวนคี่ ดังนั้นลัทธิการขนส่งสินค้าจึงเกิดขึ้นว่าเราควรทิ้งบิตลำดับต่ำเพื่อไล่ล่าสัตว์ร้ายที่เข้าใจยากของ 'การสุ่มที่ดีกว่า' (คำเตือนเกี่ยวกับสปอยเลอร์: นี่ไม่ใช่ศัพท์ทางเทคนิคนี่เป็นสัญญาณว่าใครก็ตามที่คุณอ่านร้อยแก้วไม่ทราบว่าพวกเขากำลังพูดถึงอะไรหรือคิดว่าคุณเป็นคนไร้เดียงสาและต้องถูกมองข้าม)

ปัญหาที่สองคือแม้ว่าการเรียกแต่ละครั้งจะทำตัวอย่างเป็นอิสระจากการแจกแจงแบบสุ่มที่สม่ำเสมอบน 0, 1, 2, …, RAND_MAXผลลัพธ์ของrand() % 6การกระจายจะไม่สม่ำเสมอใน 0, 1, 2, 3, 4, 5 เหมือนการตาย ม้วนเว้นแต่RAND_MAXจะสอดคล้องกับ -1 โมดูโล 6 ตัวอย่าง ง่ายๆตัวอย่าง: ถ้าRAND_MAX= 6 จากนั้นrand()ผลลัพธ์ทั้งหมดมีความน่าจะเป็นเท่ากับ 1/7 แต่จากrand() % 6ผลลัพธ์ 0 มีความน่าจะเป็น 2/7 ในขณะที่ผลลัพธ์อื่น ๆ ทั้งหมดมีความน่าจะเป็น 1/7 .

วิธีที่จะทำเช่นนี้คือมีการสุ่มตัวอย่างปฏิเสธ: ซ้ำ ๆวาดอิสระตัวอย่างสุ่มเครื่องแบบsจาก 0, 1, 2, ... , RAND_MAXและปฏิเสธ (ตัวอย่าง) ผลลัพธ์ที่ 0, 1, 2, ... , ((RAND_MAX + 1) % 6) - 1ถ้าคุณได้รับหนึ่ง เริ่มต้นใหม่ s % 6มิฉะนั้นผลผลิต

unsigned int s;
while ((s = rand()) < ((unsigned long)RAND_MAX + 1) % 6)
    continue;
return s % 6;

วิธีนี้ชุดของผลลัพธ์rand()ที่เรายอมรับจะหารด้วย 6 เท่า ๆ กันและผลลัพธ์ที่เป็นไปได้แต่ละรายการจะได้มาจากs % 6จำนวนผลลัพธ์ที่ยอมรับจากจำนวนเท่ากันrand()ดังนั้นหากrand()มีการกระจายอย่างสม่ำเสมอก็จะเป็นsเช่นนั้น ไม่มีข้อผูกมัดกับจำนวนการทดลอง แต่จำนวนที่คาดหวังน้อยกว่า 2 และความน่าจะเป็นที่จะประสบความสำเร็จเพิ่มขึ้นแบบทวีคูณตามจำนวนการทดลอง

ทางเลือกของซึ่งผลลัพธ์ของrand()คุณปฏิเสธไม่เป็นสาระสำคัญโดยมีเงื่อนไขว่าคุณแมจำนวนที่เท่ากันของพวกเขาไปยังแต่ละจำนวนเต็มด้านล่าง 6. รหัสที่ cppreference.com ที่ทำให้แตกต่างกันทางเลือกเพราะปัญหาแรกข้างต้นว่าไม่มีอะไรที่จะรับประกันเกี่ยวกับ การกระจายหรือความเป็นอิสระของเอาต์พุตของrand()และในทางปฏิบัติบิตลำดับต่ำจะแสดงรูปแบบที่ไม่ 'ดูสุ่มเพียงพอ' (ไม่ต้องสนใจว่าเอาต์พุตถัดไปเป็นฟังก์ชันที่กำหนดไว้ก่อนหน้านี้)

การออกกำลังกายสำหรับผู้อ่าน: พิสูจน์ว่ารหัสที่ cppreference.com ผลผลิตเครื่องแบบกระจายม้วนตายถ้าrand()อัตราผลตอบแทนเครื่องแบบกระจายกับ 0, 1, 2, ... RAND_MAX,

แบบฝึกหัดสำหรับผู้อ่าน: เหตุใดคุณจึงชอบที่จะปฏิเสธหนึ่งชุดหรือชุดย่อยอื่น ๆ การคำนวณแบบใดที่จำเป็นสำหรับการพิจารณาคดีแต่ละครั้งในสองกรณีนี้

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

คุณสามารถไปตามเส้นทางที่ใช้งานง่ายและคลาส C ++ 11 std::uniform_int_distributionด้วยอุปกรณ์สุ่มที่เหมาะสมและเอนจินสุ่มที่คุณชื่นชอบเช่น Mersenne twister ยอดนิยมstd::mt19937เพื่อเล่นลูกเต๋ากับลูกพี่ลูกน้องวัยสี่ขวบของคุณ แต่ถึงอย่างนั้นก็จะไม่ไป เหมาะสำหรับการสร้างวัสดุคีย์การเข้ารหัส - และ Mersenne twister ก็เป็นหมูอวกาศที่น่ากลัวเช่นกันด้วยสถานะหลายกิโลไบต์ที่สร้างความหายนะให้กับแคชของ CPU ของคุณด้วยเวลาตั้งค่าที่หยาบคายดังนั้นจึงไม่ดีแม้กระทั่งสำหรับเช่นการจำลองมอนติคาร์โลแบบขนานกับ ต้นไม้ที่ทำซ้ำได้ของการคำนวณย่อย ความนิยมน่าจะเกิดจากชื่อที่ติดปากเป็นหลัก แต่คุณสามารถใช้สำหรับทอยลูกเต๋ากลิ้งได้ดังตัวอย่างนี้!

อีกวิธีหนึ่งคือการใช้ตัวสร้างตัวเลขหลอกรหัสลับแบบธรรมดาที่มีสถานะขนาดเล็กเช่นPRNG การลบคีย์อย่างรวดเร็วอย่างง่ายหรือเพียงแค่การเข้ารหัสแบบสตรีมเช่น AES-CTR หรือ ChaCha20 หากคุณมั่นใจ ( เช่นในการจำลองมอนติคาร์โลสำหรับ การวิจัยทางวิทยาศาสตร์ธรรมชาติ) ว่าไม่มีผลเสียใด ๆ ในการทำนายผลลัพธ์ที่ผ่านมาหากรัฐถูกบุกรุก

ฉันไม่ใช่ผู้ใช้ C ++ ที่มีประสบการณ์ใด ๆ แต่สนใจที่จะดูว่าคำตอบอื่น ๆ เกี่ยวกับ std::rand()/((RAND_MAX + 1u)/6)การมีอคติน้อยกว่าที่1+std::rand()%6เป็นจริงหรือไม่ ดังนั้นฉันจึงเขียนโปรแกรมทดสอบเพื่อจัดตารางผลลัพธ์สำหรับทั้งสองวิธี (ฉันยังไม่ได้เขียน C ++ มานานแล้วโปรดตรวจสอบ) การเชื่อมโยงสำหรับการเรียกใช้รหัสที่พบที่นี่ นอกจากนี้ยังทำซ้ำดังนี้:

// Example program
#include <cstdlib>
#include <iostream>
#include <ctime>
#include <string>

int main()
{
    std::srand(std::time(nullptr)); // use current time as seed for random generator

    // Roll the die 6000000 times using the supposedly unbiased method and keep track of the results

    int results[6] = {0,0,0,0,0,0};

    // roll a 6-sided die 20 times
    for (int n=0; n != 6000000; ++n) {
        int x = 7;
        while(x > 6) 
            x = 1 + std::rand()/((RAND_MAX + 1u)/6);  // Note: 1+rand()%6 is biased

        results[x-1]++;
    }

    for (int n=0; n !=6; n++) {
        std::cout << results[n] << ' ';
    }

    std::cout << "\n";


    // Roll the die 6000000 times using the supposedly biased method and keep track of the results

    int results_bias[6] = {0,0,0,0,0,0};

    // roll a 6-sided die 20 times
    for (int n=0; n != 6000000; ++n) {
        int x = 7;
        while(x > 6) 
            x = 1 + std::rand()%6;

        results_bias[x-1]++;
    }

    for (int n=0; n !=6; n++) {
        std::cout << results_bias[n] << ' ';
    }
}

จากนั้นฉันก็เอาผลลัพธ์ของสิ่งนี้และใช้chisq.testฟังก์ชันใน R เพื่อรันการทดสอบ Chi-square เพื่อดูว่าผลลัพธ์แตกต่างจากที่คาดไว้อย่างมีนัยสำคัญหรือไม่ คำถาม stackexchange นี้มีรายละเอียดเพิ่มเติมเกี่ยวกับการใช้การทดสอบไคสแควร์เพื่อทดสอบความเป็นธรรมของแม่พิมพ์: ฉันจะทดสอบได้อย่างไรว่าการตายนั้นยุติธรรมหรือไม่ . นี่คือผลลัพธ์สำหรับการวิ่งสองสามครั้ง:

> ?chisq.test
> unbias <- c(100150, 99658, 100319, 99342, 100418, 100113)
> bias <- c(100049, 100040, 100091, 99966, 100188, 99666 )

> chisq.test(unbias)

Chi-squared test for given probabilities

data:  unbias
X-squared = 8.6168, df = 5, p-value = 0.1254

> chisq.test(bias)

Chi-squared test for given probabilities

data:  bias
X-squared = 1.6034, df = 5, p-value = 0.9008

> unbias <- c(998630, 1001188, 998932, 1001048, 1000968, 999234 )
> bias <- c(1000071, 1000910, 999078, 1000080, 998786, 1001075   )
> chisq.test(unbias)

Chi-squared test for given probabilities

data:  unbias
X-squared = 7.051, df = 5, p-value = 0.2169

> chisq.test(bias)

Chi-squared test for given probabilities

data:  bias
X-squared = 4.319, df = 5, p-value = 0.5045

> unbias <- c(998630, 999010, 1000736, 999142, 1000631, 1001851)
> bias <- c(999803, 998651, 1000639, 1000735, 1000064,1000108)
> chisq.test(unbias)

Chi-squared test for given probabilities

data:  unbias
X-squared = 7.9592, df = 5, p-value = 0.1585

> chisq.test(bias)

Chi-squared test for given probabilities

data:  bias
X-squared = 2.8229, df = 5, p-value = 0.7273

ในการรันทั้งสามครั้งที่ฉันทำค่า p สำหรับทั้งสองวิธีจะมากกว่าค่าอัลฟาทั่วไปที่ใช้ในการทดสอบนัยสำคัญเสมอ (0.05) ซึ่งหมายความว่าเราจะไม่ถือว่าทั้งสองคนมีอคติ ที่น่าสนใจคือวิธีการที่ไม่เอนเอียงตามที่คาดการณ์ไว้มีค่า p ที่ต่ำกว่าอย่างต่อเนื่องซึ่งบ่งชี้ว่าจริงๆแล้วมันอาจมีความเอนเอียงมากกว่า ข้อแม้คือฉันวิ่งได้ 3 ครั้งเท่านั้น

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

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

เราสามารถคิดว่าตัวสร้างตัวเลขสุ่มทำงานบนกระแสของเลขฐานสอง เครื่องกำเนิดไฟฟ้าเปลี่ยนสตรีมเป็นตัวเลขโดยหั่นเป็นชิ้น ๆ หากstd:randฟังก์ชันทำงานร่วมกับRAND_MAX32767 แสดงว่ากำลังใช้ 15 บิตในแต่ละชิ้น

เมื่อเรานำโมดูลที่มีตัวเลขระหว่าง 0 ถึง 32767 มารวมกันพบว่า 5462 '0 และ' 1 แต่มีเพียง 5461 '2,' 3, '4 และ' 5 ดังนั้นผลลัพธ์จึงเอนเอียง ยิ่งค่า RAND_MAX มีค่ามากเท่าใดก็จะมีอคติน้อยลง แต่ก็หลีกเลี่ยงไม่ได้

สิ่งที่ไม่เอนเอียงคือตัวเลขในช่วง [0 .. (2 ^ n) -1] คุณสามารถสร้างจำนวนที่ดีกว่า (ในทางทฤษฎี) ในช่วง 0..5 โดยการแยก 3 บิตแปลงเป็นจำนวนเต็มในช่วง 0..7 และปฏิเสธ 6 และ 7

เราหวังว่าทุกบิตในสตรีมบิตจะมีโอกาสเท่ากันที่จะเป็น '0' หรือ '1' ไม่ว่าจะอยู่ที่ใดในสตรีมหรือค่าของบิตอื่น ๆ นี่เป็นเรื่องยากมากในทางปฏิบัติ การใช้งานซอฟต์แวร์ PRNG ที่แตกต่างกันทำให้เกิดการประนีประนอมที่แตกต่างกันระหว่างความเร็วและคุณภาพ เครื่องกำเนิดไฟฟ้าที่สอดคล้องกันเชิงเส้นเช่นให้std::randความเร็วที่เร็วที่สุดสำหรับคุณภาพต่ำสุด ตัวสร้างการเข้ารหัสมีคุณภาพสูงสุดสำหรับความเร็วต่ำสุด