DM PROBA
Iheb MASTOURA & Kadir Uraz ALACALI
05/12/2018
Nos opinions (Avant le code)
Questions préliminaires
Dans notre sujet , on va utiliser deux machines A et B , et comme l’énoncé dit , on va utiliser la loi binomiale ( Bernoulli pour un tirage après en répétant T fois ça serait loi binomiale)
a) Tmax*pA loi binomiale , l'espérence np avec n= Tmax et p = pA
b) Tmax*pB loi binomiale , l'espérence np avec n= Tmax et p = pB
c) (Tmax/2)*(pB+pA) loi binomiale , l'espérence np avec n= Tmax et p = (pB+pA)/2 On intéresse au regret de chaque stratégie parce que c’est lui qui nous trouve le risque s’il est élevé ou pas , plus le regret est proche de 0 ou négatif plus qu’on est entrain de gagné plus et plus il est élevé plus on perd. Notre probabilité maximal pour gagner c’est proba pA moins estimation de la probabilité de gain , plus cette valeur est proche de 0 plus le regret est petit , et plus on gagne .
1ére Stratégie : On apprend (un peu) puis on exploite
Cette stratégie consiste à prendre une partie , on divise cette partie sur 2 après on joue 50% de fois avec machineA et 50% avec machineB , après la machine qu’elle a le plus nombre de succès on termine avec . On pense que cette stratégie n’est pas bonne , parce que on peut par exemple sur une partie d’apprentissage qui égale à 10 avoir un tirage avec machineA (avec proba égale 0.9) {0,0,0,0,0} et avec machineB {1,1,1,1,1} (avec proba égale 0.1) et on va terminer le reste du tirage avec la mauvaise machine . Après on va écrire le code pour vérifier ça .
2éme Stratégie : On exploite mais on se force à toujours apprendre (un peu)
Cette stratégie consiste à prendre une partie , faire l’apprentissage sur une partie de cette partie avec une des deux machines après faire le reste avec l’autre machine . On pense que cette stratégie est pas mal parce que on cherche la machine la plus prometteuse en diminuant la perte au cours du temps .
3éme Stratégie : On tire au hasard en biaisant selon nos observations
Cette stratégie consiste à tiré un nombre aléatoire suivant la densité bêta correspondant à chacune des machines A et B après on fait la mise à jour du gain de chaque machine .
Résultat (Aprés le code)
Stratégie 1
Comme on a dit avant on va faire un test pour voir si ce qu’on a dit et bon ou pas , on prend epsilon = 0.05 et Tmax = 1000 , donc on fait l’apprentissage sur 50 (25 avec machine A , 25 machine B ) et on exécute notre code : (pB =0.55 , pA = 0.65) on trouve que l’espérance de machine B et plus élevé que machine A :
0.52 pour machine A
0.64 pour machine BDonc on va poursuivre le jeu avec la mauvaise machine ,Donc cette stratégie n’est pas bonne . Exemple de code complet ( avec un switch pour choisir la stratégie )
strat <- function(N,Tmax,pA,pB,epsilon,epsilonchap,strategie) dans la fonction le paramétré stratégie se décide comme ça :
stratégie = 'Ml' ou
stratégie = 'Mg' ou
stratégie = 'Mt'Gm = NULL
strat <- function(N,Tmax,pA,pB,epsilon,epsilonchap,strategie) {
p = c(pA,pB)
switch (strategie== 'Ml',
{
print("Ml")
for(i in 1:N){
XA=rbinom(epsilon*Tmax/2,1,prob = pA) # on fait apprentissage sur 50% de Tmax avec la proba A
XB=rbinom(epsilon*Tmax/2,1,prob = pB) # on fait apprentissage sur 50% de Tmax avec la proba B
pA.est=mean(XA) #on estime l'espérence de la moyenne XA
pB.est=mean(XB) #on estime l'espérence de la moyenne XB
index=which.max(c(pA.est,pB.est)) # on prend la valeurs la plus grande
X1=numeric(epsilon*Tmax) # apprentissage de la bonne machine
X1[seq(1,by=2,length.out = epsilon*Tmax/2)]=XA
X1[seq(2,by=2,length.out = epsilon*Tmax/2)]=XB
X2=rbinom(Tmax*(1-epsilon),1,prob = p[index]) # suite du jeu p[index] prendre la proba du grand valeur
X=c(X1,X2) # on ajoute la partie apprentissage au reste
Gm=rbind(Gm,pA-cumsum(X)/(1:Tmax)) # regret chaque instant c pour cela l'utilisation de cumsum
}
}
)
switch (strategie=="Mg",
{ print("Mg")
for(i in 1:N){
XA=rbinom(epsilon*Tmax/2,1,prob = pA)
XB=rbinom(epsilon*Tmax/2,1,prob = pB)
pA.est=mean(XA)
pB.est=mean(XB)
if(pA.est!=pB.est) # cas si ils sont différent
{index=which.max(c(pA.est,pB.est))} else {index=sample(c(1,2),1)}
X1=numeric(epsilon*Tmax) # on prend les valeur de
X1[seq(1,by=2,length.out = epsilon*Tmax/2)]=XA #
X1[seq(2,by=2,length.out = epsilon*Tmax/2)]=XB
proba1=c(rep(p[index],Tmax*(1-epsilon)*(1-epsilonchap)),
rep(p[-index],Tmax*(1-epsilon)*epsilonchap))
# proba1 c'est la partie apprenstisage avec proba de l'indice du plus grand entre les 2 + le reste avec de cette partie
# avec proba de l'indice le plus petit entre les 2
X2=rbinom(Tmax*(1-epsilon),1,prob = proba1)
# g�n�ration d'un �chantillon 0,1 chaque valeur avec une proba
X=c(X1,X2)
Gm=rbind(Gm,pA-cumsum(X)/(1:Tmax))
}
}
)
switch (strategie=="Mt",
{
print("Mt")
n1A = 0 # gain machineA
n2A = 0 #perte machineB
n1B = 0
n2B = 0
N=100
Gm=NULL
for(i in 1:N){
X2 = c()
for(j in 1:Tmax){
vraispA=rbeta(1,n1A,n2A) # on calcule la vraisemblance de A
vraispB=rbeta(1,n1B,n2B) # on calcule la vraisemblance de B
if(vraispA == vraispB){ # on cas d"égalité
indice = sample(1:2, 1, replace=T) # on choisie par hasard
X = rbinom(1,1,prob = p[indice])
X2=c(X2,X)
if(p[indice]==pA){
if (X ==1)
{n1A = n1A +1}
else {
n2A = n2A +1
}
}
else
{
if (X ==1)
{
n1B = n1B +1
}
else
{
n2B = n2B +1
}
}
}
else{ # dans l'autre cas on choisie la valeur la plus grande
index=which.max(c(vraispA,vraispB))#add condition =
X = rbinom(1,1,prob = p[index])
X2=c(X2,X)
if(p[index]==pA){
if (X ==1)
{n1A = n1A +1}
else {
n2A = n2A +1
}
}
else
{
if (X ==1)
{
n1B = n1B +1
}
else
{
n2B = n2B +1
}
}
}
}
Gm=rbind(Gm,pA-cumsum(X2)/(1:Tmax))
}
}
)
# pour dessiner (on a pas utilsé ggplot , on a eu un probléme technique)
if(strategie == 'Ml' || strategie == 'Mg' || strategie == 'Mt'){
plot(1:Tmax,Gm[1,],ylim=c(min(Gm),max(Gm)) , type = 'l')
for(i in 2:N)
lines(1:Tmax,Gm[i,])
lines(1:Tmax,apply(Gm,2,mean),col='red',lwd=2, type = 'l')
# pour voir la meilleur stratégie je rends le derniére regrets
return (apply(Gm,2,mean)[Tmax])
# pour rendre une data frame vous décommenté cette ligne et commenté la ligne de dessus
#return (apply(Gm,2,mean)[1:Tmax]) # data
}
return (Gm) # si vous choisie une start qui n'existe pas
}
TMAX_valeur = strat(N=100,Tmax=1000,pA=0.65,pB=0.55,epsilon=0.05,epsilonchap=0.1,strategie='Ml') ## [1] "Ml"
print(TMAX_valeur)## [1] 0.02144On pense que cette stratégie n’est pas bonne vu qu’on peut estimer un petit échantillon et on peut déterminer que malgré que pA > pB ( large ) on peut tomber sur une résultat qui donne que pB est favorable sur pA tant que l’échantillon est petit ( partie d’apprentissage petite ) on peut dire que notre méthode n’est pas bonne , et elle marche bine si seulement notre partie d’apprentissage est grande +1000 .
Stratégie 2
On prend une partie dans la partie d’apprentissage on l’étudie avec pA et le reste avec pB donc la partie d’apprentissage est décomposé entre les 2 , dans les trajectoires trompeuses en diminue les pertes en jouant (epsilon)(1-ê)Tmax fois avec la bonne machine , pas mal , elle est un plus performante que la 1ére.
TMAX_valeur = strat(N=100,Tmax=1000,pA=0.65,pB=0.55,epsilon=0.05,epsilonchap=0.1,strategie='Mg') ## [1] "Mg"
print(TMAX_valeur)## [1] 0.0219Stratégie 3
Avec cette stratégie on a eu une résultat presque nulle , ce qui indique que cette stratégie est parfaite puisque le regret est presque nul ce que signifie que notre gain est élevé . la loi bêta-binomiale est une loi de probabilité discrète à support fini, correspondant à un processus de tirages Bernoulli dont la probabilité de succès est aléatoire (suivant une loi bêta). Elle est fréquemment utilisée en inférence bayésienne. ( avec l’aide de wiki ) , ce loi aide bien a trouvé un bon regret .
TMAX_valeur = strat(N=100,Tmax=1000,pA=0.65,pB=0.55,epsilon=0.05,epsilonchap=0.1,strategie='Mt') ## [1] "Mt"
print(TMAX_valeur)## [1] -0.00083Conclusion
Après voir tout les stratégies , on conclue que la dernière stratégie est la meilleure ( on regardant à l’indice TMax la valeur de regret et plus qu’il approche de 0 plus que notre stratégie est bonne) . Première stratégie qui peut nous donner un grand regret si on prends la mauvaise machine , une deuxième stratégie qui diminue la perte au cours du temps , et 3éme stratégie qui explose les deux et qui donne la meilleure valeur de regret.
Remarque
Pour le code , on a 2 possibilités comme résultat la data frame ou la dernière valeur de regret , et pour les voir ( dé-commenter des lignes et commenter des autres (c’est indiqué dans le code à coté de return ))