DM Probabilité et Simulation
Guillaume DENIS & Bastien DE ARAUJO
6 decembre 2018
Question préliminaire
1.1 Forme close avec E[G_m(T)] avec seulement la machine MA :
C’est une loi binomiale de propabilité p = pa et n =T.
1.2 Forme close avec E[G_m(T)] avec seulement la machine MB :
C’est une loi binomiale de probabilité p = pb et n = T.
1.3 Forme close avec E[G_m(T)] avec la machine MA avec probabilité 1/2 et la machine MB avec probabilité 1/2 :
C’est une loi binomiale avec une probabilité p = 1/2(pa+pb) et n =T.
1.4 Le regret :
Nous avons Rm(t) = pA − E[Gm(t)]/t. E[Gm(t)] est l’esperence du gain total pour l’instant, si on le divise par le nombre de fois que nous avons jouer (t) nous avons la probabilité que nous gagnons. Sachant que pa est la probabilité maximum ici nous faisons la soustraction avec notre probabilité. Plus le résultat se rapproche de 0 plus nous avons une bonne probabilité et plus la méthode est bonne.
On apprend puis on exploite
2.1 Intuition
Dans cette méthode nous avons e.T fois ou nous ne faisons pas d’analyse sur la probabilité de chaque machine. Ce n’est qu’au e.T+1 tirage que nous regardons quelle machine nous a plus fait gagner. Après ceci nous faisons seulement des tirage sur une seule machine.
2.2 Résultat
La methode semble raisonnable. Donc si T est très grand et que nous choisissons la bonne machine Rm_t va tendre vers 0. En revanche si nous choisissons la mauvaise machine nous n’allons jamais tendre vers 0 mais vers 0.1. Par contre si nous choisissons un e grand alors nous perdons en efficacité au debut pendant longtemps mais nous aurons une plus de chance de choisir la bonne machine.
On exploite mais on se force à toujours apprendre
3.1 Intuition
Dans cette méthode nous allons choisir avec une probabilité 1-ê la mailleur machine. Ainsi nous avons deux booléen. Un pour la meilleur machine au temp t et un autre pour savoir si on prend la meilleur machine. Après nous réalisons juste un tirage Tmax fois
3.2 Résultat
Cette methode me semble bonne pour des petites valeurs de Tmax car nous allons choisir 90% de fois la meilleur machine. Nous allons donc tendre vers 0.1*e. Elle diffère de la première sur les petites valeurs de Tmax car dans la premiere méthode nous avons plus de chance de se tromper en revanche sur les grande valeur nous aurons une plus grand probabilité de choisir la bonne machine et donc nous la choisirons 100% de fois, contrairement a cette méthode ou nous la choisirons 1-ê fois.
On tire au hasard en biaisant selon nos observations
4.1 Intuition
Dans cette méthode nous allons essayé de faire une estimation des probabilité de chaque machine avec la fonction dbeta(n1 le nombre de fois qu’on gagne, n2 nombre de fois qu’on perd) et pourvoir choisir la machine à utiliser.
4.2 Résultat
Le resutat semble similaire a la deuxième méthode. Elle fait une supposition sur la probabilité de gagné cette fois ci plus nous jouons plus nous aurons une bonne estimations contrairement a la méthode du dessus qui est meilleure sur les petites valeurs de Tmax. Nous voyons dans le graphique que la moyenne tend vers 0. Nous pensons donc que c’est une bonne stratégie.
Code source et Graphique de chaque méthode
library("ggplot2", lib.loc="~/R/x86_64-pc-linux-gnu-library/3.5")
library("rlang", lib.loc="~/R/x86_64-pc-linux-gnu-library/3.5")
library("dplyr", lib.loc="~/R/x86_64-pc-linux-gnu-library/3.5")##
## Attaching package: 'dplyr'## The following objects are masked from 'package:stats':
##
## filter, lag## The following objects are masked from 'package:base':
##
## intersect, setdiff, setequal, unionset.seed## function (seed, kind = NULL, normal.kind = NULL)
## {
## kinds <- c("Wichmann-Hill", "Marsaglia-Multicarry", "Super-Duper",
## "Mersenne-Twister", "Knuth-TAOCP", "user-supplied", "Knuth-TAOCP-2002",
## "L'Ecuyer-CMRG", "default")
## n.kinds <- c("Buggy Kinderman-Ramage", "Ahrens-Dieter", "Box-Muller",
## "user-supplied", "Inversion", "Kinderman-Ramage", "default")
## if (length(kind)) {
## if (!is.character(kind) || length(kind) > 1L)
## stop("'kind' must be a character string of length 1 (RNG to be used).")
## if (is.na(i.knd <- pmatch(kind, kinds) - 1L))
## stop(gettextf("'%s' is not a valid abbreviation of an RNG",
## kind), domain = NA)
## if (i.knd == length(kinds) - 1L)
## i.knd <- -1L
## }
## else i.knd <- NULL
## if (!is.null(normal.kind)) {
## if (!is.character(normal.kind) || length(normal.kind) !=
## 1L)
## stop("'normal.kind' must be a character string of length 1")
## normal.kind <- pmatch(normal.kind, n.kinds) - 1L
## if (is.na(normal.kind))
## stop(gettextf("'%s' is not a valid choice", normal.kind),
## domain = NA)
## if (normal.kind == 0L)
## stop("buggy version of Kinderman-Ramage generator is not allowed",
## domain = NA)
## if (normal.kind == length(n.kinds) - 1L)
## normal.kind <- -1L
## }
## .Internal(set.seed(seed, i.knd, normal.kind))
## }
## <bytecode: 0x55af565afe18>
## <environment: namespace:base>pa= .65
pb= .55
Tmax =1000
mL = function(){
e = .05
T_parties =Tmax*e
Rm_t=c()
gain =0
meilleur_ma = 0
meilleur_mb = 0
p_final =0 #Initialisation des variable e =espilon
for(i in 1:T_parties){ # On fait un for sur les 0 e.Tmax tirage ou l'on tire sur chaque machine l'une après l'autre
p = runif(1)
if(p<=pa && i%%2 == 0){
gain =gain +1
meilleur_ma =meilleur_ma +1
}
if(p<=pb && i %% 2 != 0){
gain =gain +1
meilleur_mb =meilleur_mb +1
}
Rm_t[i]=pa- gain/i
}
if(meilleur_mb>meilleur_ma){ # Nous regardons maintenant la meilleure machine
p_final = pb
}else{
p_final =pa
}
for(i in T_parties:Tmax){ # Nous continuons sur la mailleure machine jusqu'à la fin
p = runif(1)
if(p<=p_final){
gain =gain +1
}
Rm_t[i] = pa - gain/i #Nous renvoyons le tabeau de valeur qui nous intéresse
}
return(Rm_t)
}
mG= function(){
e = .1
t = c()
Rm_t=c()
gain_a =0
gain_b =0
tentative_a = 0
tentative_b =0
meilleur_ma = 1
meilleur_mb = 1
bool_mauvais = runif(1)<= e #1-e de jouer la bonne machine, e de jouer la mauvaise
bool_ma = (runif(1) >= 0.5) # tirage au sort de la machine a jouer au debut
p_final = 0 #Initialisation des variables
for(i in 1:Tmax){
p = runif(1)
if(p<=pa && (bool_ma || (bool_mauvais && !bool_ma))){ # Nous jouons sur la machine A si soit c'est la meilleur machine bool_ma =1
gain_a =gain_a +1 # Ou alors que c'est la machine la plus mauvaise et que nous avons e% de chance de jouer sur la mauvaise machine
tentative_a =tentative_a +1
meilleur_ma= gain_a /(tentative_a+1)
}
else if((bool_ma || (bool_mauvais && !bool_ma))){
tentative_a =tentative_a +1
meilleur_ma= gain_a /(tentative_a+1)
}
if(p<=pb && (!bool_ma || (bool_mauvais && bool_ma))){ #Nous jouns sur la machine B si c'est la meilleur machine bool_ma =0
gain_b =gain_b +1 # Ou alors c'est la mauvaise machine et que l'on doit jouer dessus
tentative_b =tentative_b +1
meilleur_mb = gain_b / (tentative_b+1)
}
else if((!bool_ma || (bool_mauvais && bool_ma))){
tentative_b =tentative_b +1
meilleur_mb = gain_b / (tentative_b+1)
}
if(meilleur_ma == meilleur_mb){ #On met a jour la meilleure machine qu'on trouve
bool_ma = (runif(1) >= 0.5)
}else{
bool_ma = meilleur_ma>meilleur_mb
}
bool_mauvais = runif(1)<= e # On met a jour le booleen pour savoir si c'est la bonne ou mauvaise machine qu'on tire
Rm_t[i]=pa- (gain_a + gain_b)/i
}
return(Rm_t)
}
mT =function(){
Rm_t =c()
gain = 0
n1_a = 0
n1_b = 0
n2_a = 0
n2_b = 0 #Initialisation des variables
for (i in 1:Tmax) {
p_a = dbeta(0,(n1_a+1),(n2_a+1))# On fait une estimation des probabilité de chaque machine suivant dbeta avec n1 et n2 qui varie en fonction des tirage
p_b = dbeta(0,(n1_b+1),(n2_b+1))
p =runif(1)
if(p_a >= p_b){# On joue donc sur la meilleure probabilté trouvé et on incremente les valeurs n1 et/ou n2
if(p<=pa){
gain=gain +1;
n1_a = n1_a +1
}else{
n2_a =n2_a +1
}
}
else{
if(p<=pb){
gain=gain +1;
n1_b =n1_b +1
}else{
n1_b =n1_b +1
}
}
Rm_t[i] = pa - gain/i
}
return (Rm_t)
}
probabilité_dm =function(n){
N=100
df=data.frame()
switch (n,
'1' = {
for (i in 1:N) {
t= 1:Tmax;
Rm_t = data.frame(id = i, t1 = t, G = mL());
df= rbind(df,Rm_t)
}
moyenne = df %>% group_by(t1) %>% summarise(n = n(), G_mean = mean(G)) %>% filter(n > 1) #on calcule la moyenne des gains par parties des N trajectoires
names(moyenne) = c("i", "t", "G_mean") #on renomme les colonne des données de la moyenne
df = cbind(df, moyenne) #on aoute les colonnes de la moyenne à la data frame
ggplot(df, aes(x=i, y=G, group(id))) + geom_point(alpha = 0.1, size = 0.1) +geom_point(data=df, aes(x=i, y=G_mean), size = 0.2, color = "red")
},
'2' = {
for (i in 1:N) {
t= 1:Tmax;
Rm_t = data.frame(id = i, t1 = t, G = mG());
df= rbind(df,Rm_t)
}
moyenne = df %>% group_by(t1) %>% summarise(n = n(), G_mean = mean(G)) %>% filter(n > 1) #on calcule la moyenne des gains par parties des N trajectoires
names(moyenne) = c("i", "t", "G_mean") #on renomme les colonne des données de la moyenne
df = cbind(df, moyenne) #on aoute les colonnes de la moyenne à la data frame
ggplot(df, aes(x=i, y=G, group(id))) + geom_point(alpha = 0.1, size = 0.1) +geom_point(data=df, aes(x=i, y=G_mean), size = 0.2, color = "red")
},
'3' = {
for (i in 1:N) {
t= 1:Tmax;
Rm_t = data.frame(id = i, t1 = t, G = mT());
df= rbind(df,Rm_t)
}
moyenne = df %>% group_by(t1) %>% summarise(n = n(), G_mean = mean(G)) %>% filter(n > 1) #on calcule la moyenne des gains par parties des N trajectoires
names(moyenne) = c("i", "t", "G_mean") #on renomme les colonne des données de la moyenne
df = cbind(df, moyenne) #on aoute les colonnes de la moyenne à la data frame
ggplot(df, aes(x=i, y=G, group(id))) + geom_point(alpha = 0.1, size = 0.1) +geom_point(data=df, aes(x=i, y=G_mean), size = 0.2, color = "red")
})
}
probabilité_dm('1')
probabilité_dm('2')
probabilité_dm('3')