Determine proportion of cheating students using MCMC implemented in Turing.jl - julia

Question

I am trying to solve the following problem using Julia:
Determine the frequency of students cheating during an exam. If we let N be the total number of students who took the exam, and assuming each student is interviewed post-exam using the following privacy retaining algorithm:
"In the interview process for each student, the student flips a coin, hidden from the interviewer. The student agrees to answer honestly if the coin comes up heads. Otherwise, if the coin comes up tails, the student (secretly) flips the coin again, and answers “Yes, I did cheat” if the coin flip lands heads, and “No, I did not cheat”, if the coin flip lands tails. This way, the interviewer does not know if a “Yes” was the result of a guilty plea, or a Heads on a second coin toss. Thus privacy is preserved and the researchers receive honest answers."
I have written the following code to determine the posterior distribution of cheating students:
const N = 100
const YES_ANSWERS = 35
const SAMPLES = 1000000
using DataStructures
using Distributions
function simulate(N, YES_ANSWERS, SAMPLES)
d = DefaultDict{Int64, Int64}(0)
for i in 1:SAMPLES
cheating = rand(0:N)
not_cheating = N - cheating
cheating_honest_yes = rand(Binomial(cheating, 0.5))
cheating_second_toss = cheating - cheating_honest_yes
cheating_random_yes = rand(Binomial(cheating_second_toss, 0.5))
cheating_yes_answers = cheating_honest_yes + cheating_random_yes
not_cheating_second_toss = rand(Binomial(not_cheating, 0.5))
not_cheating_random_yes = rand(Binomial(not_cheating_second_toss, 0.5))
total_yes = cheating_yes_answers + not_cheating_random_yes
if total_yes == YES_ANSWERS
d[cheating] += 1
end
end
d
end
const N = 100
const YES_ANSWERS = 35
const SAMPLES = 1000000
d = simulate(N, YES_ANSWERS, SAMPLES)
using Plots
cheaters = [k/N for k in keys(d)]
probability = [v/sum(values(d)) for v in values(d)]
g = scatter(cheaters, probability)
gui(g)
Essentially I draw and count and calculate the probabilities
I then tried to use Turing.jl but got stuck:
using DataStructures
using Distributions
using Turing
#model function CheatingDistribution(N)
cheating ~ DiscreteUniform(0, N)
not_cheating = N - cheating
cheating_honest_yes ~ Binomial(cheating, 0.5)
cheating_second_toss = cheating - cheating_honest_yes
cheating_random_yes ~ Binomial(cheating_second_toss, 0.5)
cheating_yes_answers = cheating_honest_yes + cheating_random_yes
not_cheating_second_toss ~ Binomial(not_cheating, 0.5)
not_cheating_random_yes ~ Binomial(not_cheating_second_toss, 0.5)
total_yes = cheating_yes_answers + not_cheating_random_yes
total_yes
end
I cannot infer cheating from total_yes.
That said, I could use this model to reproduce the results that I got with the previous code:
using DataStructures
using Distributions
using Turing
#model function CheatingDistribution(N)
cheating ~ DiscreteUniform(0, N)
not_cheating = N - cheating
cheating_honest_yes ~ Binomial(cheating, 0.5)
cheating_second_toss = cheating - cheating_honest_yes
cheating_random_yes ~ Binomial(cheating_second_toss, 0.5)
cheating_yes_answers = cheating_honest_yes + cheating_random_yes
not_cheating_second_toss ~ Binomial(not_cheating, 0.5)
not_cheating_random_yes ~ Binomial(not_cheating_second_toss, 0.5)
total_yes = cheating_yes_answers + not_cheating_random_yes
total_yes
end
function simulate(N, actual_yes_answers, n_samples)
d = DefaultDict{Int64, Int64}(0)
cheatDist = CheatingDistribution(N)
for _ in 1:n_samples
result = rand(cheatDist)
total_yes = result.cheating_honest_yes + result.cheating_random_yes + result.not_cheating_random_yes
if total_yes == actual_yes_answers
d[result.cheating] += 1
end
end
cheaters = [k/N for k in keys(d)]
probability = [v/sum(values(d)) for v in values(d)]
return cheaters, probability
end
const N = 100 # Number of students
const YES_ANSWERS = 35 # Number of students that answered yes (both cheating and honest students)
const SAMPLES = 1000000
cheaters, probability = simulate(N, YES_ANSWERS, SAMPLES)
using Plots
g = scatter(cheaters, probability)
gui(g)
I then wrote a new version where I sum up the probabilities and get the same result except that it is more accurate, especially when yes answers in interviews are low. For example 3 students answered yes I cheated. The following is the code using probabilities:
using DataStructures
using Distributions
function simulate(N, YES_ANSWERS)
d = DefaultOrderedDict{Int64, Float64}(0)
for cheating in 0:N
p1 = 1.0 / N
not_cheating = N - cheating
for cheating_honest_yes in 0:cheating
p2 = p1 * pdf(Binomial(cheating, 0.5), cheating_honest_yes)
cheating_second_toss = cheating - cheating_honest_yes
for cheating_random_yes in 0:cheating_second_toss
p3 = p2 * pdf(Binomial(cheating_second_toss, 0.5), cheating_random_yes)
cheating_yes_answers = cheating_honest_yes + cheating_random_yes
for not_cheating_second_toss in 0:not_cheating
p4 = p3 * pdf(Binomial(not_cheating, 0.5), not_cheating_second_toss)
for not_cheating_random_yes in 0:not_cheating_second_toss
p5 = p4 * pdf(Binomial(not_cheating_second_toss, 0.5), not_cheating_random_yes)
total_yes = cheating_yes_answers + not_cheating_random_yes
if total_yes == YES_ANSWERS
d[cheating] += p5
end
end
end
end
end
end
d
end
const N = 100
const YES_ANSWERS = 35
d = simulate(N, YES_ANSWERS)
using Plots
cheaters = [k/N for k in keys(d)]
probability = [v/sum(values(d)) for v in values(d)]
g = bar(cheaters, probability)
gui(g)
I got this toy problem from the book "Baysian Methods for Hackers". The following is how the solution look like:
Note that the bin size in the solution is 10 while I am showing the PMF. So I am showing densities one tenth of the solution above.
My question: How do I solve this problem using MCMCChain.jl?