1
0
forked from ScoDoc/ScoDoc

Corrige tri etuds/compétences dans traduction SxTag -> RSCTag

This commit is contained in:
Cléo Baras 2024-02-19 20:12:49 +01:00
parent 491d600bd4
commit 8de1a44583

View File

@ -43,7 +43,7 @@ import numpy as np
import app.pe.rcss.pe_rcs as pe_rcs
import app.pe.rcss.pe_rcrcf as pe_rcrcf
import app.pe.pe_sxtag as pe_sxtag
import app.pe.pe_comp as pe_comp
from app.pe.pe_tabletags import TableTag
from app.pe.pe_moytag import MoyennesTag
@ -93,16 +93,16 @@ class RCSTag(TableTag):
# Les étudiants (etuds, états civils & etudis)
self.etuds = nt.etuds
self.add_etuds(nt.etuds)
self.etudids_sorted = sorted(self.etudids)
"""Etudids triés"""
# Les compétences (extraites de tous les Sxtags)
self.association_ues_comp = self.mapping_ue_competences()
print(self.association_ues_comp)
"""Association indiquant pour chaque UE , quelle compétence lui correspond"""
pe_affichage.pe_print(f"* Association UEs -> compétences : {self.association_ues_comp}")
self.competences_sorted = self.do_complist()
"""Liste des compétences triées"""
"""Compétences extraites de tous les SxTag aggrégés"""
"""Compétences (triées) extraites de tous les SxTag aggrégés"""
pe_affichage.pe_print(f"* Compétences : {', '.join(self.competences_sorted)}")
# Les tags
@ -116,11 +116,11 @@ class RCSTag(TableTag):
for tag in self.tags_sorted:
# Cube de note
notes_cube, coeffs_cube = self.compute_notes_comps_cube(tag)
notes_cube, coeffs_cube = self.compute_notes_comps_cube(tag, self.etudids_sorted, self.competences_sorted)
# Calcule des moyennes/coeffs sous forme d'un dataframe"""
moys_competences, coeffs_competences = compute_notes_competences(
notes_cube, coeffs_cube, self.etudids, self.competences_sorted
notes_cube, coeffs_cube, self.etudids_sorted, self.competences_sorted
)
# Les moyennes
@ -139,20 +139,25 @@ class RCSTag(TableTag):
else:
return f"{self.__class__.__name__} ({self.rcs_id})"
def compute_notes_comps_cube(self, tag):
def compute_notes_comps_cube(self, tag, etudids_sorted: list[int], competences_sorted: list[str]):
"""Pour un tag donné, construit :
* le cube de notes (etudid x competences x SxTag) nécessaire au calcul des moyennes,
en remplaçant les données d'UE (obtenus du SxTag) par les compétences
* le cube de coeffs (etudid x competences x SxTag) (traduisant les inscriptions)
appliqué au calcul des différents SxTag
Args:
tag: Le tag visé
etudids_sorted: Les etudis triés
competences_sorted: Les compétences triées
"""
# nb_tags = len(self.tags_sorted)
# nb_etudiants = len(self.etuds)
# nb_semestres = len(self.semestres_tags_aggreges)
# Index du cube (etudids -> dim 0, tags -> dim 1)
etudids = [etud.etudid for etud in self.etuds]
competences_sorted = self.competences_sorted
# etudids = [etud.etudid for etud in self.etuds]
# competences_sorted = self.competences_sorted
sxstags_ids = list(self.sxstags.keys())
notes_dfs = {}
@ -160,8 +165,8 @@ class RCSTag(TableTag):
for sxtag_id, sxtag in self.sxstags.items():
# Partant d'un dataframe vierge
notes_df = pd.DataFrame(np.nan, index=etudids, columns=competences_sorted)
coeffs_df = pd.DataFrame(np.nan, index=etudids, columns=competences_sorted)
notes_df = pd.DataFrame(np.nan, index=etudids_sorted, columns=competences_sorted)
coeffs_df = pd.DataFrame(np.nan, index=etudids_sorted, columns=competences_sorted)
moys_tag = sxtag.moyennes_tags[tag]
@ -175,11 +180,8 @@ class RCSTag(TableTag):
notes.columns = comp_associes_aux_ues
coeffs.columns = comp_associes_aux_ues
# Compétences communes
comp_communes = list(set(competences_sorted) & set(comp_associes_aux_ues))
# Etudiants communs
etudids_communs = notes_df.index.intersection(notes.index)
# Les étudiants et les compétences communes
etudids_communs, comp_communes = pe_comp.find_index_and_columns_communs(notes_df, notes)
# Recopie des notes et des coeffs
notes_df.loc[etudids_communs, comp_communes] = notes.loc[
@ -233,7 +235,7 @@ class RCSTag(TableTag):
def compute_notes_competences(
set_cube: np.array, coeff_cube: np.array, etudids: list, competences: list
set_cube: np.array, coeff_cube: np.array, etudids_sorted: list, competences_sorted: list
):
"""Calcule:
* la moyenne par compétences à un tag donné sur plusieurs semestres (partant du set_cube).
@ -248,16 +250,16 @@ def compute_notes_competences(
set_cube: notes moyennes aux modules ndarray
(etuds x UEs|compétences x sxtags), des floats avec des NaN
coeffs_cube: somme des coeffs impliqués dans la moyennes
etudids: liste des étudiants (dim. 0 du cube)
competences: list
etudids_sorted: liste des étudiants (dim. 0 du cube)
competences_sorted: list
tags: liste des tags (dim. 1 du cube)
Returns:
Un DataFrame avec pour columns les moyennes par tags,
et pour rows les etudid
"""
nb_etuds, nb_comps, nb_semestres = set_cube.shape
assert nb_etuds == len(etudids)
assert nb_comps == len(competences)
assert nb_etuds == len(etudids_sorted)
assert nb_comps == len(competences_sorted)
# Quelles entrées du cube contiennent des notes ?
mask = ~np.isnan(set_cube)
@ -275,12 +277,12 @@ def compute_notes_competences(
# Le dataFrame des notes moyennes
etud_moy_tag_df = pd.DataFrame(
etud_moy_tag,
index=etudids, # les etudids
columns=competences, # les competences
index=etudids_sorted, # les etudids
columns=competences_sorted, # les competences
)
etud_moy_tag_df.fillna(np.nan)
coeffs_df = pd.DataFrame(coeff_tag, index=etudids, columns=competences)
coeffs_df = pd.DataFrame(coeff_tag, index=etudids_sorted, columns=competences_sorted)
coeffs_df.fillna(np.nan)
return etud_moy_tag_df, coeffs_df