WIP step 3

- KWAttributeStats: correction des assertion pour l'ecriture des "parts" dans le cas non supervise
- DTDecisionTreeNodeSplit::CompareName
  - implementation desormais avec GetAttributeStats()->CompareName, pour se baser sur le tri des AttributeStats
- KWDataPreparationAttributeCompareSortValue
  - implementation desormais avec GetAttributeStats()->CompareName, pour se baser sur le tri des AttributeStats
- KWSelectedDataGridReport
  - SetSortName: suppression
  - InternalTrain: parametrage du nommage interpretable ou non de l'attributeSubsetStats associe au predicteur
  - GetSortName: reimplemente avec la methode ExportVariableNames de la grille

- KWDataPreparationStats
  - GetInterpretableName: nouvelle methode virtuelle (par defaut: GetSortName)
- KWAttributeSubsetStats
  - Set|GetSortNameIndex: pour parametrer la generation d'un nom de paire non interpretable
  - BuildInterpretableName, BuildNonInterpretableName
  - GetSortName: renvoie la version interpretable ou non selon le SortNameIndex
  - GetInterpretableName: reimplementation de methode virtuelle
- KWDataPreparationBivariateTask::MasterFinalize
  - parametrage du nommage interpretable ou non des paires de variables

src/Learning/DTForest/DTDecisionTree.h

@@ -515,7 +515,7 @@ inline int DTDecisionTreeNodeSplit::CompareName(const DTDecisionTreeNodeSplit* o
 	require(GetAttributeStats() != NULL);
 	require(otherReport->GetAttributeStats() != NULL);
 
-	return GetAttributeStats()->GetAttributeName().Compare(otherReport->GetAttributeStats()->GetAttributeName());
+	return GetAttributeStats()->CompareName(otherReport->GetAttributeStats());
 }
 //
 // inline ObjectArray* DTDecisionTree::GetObjectsDataBase() const

src/Learning/KWDataPreparation/KWAttributeStats.cpp

@@ -368,10 +368,10 @@ void KWAttributeStats::WriteLineReport(ostream& ost)
 			ost << "\t1";
 		}
 	}
-	// Nombre de partie uniquement dans le cas supervise
+	// Dans le cas non supervise, on ecrit eventuellement le nombre de parties
 	else
 	{
-		assert(GetTargetAttributeName() != "");
+		assert(GetTargetAttributeName() == "");
 
 		if (GetPreparedDataGridStats() != NULL)
 		{
@@ -508,7 +508,7 @@ void KWAttributeStats::WriteJSONArrayFields(JSONFile* fJSON, boolean bSummary)
 		// Dans le cas non supervise, on ecrit eventuellement le nombre de parties
 		else
 		{
-			assert(GetTargetAttributeName() != "");
+			assert(GetTargetAttributeName() == "");
 			if (GetPreparedDataGridStats() != NULL)
 			{
 				assert(GetPreparedDataGridStats()->GetAttributeNumber() == 1);

src/Learning/KWDataPreparation/KWAttributeSubsetStats.cpp

@@ -11,6 +11,9 @@ KWAttributeSubsetStats::KWAttributeSubsetStats()
 {
 	classStats = NULL;
 
+	// Par defaut, on construit des noms interpretables
+	nSortNameIndex = -1;
+
 	// L'indicateur est mis a vrai des que l'attribut cible est ajoute
 	// dans la liste des attributs
 	bIsTargetAttributePartitioned = false;
@@ -256,19 +259,66 @@ boolean KWAttributeSubsetStats::ComputeStats(const KWTupleTable* tupleTable)
 	return bIsStatsComputed;
 }
 
-const ALString KWAttributeSubsetStats::GetSortName() const
+void KWAttributeSubsetStats::SetSortNameIndex(int nValue)
+{
+	require(nValue >= -1);
+	nSortNameIndex = nValue;
+}
+
+int KWAttributeSubsetStats::GetSortNameIndex() const
+{
+	return nSortNameIndex;
+}
+
+const ALString KWAttributeSubsetStats::BuildInterpretableName() const
 {
-	ALString sSortName;
+	ALString sInterpretableName;
 	int i;
 
 	// Calcul d'un nom par concatenation des noms des attributs
 	for (i = 0; i < GetAttributeNumber(); i++)
 	{
 		if (i > 0)
-			sSortName += "`";
-		sSortName += GetAttributeNameAt(i);
+			sInterpretableName += "`";
+		sInterpretableName += GetAttributeNameAt(i);
 	}
-	return sSortName;
+	return sInterpretableName;
+}
+
+const ALString KWAttributeSubsetStats::BuildNonInterpretableName() const
+{
+	const ALString sPairPrefix = "VariablePair";
+	const ALString sSubsetPrefix = "VariableSubset";
+	ALString sNonInterpretableName;
+	int i;
+
+	require(GetAttributeNumber() > 0);
+	require(GetSortNameIndex() >= 0);
+
+	// Cas univarie: on rend l'attribut tel quel
+	if (GetAttributeNumber() == 1)
+		sNonInterpretableName == GetAttributeNameAt(0);
+	// Cas multivarie
+	{
+		if (GetAttributeNumber() == 2)
+			sNonInterpretableName = sPairPrefix;
+		else
+			sNonInterpretableName = sSubsetPrefix;
+		if (GetSortNameIndex() > 0)
+		{
+			sNonInterpretableName += "_";
+			sNonInterpretableName += IntToString(GetSortNameIndex());
+		}
+	}
+	return sNonInterpretableName;
+}
+
+const ALString KWAttributeSubsetStats::GetSortName() const
+{
+	if (nSortNameIndex == -1)
+		return BuildInterpretableName();
+	else
+		return BuildNonInterpretableName();
 }
 
 double KWAttributeSubsetStats::GetSortValue() const
@@ -278,6 +328,11 @@ double KWAttributeSubsetStats::GetSortValue() const
 	return GetLevel();
 }
 
+const ALString KWAttributeSubsetStats::GetInterpretableName() const
+{
+	return BuildInterpretableName();
+}
+
 longint KWAttributeSubsetStats::GetUsedMemory() const
 {
 	longint lUsedMemory;
@@ -1505,6 +1560,7 @@ void PLShared_AttributeSubsetStats::SerializeObject(PLSerializer* serializer, co
 
 	// Serialisation des attributs (sauf classStats et oaDataGridStats)
 	serializer->PutStringVector(&attributeSubsetStats->svAttributeNames);
+	serializer->PutInt(attributeSubsetStats->nSortNameIndex);
 	serializer->PutBoolean(attributeSubsetStats->GetTargetAttributePartitioned());
 	serializer->PutInt(attributeSubsetStats->nMaxCellNumberConstraint);
 }
@@ -1521,6 +1577,7 @@ void PLShared_AttributeSubsetStats::DeserializeObject(PLSerializer* serializer,
 	// Deserialisation des attributs specifiques
 	attributeSubsetStats = cast(KWAttributeSubsetStats*, o);
 	serializer->GetStringVector(&attributeSubsetStats->svAttributeNames);
+	attributeSubsetStats->nSortNameIndex = serializer->GetInt();
 	attributeSubsetStats->SetTargetAttributePartitioned(serializer->GetBoolean());
 	attributeSubsetStats->nMaxCellNumberConstraint = serializer->GetInt();
 }

src/Learning/KWDataPreparation/KWAttributeSubsetStats.h

@@ -56,10 +56,29 @@ class KWAttributeSubsetStats : public KWDataPreparationStats
 	// Les attributs doivent etre initialises et leurs stats calculees
 	boolean ComputeStats(const KWTupleTable* tupleTable) override;
 
+	// Parametrage d'un index suffixe de nom de variable (SortName) dans le cas non interpretable
+	// Valeurs possible
+	// . -1: nom de variable interpretable (par defaut)
+	// . 0: nom de variable non-interpretable, sans index
+	// . >0: nom de variable non-interpretable, avec index en suffixe
+	void SetSortNameIndex(int nValue);
+	int GetSortNameIndex() const;
+
+	// Construction d'un nom interpretable a partir des nom des variables specifies
+	// Peut servir a genere ujn libelle en cas de nom de variable non-interpretable
+	const ALString BuildInterpretableName() const;
+
+	// Construction d'un nom non-interpretable a partir des nom des variables specifies et de l'index de nom
+	const ALString BuildNonInterpretableName() const;
+
 	// Redefinition des criteres de tri (le SortValue correspond a l'evaluation de la grille preparee)
+	// Le SortName est interpretable ou non selon le parametrage d'index du nom de variable
 	const ALString GetSortName() const override;
 	double GetSortValue() const override;
 
+	// Nom interpretable, potentiellement different du SortName
+	const ALString GetInterpretableName() const override;
+
 	// Memoire utilisee
 	longint GetUsedMemory() const override;
 
@@ -147,6 +166,9 @@ class KWAttributeSubsetStats : public KWDataPreparationStats
 	// Nom des attributs
 	StringVector svAttributeNames;
 
+	// Index du nom de variable
+	int nSortNameIndex;
+
 	// Specification du type d'apprentissage (partition de la cible ou pas)
 	// Indique si l'attribut cible fait partie des attributs du subset, et doit donc etre partitionne egalement
 	// Les cas suivants sont possibles:

src/Learning/KWDataPreparation/KWClassStats.h

@@ -42,7 +42,7 @@ class KWClassStats : public KWLearningReport
 	//  . Text: en exploitant les variable de type texte (Text ou TextList) presente dans le schema multi-table
 	//  . Tree: en combinant des variables au moyen des arbres
 	//  . 2D: en analysant des paires de variables
-	// De facon a maitriser la combinatoire des interaction possible et a facilite l'interpretabilite
+	// De facon a maitriser la combinatoire des interactions possibles et a facilite l'interpretabilite
 	// des modeles, les familles sont explote selon les relation suivantes:
 	//  . MultiTable et Text sont deux familles independantes (sans variable Text, ou uniquement les variables Text)
 	//    exploitant le schema multi-table

src/Learning/KWDataPreparation/KWDataPreparationBivariateTask.cpp

@@ -341,6 +341,8 @@ boolean KWDataPreparationBivariateTask::MasterAggregateResults()
 boolean KWDataPreparationBivariateTask::MasterFinalize(boolean bProcessEndedCorrectly)
 {
 	boolean bOk = true;
+	KWAttributePairStats* attributePairStats;
+	int i;
 
 	require(masterClassStats != NULL);
 
@@ -359,6 +361,17 @@ boolean KWDataPreparationBivariateTask::MasterFinalize(boolean bProcessEndedCorr
 		// Tri par nom, pour assurer la reproductibilite de l'ordre des resultats
 		oaMasterOutputAttributePairStats->SetCompareFunction(KWLearningReportCompareSortName);
 		oaMasterOutputAttributePairStats->Sort();
+
+		// Parametetrage si necessaire de noms de paires non interpretables
+		if (not KWClass::GetInterpretableNames())
+		{
+			for (i = 0; i < oaMasterOutputAttributePairStats->GetSize(); i++)
+			{
+				attributePairStats =
+				    cast(KWAttributePairStats*, oaMasterOutputAttributePairStats->GetAt(i));
+				attributePairStats->SetSortNameIndex(i + 1);
+			}
+		}
 	}
 	return bOk;
 }
@@ -732,7 +745,7 @@ void KWDataPreparationBivariateTask::ComputeTaskInputs()
 	GetAttributePairsSpec()->SelectAttributePairStats(masterClassStats->GetAttributeStats(),
 							  &oaInputAttributePairStats);
 
-	// Memorisation de toutes les stats univariees d'attributs impliquees dans les parires
+	// Memorisation de toutes les stats univariees d'attributs impliquees dans les paires
 	for (n = 0; n < oaInputAttributePairStats.GetSize(); n++)
 	{
 		attributePairStats = cast(KWAttributePairStats*, oaInputAttributePairStats.GetAt(n));

src/Learning/KWDataPreparation/KWLearningReport.cpp

@@ -106,7 +106,7 @@ int KWLearningReport::CompareValue(const KWLearningReport* otherReport) const
 	int nCompare;
 
 	// Comparaison selon la precison du type Continuous, pour eviter les differences a epsilon pres
-	nCompare = -KWContinuous::CompareIndicatorValue(1 + GetSortValue(), 1 + otherReport->GetSortValue());
+	nCompare = -KWContinuous::CompareIndicatorValue(GetSortValue(), otherReport->GetSortValue());
 
 	// En cas d'egalite, on se base sur le nom
 	if (nCompare == 0)
@@ -585,6 +585,12 @@ double KWDataPreparationStats::GetSortValue() const
 		return 0;
 }
 
+const ALString KWDataPreparationStats::GetInterpretableName() const
+{
+	require(IsStatsComputed());
+	return GetSortName();
+}
+
 void KWDataPreparationStats::CleanDataPreparationResults()
 {
 	if (preparedDataGridStats != NULL)

src/Learning/KWDataPreparation/KWLearningReport.h

@@ -180,6 +180,9 @@ class KWDataPreparationStats : public KWLearningReport
 	// comme dans le cas du DeltaLevel pour les paires
 	double GetSortValue() const override;
 
+	// Nom interpretable, par defaut egal a SortName
+	virtual const ALString GetInterpretableName() const;
+
 	/////////////////////////////////////////////////////////
 	// Structure des couts dans le cas de traitement MODL
 

src/Learning/KWModeling/KWDataPreparationClass.cpp

@@ -1134,8 +1134,8 @@ int KWDataPreparationAttributeCompareSortValue(const void* elem1, const void* el
 
 	// Comparaison si necessaire sur le nom
 	if (nCompare == 0)
-		nCompare = dataPreparationAttribute1->GetPreparedStats()->GetSortName().Compare(
-		    dataPreparationAttribute2->GetPreparedStats()->GetSortName());
+		nCompare = dataPreparationAttribute1->GetPreparedStats()->CompareName(
+		    dataPreparationAttribute2->GetPreparedStats());
 	return nCompare;
 }
 

src/Learning/KWModeling/KWDataPreparationClass.h

@@ -216,7 +216,7 @@ class KWDataPreparationAttribute : public Object
 	///////////////////////////////////////////////////////////////////////
 	// Services divers
 
-	// Calcul d'un nom decrivant le ou les attributs natifs (dans ce cas, les noms sont separes par "`")
+	// Calcul d'un nom decrivant le ou les attributs natifs
 	const ALString ComputeNativeAttributeName() const;
 
 	// Test de validite

src/Learning/KWModeling/KWPredictorDataGrid.cpp

@@ -93,7 +93,6 @@ int KWPredictorDataGrid::FillPredictorDataGridReport(ObjectArray* oaDataPreparat
 		dataGridReport->GetSelectedDataGridReports()->Add(selectedDataGridReport);
 		selectedDataGridReport->SetPreparedDataGridStats(
 		    dataPreparationAttribute->GetPreparedStats()->GetPreparedDataGridStats()->Clone());
-		selectedDataGridReport->SetSortName(dataPreparationAttribute->GetPreparedStats()->GetSortName());
 		selectedDataGridReport->SetUnivariateEvaluation(
 		    dataPreparationAttribute->GetPreparedStats()->GetSortValue());
 		if (cvWeights != NULL)
@@ -166,6 +165,10 @@ boolean KWPredictorDataGrid::InternalTrain()
 			attributeSubsetStats->SetAttributeNameAt(nAttribute, dataPreparationStats->GetSortName());
 		}
 
+		// Parametrage d'un nom de variable non interpretable si necessaire
+		if (not KWClass::GetInterpretableNames())
+			attributeSubsetStats->SetSortNameIndex(0);
+
 		// Preparation des donnees a charger
 		PrepareClassForLoad(oaTrainAttributeStats);
 
@@ -775,13 +778,13 @@ void KWSelectedDataGridReport::WriteReport(ostream& ost)
 	preparedDataGridStats->WritePartial(ost, true, preparedDataGridStats->GetSourceAttributeNumber() == 0);
 }
 
-void KWSelectedDataGridReport::SetSortName(const ALString sValue)
-{
-	sSortName = sValue;
-}
-
 const ALString KWSelectedDataGridReport::GetSortName() const
 {
+	ALString sSortName;
+
+	require(preparedDataGridStats != NULL);
+
+	sSortName = preparedDataGridStats->ExportVariableNames();
 	return sSortName;
 }
 

src/Learning/KWModeling/KWPredictorDataGrid.h

@@ -169,9 +169,6 @@ class KWSelectedDataGridReport : public KWLearningReport
 	// Ecriture d'un rapport
 	void WriteReport(ostream& ost) override;
 
-	// Parametrage du nom
-	void SetSortName(const ALString sValue);
-
 	// Redefinition des criteres de tri pour trier les grilles d'un classifieur
 	const ALString GetSortName() const override;
 	double GetSortValue() const override;
@@ -182,5 +179,4 @@ class KWSelectedDataGridReport : public KWLearningReport
 	double dUnivariateEvaluation;
 	double dWeight;
 	KWDataGridStats* preparedDataGridStats;
-	ALString sSortName;
 };

src/Learning/MODL/MODL.cpp

@@ -34,9 +34,9 @@ int main(int argc, char** argv)
 	Global::ActivateSignalErrorManagement();
 
 	// Choix du repertoire de lancement pour le debugage sous Windows (a commenter apres fin du debug)
-	// SetWindowsDebugDir("Standard", "IrisLight");
+	SetWindowsDebugDir("Standard", "IrisLight");
 	// SetWindowsDebugDir("Standard", "Iris2D");
-	SetWindowsDebugDir("TextVariables", "BuildNonInterpretablePairNames");
+	// SetWindowsDebugDir("TextVariables", "BuildNonInterpretableNames");
 
 	// Parametrage des logs memoires depuis les variables d'environnement, pris en compte dans KWLearningProject
 	//   KhiopsMemStatsLogFileName, KhiopsMemStatsLogFrequency, KhiopsMemStatsLogToCollect