Raisonnez avec les probabilités grâce à Bayes

Un arbre de décision répond « jouer » ou « ne pas jouer ». Mais un entraîneur préférerait sans doute entendre : « il y a 80 % de chances que personne ne vienne ». Les méthodes bayésiennes raisonnent directement en probabilités : elles combinent ce que l’on sait d’avance avec ce que l’on observe, et elles disent à quel point elles sont sûres d’elles.

Dans ce chapitre, nous reprenons le club de tennis du chapitre 4 et ses 14 jours de météo (9 jours où l’on a joué, 5 où l’on n’a pas joué), et nous allons refaire à la main les calculs du TP.

La règle de Bayes

Tout part d’une formule que vous avez peut-être vue en probabilités. Pour une classe $\omega$ (par exemple « jouer ») et une observation $x$ (la météo du jour) :

$$P(\omega \mid x) = \frac{p(x \mid \omega) \, P(\omega)}{p(x)}$$

Chaque terme a un nom et un rôle :

• $P(\omega)$ est la probabilité a priori (prior) de la classe, avant de regarder la météo. Ici, $P(\text{jouer}) = 9/14$ et $P(\text{ne pas jouer}) = 5/14$.
• $p(x \mid \omega)$ est la vraisemblance (likelihood) : à quel point la météo $x$ est typique des jours de cette classe.
• $p(x)$ est la probabilité de l’observation, toutes classes confondues. Elle vaut $\sum_j p(x \mid \omega_j) P(\omega_j)$ et sert seulement à normaliser, pour que les probabilités des classes somment à 1.
• $P(\omega \mid x)$ est la probabilité a posteriori : ce qu’on sait de la classe une fois la météo observée.

L’idée est très naturelle : on part de ce qu’on croyait (le prior), on le corrige par ce qu’on voit (la vraisemblance), et on obtient une croyance mise à jour.

Piège

Ne confondez pas $p(x \mid \omega)$ et $P(\omega \mid x)$. Un test médical peut détecter 99 % des malades ($P(\text{positif} \mid \text{malade}) = 0{,}99$), et pourtant la plupart des personnes testées positives peuvent être saines si la maladie est rare. C’est l’objet du deuxième exercice.

Décider : la règle MAP et l’erreur de Bayes

Une fois les probabilités a posteriori calculées, comment décider ? On choisit la classe la plus probable : c’est la règle du maximum a posteriori (MAP).

$$\omega^* = \arg\max_{i} \; p(x \mid \omega_i) \, P(\omega_i)$$

La notation $\arg\max_i$ signifie « la valeur de $i$ qui rend l’expression maximale ». Remarquez que $p(x)$ a disparu : il est le même pour toutes les classes, il ne change donc pas laquelle l’emporte.

Si toutes les classes ont le même prior, la règle devient $\arg\max_i p(x \mid \omega_i)$ : c’est le maximum de vraisemblance. Mais attention, ignorer le prior est risqué quand les classes sont déséquilibrées.

Pourquoi cette règle est-elle si importante ? Parce qu’on peut montrer que, si l’on connaissait les vraies probabilités, la règle MAP serait celle qui fait le moins d’erreurs possible. Son taux d’erreur s’appelle l’erreur de Bayes : c’est un plancher théorique qu’aucun classifieur ne peut franchir, parce qu’il reste des cas où deux classes produisent exactement la même observation (deux journées à la météo identique, l’une avec joueurs, l’autre sans). C’est l’équivalent, en classification, du bruit irréductible du chapitre 2.

Avec les lois normales du TP pour l'humidité : la règle MAP choisit la courbe la plus haute. La zone colorée, où l'autre classe reste possible, est l'erreur incompressible, même avec les vraies probabilités.

À retenir

La règle MAP choisit la classe qui maximise $p(x \mid \omega) P(\omega)$. Avec les vraies probabilités, c’est la règle d’erreur minimale, et son erreur, l’erreur de Bayes, est le meilleur score atteignable. Tout le problème pratique est d’estimer ces probabilités à partir des données.

Comment estimer $p(x \mid \omega)$ ? Deux grandes approches existent. L’approche paramétrique suppose une forme de loi, par exemple une loi normale multivariée par classe, et en estime les paramètres (moyenne, covariance). Avec une covariance propre à chaque classe, la frontière entre deux classes est une surface quadratique (on parle d’analyse discriminante quadratique, QDA) ; si l’on impose la même covariance à toutes les classes, elle devient un hyperplan (analyse discriminante linéaire, LDA). L’approche non paramétrique estime la densité localement, autour de $x$, et mène notamment aux k plus proches voisins du chapitre 6. Le classifieur bayésien naïf, lui, fait une hypothèse radicale qui rend tout calculable.

Quand les deux classes partagent la même covariance, la frontière MAP est un hyperplan (LDA) ; avec une covariance par classe, elle devient une courbe du second degré (QDA).

Le classifieur bayésien naïf

La difficulté est que $x$ contient plusieurs caractéristiques : $x = (x_1, \dots, x_d)$. Estimer la loi jointe de toutes les combinaisons (ciel, température, humidité, vent) demanderait énormément de données. L’hypothèse naïve consiste à supposer les caractéristiques indépendantes sachant la classe :

$$p(x \mid \omega) = \prod_{j=1}^{d} p(x_j \mid \omega)$$

Le symbole $\prod$ désigne un produit : la vraisemblance d’une journée complète est le produit des vraisemblances de chacune de ses caractéristiques. Chaque $p(x_j \mid \omega)$ s’estime simplement en comptant.

Cette hypothèse est presque toujours fausse (l’humidité et le ciel sont évidemment liés). Et pourtant, le classifieur marche souvent très bien, en particulier sur le texte (filtres anti-spam). Pourquoi ? Parce que pour décider, il suffit que la bonne classe obtienne le plus grand score, même si les probabilités elles-mêmes sont mal calibrées.

Exemple

Un nouveau jour : ciel ensoleillé, température fraîche, humidité élevée, vent. Joue-t-on ?

Pour la classe « jouer » (9 jours), on compte parmi ces 9 jours : 2 ensoleillés, 3 frais, 3 à humidité élevée, 3 venteux.

$$P(\text{jouer}) \prod_j p(x_j \mid \text{jouer}) = \tfrac{9}{14} \times \tfrac{2}{9} \times \tfrac{3}{9} \times \tfrac{3}{9} \times \tfrac{3}{9} \approx 0{,}0053$$

Pour la classe « ne pas jouer » (5 jours) : 3 ensoleillés, 1 frais, 4 à humidité élevée, 3 venteux.

$$P(\text{non}) \prod_j p(x_j \mid \text{non}) = \tfrac{5}{14} \times \tfrac{3}{5} \times \tfrac{1}{5} \times \tfrac{4}{5} \times \tfrac{3}{5} \approx 0{,}0206$$

La règle MAP choisit « ne pas jouer ». En normalisant, $P(\text{non} \mid x) = 0{,}0206 / (0{,}0206 + 0{,}0053) \approx 0{,}80$.

Le calcul de l'exemple, facteur par facteur. Chaque classe multiplie son prior par une fréquence par caractéristique ; seule la comparaison des deux produits compte, la normalisation vient après.

Avec des dizaines de caractéristiques, ces produits deviennent minuscules et finissent par valoir 0 en machine (dépassement par le bas, underflow). On calcule donc plutôt la somme des logarithmes, $\log P(\omega) + \sum_j \log p(x_j \mid \omega)$ : le logarithme est croissant, donc la classe gagnante ne change pas. C’est pour cela que scikit-learn expose des attributs comme class_log_prior_ et feature_log_prob_.

Le problème des zéros et le lissage de Laplace

Essayez maintenant un jour couvert. Parmi les 5 jours sans joueurs, aucun n’était couvert : $p(\text{couvert} \mid \text{non}) = 0/5 = 0$. Le produit entier vaut 0, quelles que soient les autres caractéristiques. Une seule valeur jamais vue suffit à éliminer une classe, ce qui est beaucoup trop brutal : ce n’est pas parce qu’on n’a jamais vu un événement sur 5 jours qu’il est impossible.

Le lissage de Laplace ajoute un compte fictif à chaque valeur :

$$p(x_j = v \mid \omega) = \frac{n_{v,\omega} + \alpha}{n_\omega + \alpha \, V_j}$$

• $n_{v,\omega}$ est le nombre d’exemples de la classe $\omega$ pour lesquels la caractéristique $j$ vaut $v$ ;
• $n_\omega$ est le nombre d’exemples de la classe $\omega$ ;
• $V_j$ est le nombre de valeurs possibles de la caractéristique $j$ (3 pour le ciel, 2 pour le vent) ;
• $\alpha$ est l’intensité du lissage ; $\alpha = 1$ correspond au lissage de Laplace proprement dit.

Le lissage ajoute un jour fictif à chaque valeur du ciel : la probabilité de « couvert » passe de 0 à 1/8, et les autres se resserrent un peu vers 1/3.

En TP, nous avons d’ailleurs constaté que les probabilités de CategoricalNB ne correspondaient pas à nos comptages. Les priors, eux, étaient identiques ($5/14$ et $9/14$). L’explication était ce lissage, appliqué par défaut avec $\alpha = 1$ : pour « ensoleillé sachant jouer », nous avions compté $2/9 \approx 0{,}222$, alors que scikit-learn donnait $(2 + 1)/(9 + 3) = 0{,}25$ ; pour « humidité normale sachant ne pas jouer », $1/5$ à la main contre $(1 + 1)/(5 + 2) = 2/7$ pour scikit-learn. Le modèle entraîné sur les 14 jours les classait correctement à une exception près, soit une exactitude de 0,929 mesurée sur ces mêmes données d’apprentissage.

import pandas as pd
from sklearn.naive_bayes import CategoricalNB
from sklearn.preprocessing import OrdinalEncoder

df = pd.read_csv("weather.nominal.csv")          # outlook, temperature, humidity, windy, play
X = df.drop(columns=["play"]).astype(str)
y = df["play"]

encodeur = OrdinalEncoder()                      # chaque catégorie devient un entier
X_code = encodeur.fit_transform(X)

nb = CategoricalNB(alpha=1.0).fit(X_code, y)     # alpha = 1 : lissage de Laplace
print(nb.class_log_prior_)                       # log(5/14), log(9/14)
print(nb.predict_proba(X_code[:3]))              # probabilités a posteriori des 3 premiers jours

Le Bayes naïf gaussien pour les variables continues

Et si la température est donnée en degrés plutôt qu’en « chaud / doux / frais » ? On ne peut plus compter les occurrences d’une valeur précise. Le Bayes naïf gaussien suppose que, dans chaque classe, chaque variable continue suit une loi normale, dont on estime la moyenne $\mu$ et l’écart-type $\sigma$ sur les exemples de la classe. La vraisemblance devient une densité :

$$p(x_j \mid \omega) = \frac{1}{\sigma_{j,\omega} \sqrt{2\pi}} \exp\left(-\frac{(x_j - \mu_{j,\omega})^2}{2 \, \sigma_{j,\omega}^2}\right)$$

où $\mu_{j,\omega}$ et $\sigma_{j,\omega}$ sont la moyenne et l’écart-type de la caractéristique $j$ parmi les exemples de la classe $\omega$.

En TP, sur la version continue du jeu météo (températures en degrés Fahrenheit, humidité en pourcentage), nous avons classé à la main le jour (ensoleillé, 73 °F, 81 %, vent). Plutôt qu’une densité, nous avons utilisé la probabilité d’un petit intervalle, de $\pm 1$ autour de la valeur observée, lue sur la loi normale :

Classe	Température : $\mu$ ; $\sigma$	$P(72 \le T \le 74)$	Humidité : $\mu$ ; $\sigma$	$P(80 \le H \le 82)$
ne pas jouer	74,6 ; 7,06	0,1098	86,2 ; 8,70	0,0766
jouer	73,0 ; 5,81	0,1366	79,1 ; 9,63	0,0811

En multipliant ces valeurs par les vraisemblances catégorielles (ensoleillé : $3/5$ et $2/9$ ; vent : $3/5$ et $3/9$) puis par les priors, et en normalisant, nous avons obtenu $P(\text{ne pas jouer} \mid x) = 0{,}672$ et $P(\text{jouer} \mid x) = 0{,}328$ : le jour est classé « ne pas jouer », ce qui correspondait à l’étiquette attendue.

Les lois normales estimées en TP et les petites aires de ±1 autour du jour observé (73 °F, 81 %). Ces aires remplacent les comptages du cas catégoriel dans le produit.

Attention

Utiliser un intervalle de même largeur pour les deux classes revient, à peu près, à multiplier chaque densité par cette largeur : le facteur est commun et ne change pas la décision. C’est pourquoi le calcul par intervalles et le calcul par densités (celui de GaussianNB) mènent en général à la même classe.

from sklearn.naive_bayes import GaussianNB

meteo = pd.read_csv("weather.csv")
X_num = meteo[["temperature", "humidity"]]      # les deux variables continues
gnb = GaussianNB().fit(X_num, meteo["play"])
print(gnb.theta_)                               # moyennes par classe
print(gnb.predict_proba(pd.DataFrame({"temperature": [73], "humidity": [81]})))

Pour combiner variables continues et catégorielles dans un même modèle, il faut soit discrétiser les continues (des tranches d’âge, par exemple), soit multiplier soi-même les vraisemblances des deux modèles, comme nous l’avons fait à la main.

En entretien

« Le Bayes naïf applique la règle de Bayes en supposant les caractéristiques indépendantes sachant la classe. L’hypothèse est fausse en général, mais le modèle est rapide, robuste avec peu de données et très bon sur le texte ; on le lisse (Laplace) pour éviter les probabilités nulles. »

En résumé

• La règle de Bayes combine le prior $P(\omega)$ et la vraisemblance $p(x \mid \omega)$ pour obtenir la probabilité a posteriori $P(\omega \mid x)$.
• La règle MAP choisit la classe qui maximise $p(x \mid \omega) P(\omega)$ ; avec les vraies probabilités, elle atteint l’erreur de Bayes, le plancher théorique.
• Le Bayes naïf suppose les caractéristiques indépendantes sachant la classe, ce qui réduit la vraisemblance à un produit de termes faciles à compter.
• On calcule en logarithmes pour éviter les dépassements par le bas.
• Le lissage de Laplace évite qu’une valeur jamais vue annule toute une classe ; scikit-learn l’applique par défaut.
• Le Bayes naïf gaussien modélise chaque variable continue par une loi normale par classe.

Exercices

Exercice · Un jour couvert

facile

Avec les 14 jours du fil rouge, sans lissage, calculez les scores bayésiens naïfs des deux classes pour le jour (couvert, frais, humidité élevée, vent). Que constatez-vous ?

Voir la solution

Pour « ne pas jouer », aucun des 5 jours n’était couvert : $p(\text{couvert} \mid \text{non}) = 0$, donc le score de la classe est nul, quelles que soient les autres valeurs.

Pour « jouer » : $\tfrac{9}{14} \times \tfrac{4}{9} \times \tfrac{3}{9} \times \tfrac{3}{9} \times \tfrac{3}{9} \approx 0{,}0106$.

La décision est « jouer » avec une probabilité a posteriori de 1 : le modèle est certain, uniquement parce qu’il n’a jamais vu de jour couvert sans joueurs sur un échantillon de 5 jours. C’est exactement le problème que résout le lissage de Laplace.

En code

Python

import numpy as np
import pandas as pd

# Les 14 jours du fil rouge
meteo = pd.DataFrame(
    [r.split() for r in """ensoleillé chaud élevée non non
ensoleillé chaud élevée oui non
couvert chaud élevée non oui
pluvieux doux élevée non oui
pluvieux frais normale non oui
pluvieux frais normale oui non
couvert frais normale oui oui
ensoleillé doux élevée non non
ensoleillé frais normale non oui
pluvieux doux normale non oui
ensoleillé doux normale oui oui
couvert doux élevée oui oui
couvert chaud normale non oui
pluvieux doux élevée oui non""".splitlines()],
    columns=["ciel", "temperature", "humidite", "vent", "jouer"])
jour = {"ciel": "couvert", "temperature": "frais", "humidite": "élevée", "vent": "oui"}

scores = {}
for classe, groupe in meteo.groupby("jouer"):
    prior = len(groupe) / len(meteo)
    # vraisemblances sans lissage : simple proportion dans la classe
    vraisemblances = [np.mean(groupe[c] == v) for c, v in jour.items()]
    scores[classe] = prior * np.prod(vraisemblances)

print({c: round(float(s), 4) for c, s in scores.items()})   # {'non': 0.0, 'oui': 0.0106}
print(float(scores["oui"] / sum(scores.values())))        # P(jouer | x) = 1.0

R

# Les 14 jours du fil rouge
meteo <- read.table(header = TRUE, text = "
ciel temperature humidite vent jouer
ensoleillé chaud élevée non non
ensoleillé chaud élevée oui non
couvert chaud élevée non oui
pluvieux doux élevée non oui
pluvieux frais normale non oui
pluvieux frais normale oui non
couvert frais normale oui oui
ensoleillé doux élevée non non
ensoleillé frais normale non oui
pluvieux doux normale non oui
ensoleillé doux normale oui oui
couvert doux élevée oui oui
couvert chaud normale non oui
pluvieux doux élevée oui non")
jour <- c(ciel = "couvert", temperature = "frais", humidite = "élevée", vent = "oui")

scores <- sapply(c("non", "oui"), function(classe) {
  groupe <- meteo[meteo$jouer == classe, ]
  prior <- nrow(groupe) / nrow(meteo)
  # vraisemblances sans lissage : simple proportion dans la classe
  vraisemblances <- sapply(names(jour), function(c) mean(groupe[[c]] == jour[c]))
  prior * prod(vraisemblances)
})
round(scores, 4)                     # non 0, oui 0.0106
scores["oui"] / sum(scores)          # P(jouer | x) = 1

Exercice · Le piège du test positif

moyen

Une maladie touche 1 % de la population. Un test la détecte chez 99 % des malades, et il est positif à tort chez 5 % des personnes saines. Une personne est testée positive. Quelle est la probabilité qu’elle soit réellement malade ?

Voir la solution

On applique la règle de Bayes avec $\omega$ = malade et $x$ = test positif :

• prior : $P(M) = 0{,}01$, donc $P(\bar{M}) = 0{,}99$ ;
• vraisemblances : $P(+ \mid M) = 0{,}99$ et $P(+ \mid \bar{M}) = 0{,}05$.

$$P(M \mid +) = \frac{0{,}99 \times 0{,}01}{0{,}99 \times 0{,}01 + 0{,}05 \times 0{,}99} = \frac{0{,}0099}{0{,}0099 + 0{,}0495} \approx 0{,}167$$

Seulement 16,7 % ! Parce que la maladie est rare, les faux positifs parmi les 99 % de personnes saines sont bien plus nombreux que les vrais positifs. C’est l’importance du prior, et c’est aussi pourquoi la précision d’un modèle chute quand la classe positive est rare (chapitre 3).

En code

Python

import numpy as np

p_malade = 0.01
p_pos_si_malade, p_pos_si_sain = 0.99, 0.05

# Règle de Bayes : P(M | +) = P(+ | M) P(M) / P(+)
p_pos = p_pos_si_malade * p_malade + p_pos_si_sain * (1 - p_malade)
print(round(p_pos_si_malade * p_malade / p_pos, 3))      # 0.167

# Vérification par simulation sur un million de personnes
rng = np.random.default_rng(0)
malade = rng.random(1_000_000) < p_malade
positif = np.where(malade, rng.random(1_000_000) < p_pos_si_malade,
                           rng.random(1_000_000) < p_pos_si_sain)
print(round(malade[positif].mean(), 3))                  # 0.167 : part de malades parmi les positifs

R

p_malade <- 0.01
p_pos_si_malade <- 0.99; p_pos_si_sain <- 0.05

# Règle de Bayes : P(M | +) = P(+ | M) P(M) / P(+)
p_pos <- p_pos_si_malade * p_malade + p_pos_si_sain * (1 - p_malade)
round(p_pos_si_malade * p_malade / p_pos, 3)        # 0.167

# Vérification par simulation sur un million de personnes
set.seed(0)
n <- 1e6
malade <- runif(n) < p_malade
positif <- ifelse(malade, runif(n) < p_pos_si_malade, runif(n) < p_pos_si_sain)
round(mean(malade[positif]), 3)                     # 0.164 : part de malades parmi les positifs

Exercice · Le même jour, avec lissage

difficile

Reprenez le jour (couvert, frais, humidité élevée, vent) avec le lissage de Laplace ($\alpha = 1$) sur les vraisemblances, en gardant les priors non lissés comme le fait scikit-learn. Rappel : le ciel a 3 valeurs, la température 3, l’humidité 2 et le vent 2. Calculez $P(\text{jouer} \mid x)$.

Voir la solution

Pour « jouer » ($n_\omega = 9$) : couvert $(4+1)/(9+3) = 5/12$ ; frais $(3+1)/(9+3) = 4/12$ ; humidité élevée $(3+1)/(9+2) = 4/11$ ; vent $(3+1)/(9+2) = 4/11$.

$$\tfrac{9}{14} \times \tfrac{5}{12} \times \tfrac{4}{12} \times \tfrac{4}{11} \times \tfrac{4}{11} \approx 0{,}0118$$

Pour « ne pas jouer » ($n_\omega = 5$) : couvert $(0+1)/(5+3) = 1/8$ ; frais $(1+1)/(5+3) = 2/8$ ; humidité élevée $(4+1)/(5+2) = 5/7$ ; vent $(3+1)/(5+2) = 4/7$.

$$\tfrac{5}{14} \times \tfrac{1}{8} \times \tfrac{2}{8} \times \tfrac{5}{7} \times \tfrac{4}{7} \approx 0{,}0046$$

Après normalisation, $P(\text{jouer} \mid x) \approx 0{,}0118 / (0{,}0118 + 0{,}0046) \approx 0{,}72$. La décision reste « jouer », mais le modèle n’est plus absurdement certain : l’humidité élevée et le vent, plus fréquents les jours sans joueurs, pèsent désormais dans la balance.

En code

Python

import numpy as np
import pandas as pd
from sklearn.naive_bayes import CategoricalNB
from sklearn.preprocessing import OrdinalEncoder

# Les 14 jours du fil rouge
meteo = pd.DataFrame(
    [r.split() for r in """ensoleillé chaud élevée non non
ensoleillé chaud élevée oui non
couvert chaud élevée non oui
pluvieux doux élevée non oui
pluvieux frais normale non oui
pluvieux frais normale oui non
couvert frais normale oui oui
ensoleillé doux élevée non non
ensoleillé frais normale non oui
pluvieux doux normale non oui
ensoleillé doux normale oui oui
couvert doux élevée oui oui
couvert chaud normale non oui
pluvieux doux élevée oui non""".splitlines()],
    columns=["ciel", "temperature", "humidite", "vent", "jouer"])
X, y = meteo.drop(columns="jouer"), meteo["jouer"]
jour = pd.DataFrame([["couvert", "frais", "élevée", "oui"]], columns=X.columns)

# À la main : (n_v + 1) / (n_classe + V), priors non lissés
scores = {}
for classe, groupe in meteo.groupby("jouer"):
    lik = [(np.sum(groupe[c] == jour[c][0]) + 1) / (len(groupe) + X[c].nunique()) for c in X]
    scores[classe] = len(groupe) / len(meteo) * np.prod(lik)
print({c: round(float(s), 4) for c, s in scores.items()})  # {'non': 0.0046, 'oui': 0.0118}
print(round(float(scores["oui"] / sum(scores.values())), 3))  # P(jouer | x) = 0.722

# Avec scikit-learn : même résultat
enc = OrdinalEncoder().fit(X)
nb = CategoricalNB(alpha=1.0).fit(enc.transform(X), y)
print(nb.predict_proba(enc.transform(jour)).round(3))   # [[0.278 0.722]] (non, oui)

R

# Les 14 jours du fil rouge
meteo <- read.table(header = TRUE, text = "
ciel temperature humidite vent jouer
ensoleillé chaud élevée non non
ensoleillé chaud élevée oui non
couvert chaud élevée non oui
pluvieux doux élevée non oui
pluvieux frais normale non oui
pluvieux frais normale oui non
couvert frais normale oui oui
ensoleillé doux élevée non non
ensoleillé frais normale non oui
pluvieux doux normale non oui
ensoleillé doux normale oui oui
couvert doux élevée oui oui
couvert chaud normale non oui
pluvieux doux élevée oui non")
jour <- c(ciel = "couvert", temperature = "frais", humidite = "élevée", vent = "oui")
V <- sapply(meteo[names(jour)], function(col) length(unique(col)))   # 3, 3, 2, 2 valeurs

scores <- sapply(c("non", "oui"), function(classe) {
  groupe <- meteo[meteo$jouer == classe, ]
  # lissage de Laplace sur les vraisemblances, prior non lissé
  lik <- sapply(names(jour), function(c) (sum(groupe[[c]] == jour[c]) + 1) / (nrow(groupe) + V[c]))
  nrow(groupe) / nrow(meteo) * prod(lik)
})
round(scores, 4)                         # non 0.0046, oui 0.0118
round(scores["oui"] / sum(scores), 3)    # P(jouer | x) = 0.722