Concours Nationaux d’Entrée aux Cycles de Formation d’Ingénieurs Session 2019
Concours Nationaux d’Entrée aux Cycles de Formation d’Ingénieurs Session 2019
Biology, Computer Science, SQL, Programming · exam
Voir tous les documents en bases de données
Fiche de révisionCorrigé
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document présente la correction de l'épreuve d'informatique issue du Concours National d’Entrée aux Cycles de Formation d’Ingénieurs, session 2019, dans la filière Biologie. Il permet de réviser la programmation Python pour la manipulation de données, l'algèbre relationnelle, les requêtes SQL avancées, ainsi que l’utilisation de SQLite3 et Matplotlib.
Ce problème porte sur plusieurs fonctions Python destinées à manipuler un ensemble de données représenté sous forme de dictionnaire. Chaque clé correspond à un attribut et chaque valeur à une liste d'observations associées.
La fonction charge un fichier texte dont la première ligne contient les noms des colonnes séparés par le caractère « # », et les lignes suivantes les valeurs associées.
def LoadFile(fname):
with open(fname) as f:
keys = f.readline().strip().split("#")
values = [[int(x) for x in l.split("#")] for l in f]
return {k: list(v) for k, v in zip(keys, zip(*values))}
Étapes clés :
with).keys).zip(*values) pour regrouper les valeurs par colonne.Cette fonction compte le nombre de valeurs distinctes pour un attribut donné dans le jeu de données.
def CountValues(DEST, obs):
return len(set(DEST[obs]))
DEST[obs].set) pour éliminer automatiquement les doublons.len().Cette fonction évalue la distribution des décisions (classes 0 et 1) au sein de la clé "decision".
def EvalDistr(DSET):
decision = DSET.get("decision", [])
if len(decision) == 0:
return {0: 0.5, 1: 0.5}
p0 = decision.count(0) / len(decision)
return {0: p0, 1: 1 - p0}
{0: 0.5, 1: 0.5}.p0 de la classe 0.Cette fonction vérifie si le jeu de données contient une seule classe de décision.
def IsPure(DSET):
return 1 in EvalDistr(DSET).values()
Si l'une des proportions calculées par EvalDistr est égale à 1, cela signifie que toutes les observations appartiennent à la même classe.
Cette fonction contrôle si chaque attribut du jeu de données contient exclusivement des valeurs binaires (0 ou 1).
def IsQualitative(DSET):
return {k: set(v) <= {0, 1} for k, v in DSET.items()}
Elle parcourt chaque variable et vérifie si l'ensemble de ses valeurs est un sous-ensemble de {0, 1}.
La fonction divise le jeu de données en deux sous-ensembles en fonction d'un seuil S appliqué à la variable obs.
def Cut(DSET, obs, S=0.5):
keys = set(DSET)
keys.remove(obs)
DSET1, DSET2 = {}, {}
for k in keys:
vals1, vals2 = [], []
vals = DSET[k]
for i in range(len(vals)):
if DSET[obs][i] >= S:
vals1.append(vals[i])
else:
vals2.append(vals[i])
DSET1[k], DSET2[k] = vals1, vals2
oth_obs = keys.pop()
p0 = len(DSET1[oth_obs]) / len(DSET[obs])
return [DSET1, DSET2], [p0, 1 - p0]
Cette fonction évalue l'impureté résiduelle après la scission du jeu de données selon un seuil.
def Impurity(DSET, obs, S=0.5):
[DSET1, DSET2], [p1, p2] = Cut(DSET, obs, S)
return p1 * min(EvalDistr(DSET1).values()) + p2 * min(EvalDistr(DSET2).values())
L'impureté totale est obtenue en calculant la moyenne pondérée de l'impureté minimale des sous-ensembles obtenus.
Cette fonction réorganise les couples (valeur de l'observation, décision) par ordre croissant des valeurs de l'observation.
def SortObs(DSET, obs):
return sorted((v, d) for v, d in zip(DSET[obs], DSET["decision"]))
La fonction détermine le seuil de coupure optimal minimisant l'impureté pour une observation donnée.
def BestCut(DSET, obs, Qual):
if Qual[obs]:
return (0.5, Impurity(DSET, obs))
else:
Lc = SortObs(DSET, obs)
Lseuil = []
if IsPure(DSET):
Lseuil.append(max(Lc)[0])
else:
for i in range(len(Lc) - 1):
vc, dc = Lc[i]
vn, dn = Lc[i + 1]
if dc != dn:
Lseuil.append((vc + vn) / 2)
sBest = min(Lseuil, key=lambda s: Impurity(DSET, obs, s))
return (sBest, Impurity(DSET, obs, sBest))
Question 1 : Extraction des identifiants, noms et descriptions des jeux de données au format « csv ».
Π ds_id, ds_name, ds_description (σ format = 'csv' (DataSet))
Question 2 : Extraction de la description des classifieurs utilisant le langage Python et la catégorie KNN.
Π cls_description (σ language = 'Python' et category = 'KNN' (Classifieur ⋈ cls_id Combine ⋈ m_name Method))
Question 3 : Modification du format des jeux de données de « csv » vers « docx ».
UPDATE DataSET
SET format = 'docx'
WHERE format = 'csv';
Question 4 : Suppression des classifieurs programmé en PASCAL.
DELETE FROM Classifieur
WHERE language = 'PASCAL';
Question 5 : Identifiants des classifieurs ayant un taux d'erreur strictement inférieur à 0.3.
SELECT ds_id
FROM Classifieur
WHERE error_rate < 0.3;
Question 6 : Recherche du nom du jeu de données contenant le plus grand nombre d'instances.
SELECT ds_name
FROM DataSET
WHERE nb_instances = (
SELECT MAX(nb_instances)
FROM DataSet
);
Question 7 : Jeux de données associés exclusivement à des classifieurs en Python (ou sans aucun classifieur).
SELECT ds_id
FROM DataSet AS D
WHERE NOT EXISTS (
SELECT * FROM Classifieur AS C
WHERE C.ds_id = D.ds_id AND language != 'Python'
);Question 8 : Jeux de données n'ayant aucun classifieur associé.
SELECT ds_id
FROM DataSet
WHERE ds_id NOT IN (
SELECT ds_id
FROM Classifieur
);
Question 9 : Nombre de classifieurs dont le taux d'erreur est supérieur à la moyenne globale.
SELECT COUNT(*)
FROM Classifieur
WHERE error_rate > (SELECT AVG(error_rate) FROM Classifieur);
Question 10 : Nombre de méthodes distinctes utilisées par chaque classifieur.
SELECT D.ds_id, COUNT(DISTINCT M.m_name) AS NB_M
FROM DataSet AS D,
Classifieur AS C,
Combine AS CM,
Method AS M
WHERE (D.ds_id = C.ds_id) AND
(C.cls_id = CM.cls_id) AND
(CM.m_name = M.m_name)
GROUP BY C.cls_id;
Question 11 : Liste des jeux de données associés aux classifieurs affichant le taux d'erreur minimal.
SELECT * FROM DataSet
WHERE ds_id IN (
SELECT ds_id FROM Classifieur
WHERE error_rate = (
SELECT MIN(error_rate)
FROM Classifieur
)
);
Question 12 : Jeux de données associés à au moins trois classifieurs développés en Java.
SELECT D.ds_id, ds_name
FROM DataSet AS D,
Classifieur AS C
WHERE (D.ds_id = C.ds_id) AND (language = 'Java')
GROUP BY ds_id
HAVING COUNT(*) >= 3;
Question 13 : Création de table, insertion groupée et génération de graphiques statistiques.
import sqlite3
import matplotlib.pyplot as plt
cnx = sqlite3.connect('C1.db')
cur = cnx.cursor()
sql_tbl = """
CREATE TABLE Method
(
m_name TEXT PRIMARY KEY,
category TEXT,
m_description TEXT
);
"""
cur.execute(sql_tbl)
sql_ins = """
INSERT INTO Method Values(?,?,?)
"""
lst_data = [(k,) + tuple(v) for k, v in dict_M.items()]
cur.executemany(sql_ins, lst_data)
cnx.commit()
sql_sel = """
SELECT ds_id, AVG(error_rate) AS M_erreur
FROM Classifieur
GROUP BY ds_id
ORDER BY ds_id
"""
cur.execute(sql_sel)
x, y = zip(*cur.fetchall())
plt.plot(x, y)
plt.show()
cnx.close()
Pour réussir cette épreuve aux concours d'ingénieurs, plusieurs compétences clés sont évaluées :
set) et le module zip pour transposer efficacement des matrices.WHERE (filtrage des lignes) et HAVING (filtrage après agrégation GROUP BY).NOT EXISTS ou NOT IN pour traiter les exclusions et vérifiez la cohérence des jointures multiples.cnx.commit() après des requêtes de modification (INSERT, UPDATE, DELETE) et de fermer la connexion.