Random Integer Generator Using a Binary Integer Generator

Problem

0과 1을 리턴하는 함수 get_random_binary()가 있습니다.

이 함수는 다음과 같이 이미 정의 되어 있습니다.
Python:

from random import randrange
def get_random_binary():
    return randrange(2)

get_random_binary <- function(){
  sample(0:1,1)
}

이 함수만을 이용하여 0과 주어진 n-1까지의 랜덤값을 리턴하는 함수get_rand_int(n)을 구현하세요.

예제

실행: get_rand_int(12)
결과: 0 or 1 or 2 or 3 or 4... or 11

제약사항 : Python, R 두가지 언어중 하나로 구현합니다.

R Markdown이나 Jupyter notebook으로 아이디어부터 구현에서 실험, 테스트, 결과까지 정리해서 제출해야 합니다. 시각화나 통계검증을 위한 라이브러리등의 패키지는 자유롭게 사용하셔도 됩니다.(ggplot, matplotlib, seabron, scipy…) 하지만 내장된 랜덤 함수는 사용하시면 안됩니다.

Solution

문제 풀이 접근 방법은 get_rand_int()를 이용해 이진수를 생성하고, 이진수를 십진수로 바꾸고, 생성되는 십진수가 원하는 숫자 n보다 클 경우 다시 이진수를 생성 한다.

절차는 다음과 같습니다:

Process

Step 1:
2^k > n 에서 가능한 가장 작은 k를 찾는다

Step 2:
k길이의 list를 생성한다

Step 3:
list를 get_random_binary() 함수를 통해 생성되는 0 또는 1로 채운다

Step 4:
생성된 이진 난수를 십진수로 바꾼다

Step 5:
십진수 output이 n 보다 클 경우, 위 Step 3와 Step 4를 반복한다

Code

get_random_binary 함수
문제에서 주어진 함수. uniform 분포에 따라 0 또는 1을 생성한다.

get_random_binary <- function(){
  sample(0:1,1)
}
get_random_binary()

[1] 1

bin2int 함수
이진수를 십진수로 바꾸는 함수다.

bin2int <- function(x){
  if(!is.numeric(x)){
    throw("Only numeric inputs are allowed")
  }
  
  x %>% 
  as.character() %>%   # 이진수를 string으로 변환 
  str_split("") %>%    # string의 각 요소를 분리 
  unlist() %>%         # list를 vector로 변환
  {rev(. == 1)} %>%    # 후 계산을 위해 순서를 바꾸고 boolean으로 변환
                       # {}로 전 단계의 output을 evaluation 한다
  which() %>%          # TRUE인 index를 찾는다. 이진수의 자릿수 이다
  {2^(.-1)} %>%        # 2**자릿수를 계산해 십진수로 변환
  sum()                # 합을 구한다
}
#bin2int("1001010101")
bin2int(100101101011111)

[1] 19295

get_rand_int 함수
문제에서 주어진 get_random_binary()를 이용한 난수 생성 함수다.

get_rand_int <- function(n){
  if(n == 0){
    throw("0 is outside the allowed subset")
  } else if (!is.numeric(n)){
    throw("Only numeric inputs are allowed")
  } else if (n == 1) {
    0
  } else {
    x <- n - 1                         # n-1 저장하기
    k <- 0                            # Step 1: 이진수의 길이 k 구하기
    while(x/2**k > 1){
     k = k + 1
    }
    
    list <- 1:k                       # Step 2: k길이의 list 생성 
    out_int <- n                      
    while(out_int > x){               # Step 3, 4, 5: while을 이용한 난수 생성
      out_int <-                      
        sapply(list, 
               function(y) y = get_random_binary()) %>% # Step 3: list를 0,1로 채움
        {as.numeric(paste(., collapse = ""))} %>%       # Step 3: 이진수 생성
        bin2int()                                       # Step 4: 이진수를 십진수라 바꾼다
    }
    out_int
  }
}
#get_rand_int(0)
#get_rand_int(1)
#get_rand_int("12")
get_rand_int(12)

[1] 6

Test

Exploratory Data Analysis

sample_fun 함수 get_rand_int() 함수를 이용해 sampling을 한다. nsim은 sampling 횟수이고, n은 get_rant_int(n)의 n이다.

sample_fun <- function(nsim, n){
  list <- numeric(nsim)
  out <- sapply(list, function(x) x = get_rand_int(n))
  out
}

n=12이라는 가정하에, get_rand_int() sampling을 100,000번 시도한다

df <- sample_fun(nsim = 100000, n = 12)
df <- data.frame(df)
head(df, 10)

각 숫자가 몇번 생성이 됬는지 알아보자.

table(df)

df
   0    1    2    3    4    5    6    7    8    9   10   11 
8347 8216 8293 8428 8420 8509 8226 8194 8368 8321 8415 8263

0 에서 11이 생성으로 인해 단순 평균은 5.5와 어느정도 비슷해야한다.

df %>% 
  plyr::summarize(mean = mean(df))

     mean
1 5.49901

생성된 자료의 평균 5.51 은 5.50와 비슷하다.

ggplot을 이용해 uniform distribution인 것 같은지 살펴본다.

ggplot(df, aes(x = df)) +
  geom_histogram(binwidth = 1) +
  theme_minimal() +
  ylab("반복 횟수") +
  theme_set(theme_gray(base_family="AppleGothic")) +
  theme(axis.title.x = element_blank()) +
  scale_x_discrete(limits = 0:11)

Figure 2. 난수 생성 10만번 반복 결과

보다시피 uniform distribution인것 처럼 보이지만 통계적 검증이 필요하다.

Statistical Testing

어떠한 사람이든 연산적인 방법으로 난수 생성을 고려 하는 자는 당연히 죄의 상태에 이르렀다… 난수 생성이라는 것은 없다. 그저 난수 생성하는 법만 있을 뿐이다. 우리는 단순히 숫자를 만드는 요리 레시피를 다룰 뿐이다.
- Monte Carlo Method (1951), John von Neumann

우리가 생성한 난수는 연산 방법으로 구한 의사 난수이기에 통계적으로 검증을 해야한다. 함수에서 생성된 자료가 난수인지를 확실하게 알려면 다음 두가지 조건이 충족되야한다:
1. 통계적으로 유의한 수준에서 uniform 분포를 따른는지
2. 숫자간에 상관관계가 있는지

생성된 자료는 정규 분포를 따르지 않으므로, 비모수적 통계적인 검증 방법을 세가지 시도해본다:
1. 자료의 예상 및 관측된 빈도로 chi-square goodness of fit test를 이용한 uniform distribution 검증.
2. 생성된 수간의 독립성을 검증하는 Wald-Wolfowitz runs test.
3. 생성된 수의 계열 상관 검증 (serial correlation test).

위 세가지 검정은 내부적인 난수 생성 함수를 쓰지 않으므로 제약 조건을 충족한다.

Chi-square Goodness of Fit Test

난수 생성이 uniform 분포를 따를시 예측 되는 빈도와 관측된 빈도를 비교해 chi-square test를 통해 두 표본이 다른지를 검증한다.

\[H_o: 생성된\;수의\;예상\;빈도와\;관측\;빈도가\;같다\] \[H_a: 생성된\;수의\;예상\;빈도와\;관측\;빈도가\;같지\;않다\]

df_chi <- cbind(observed = table(df),
                expected = 100000/12)
df_chi

   observed expected
0      8347 8333.333
1      8216 8333.333
2      8293 8333.333
3      8428 8333.333
4      8420 8333.333
5      8509 8333.333
6      8226 8333.333
7      8194 8333.333
8      8368 8333.333
9      8321 8333.333
10     8415 8333.333
11     8263 8333.333

chisq.test(df_chi)


    Pearson's Chi-squared test

data:  df_chi
X-squared = 6.4039, df = 11, p-value = 0.8451

p-value 0.9896은 유의 수준 0.05보다 현저히 크기 때문에 귀무가설을 채택하고 생성된 난수들의 예측 빈도와 관측 빈도가 같다고 판단을 내린다. 즉 chi-square test for independence를 통해 uniformity는 주장 할 수 있지만, 무작위성을 검증하기에는 통계적 검증력이 다른 방법에 비해 낮다고 알려져있고[1] 숫자간에 트렌드가 있는지를 판단 할 수 없다. 만약 트렌드가 있다면 무작위성을 주장 할 수 없다.

Wald-Wolfowitz Runs Test

다음은 Wald-Wolfowitz Runs Test를 살펴보자. chi-square test보다는 통계적 검정력이 높기로 알려져 있고[2], 트렌드를 검증할 수 있는 장점이 있다. 다음수가 전수보다 클 경우 +, 작을 경우 -로하고 모든 수를 계산한다. +와 -의 조합의 모든 경우의 수를 계산하고 조합 검정을 한다.

\[H_o: 생성된\;시퀀스는\;무작위로\;생성됐다\] \[H_a: 생성된\;시퀀스는\;무작위로\;생성되지\;않았다\]

runs.test(df$df)


    Runs Test

data:  df$df
statistic = -1.5024, runs = 45164, n1 = 49787, n2 = 41704, n = 91491, p-value = 0.133
alternative hypothesis: nonrandomness

p-value인 0.5882는 유의수준 0.05보다 높은 것으로 보아 귀무가설을 채택하고 생성된 자료의 무작위성을 받아들일 수 있다.

Serial Correlation Test

특정한 경우에는 von Neumann rank test가 runs test보다 뛰어나다고 알려져 있으므로[3] 마지막으로 rank test로 무작위성을 검증 해보자. 연속적으로 이어지는 숫자들의 상관 계수 \(\rho_1\)를 계산한다. \[H_o: \rho_1 = 0\] \[H_a: \rho_1 \neq 1\]

BartelsRankTest(df$df,alternative = "trend")


    Bartels Ratio Test

data:  df$df
RVN = 1.99390, z = -0.96386, n = 100000, p-value = 0.1676
alternative hypothesis: trend

p-value는 0.829로, 유의수준인 0.05보다 월등히 높다. 현재의 자료에서는 숫자와 전숫자의 lag인 k = 0일 경우와 lag k = 1일 경우의 분포는 의존도가 없는 것으로 판단 할수 있지만, lag k = 100 까지를 계산을 하자. 이를 하기 위해선 연산이 간편한 계열 상관계수를 계산해보자. 상관계수가 0에 가까우면 수가 무작위로 생성이 됬다고 판단을 내릴 수 있다.

df_shift <- shift(df, n = 1:100, fill = get_rand_int(12), type = "lag")
df_shift <- do.call("cbind", df_shift)
df_shift.cor <- cor(df_shift)
corrplot(df_shift.cor,
         tl.pos = "n")

Figure 3. Lag k = 100까지의 상관계수들의 correlation 표.

Figure 4. lag = 10000 까지의 auto-correlation

같은 표본간의 상관계수는 당연히 1 (파랑색) 이지만, 표본간의 상관계수는 모두 0인것으로 보여, k = 10000까지는 표본관의 의존도가 없는것으로 보고, 생성된 자료의 무작위성을 입증 할 수 있다.

Conclusion

get_random_binary()를 통해 만든 get_rand_int() 함수를 만들었고, get_rand_int()에서 나오는 output은 chi-square test를 통해 uniform 분포를 따르는것으로 검증됬고, Wald-Wolfowitz runs test와 von Neumann Rank test와 serial correlation로 무작위성이 검증되었다.

향후에는 benchmarking을 통해 get_rand_int() 함수의 성능을 더 향상 시키고 싶고, 위 사용한 방법이 아닌 다른 방법이 있는지 조사를 하고 싶다.

References

[1] McHugh, ML. The chi-square test of independence. Biochem Med (Zagreb). 2013;23(2):143-9.
[2] C. Heschl, William. An Investigation of the Power of the Wald-Wolfowitz, Two Sample, Runs Test. 1971;190.
[3] Bartels, R. The rank version of von Neumann’s ratio test for randomness, Journal of the American Statistical Association, vol.77, pp.40-46.

---
title: "Random Integer Generator Using a Binary Integer Generator"
author: "Eugene Cha"
date: "March 1, 2019"
output: html_notebook
---


```{r, echo = FALSE, message = FALSE}
library('tidyverse')
library('ggplot2')
library('EnvStats')
library('lawstat')
library('data.table')
library('corrplot')
library('Hmisc')
library('randtests')
library('DescTools')
library('R.oo')

options(scipen = 999)
```

## Problem 
0과 1을 리턴하는 함수 get_random_binary()가 있습니다.

이 함수는 다음과 같이 이미 정의 되어 있습니다.  
**Python:**
```{python}
from random import randrange
def get_random_binary():
	return randrange(2)
```

**R:**
```{r}
get_random_binary <- function(){
  sample(0:1,1)
}
```

이 함수만을 이용하여 0과 주어진 n-1까지의 랜덤값을 리턴하는 함수get_rand_int(n)을 구현하세요.


**예제**
```{null, results = 'hide'}
실행: get_rand_int(12)
결과: 0 or 1 or 2 or 3 or 4... or 11
```

**제약사항** : Python, R 두가지 언어중 하나로 구현합니다. 

R Markdown이나 Jupyter notebook으로 아이디어부터 구현에서 실험, 테스트, 결과까지 정리해서 제출해야 합니다. 시각화나 통계검증을 위한 라이브러리등의 패키지는 자유롭게 사용하셔도 됩니다.(ggplot, matplotlib, seabron, scipy…) 하지만 내장된 랜덤 함수는 사용하시면 안됩니다.
<br>

## Solution

문제 풀이 접근 방법은 get_rand_int()를 이용해 이진수를 생성하고, 이진수를 십진수로 바꾸고, 생성되는 십진수가 원하는 숫자 n보다 클 경우 다시 이진수를 생성 한다.

절차는 다음과 같습니다:

### Process
**Step 1:**  
2^k^ > n 에서 가능한 가장 작은 k를 찾는다

**Step 2:**  
k길이의 list를 생성한다

**Step 3:**  
list를 get_random_binary() 함수를 통해 생성되는 0 또는 1로 채운다

**Step 4:**  
생성된 이진 난수를 십진수로 바꾼다

**Step 5:**  
십진수 output이 n 보다 클 경우, 위 Step 3와 Step 4를 반복한다

<center>
![](190223_png_figure1.png)
</center>

<br>

### Code
**get_random_binary 함수**  
문제에서 주어진 함수. uniform 분포에 따라 0 또는 1을 생성한다.
```{r}
get_random_binary <- function(){
  sample(0:1,1)
}
get_random_binary()
```

**bin2int 함수**  
이진수를 십진수로 바꾸는 함수다. 
```{r}
bin2int <- function(x){
  if(!is.numeric(x)){
    throw("Only numeric inputs are allowed")
  }
  
  x %>% 
  as.character() %>%   # 이진수를 string으로 변환 
  str_split("") %>%    # string의 각 요소를 분리 
  unlist() %>%         # list를 vector로 변환
  {rev(. == 1)} %>%    # 후 계산을 위해 순서를 바꾸고 boolean으로 변환
                       # {}로 전 단계의 output을 evaluation 한다
  which() %>%          # TRUE인 index를 찾는다. 이진수의 자릿수 이다
  {2^(.-1)} %>%        # 2**자릿수를 계산해 십진수로 변환
  sum()                # 합을 구한다
}
#bin2int("1001010101")
bin2int(100101101011111)
```

**get_rand_int 함수**  
문제에서 주어진 get_random_binary()를 이용한 난수 생성 함수다.
```{r}
get_rand_int <- function(n){
  if(n == 0){
    throw("0 is outside the allowed subset")
  } else if (!is.numeric(n)){
    throw("Only numeric inputs are allowed")
  } else if (n == 1) {
    0
  } else {
    x <- n - 1                         # n-1 저장하기
    k <- 0                            # Step 1: 이진수의 길이 k 구하기
    while(x/2**k > 1){
     k = k + 1
    }
    
    list <- seq_len(k)                      # Step 2: k길이의 list 생성 
    out_int <- n                      
    while(out_int > x){               # Step 3, 4, 5: while을 이용한 난수 생성
      out_int <-                      
        sapply(list, 
               function(y) y = get_random_binary()) %>% # Step 3: list를 0,1로 채움
        {as.numeric(paste(., collapse = ""))} %>%       # Step 3: 이진수 생성
        bin2int()                                       # Step 4: 이진수를 십진수라 바꾼다
    }
    out_int
  }
}
#get_rand_int(0)
#get_rand_int(1)
#get_rand_int("12")
get_rand_int(12)
```
<br>

## Test

### Exploratory Data Analysis

**sample_fun 함수**
get_rand_int() 함수를 이용해 sampling을 한다. nsim은 sampling 횟수이고, n은 get_rant_int(n)의 n이다.
```{r}
sample_fun <- function(nsim, n){
  list <- numeric(nsim)
  out <- sapply(list, function(x) x = get_rand_int(n))
  out
}
```
<br>
n=12이라는 가정하에, get_rand_int() sampling을 100,000번 시도한다
```{r}
df <- sample_fun(nsim = 100000, n = 12)
df <- data.frame(df)
head(df, 10)
```
<br>
각 숫자가 몇번 생성이 됬는지 알아보자.
```{r}
table(df)
```
<br>
0 에서 11이 생성으로 인해 단순 평균은 5.5와 어느정도 비슷해야한다.
```{r}
df %>% 
  plyr::summarize(mean = mean(df))
```
<br>
생성된 자료의 평균 5.51 은 5.50와 비슷하다.
<br>  
ggplot을 이용해 uniform distribution인 것 같은지 살펴본다.
```{r}
ggplot(df, aes(x = df)) +
  geom_histogram(binwidth = 1) +
  theme_minimal() +
  ylab("반복 횟수") +
  theme_set(theme_gray(base_family="AppleGothic")) +
  theme(axis.title.x = element_blank()) +
  scale_x_discrete(limits = 0:11)
```
<center><font size = 4>
**Figure 2**. 난수 생성 10만번 반복 결과
</font></center>
<br>
보다시피 uniform distribution인것 처럼 보이지만 통계적 검증이 필요하다.
<br>

### Statistical Testing
>어떠한 사람이든 연산적인 방법으로 난수 생성을 고려 하는 자는 당연히 죄의 상태에 이르렀다... 난수 생성이라는 것은 없다. 그저 난수 생성하는 법만 있을 뿐이다. 우리는 단순히 숫자를 만드는 요리 레시피를 다룰 뿐이다.  
- *Monte Carlo Method* (1951), John von Neumann

우리가 생성한 난수는 연산 방법으로 구한 의사 난수이기에 통계적으로 검증을 해야한다. 함수에서 생성된 자료가 난수인지를 확실하게 알려면 다음 두가지 조건이 충족되야한다:  
1. 통계적으로 유의한 수준에서 uniform 분포를 따른는지  
2. 숫자간에 상관관계가 있는지

생성된 자료는 정규 분포를 따르지 않으므로, 비모수적 통계적인 검증 방법을 세가지 시도해본다:  
1. 자료의 예상 및 관측된 빈도로 chi-square goodness of fit test를 이용한 uniform distribution 검증.  
2. 생성된 수간의 독립성을 검증하는 Wald-Wolfowitz runs test.  
3. 생성된 수의 계열 상관 검증 (serial correlation test).  

위 세가지 검정은 내부적인 난수 생성 함수를 쓰지 않으므로 제약 조건을 충족한다.

#### Chi-square Goodness of Fit Test
난수 생성이 uniform 분포를 따를시 예측 되는 빈도와 관측된 빈도를 비교해 chi-square test를 통해 두 표본이 다른지를 검증한다.

$$H_o: 생성된\;수의\;예상\;빈도와\;관측\;빈도가\;같다$$
$$H_a: 생성된\;수의\;예상\;빈도와\;관측\;빈도가\;같지\;않다$$
```{r}
df_chi <- cbind(observed = table(df),
                expected = 100000/12)
df_chi
chisq.test(df_chi)
```
p-value 0.9896은 유의 수준 0.05보다 현저히 크기 때문에 귀무가설을 채택하고 생성된 난수들의 예측 빈도와 관측 빈도가 같다고 판단을 내린다. 즉 chi-square test for independence를 통해 uniformity는 주장 할 수 있지만, 무작위성을 검증하기에는 통계적 검증력이 다른 방법에 비해 낮다고 알려져있고[1] 숫자간에 트렌드가 있는지를 판단 할 수 없다. 만약 트렌드가 있다면 무작위성을 주장 할 수 없다.

#### Wald-Wolfowitz Runs Test

다음은 Wald-Wolfowitz Runs Test를 살펴보자. chi-square test보다는 통계적 검정력이 높기로 알려져 있고[2], 트렌드를 검증할 수 있는 장점이 있다. 다음수가 전수보다 클 경우 +, 작을 경우 -로하고 모든 수를 계산한다. +와 -의 조합의 모든 경우의 수를 계산하고 조합 검정을 한다.

$$H_o: 생성된\;시퀀스는\;무작위로\;생성됐다$$
$$H_a: 생성된\;시퀀스는\;무작위로\;생성되지\;않았다$$
```{r}
runs.test(df$df)
```
p-value인 0.5882는 유의수준 0.05보다 높은 것으로 보아 귀무가설을 채택하고 생성된 자료의 무작위성을 받아들일 수 있다. 

#### Serial Correlation Test

특정한 경우에는 von Neumann rank test가 runs test보다 뛰어나다고 알려져 있으므로[3] 마지막으로 rank test로 무작위성을 검증 해보자. 연속적으로 이어지는 숫자들의 상관 계수 $\rho_1$를 계산한다.
$$H_o: \rho_1 = 0$$
$$H_a: \rho_1 \neq 1$$

```{r}
BartelsRankTest(df$df,alternative = "trend")
```
p-value는 0.829로, 유의수준인 0.05보다 월등히 높다. 현재의 자료에서는 숫자와 전숫자의 lag인 k = 0일 경우와 lag k = 1일 경우의 분포는 의존도가 없는 것으로 판단 할수 있지만, lag k = 100 까지를 계산을 하자. 이를 하기 위해선 연산이 간편한 계열 상관계수를 계산해보자. 상관계수가 0에 가까우면 수가 무작위로 생성이 됬다고 판단을 내릴 수 있다.

```{r}
df_shift <- shift(df, n = 1:100, fill = get_rand_int(12), type = "lag")
df_shift <- do.call("cbind", df_shift)
df_shift.cor <- cor(df_shift)
corrplot(df_shift.cor,
         tl.pos = "n")
```
<center><font size = "4">
**Figure 3**.  Lag k = 100까지의 상관계수들의 correlation 표. 
</font></center>

```{r}
acf(df, lag.max = 10000, plot = TRUE)
```


<center><font size = "4">
**Figure 4**.   lag = 10000 까지의 auto-correlation 
</font></center>
<br>
같은 표본간의 상관계수는 당연히 1 (파랑색) 이지만, 표본간의 상관계수는 모두 0인것으로 보여, k = 10000까지는 표본관의 의존도가 없는것으로 보고, 생성된 자료의 무작위성을 입증 할 수 있다.

## Conclusion

get_random_binary()를 통해 만든 get_rand_int() 함수를 만들었고, get_rand_int()에서 나오는 output은 chi-square test를 통해 uniform 분포를 따르는것으로 검증됬고, Wald-Wolfowitz runs test와 von Neumann Rank test와 serial correlation로 무작위성이 검증되었다.

향후에는 benchmarking을 통해 get_rand_int() 함수의 성능을 더 향상 시키고 싶고, 위 사용한 방법이 아닌 다른 방법이 있는지 조사를 하고 싶다.

<br>

#### References
[1] McHugh, ML. [The chi-square test of independence](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3900058/). Biochem Med (Zagreb). 2013;23(2):143-9.
<br>
[2] C. Heschl, William. [An Investigation of the Power of the Wald-Wolfowitz, Two Sample, Runs Test](https://apps.dtic.mil/dtic/tr/fulltext/u2/743078.pdf). 1971;190.
<br>
[3] Bartels, R. [The rank version of von Neumann’s ratio test for randomness](https://www.researchgate.net/publication/230639951_The_Rank_Version_of_von_Neumann's_Ratio_Test_for_Randomness), Journal of the American Statistical Association, vol.77, pp.40-46. 

