def statsOnDF(self, data):
vp = 0
vn = 0
fp = 0
fn = 0
for i in range(len(data)):
e = data["target"][i]
if e == 0:
if self.estimClass(utils.getNthDict(data, i)) == 1:
fp += 1
else:
vn += 1
else:
if self.estimClass(utils.getNthDict(data, i)) == 1:
vp += 1
else:
fn += 1
return {
"VP": vp,
"VN": vn,
"FP": fp,
"FN": fn,
"Précision": vp / (vp + fp),
"Rappel": vp / (vp + fn)
}
def __init__(self, df, seuil):
self.df = df
self.liste_attributs = utils.getNthDict(df, 0).keys()
self.proba = {}
for attribut in self.liste_attributs:
if not isIndepFromTarget(df, attribut, seuil):
self.proba[attribut] = P2D_l(self.df, attribut)
def statsOnDF(self, df):
"""
A partir d'un pandas.dataframe, calcule les taux d'erreurs de classification
et rend un dictionnaire.
VP : nombre d'individus avec target=1 et classe prévue=1
VN : nombre d'individus avec target=0 et classe prévue=0
FP : nombre d'individus avec target=0 et classe prévue=1
FN : nombre d'individus avec target=1 et classe prévue=0
Précision : combien de candidats sélectionnés sont pertinents = VP/(VP+FP)
Rappel : combien d'éléments pertinents sont sélectionnés = VP/(VP+FN)
:param df: le dataframe à tester
:return: un dictionnaire contennat les VP, FP, VN, FN, précision et rappel
"""
dic = dict()
dic['VP'] = 0
dic['VN'] = 0
dic['FP'] = 0
dic['FN'] = 0
for t in df.itertuples():
dicEl = t._asdict()
ligne = utils.getNthDict(df, dicEl.get('Index'))
if (dicEl.get('target') == 1 and self.estimClass(ligne) == 1):
dic['VP'] += 1
if (dicEl.get('target') == 0 and self.estimClass(ligne) == 0):
dic['VN'] += 1
if (dicEl.get('target') == 0 and self.estimClass(ligne) == 1):
dic['FP'] += 1
if (dicEl.get('target') == 1 and self.estimClass(ligne) == 0):
dic['FN'] += 1
dic['Précision'] = dic['VP'] / (dic['VP'] + dic['FP'])
dic['Rappel'] = (dic['VP']) / (dic['VP'] + dic['FN'])
return dic
def __init__(self, df):
self.df = df
self.liste_attributs = list(utils.getNthDict(df, 0).keys())
self.liste_attributs.remove('target')
self.proba = {}
for i in self.liste_attributs:
self.proba[i] = P2D_l(self.df, i)
def nbParamsNaiveBayes(df, attribut, liste_attributs=None):
valAttr = len(P2D_p(df, attribut))
result = 0
units = ["o", "Ko", "Mo", "Go"]
if (liste_attributs == None):
liste_attributs = utils.getNthDict(df, 0).keys()
for i in liste_attributs:
if i == attribut:
result += 1
else:
result += len(P2D_p(df, i))
if (result != 0):
result *= 8 * valAttr
else:
result = 8 * valAttr
string = str(
len(liste_attributs)) + " variable(s) : " + str(result) + " octets"
if result >= 1024:
string += " ="
conver = conversion(result)
i = len(conver) - 1
while i >= 0:
while i > 0 and conver[i] == 0:
i -= 1
string = string + " " + str(conver[i]) + units[i]
i -= 1
print(string)
def P2D_l(df, attr):
"""
On prend toutes les valeurs uniques dans la target et toutes les valeurs uniques dans l'attribut
en utilisant 2 sets. La clé du dictionnaire principal doit être target, donc pour chaque valeur on
crée un nouveau dictionnaire avec toutes les valeurs de s2 commes cles, avec les valeurs correspondantes
initialisées avec 0. On parcours le tableau et compte les apparitions de chaque attribut.
A la fin on divise par la taille du tableau pour trouver la probabilité de chacun.
"""
x = {}
s1 = set()
s2 = set()
for i in df['target']:
s1.add(i)
for i in df[attr]:
s2.add(i)
for i in s1:
x[i] = {}
for j in s2:
x[i][j] = 0
size_target = df.groupby('target')[attr].count()
for i in range(0, df.shape[0]):
dic = util.getNthDict(df, i)
x[dic['target']][dic[attr]] += 1
for target, attribute in x.items():
for key in attribute:
attribute[key] /= size_target[target]
return x
def statsOnDF(self, df):
"""
à partir d'un pandas.dataframe, calcule les taux d'erreurs de classification et rend un dictionnaire.
:param df: le dataframe à tester
:return: un dictionnaire incluant les VP,FP,VN,FN,précision et rappel
"""
dic = {}
dic['VP'] = 0
dic['VN'] = 0
dic['FP'] = 0
dic['FN'] = 0
n = df.shape[0]
for i in range(n):
line = utils.getNthDict(df, i)
t = self.estimClass(line)
if line['target'] == t:
if t == 1:
dic['VP'] += 1
else:
dic['VN'] += 1
else:
if t == 1:
dic['FP'] += 1
else:
dic['FN'] += 1
dic['rappel'] = dic['VP'] / (dic['VP'] + dic['FN'])
dic['précision'] = dic['VP'] / (dic['VP'] + dic['FP'])
return dic
def nbParamsIndep(df, attrs=None):
"""calcule la taille mémoire nécessaire pour représenter les tables de probabilité
étant donné un dataframe, en supposant qu'un float est représenté sur 8octets
et en supposant l'indépendance des variables """
result = 0
if (attrs == None):
attrs = utils.getNthDict(df, 0).keys()
for i in attrs:
result += len(P2D_p(df, i))
result *= 8
string = str(len(attrs)) + " variable(s) : " + str(result) + " octets"
if (result > 1024):
quotient = result // 1024
reste = result % 1024
string = string + " = " + str(quotient) + "ko " + str(reste) + "o"
print(string)
def statsOnDF(self, df):
"""
à partir d'un pandas.dataframe, calcule les taux d'erreurs de classification et rend un dictionnaire.
:param df: le dataframe à tester
:return: un dictionnaire incluant les VP,FP,VN,FN,précision et rappel
"""
dico = dict()
VP = 0
FP = 0
VN = 0
FN = 0
i = 0
for t in df.itertuples():
dic = t._asdict()
attrs = ut.getNthDict(df, i)
c = self.estimClass(attrs)
if dic['target'] == 1 and c == 1:
VP += 1
if dic['target'] == 0 and c == 0:
VN += 1
if dic['target'] == 0 and c == 1:
FP += 1
if dic['target'] == 1 and c == 0:
FN += 1
i += 1
precision = VP / (VP + FP)
rappel = VP / (VP + FN)
dico = {
"VP": VP,
"VN": VN,
"FP": FP,
"FN": FN,
"precision": precision,
"rappel": rappel
}
return dico
def statsOnDF(self, df):
"""
res = {'VP': 0, 'VN': 0, 'FP': 0, 'FN': 0 , 'Precision': 0 , 'Rappel': 0 }
classMajoritaire = self.estimClass(df)
for t in df.itertuples():
dic = t._asdict()
v = dic['target']
if v == 1 and classMajoritaire == 1:
res['VP'] += 1
elif v == 0 and classMajoritaire == 0:
res['VN'] += 1
elif v == 0 and classMajoritaire == 1:
res['FP'] += 1
else:
res['FN'] += 1
res['Précision'] = res['VP'] / (res['VP'] + res['FP'])
res['Rappel'] = res['VP'] / (res['VP'] + res['FN'])
return res
"""
res = {'VP': 0, 'VN': 0, 'FP': 0, 'FN': 0 , 'Precision': 0 , 'Rappel': 0 }
i = 0
for t in df.itertuples():
dic = t._asdict()
v = dic['target']
attrs = ut.getNthDict(df,i)
classePrevue = self.estimClass(attrs)
if v == 1 and classePrevue == 1:
res['VP'] += 1
elif v == 0 and classePrevue == 0:
res['VN'] += 1
elif v == 0 and classePrevue == 1:
res['FP'] += 1
else:
res['FN'] += 1
i += 1
res['Precision'] = res['VP'] / (res['VP'] + res['FP'])
res['Rappel'] = res['VP'] / (res['VP'] + res['FN'])
return res
def statsOnDF(self, train):
stats = dict()
stats["VP"] = stats["VN"] = stats["FP"] = stats["FN"] = 0
for i in range(len(train)):
t = ut.getNthDict(train, i)
x = t['target']
if x == 1 and self.estimClass(t) == 1:
stats["VP"] += 1
elif x == 1 and self.estimClass(t) == 0:
stats["FN"] += 1
elif t['target'] == 0 and self.estimClass(t) == 1:
stats["FP"] += 1
else:
stats["VN"] += 1
stats["Précision"] = stats["VP"] / (stats["VP"] + stats["FP"])
stats["Rappel"] = stats["VP"] / (stats["VP"] + stats["FN"])
return stats
###########################
"""Question 3.a"""
def statsOnDF(self, df):
"""
à partir d'un pandas.dataframe, calcule les taux d'erreurs de classification et rend un dictionnaire.
VP : nombre d'individus avec target=1 et classe prévue=1
VN : nombre d'individus avec target=0 et classe prévue=0
FP : nombre d'individus avec target=0 et classe prévue=1
FN : nombre d'individus avec target=1 et classe prévue=0
Précision : combien de candidats sélectionnés sont pertinents (VP/(VP+FP))
Rappel : combien d'éléments pertinents sont sélectionnés (VP/(VP+FN))
*le parametre df:
le dataframe
*le return:
un dictionnaire incluant les VP,FP,VN,FN,précision et rappel
"""
dictionnaire_proba = {}
dictionnaire_proba["VP"] = 0
dictionnaire_proba["VN"] = 0
dictionnaire_proba["FP"] = 0
dictionnaire_proba["FN"] = 0
#calcul stats: estim représente l'estimation de la classe de la personne et dic['target'] sa classe réelle
for t in range(df.shape[0]):
dic = utils.getNthDict(df, t)
estim = self.estimClass(dic)
if dic["target"] == 1:
if estim == 1:
dictionnaire_proba["VP"] += 1
else:
dictionnaire_proba["FN"] += 1
else:
if estim == 1:
dictionnaire_proba["FP"] += 1
else:
dictionnaire_proba["VN"] += 1
dictionnaire_proba["Précision"] = dictionnaire_proba["VP"] / (
dictionnaire_proba["VP"] + dictionnaire_proba["FP"])
dictionnaire_proba["Rappel"] = dictionnaire_proba["VP"] / (
dictionnaire_proba["VP"] + dictionnaire_proba["FN"])
return dictionnaire_proba
def nbParams(df, attrs=None):
"""nbParams calcule la taille mémoire des tables $P(target|attr_1,..,attr_k)$
étant donné un dataframe et la liste $[target,attr_1,...,attr_l]$
en supposant qu'un float est représenté sur 8octets"""
result = 1
units = ["o", "Ko", "Mo", "Go"]
if (attrs == None):
attrs = utils.getNthDict(df, 0).keys()
for i in attrs:
result *= len(P2D_p(df, i))
result *= 8
string = str(len(attrs)) + " variable(s) : " + str(result) + " octets"
if result >= 1024:
string += " ="
conver = conversion(result)
i = len(conver) - 1
while i >= 0:
while i > 0 and conver[i] == 0:
i -= 1
string = string + " " + str(conver[i]) + units[i]
i -= 1
print(string)
def statsOnDF(self, df):
"""
à partir d'un pandas.dataframe, calcule les taux d'erreurs de classification et rend un dictionnaire.
:param df: le dataframe à tester
:return: un dictionnaire incluant les VP,FP,VN,FN,précision et rappel
VP : nombre d'individus avec target=1 et classe prévue=1
VN : nombre d'individus avec target=0 et classe prévue=0
FP : nombre d'individus avec target=0 et classe prévue=1
FN : nombre d'individus avec target=1 et classe prévue=0
Précision : combien de candidats sélectionnés sont pertinents (VP/(VP+FP))
Rappel : combien d'éléments pertinents sont sélectionnés (VP/(VP+FN))
"""
dico = {}
dico["VP"] = 0
dico["VN"] = 0
dico["FP"] = 0
dico["FN"] = 0
for t in range(df.shape[0]):
dic = utils.getNthDict(df, t)
resultat = self.estimClass(dic)
if dic["target"] == 1:
if resultat == 1:
dico["VP"] += 1
else:
dico["FN"] += 1
else:
if resultat == 1:
dico["FP"] += 1
else:
dico["VN"] += 1
dico["Précision"] = dico["VP"] / (dico["VP"] + dico["FP"])
dico["Rappel"] = dico["VP"] / (dico["VP"] + dico["FN"])
return dico
def __init__(self, df):
self.df = df
self.liste_attributs = utils.getNthDict(df, 0).keys()
self.proba = {}
for attribut in self.liste_attributs:
self.proba[attribut] = P2D_l(self.df, attribut)
def drawNaiveBayes(df, attr):
result = ""
for i in utils.getNthDict(df, 0).keys():
if (i != attr):
result += attr + "->" + i + ";"
return utils.drawGraph(result)
