WIP step 2

CCCoclusteringBuilder::HandleOptimizationStep
- correction sur les infos de taille du coclustering dans le log

KWDataGridManager::ComputeGranularizedTotalPartNumbers
- nouvelle methode de comptage des nombretotaux de partie par granularite

src/Learning/KWDataPreparation/KWDataGridManager.cpp

@@ -634,6 +634,7 @@ void KWDataGridManager::ExportGranularizedDataGridForVarPartAttributes(
 	require(targetDataGrid != NULL and targetDataGrid->IsEmpty());
 	require(nGranularity > 0);
 	require(sourceDataGrid->IsVarPartDataGrid());
+	require(odInnerAttributesQuantilesBuilders != NULL);
 	require(odInnerAttributesQuantilesBuilders->GetCount() ==
 		sourceDataGrid->GetInnerAttributes()->GetInnerAttributeNumber());
 
@@ -688,6 +689,70 @@ void KWDataGridManager::ExportGranularizedDataGridForVarPartAttributes(
 		   sourceDataGrid->GetVarPartAttribute()->GetInnerAttributes());
 }
 
+void KWDataGridManager::ComputeGranularizedTotalPartNumbers(const ObjectDictionary* odQuantilesBuilders,
+							    IntVector* ivGranularityTotalPartNumbers) const
+{
+	boolean bDisplay = true;
+	KWQuantileBuilder* quantileBuilder;
+	ObjectArray oaQuantilesBuilders;
+	int nAttribute;
+	int nGranularity;
+	int nPartileNumber;
+	int nActualPartileNumber;
+	int nTotalActualPartileNumber;
+	boolean bMaximumQuantilization;
+
+	require(odQuantilesBuilders != NULL);
+	require(odQuantilesBuilders->GetCount() > 0);
+	require(ivGranularityTotalPartNumbers != NULL);
+
+	// Export des quantile builder dans un tableau
+	odQuantilesBuilders->ExportObjectArray(&oaQuantilesBuilders);
+	if (bDisplay)
+		cout << "ComputeGranularizedTotalPartNumbers\t" << odQuantilesBuilders->GetCount() << "\n";
+
+	// Parcours des quantile builders pour calculer les nombre totaux de partie
+	ivGranularityTotalPartNumbers->SetSize(0);
+	nGranularity = 0;
+	bMaximumQuantilization = false;
+	while (not bMaximumQuantilization)
+	{
+		// Nombre de partiles theoriques
+		nPartileNumber = (int)pow(2, nGranularity);
+
+		// Parcours des attributs a quantilser
+		bMaximumQuantilization = true;
+		nTotalActualPartileNumber = 0;
+		for (nAttribute = 0; nAttribute < oaQuantilesBuilders.GetSize(); nAttribute++)
+		{
+			quantileBuilder = cast(KWQuantileBuilder*, oaQuantilesBuilders.GetAt(nAttribute));
+
+			// Calcul du nombre effectif de quantiles
+			// (peut etre inferieur au nombre theorique du fait de doublons)
+			nActualPartileNumber = quantileBuilder->ComputeQuantiles(nPartileNumber);
+
+			// Mise a jour du total
+			nTotalActualPartileNumber += nActualPartileNumber;
+
+			// On test si on a atteint le maximum
+			bMaximumQuantilization =
+			    bMaximumQuantilization and nActualPartileNumber == quantileBuilder->GetValueNumber();
+		}
+
+		// Memorisation du total
+		ivGranularityTotalPartNumbers->Add(nTotalActualPartileNumber);
+		assert(ivGranularityTotalPartNumbers->GetSize() == nGranularity + 1);
+		assert(nGranularity == 0 or ivGranularityTotalPartNumbers->GetAt(nGranularity) >=
+						ivGranularityTotalPartNumbers->GetAt(nGranularity - 1));
+		if (bDisplay)
+			cout << "\t" << nGranularity << "\t" << ivGranularityTotalPartNumbers->GetAt(nGranularity)
+			     << "\n";
+
+		// Granularite suivante
+		nGranularity++;
+	}
+}
+
 void KWDataGridManager::ExportFrequencyTableFromOneAttribute(KWFrequencyTable* kwFrequencyTable,
 							     const ALString& sAttributeName) const
 {

src/Learning/KWDataPreparation/KWDataGridManager.h

@@ -155,7 +155,7 @@ class KWDataGridManager : public Object
 	// En sortie, le vecteur ivMaxPartNumbers contient pour chaque attribut le nombre maximal
 	// de parties attendu apres granularisation
 	// Pour un attribut numerique, il s'agit du nombre de valeurs distinctes
-	// Pour un attribut categoriel,  il s'agit du nombre de parties dont l'effectif est > 1,
+	// Pour un attribut categoriel, il s'agit du nombre de parties dont l'effectif est > 1,
 	// plus une partie en presence de singletons
 	void InitializeQuantileBuilders(ObjectDictionary* odQuantilesBuilders, IntVector* ivMaxPartNumbers) const;
 
@@ -176,6 +176,15 @@ class KWDataGridManager : public Object
 	    KWDataGrid* targetDataGrid, int nGranularity,
 	    const ObjectDictionary* odInnerAttributesQuantilesBuilders) const;
 
+	// Calcul des nombres total de parties reel pour chaque niveau de granularisation
+	// En entree, on a un dictionnaire de quantile builders pour un ensemble d'attribut, de grille ou internes.
+	// En sortie, le vecteur contient pour chaque granularite i de 0 a max la somme des nombres de parties
+	// effectivement obtenus par attributs quand on demande 2^i partiles.
+	// Le max est detremine par la methode, en s'arretant quand a la granularite permettant d'obtenir
+	// le total de parties des quantile buyilders
+	void ComputeGranularizedTotalPartNumbers(const ObjectDictionary* odQuantilesBuilders,
+						 IntVector* ivGranularityTotalPartNumbers) const;
+
 	////////////////////////////////////////////////////////////////////////////////////////////
 	// Services avances de construction de grille
 

src/Learning/MODL_Coclustering/CCCoclusteringBuilder.cpp

@@ -349,7 +349,7 @@ boolean CCCoclusteringBuilder::CheckVarPartSpecifications() const
 boolean CCCoclusteringBuilder::ComputeCoclustering()
 {
 	boolean bOk = true;
-	boolean bProfileOptimisation = false;
+	boolean bProfileOptimisation = true;
 	KWTupleTable tupleTable;
 	KWTupleTable tupleFrequencyTable;
 	KWDataGridOptimizer dataGridOptimizer;
@@ -1138,6 +1138,11 @@ void CCCoclusteringBuilder::PROTO_OptimizeVarPartDataGrid(const KWDataGrid* inpu
 	dataGridManager.InitializeInnerAttributesQuantileBuilders(&odInnerAttributesQuantileBuilders,
 								  &ivMaxPartNumbers);
 
+	//DDD
+	//IntVector ivGranularityTotalPartNumbers;
+	//dataGridManager.ComputeGranularizedTotalPartNumbers(&odInnerAttributesQuantileBuilders,
+	//						    &ivGranularityTotalPartNumbers);
+
 	if (bDisplayPrePartitioning)
 	{
 		cout << "ivMaxPartNumbers\t" << ivMaxPartNumbers;
@@ -2185,15 +2190,12 @@ void CCCoclusteringBuilder::HandleOptimizationStep(const KWDataGrid* optimizedDa
 		dLevel = 1 - dAnyTimeBestCost / dAnyTimeDefaultCost;
 
 		// Calcul d'un libelle sur la taille de la grille (nombre de parties par dimension)
-		for (nAttribute = 0; nAttribute < GetAttributeNumber(); nAttribute++)
+		for (nAttribute = 0; nAttribute < coclusteringDataGrid->GetAttributeNumber(); nAttribute++)
 		{
-			dgAttribute = coclusteringDataGrid->SearchAttribute(GetAttributeNameAt(nAttribute));
+			dgAttribute = coclusteringDataGrid->GetAttributeAt(nAttribute);
 			if (nAttribute > 0)
 				sCoclusteringSizeInfo += "*";
-			if (dgAttribute == NULL)
-				sCoclusteringSizeInfo += "1";
-			else
-				sCoclusteringSizeInfo += IntToString(dgAttribute->GetPartNumber());
+			sCoclusteringSizeInfo += IntToString(dgAttribute->GetPartNumber());
 		}
 
 		// Cas d'une grille individu * variable; ajout d'infos la partition des attributs
@@ -2221,7 +2223,7 @@ void CCCoclusteringBuilder::HandleOptimizationStep(const KWDataGrid* optimizedDa
 			}
 
 			// Granularite de tokenisation des attributs internes
-			sCoclusteringSizeInfo += "\tTokenization:";
+			sCoclusteringSizeInfo += "\tTokenization: ";
 			sCoclusteringSizeInfo +=
 			    IntToString(coclusteringDataGrid->GetInnerAttributes()->GetVarPartGranularity());
 		}