def UCB(arg):
T = arg[0] #Nombre de tests total
N = arg[1] #Nombre de medicaments
s = [0] * N #Compteur du nombre de fois ou on a teste chaque medicament
regret = [0]
moy = [0] * N
B = [0] * N
a = 0
b = 1
#Initialisation
for i in range(N):
moy[i] = gain.resMed(i + 1)[0]
s[i] += 1
regret.append(regret[-1] + (-gain.resMed(i + 1)[1] + gain_max) / T)
for t in range(N, T + 1):
for k in range(N):
B[k] = moy[k] + (b - a) * math.sqrt(2 * np.log(1 / 0.95) /
(1 * s[k]))
k = np.argmax(np.asarray(B))
moy[k] = gain.resMed(k + 1)[0] / (s[k] + 1) + (s[k]) / (s[k] +
1) * moy[k]
s[k] += 1
regret.append(regret[-1] + (-gain.resMed(k + 1)[1] + gain_max) / T)
return np.asarray(regret[1:-1]), s
def Eps_greedy_temps(arg):
eps = arg[0] #Constante de temps
T = arg[1] #Nombre de tests total
N = arg[2] #Nombre de medicaments
moy = [0] * N
s = [0] * N #Compteur du nombre de fois ou on a teste chaque medicament
regret = [0]
#Initialisation
for i in range(N):
moy[i] = gain.resMed(i + 1)[0]
s[i] += 1
regret.append(regret[-1] + (-gain.resMed(i + 1)[1] + gain_max) / T)
for i in range(N, T + 1):
if np.random.random(
) < 1 - eps / i**2: #Meilleure courbe de regret lorsque E decroit en 1/t²
k = np.argmax(moy)
else:
k = np.random.randint(0, N)
moy[k] = gain.resMed(k + 1)[0] / (s[k] + 1) + (s[k]) / (s[k] +
1) * moy[k]
s[k] += 1
regret.append(regret[-1] + (-gain.resMed(k + 1)[1] + gain_max) / T)
return np.asarray(regret[1:-1]), s
def Exp3(arg):
T = arg[0] #Nombre de tests total
N = arg[1] #Nombre de medicaments
p = [1 / N] * N
regret = [0]
G = [0] * N
gain_estim = 0
gamma = np.sqrt(N * np.log(N) / T)
eta = np.sqrt(2 * np.log(N) / (T * N))
liste = np.array(list(range(1, N + 1)))
choix = [0
] * N #Compteur du nombre de fois ou on a teste chaque medicament
for t in range(T):
k = np.random.choice(a=liste, p=p)
choix[k - 1] += 1
gain_obtenu = gain.resMed(k)[1]
regret.append(regret[-1] + (-gain_obtenu + gain_max) / T)
gain_estim = gain_obtenu / p[k - 1]
G[k - 1] += gain_estim
somme = 0
for i in range(len(p)):
somme += np.sum(np.exp(eta * G[i]))
for i in range(len(p)):
p[i] = (1 - gamma) * np.exp(eta * G[i]) / somme + gamma / N
return np.asarray(regret[1:]), choix
def Eps_greedy(arg):
eps = arg[0] #Epsilon
T = arg[1] #Nombre de tests total
N = arg[2] #Nombre de médicaments
s = [0] * N #Compteur du nombre de fois ou on a teste chaque medicament
regret = [0]
moy = [0] * N
med = list(range(N))
#Initialisation
for i in range(N):
moy[i] = gain.resMed(i)[0]
s[i] += 1
regret.append(regret[-1] + (-gain.resMed(i)[1] + gain_max) / T)
for i in range(N, arg[1] + 1):
if np.random.random() < 1 - eps:
if np.where(moy == np.max(moy))[0].shape[
0] > 1: # Si plusieurs médicaments ont la meilleure moyenne empirique
# On choisit le médicament le plus testé
indices = np.take(med,
np.where(moy == np.max(moy))
[0]) # indices des meilleures moyennes
essais = np.take(
s, indices) # nombre d'essais pour ces médicaments
k = indices[np.argmax(
essais)] # indice du médicament le plus testé
else:
k = np.argmax(
moy
) #on choisit le médicament avec la meilleure moyenne avec une probabilite 1-E
else:
k = np.random.randint(
0, N) #ou on choisit le médicament aleatoirement (proba E)
moy[k] = gain.resMed(k + 1)[0] / (s[k] + 1) + (s[k]) / (s[k] +
1) * moy[k]
s[k] += 1
regret.append(regret[-1] + (-gain.resMed(k + 1)[1] + gain_max) / T)
return np.asarray(regret[1:-1]), s
def Strategie_1(arg):
T1 = arg[0] #Nombre de jeton en phase d'exploration
T = arg[1] #Nombre de tests total
N = arg[2] #Nombre de medicaments
n = T1 // N #Nombre d'essais de chaque medicaments en phase d'exploration
essais = [
] #Contient un vecteur d'essais par medicament pour les T1 premiers lancers
regret = [0]
choix = [0
] * N #Compteur du nombre de fois ou on a teste chaque medicament
#On fait n essais pour chaque medicament qu'on range dans essais_machine
for k in range(N):
essai_machine = []
for i in range(n):
essai_machine.append(gain.resMed(k + 1)[0])
choix[k] += 1
regret.append(regret[-1] + (-gain.resMed(k + 1)[1] + gain_max) / T)
essais.append(essai_machine)
res = np.asarray(essais)
#On determine la medicament avec la meilleure moyenne
moy = []
for i in range(N):
moy.append(np.mean(res[i]))
k = np.argmax(moy) + 1
#On joue le reste de nos essais avec le meilleur medicament
essai_machine = []
for i in range(T - T1 - 1):
essai_machine.append(gain.resMed(k)[0])
choix[k - 1] += 1
regret.append(regret[-1] + (-gain.resMed(k)[1] + gain_max) / T)
return np.array(regret), choix
def KL_UCB(arg):
f = (lambda t: np.log(t) + 3. * np.log(np.log(t)))
s = np.ones(arg[0]) # Nombre de fois ou chaque bras a été joué
p_space = [
0, 1
] # On suppose que la variable aléatoire peut prendre des valeurs entre 0 et 1, changer les bornes ici si necessaire
mu_estim = np.zeros(
(arg[0],
arg[1])) #ligne=bras, colone=discretisation, densité empirique
R = np.zeros(arg[2])
regret = [0]
# Dictionnaire contenant pour chaque bras, le nombre de fois ou chaque valeur possible à été observé, initialisé à 0 fois vue la valeur 1.
obs = dict()
for arm in range(arg[0]):
obs[arm] = dict({1.: 0})
idx = np.zeros(arg[0])
# print(list(obs[1].items()))
### Initialisation pour chaque bras
for t in np.arange(0, arg[0]):
# p_t = gain du bras t
R[t] = gain.resMed(t + 1)[0]
regret.append(regret[-1] +
(-gain.resMed(t + 1)[1] + gain_max) / arg[2])
loc = np.argmin(
np.abs(p_space - R[t])
) # On cherche le point de discretisation le plus proche de la valeur obtenue.
mu_estim[t, loc] += 1.
# Ajouté la valeur obsérvé au dictionnaire
reward = p_space[loc]
if reward in obs[t]:
obs[t][reward] += 1
else:
obs[t][reward] = 1
### Boucle principale
t = arg[0]
while t < arg[2]:
## Résolution du problème d'optimisation
# Pour chaque bras on:
for arm in range(arg[0]):
if s[arm] != 0:
p = (np.array(list(obs[arm].values()))) / float(
sum(obs[arm].values())) # normalise la densité estimée
v = np.array(list(obs[arm].keys()))
q = maxEV(
p, v,
f(t / s[arm]) /
s[arm]) # Résoud le problème d'optimisation discrétisé
idx[arm] = (np.dot(q, v)) # calcul la valeur associé à ce bras
#print(arm, obs)
else:
idx[arm] = 10**10 # Si on a jamais joué se bras, on va vouloir le jouer prochainement donc on met sa valeur au maximum
#print(idx) # Marche pas, donne les mêmes valeurs pour tous les bras
current_idx = np.argmax(
idx) # On cherche l'indice du bras à la plus forte valeur
# p_t=p_space[current_idx]
s[current_idx] += 1
R[current_idx] = gain.resMed(current_idx + 1)[0]
regret.append(regret[-1] +
(-gain.resMed(current_idx)[1] + gain_max) / arg[2])
loc = np.argmin(np.abs(p_space - np.array(R[current_idx])))
reward = p_space[loc]
if reward in obs[current_idx]:
obs[current_idx][reward] += 1
else:
obs[current_idx][reward] = 1
# print(obs)
t = t + 1
#==============================================================================
# if not(np.mod(t,np.round(arg[2]/10.).astype(int))):
# print('Progress: '+ repr(100.*t/arg[2]) + '%.')
#==============================================================================
return np.asarray(regret[1:])
# -*- coding: utf-8 -*-
import numpy as np
import gain
# =============================================================================
#KL-UCB, VARIABLES DE DEMO
pt_discr = 10 # Nb de points pour discrétiser pour KL_UCB
c = 3 # reprise de code KL_UCB
# =============================================================================
gain_max = gain.resMed(0)[2]
#==============================================================================
#==============================================================================
# # Go KL-UCB...
#==============================================================================
#==============================================================================
def reseqp(p, V, klMax, max_iterations=50):
""" Solve ``f(reseqp(p, V, klMax)) = klMax``, using Newton method.
.. note:: This is a subroutine of :func:`maxEV`.
- Reference: Eq. (4) in Section 3.2 of [Filippi, Cappé & Garivier - Allerton, 2011](https://arxiv.org/pdf/1004.5229.pdf).
.. warning:: `np.dot` is very slow!
"""
MV = np.max(V)
mV = np.min(V)
value = MV + 0.1
def Strategie_2(arg):
T = arg[0] #Nombre de tests total
N = arg[1] #Nombre de medicaments
init = arg[2]
alp = arg[3]
intervalles = [[0, 1]]
essais = [[0]]
for i in range(N - 1):
intervalles.append([0, 1])
essais.append([0])
regret = [0]
int_a_tester = [True] * N
choix = [0
] * N #Compteur du nombre de fois ou on a teste chaque medicament
trouve = False
jetons_joues = 0
e2 = 0
while jetons_joues < init * N:
for i in range(N):
jetons_joues += 1
essais[i].append(gain.resMed(i + 1)[0])
regret.append(regret[-1] + (-gain.resMed(i + 1)[1] + gain_max) / T)
choix[i] += 1
for i in range(N):
intervalles[i] = list(
ssp.proportion_confint(sum(essais[i]),
len(essais[i]) - 1,
alpha=alp))
while jetons_joues < T and not trouve:
e2 += 1
for i in range(len(intervalles)):
if int_a_tester[i]:
if intDisjInf(intervalles, i):
int_a_tester[i] = False
elif intDisjSup(intervalles, i):
trouve = True
meilleur = i
else:
if jetons_joues == T:
break
jetons_joues += 1
choix[i] += 1
essais[i].append(gain.resMed(i + 1)[0])
regret.append(regret[-1] +
(-gain.resMed(i + 1)[1] + gain_max) / T)
intervalles[i] = list(
ssp.proportion_confint(sum(essais[i]),
len(essais[i]) - 1,
alpha=alp))
if int_a_tester.count(True) == 1:
meilleur = int_a_tester.index(True)
trouve = True
break
while jetons_joues < T:
regret.append(regret[-1] +
(-gain.resMed(meilleur + 1)[1] + gain_max) / T)
jetons_joues += 1
choix[meilleur] += 1
return np.asarray(regret[1:]), choix
# -*- coding: utf-8 -*-
import numpy as np
import gain
import math
import statsmodels.stats.proportion as ssp
gain_max = gain.resMed(0)[2] #Gain maximum pour le calcul de nos regrets
def Strategie_1(arg):
T1 = arg[0] #Nombre de jeton en phase d'exploration
T = arg[1] #Nombre de tests total
N = arg[2] #Nombre de medicaments
n = T1 // N #Nombre d'essais de chaque medicaments en phase d'exploration
essais = [
] #Contient un vecteur d'essais par medicament pour les T1 premiers lancers
regret = [0]
choix = [0
] * N #Compteur du nombre de fois ou on a teste chaque medicament
#On fait n essais pour chaque medicament qu'on range dans essais_machine
for k in range(N):
essai_machine = []
for i in range(n):
essai_machine.append(gain.resMed(k + 1)[0])
choix[k] += 1
regret.append(regret[-1] + (-gain.resMed(k + 1)[1] + gain_max) / T)