diff --git a/src/Learning/KWData/KWCYac.cpp b/src/Learning/KWData/KWCYac.cpp
index d8b3dd6b0..de868a771 100644
--- a/src/Learning/KWData/KWCYac.cpp
+++ b/src/Learning/KWData/KWCYac.cpp
@@ -1,3 +1,7 @@
+// Copyright (c) 2023 Orange. All rights reserved.
+// This software is distributed under the BSD 3-Clause-clear License, the text of which is available
+// at https://spdx.org/licenses/BSD-3-Clause-Clear.html or see the "LICENSE" file for more details.
+
 /* A Bison parser, made by GNU Bison 3.8.2.  */
 
 /* Bison implementation for Yacc-like parsers in C
@@ -112,8 +116,8 @@ static int nFileParsingErrorNumber = 0;
 /* Debugging YAC */
 
 /*
-#define YYDEBUG 1 
-extern char   *yyptok(int i); 
+#define YYDEBUG 1
+extern char   *yyptok(int i);
 */
 
 #line 127 "KWCYac.cpp"
diff --git a/src/Learning/KWDataPreparation/KWDataGrid.cpp b/src/Learning/KWDataPreparation/KWDataGrid.cpp
index 9e46e24ba..4690ee064 100644
--- a/src/Learning/KWDataPreparation/KWDataGrid.cpp
+++ b/src/Learning/KWDataPreparation/KWDataGrid.cpp
@@ -4388,7 +4388,7 @@ boolean KWDGValueSet::Check() const
 				bOk = false;
 				break;
 			}
-			// Erreur si typivcalite incorrecte
+			// Erreur si typicalite incorrecte
 			else if (value->GetTypicality() < 0 or value->GetTypicality() > 1)
 			{
 				AddError(sTmp + value->GetClassLabel() + " " + value->GetObjectLabel() +
diff --git a/src/Learning/KWDataPreparation/KWDataGrid.h b/src/Learning/KWDataPreparation/KWDataGrid.h
index 259eea0ab..f27044a07 100644
--- a/src/Learning/KWDataPreparation/KWDataGrid.h
+++ b/src/Learning/KWDataPreparation/KWDataGrid.h
@@ -51,13 +51,13 @@ class KWDGInnerAttributes;
 //        - un attribut de la grille peut etre soit numerique, soit categoriel, soit constitue de parties de variables
 //        - dans la these d'Aichetou
 //          - dedie au cas instances x variables
-//          - chaque variables descriptives est partitionnees en parties, intervalles ou groupes de valeurs
+//          - chaque variable descriptive est partitionnee en parties, intervalles ou groupes de valeurs
 //          - chaque partie de variable est l'analogue d'un mot
-//          - chaque instance est decrites par l'ensmeble des mots correspondant aux valeurs de ses variables
+//          - chaque instance est decrite par l'ensemble des mots correspondant aux valeurs de ses variables
 //          descriptives
-//        - on a une grille à deux dimension, analogue au cas d'une grille textes x mots
+//        - on a une grille à deux dimensions, analogue au cas d'une grille textes x mots
 //          - un attribut de la grille contient des groupes d'instances (textes), par leur identifiant
-//          - l'autre attribut de la grille contients des groupes de parties de variables (mots)
+//          - l'autre attribut de la grille contient des groupes de parties de variables (mots)
 //      - terminologie
 //         VarPart
 //           - nouveau type, pour un attribut de DataGrid
@@ -520,10 +520,11 @@ class KWDGAttribute : public Object
 	// Attribut continu : nombre total d'instances
 	// Attribut categoriel : nombre de valeurs distinctes (sans la StarValue)
 	// Attribut parties de variables : nombre de parties de variables distinctes
+	// CH IV Refactoring  : le nombre de PV distinctes depend du niveau de tokenisation, pour les innerAttributes et pour l'attribut VarPart
 	void SetInitialValueNumber(int nValue);
 	int GetInitialValueNumber() const;
 
-	// Nomre de valeurs apres granularisation
+	// Nombre de valeurs apres granularisation
 	// Attribut continu : nombre theorique de partiles Ng=2^G
 	// Attribute categoriel : nombre de partiles obtenus suite a la granularisation Vg
 	void SetGranularizedValueNumber(int nValue);
@@ -540,7 +541,6 @@ class KWDGAttribute : public Object
 	// Initialisation des parties de l'attribut de type VarPart a partir des attributs internes initialises en
 	// creant une partie par partie de variable
 	void CreateVarPartsSet();
-	// CH IV End
 
 	////////////////////////////////////////////////
 	// Gestion des parties de l'attribut
diff --git a/src/Learning/KWDataPreparation/KWDataGridManager.cpp b/src/Learning/KWDataPreparation/KWDataGridManager.cpp
index 113828d81..bcaa959f5 100644
--- a/src/Learning/KWDataPreparation/KWDataGridManager.cpp
+++ b/src/Learning/KWDataPreparation/KWDataGridManager.cpp
@@ -293,6 +293,69 @@ void KWDataGridManager::ExportNullDataGrid(KWDataGrid* targetDataGrid) const
 		   sourceDataGrid->GetVarPartAttribute()->GetInnerAttributes());
 }
 
+void KWDataGridManager::ExportDataGridWithRandomizedInnerAttributes(const KWDataGrid* inputDataGrid,
+								    const KWDGInnerAttributes* referenceInnerAttributes,
+								    KWDataGrid* targetDataGrid, int nTargetTokenNumber)
+{
+	int nCurrentTokenNumber;
+	int nReferenceTokenNumber;
+	int nAttribute;
+	KWDGAttribute* targetAttribute;
+	KWDGAttribute* sourceAttribute;
+	KWDGInnerAttributes* surtokenizedInnerAttributes;
+
+	require(Check());
+	require(targetDataGrid != NULL and targetDataGrid->IsEmpty());
+	require(sourceDataGrid->IsVarPartDataGrid());
+
+	// Nombre de tokens de la grille en entree
+	nCurrentTokenNumber =
+	    inputDataGrid->GetVarPartAttribute()->GetInnerAttributes()->ComputeTotalInnerAttributeVarParts();
+
+	// Nombre de tokens des innerAttributes de reference
+	nReferenceTokenNumber = referenceInnerAttributes->ComputeTotalInnerAttributeVarParts();
+
+	assert(nReferenceTokenNumber > nCurrentTokenNumber);
+
+	// Cas ou le nombre de tokens objectif est inferieur au nombre de tokens en entree : recopie de la grille en entree a l'identique
+	// Cas ou le nombre de tokens de la partition de reference est inferieur au nombre de tokens en entree : pas de sur-tokenisation possible
+	if (nTargetTokenNumber <= nCurrentTokenNumber or nReferenceTokenNumber < nCurrentTokenNumber)
+		CopyDataGrid(inputDataGrid, targetDataGrid);
+	// Sinon
+	else
+	{
+		// Export des attributs (avec innerAtributes non surtokenises a ce stade)
+		ExportAttributes(targetDataGrid);
+
+		// Initialisation des parties des attributs
+		for (nAttribute = 0; nAttribute < targetDataGrid->GetAttributeNumber(); nAttribute++)
+		{
+			targetAttribute = targetDataGrid->GetAttributeAt(nAttribute);
+
+			// Recherche de l'attribut source correspondant
+			sourceAttribute = sourceDataGrid->SearchAttribute(targetAttribute->GetAttributeName());
+			check(sourceAttribute);
+
+			// Pour un attribut simple, export des parties
+			if (KWType::IsSimple(sourceAttribute->GetAttributeType()))
+				InitialiseAttributeParts(sourceAttribute, targetAttribute);
+			// Pour l'attribut VarPart, export des parties apres surtokenisation des attributs internes
+			else
+			{
+				// Creation d'un nouveau KWDGInnerAttributes surtokenise
+				surtokenizedInnerAttributes = CreateRandomInnerAttributes(
+				    inputDataGrid->GetInnerAttributes(), GetSourceDataGrid()->GetInnerAttributes(),
+				    nTargetTokenNumber);
+
+				// Creation de l'attribut VarPart associe a ces innerAttributes selon la meme partition que l'attribut en entree
+				InitialiseVarPartAttributeWithNewInnerAttributes(
+				    inputDataGrid->GetVarPartAttribute(), surtokenizedInnerAttributes, targetAttribute);
+			}
+		}
+		ExportCells(targetDataGrid);
+	}
+}
+
 void KWDataGridManager::InitializeQuantileBuilders(ObjectDictionary* odQuantilesBuilders,
 						   IntVector* ivMaxPartNumbers) const
 {
@@ -1006,7 +1069,7 @@ void KWDataGridManager::ExportDataGridWithReferenceVarPartClusters(KWDataGrid* r
 	initialAttribute = sourceDataGrid->GetVarPartAttribute();
 	referenceAttribute = referenceDataGrid->GetVarPartAttribute();
 
-	// Initialisation du vecteur d'index de grpupe cible
+	// Initialisation du vecteur d'index de groupe cible
 	ivTargetGroupIndexes.SetSize(initialAttribute->GetPartNumber());
 	nTargetGroupNumber = referenceAttribute->GetPartNumber();
 
@@ -1080,7 +1143,7 @@ void KWDataGridManager::ExportDataGridWithReferenceVarPartClusters(KWDataGrid* r
 	}
 
 	// Mise a jour de la grille cible sur la base de la nouvelle partition specifiee
-	// Les cellule sont reexportee par la methode appelee
+	// Les cellules sont reexportees par la methode appelee
 	UpdateVarPartDataGridFromVarPartGroups(targetDataGrid, &ivTargetGroupIndexes, nTargetGroupNumber);
 
 	ensure(targetDataGrid->GetVarPartAttribute()->GetInnerAttributes() ==
@@ -2710,7 +2773,7 @@ void KWDataGridManager::InitialiseAttributeParts(const KWDGAttribute* sourceAttr
 			targetAttribute->SetGarbagePart(targetPart);
 
 		// Memorisation de l'effectif de la partie pour les attribut internes
-		// Pour les autre attribut, c'es calcule a partir des cellules
+		// Pour les autre attributs, c'es calcule a partir des cellules
 		if (sourceAttribute->IsInnerAttribute())
 			targetPart->SetPartFrequency(sourcePart->GetPartFrequency());
 
@@ -2787,6 +2850,107 @@ void KWDataGridManager::InitialiseVarPartAttributeClonedParts(const KWDGAttribut
 	assert(targetAttribute->GetPartNumber() == sourceAttribute->GetPartNumber());
 }
 
+void KWDataGridManager::InitialiseVarPartAttributeWithNewInnerAttributes(const KWDGAttribute* sourceVarPartAttribute,
+									 KWDGInnerAttributes* newInnerAttributes,
+									 KWDGAttribute* targetVarPartAttribute) const
+{
+	ObjectArray oaSourceInnerAttributeVarParts;
+	ObjectArray oaNewInnerAttributeVarParts;
+	ObjectArray* oaVarPart;
+	NumericKeyDictionary nkdTargetInnerAttributeVarParts;
+	int nSourceIndex;
+	int nTargetIndex;
+	KWDGPart* sourcePart;
+	KWDGPart* targetPart;
+	KWDGPart* sourceVarPart;
+	KWDGPart* targetVarPart;
+	KWDGValue* sourceValue;
+	boolean bOk;
+	boolean bDisplayResults = false;
+
+	require(CheckAttributesConsistency(sourceVarPartAttribute, targetVarPartAttribute));
+	require(targetVarPartAttribute->GetAttributeType() == KWType::VarPart);
+	require(targetVarPartAttribute->GetPartNumber() == 0);
+
+	targetVarPartAttribute->SetInnerAttributes(newInnerAttributes);
+	targetVarPartAttribute->SetVarPartsShared(false);
+
+	// Memorisation de l'association entre VarPart source et une a plusieurs VarParts dans les nouveaux innerAttributes
+	sourceVarPartAttribute->GetInnerAttributes()->ExportAllInnerAttributeVarParts(&oaSourceInnerAttributeVarParts);
+	newInnerAttributes->ExportAllInnerAttributeVarParts(&oaNewInnerAttributeVarParts);
+	nTargetIndex = 0;
+	for (nSourceIndex = 0; nSourceIndex < oaSourceInnerAttributeVarParts.GetSize(); nSourceIndex++)
+	{
+		sourceVarPart = cast(KWDGPart*, oaSourceInnerAttributeVarParts.GetAt(nSourceIndex));
+
+		oaVarPart = new ObjectArray;
+		bOk = true;
+		while (bOk and nTargetIndex < oaNewInnerAttributeVarParts.GetSize())
+		{
+			targetVarPart = cast(KWDGPart*, oaNewInnerAttributeVarParts.GetAt(nTargetIndex));
+
+			if (targetVarPart->GetAttribute()->GetAttributeName() ==
+				sourceVarPart->GetAttribute()->GetAttributeName() and
+			    targetVarPart->IsSubPart(sourceVarPart))
+			{
+				oaVarPart->Add(targetVarPart);
+				nTargetIndex++;
+			}
+			else
+				bOk = false;
+		}
+
+		nkdTargetInnerAttributeVarParts.SetAt(sourceVarPart, oaVarPart);
+	}
+
+	// Recopie des parties de l'attribut source, en utilisant les VarPartCibles
+	sourcePart = sourceVarPartAttribute->GetHeadPart();
+	while (sourcePart != NULL)
+	{
+		// Creation de la partie cible
+		targetPart = targetVarPartAttribute->AddPart();
+
+		// Transfert des parties de parties de variable avec de nouvelles parties de variable
+		sourceValue = sourcePart->GetVarPartSet()->GetHeadValue();
+		while (sourceValue != NULL)
+		{
+			sourceVarPart = sourceValue->GetVarPart();
+
+			// Memorisation de la partie cible correspondante
+			oaVarPart = cast(ObjectArray*, nkdTargetInnerAttributeVarParts.Lookup(sourceVarPart));
+			for (nTargetIndex = 0; nTargetIndex < oaVarPart->GetSize(); nTargetIndex++)
+			{
+				targetPart->GetVarPartSet()->AddVarPart(
+				    cast(KWDGPart*, oaVarPart->GetAt(nTargetIndex)));
+			}
+
+			// Ajout de cette partie pour l'attribut interne
+			sourcePart->GetVarPartSet()->GetNextValue(sourceValue);
+		}
+
+		// Transfert du parametrage du groupe poubelle
+		if (sourcePart == sourceVarPartAttribute->GetGarbagePart())
+			targetVarPartAttribute->SetGarbagePart(targetPart);
+
+		// Partie suivante
+		sourceVarPartAttribute->GetNextPart(sourcePart);
+	}
+
+	// Affichage des resultats
+	if (bDisplayResults)
+	{
+		cout << "InitialiseVarPartAttribute" << endl;
+		cout << "Attribut varPart input" << endl;
+		sourceVarPartAttribute->Write(cout);
+		cout << "Attribut varPart surtokenise" << endl;
+		targetVarPartAttribute->Write(cout);
+	}
+
+	// Nettoyage
+	nkdTargetInnerAttributeVarParts.DeleteAll();
+	assert(targetVarPartAttribute->GetPartNumber() == sourceVarPartAttribute->GetPartNumber());
+}
+
 void KWDataGridManager::InitialiseAttributeNullPart(const KWDGAttribute* sourceAttribute,
 						    KWDGAttribute* targetAttribute) const
 {
@@ -2878,6 +3042,12 @@ void KWDataGridManager::InitialiseAttributeRandomParts(const KWDGAttribute* sour
 
 				// Initialisation de ses bornes
 				targetPart->GetInterval()->CopyFrom(sourcePart->GetInterval());
+
+				// CH IV Surtokenisation
+				// Mise a jour des effectifs dans le cas d'un innerAttribute
+				if (sourceAttribute->IsInnerAttribute())
+					targetPart->SetPartFrequency(targetPart->GetPartFrequency() +
+								     sourcePart->GetPartFrequency());
 			}
 			// Sinon, mise a jour de la borne sup de l'intervalle cible en cours
 			else
@@ -2961,6 +3131,12 @@ void KWDataGridManager::InitialiseAttributeRandomParts(const KWDGAttribute* sour
 					targetPart->GetValueSet()->UpgradeFrom(sourcePart->GetValueSet());
 				}
 
+				// CH IV Surtokenisation
+				// Mise a jour des effectifs dans le cas d'un innerAttribute
+				if (sourceAttribute->IsInnerAttribute())
+					targetPart->SetPartFrequency(targetPart->GetPartFrequency() +
+								     sourcePart->GetPartFrequency());
+
 				// La partie cible est valide si son nombre de partie sources est atteint
 				if (nTargetPart < ivValueIndexes.GetSize() and
 				    nSourcePart >= ivValueIndexes.GetAt(nTargetPart))
@@ -2971,6 +3147,11 @@ void KWDataGridManager::InitialiseAttributeRandomParts(const KWDGAttribute* sour
 					targetPart = NULL;
 				}
 			}
+
+			// CH IV Surtokenisation
+			if (sourceAttribute->IsInnerAttribute())
+				targetAttribute->SortParts();
+
 			assert(targetAttribute->GetPartNumber() == ivValueIndexes.GetSize() + 1);
 		}
 	}
@@ -3064,6 +3245,12 @@ void KWDataGridManager::AddAttributeRandomParts(const KWDGAttribute* sourceAttri
 
 				// Reinitialisation de ses bornes
 				targetPart->GetInterval()->CopyFrom(sourcePart->GetInterval());
+
+				// CH IV Surtokenisation
+				// Mise a jour des effectifs dans le cas d'un innerAttribute
+				if (sourceAttribute->IsInnerAttribute())
+					targetPart->SetPartFrequency(targetPart->GetPartFrequency() +
+								     sourcePart->GetPartFrequency());
 			}
 			// Sinon, mise a jour de la borne sup de l'intervalle cible en cours
 			else
@@ -3151,6 +3338,12 @@ void KWDataGridManager::AddAttributeRandomParts(const KWDGAttribute* sourceAttri
 					targetPart->GetValueSet()->UpgradeFrom(sourcePart->GetValueSet());
 				}
 
+				// CH IV Surtokenisation
+				// Mise a jour des effectifs dans le cas d'un innerAttribute
+				if (sourceAttribute->IsInnerAttribute())
+					targetPart->SetPartFrequency(targetPart->GetPartFrequency() +
+								     sourcePart->GetPartFrequency());
+
 				// La partie cible est valide si elle finalise une partie mandatorye
 				if (nSourcePart == oaSourceParts.GetSize() - 1 or
 				    mandatoryPart != cast(KWDGPart*, oaMandatoryParts.GetAt(nSourcePart + 1)))
@@ -3169,6 +3362,11 @@ void KWDataGridManager::AddAttributeRandomParts(const KWDGAttribute* sourceAttri
 					targetPart = NULL;
 				}
 			}
+
+			// CH IV Surtokenisation
+			if (sourceAttribute->IsInnerAttribute())
+				targetAttribute->SortParts();
+
 			assert(targetAttribute->GetPartNumber() >= mandatoryAttribute->GetPartNumber());
 		}
 	}
@@ -3444,7 +3642,8 @@ boolean KWDataGridManager::CheckAttributesConsistency(const KWDGAttribute* attri
 	bOk = bOk and attribute1->GetAttributeName() == attribute2->GetAttributeName();
 	bOk = bOk and attribute1->GetAttributeType() == attribute2->GetAttributeType();
 	bOk = bOk and attribute1->GetAttributeTargetFunction() == attribute2->GetAttributeTargetFunction();
-	bOk = bOk and attribute1->GetInitialValueNumber() == attribute2->GetInitialValueNumber();
+	bOk = bOk and (attribute1->GetAttributeType() == KWType::VarPart or
+		       attribute1->GetInitialValueNumber() == attribute2->GetInitialValueNumber());
 	bOk = bOk and attribute1->GetOwnerAttributeName() == attribute2->GetOwnerAttributeName();
 	bOk = bOk and attribute1->GetCost() == attribute2->GetCost();
 	return bOk;
@@ -3473,7 +3672,7 @@ KWDGInnerAttributes* KWDataGridManager::CloneInnerAttributes(const KWDGInnerAttr
 		// Extraction de l'attribut internes source
 		sourceInnerAttribute = sourceInnerAttributes->GetInnerAttributeAt(nInnerAttribute);
 
-		// Creation d'un attribut interne identique en exploitant le createur virtuelle de la grille cibke en parametre
+		// Creation d'un attribut interne identique en exploitant le createur virtuelle de la grille cible en parametre
 		targetInnerAttribute = targetDataGrid->NewAttribute();
 
 		// Parametrage
@@ -3593,6 +3792,84 @@ KWDataGridManager::CreateGranularizedInnerAttributes(const KWDGInnerAttributes*
 	return resultInnerAttributes;
 }
 
+KWDGInnerAttributes* KWDataGridManager::CreateRandomInnerAttributes(const KWDGInnerAttributes* sourceInnerAttributes,
+								    const KWDGInnerAttributes* referenceInnerAttributes,
+								    int nTargetTokenNumber) const
+{
+	KWDGInnerAttributes* resultInnerAttributes;
+	int nInnerAttribute;
+	KWDGAttribute* sourceInnerAttribute;
+	KWDGAttribute* targetInnerAttribute;
+	KWDGAttribute* referenceInnerAttribute;
+	int nRequestedTotalPartNumber;
+	int nRequestedPartNumber;
+	int nAddedPartNumber;
+	int nMeanRequestedPartNumber;
+	boolean bDisplayResults = false;
+
+	// Creation du nouvel innerAttributes
+	resultInnerAttributes = new KWDGInnerAttributes;
+	resultInnerAttributes->SetVarPartGranularity(sourceInnerAttributes->GetVarPartGranularity());
+
+	// Nombre de tokens que l'on doit ajouter sur l'ensemble des attributs
+	nRequestedTotalPartNumber = nTargetTokenNumber - sourceInnerAttributes->ComputeTotalInnerAttributeVarParts();
+
+	// Nombre de tokens que l'on devrait ajouter en moyenne a chaque innerAttribute
+	nMeanRequestedPartNumber =
+	    (int)ceil(nRequestedTotalPartNumber / sourceInnerAttributes->GetInnerAttributeNumber());
+
+	// Initialisation du nombre de tokens effectivement ajoute
+	nAddedPartNumber = 0;
+	nInnerAttribute = 0;
+
+	// Ajout de tokens aux innerAttributes
+	// Boucle sur les innerAttributes
+	for (nInnerAttribute = 0; nInnerAttribute < sourceInnerAttributes->GetInnerAttributeNumber(); nInnerAttribute++)
+	{
+		sourceInnerAttribute = sourceInnerAttributes->GetInnerAttributeAt(nInnerAttribute);
+		referenceInnerAttribute = referenceInnerAttributes->GetInnerAttributeAt(nInnerAttribute);
+
+		// Creation d'un attribut interne
+		targetInnerAttribute = new KWDGAttribute;
+
+		// Parametrage
+		InitialiseAttribute(sourceInnerAttribute, targetInnerAttribute);
+		resultInnerAttributes->AddInnerAttribute(targetInnerAttribute);
+
+		// Calcul du nombre de tokens a ajoute pour cet attribut en fonctionn des tokens deja attribues et du nombre cible a ne pas depasser
+		nRequestedPartNumber = min(nMeanRequestedPartNumber, nTargetTokenNumber - nAddedPartNumber);
+
+		if (nAddedPartNumber < nTargetTokenNumber)
+		{
+			if (nRequestedPartNumber == 0)
+				nRequestedPartNumber++;
+			// Ajout de parties aleatoires
+			AddAttributeRandomParts(referenceInnerAttribute, sourceInnerAttribute, targetInnerAttribute,
+						nRequestedPartNumber);
+		}
+		else
+			// Recopie de l'attribut
+			InitialiseAttributeParts(sourceInnerAttribute, targetInnerAttribute);
+
+		// Mise a jour du nombre de parties ajoutees
+		nAddedPartNumber += targetInnerAttribute->GetPartNumber() - sourceInnerAttribute->GetPartNumber();
+	}
+
+	// Affichage des innerAttributes
+	if (bDisplayResults)
+	{
+		cout << "CreateRandomInnerAttributes : sortie" << endl;
+		cout << "Inner attributes source" << endl;
+		sourceInnerAttributes->Write(cout);
+		cout << "Inner attributes reference" << endl;
+		referenceInnerAttributes->Write(cout);
+		cout << "Inner attributes surtokenise\t" << nTargetTokenNumber << endl;
+		resultInnerAttributes->Write(cout);
+	}
+
+	return resultInnerAttributes;
+}
+
 double KWDataGridManager::MergePartsForVarPartAttributes(KWDataGrid* targetDataGrid) const
 {
 	KWDGAttribute* sourceVarPartAttribute;
diff --git a/src/Learning/KWDataPreparation/KWDataGridManager.h b/src/Learning/KWDataPreparation/KWDataGridManager.h
index 63703fd5d..1a23e8e56 100644
--- a/src/Learning/KWDataPreparation/KWDataGridManager.h
+++ b/src/Learning/KWDataPreparation/KWDataGridManager.h
@@ -70,7 +70,7 @@ class KWDataGridManager : public Object
 						 boolean bSourceSimpleAttributeParts) const;
 
 	// Export total (attribut, parties et cellules) en exploitant une grille de reference,
-	// avec des partie de VarPart de la grille source, exploitant la partition de la grille de refere
+	// avec des partie de VarPart de la grille source, exploitant la partition de la grille de reference
 	// Cette grille de reference n'a pas les memes VarParts que la grille source, alors que la grille en sortie
 	// reutilise les VarPart de la grille source
 	void ExportDataGridWithReferenceVarPartClusters(KWDataGrid* referenceDataGrid, KWDataGrid* targetDataGrid);
@@ -84,6 +84,35 @@ class KWDataGridManager : public Object
 	// Attention: creation de nouveaux attributs internes qui doivent etre detruit par l'appelant
 	void ExportNullDataGrid(KWDataGrid* targetDataGrid) const;
 
+	// CH IV Surtokenisation
+	// Export total (attribut, parties et cellules)
+	// Cas d'une grille de type VarPart
+	// En entree :
+	// - inputDataGrid : grille dont on souhaite sur-echantillonner le KWDGInnerAttributes
+	// - referenceInnerAttributes : les innerAttributes avec la partition de reference la plus fine sur laquelle on procede au tirage aleatoire
+	// - nTargetTokenNumber : nombre total de parties de variables souhaite sur l'ensemble des innerAttributes
+	// En sortie :
+	// targetDataGrid : nouvelle grille dont le KWDGInnerAttributes a ete sur-echantillonne
+	// Les partitions des attributs Identifier et VarPart ne sont pas modifiees
+	// Les innerAttributes sont sub-tokenises par tirage aleatoire
+	// Le nombre de parties de variables obtenu peut etre inferieur a cet objectif
+	void ExportDataGridWithRandomizedInnerAttributes(const KWDataGrid* inputDataGrid,
+							 const KWDGInnerAttributes* referenceInnerAttributes,
+							 KWDataGrid* targetDataGrid, int nTargetTokenNumber);
+
+	/*Contenu de cette methode :
+	voir si cette methode est necessaire : pas de besoin pour l'adaptation de GenerateNeighbourSolution a la surtokenisation
+	1 / Initialisation des attributs pour la targetDataGrid
+		- InitialiseAttributes
+	    - nouvelle methode CreateRandomInnerAttributes avec le referenceInnerAttributes extrait de
+		l'initiaVarPartDataGrid
+		- remplacement du innerAttributes de la targetDataGrid par ce nouvel innerAttributes
+	2 / Export des parties
+		- construction des parties pour l'attribut VarPart par appel de la nouvelle methode BuildVarPartAttributeFromNewInnerAttributes
+	3 /	ExportCells */
+
+	// Fin CH IV
+
 	/////////////////////////////////////////////////////////////////////////////////////////
 	// Service elementaires de transfert du contenu de la grille source vers la grille cible
 	// dedies aux attributs, parties et cellules
@@ -155,7 +184,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;
 
@@ -336,6 +365,20 @@ class KWDataGridManager : public Object
 	void InitialiseVarPartAttributeClonedParts(const KWDGAttribute* sourceAttribute,
 						   KWDGAttribute* targetAttribute) const;
 
+	// CH IV Surtokenisation
+	// Initialisation des parties pour un attribut VarPart a partir des PV d'un KWDGInnerAttribute et d'une partition source
+	// En entree :
+	// - sourceVarPartAttribute : attribute de type VarPart
+	// - targetInnerAttributes : KWDGInnerAttributes dont les partitions sont differentes de celles du KWDGInnerAttribute du sourceAttribute
+	// En sortie :
+	// - targetVarPartAttribute :
+	// L'attribut cible contient en entree une nouvelle partition des attributs internes, plus fine que la partition des attributs internes source.
+	// La methode construit les parties de l'attribut VarPart cible en conservant les parties de l'attribut VarPart source et en y mettant les PV des attributs internes surtokenises
+	void InitialiseVarPartAttributeWithNewInnerAttributes(const KWDGAttribute* sourceVarPartAttribute,
+							      KWDGInnerAttributes* targetInnerAttributes,
+							      KWDGAttribute* targetVarPartAttribute) const;
+	// Fin CH IV
+
 	// Initialisation d'une unique parties pour un attribut venant d'etre initialise, sans partie, a partir d'un attribut valide
 	void InitialiseAttributeNullPart(const KWDGAttribute* sourceAttribute, KWDGAttribute* targetAttribute) const;
 
@@ -380,6 +423,18 @@ class KWDataGridManager : public Object
 	CreateGranularizedInnerAttributes(const KWDGInnerAttributes* sourceInnerAttributes, int nGranularity,
 					  const ObjectDictionary* odInnerAttributesQuantilesBuilders) const;
 
+	// CH IV Surtokenisation
+	// Creation d'attributs internes par ajout aleatoire de parties de variable dans chaque attribut
+	// parmi les partitions de reference les plus fines pour ces innerAttributes
+	KWDGInnerAttributes* CreateRandomInnerAttributes(const KWDGInnerAttributes* sourceInnerAttributes,
+							 const KWDGInnerAttributes* referenceInnerAttributes,
+							 int nTargetTokenNumber) const;
+	/*Contenu
+	Boucle sur les innerAttributes et appel des methodes AddContinuousAttributeRandomParts et
+	    AddSymbolAttributeRandomParts en garantissant que la somme des nRequestedPartNumber par innerAttribut
+		ne depasse pas les nTargetTokenNumber*/
+	// Fin CH IV
+
 	//////////////////////////////////////////////////////////////////////////////////
 	// Services divers
 
diff --git a/src/Learning/KWDataPreparation/KWDataGridOptimizer.cpp b/src/Learning/KWDataPreparation/KWDataGridOptimizer.cpp
index 9c940cbae..c271d607b 100644
--- a/src/Learning/KWDataPreparation/KWDataGridOptimizer.cpp
+++ b/src/Learning/KWDataPreparation/KWDataGridOptimizer.cpp
@@ -322,6 +322,17 @@ double KWDataGridOptimizer::OptimizeDataGrid(const KWDataGrid* initialDataGrid,
 					    IntToString(
 						optimizedDataGrid->GetInnerAttributes()->GetVarPartGranularity()));
 
+				// CH IV VNS
+				if (bDisplayGranularities)
+				{
+					cout << "OptimizeDataGrid\t Granularite \t" << nGranularityIndex << "\n";
+					if (granularizedDataGrid.IsVarPartDataGrid())
+						cout << "attribut VarPart granularise : initial value number\t"
+						     << granularizedDataGrid.GetVarPartAttribute()
+							    ->GetInitialValueNumber()
+						     << endl;
+				}
+
 				// Optimisation de la grille granularisee
 				dGranularityBestCost =
 				    OptimizeGranularizedDataGrid(&granularizedDataGrid, granularizedOptimizedDataGrid,
@@ -1774,7 +1785,7 @@ double KWDataGridVNSOptimizer::VNSOptimizeVarPartDataGrid(const KWDataGrid* init
 		dNeighbourhoodSize = pow(1.0 / dDecreaseFactor, nIndex);
 		dVNSNeighbourhoodSize = dNeighbourhoodSize;
 
-		// Generation d'une solution dans un voisinnage de la meilleure solution
+		// Generation d'une solution dans un voisinage de la meilleure solution
 		KWDataGridOptimizer::GetProfiler()->BeginMethod("Generate neighbour solution");
 		KWDataGridOptimizer::GetProfiler()->WriteKeyString("Neighbourhood size",
 								   DoubleToString(dNeighbourhoodSize));
@@ -2282,6 +2293,101 @@ double KWDataGridVNSOptimizer::OptimizeSolution(const KWDataGrid* initialDataGri
 	return dCost;
 }
 
+void KWDataGridVNSOptimizer::PROTOGenerateNeighbourSolution(const KWDataGrid* initialDataGrid,
+							    const KWDataGrid* optimizedDataGrid, double dNoiseRate,
+							    KWDataGridMerger* neighbourDataGridMerger) const
+{
+	KWDataGridManager dataGridManager;
+	KWDataGrid mandatoryDataGrid;
+	int nMandatoryAttributeNumber;
+	int nMaxAttributeNumber;
+	int nMaxPartNumber;
+	int nMaxContinuousPartNumber;
+	int nMaxSymbolPartNumber;
+	int nRequestedContinuousPartNumber;
+	int nRequestedSymbolPartNumber;
+	int nAttributeNumber;
+	int nGridSize;
+	ALString sTmp;
+
+	require(initialDataGrid != NULL);
+	require(optimizedDataGrid != NULL);
+	require(neighbourDataGridMerger != NULL);
+	require(0 <= dNoiseRate and dNoiseRate <= 1);
+
+	// Debut de tache
+	TaskProgression::BeginTask();
+	TaskProgression::DisplayMainLabel(sTmp + "New surtokenized initial solution (" + DoubleToString(dNoiseRate) +
+					  ")");
+
+	// Initialisation de la taille de la grille prise en compte
+	// La taille de la grille est initialise avec le nombre de cellules non vides de la grille initiale
+	// pour une granularite donnee.
+	// - a noter: on a toujours GetCellNumber <= GetGridFrequency.
+	// - pour la granularite max, cela permet d'avoir un indicateur de sparsite de la grille plus fiable
+	//   que le nombre d'individus (GetGridFrequency), qui reflete la proportion de cellules non vides.
+	// - pour les granularites intermediaires, ce nombre est plus petit, ce qui entrainera la generation
+	//   de grilles voisines aleatoires plus petites, et donc plus rapides a optimiser:
+	//   - dans le cas non supervise, c'est ce que l'on souhaite pour obtenir des premieres solutions rapidement
+	//   - dans le cas supervise, cette taille reduite limite l'espace de recherche avec un impact
+	//     pontiellement negatif sur la qualite des solutions: on considere ce probleme comme negligeable
+	nGridSize = initialDataGrid->GetCellNumber();
+
+	// Calcul du nombre d'attributs a exporter
+	// -> dans le cas VarPart, considerer tous les attributs comme obligatoires
+	nAttributeNumber = optimizedDataGrid->GetAttributeNumber();
+
+	// Calcul des nombres de parties a exporter
+	nMaxContinuousPartNumber = (int)(nGridSize / log(nGridSize + 1.0));
+	nMaxSymbolPartNumber = (int)sqrt(nGridSize * 1.0);
+	nMaxPartNumber = (int)pow(nGridSize * 1.0, 1.0 / nAttributeNumber);
+	if (nMaxPartNumber > nGridSize)
+		nMaxPartNumber = nGridSize;
+	if (nMaxPartNumber < 2)
+		nMaxPartNumber = 2;
+	if (nMaxContinuousPartNumber > nMaxPartNumber)
+		nMaxContinuousPartNumber = nMaxPartNumber;
+	if (nMaxSymbolPartNumber > nMaxPartNumber)
+		nMaxSymbolPartNumber = nMaxPartNumber;
+	nRequestedContinuousPartNumber = 1 + (int)(dNoiseRate * nMaxContinuousPartNumber);
+	nRequestedSymbolPartNumber = 1 + (int)(dNoiseRate * nMaxSymbolPartNumber);
+
+	// Cas VarPart : export de l'ensemble des attributs en tant qu'attributs obligatoires
+	dataGridManager.SetSourceDataGrid(optimizedDataGrid);
+	dataGridManager.ExportRandomAttributes(&mandatoryDataGrid, nAttributeNumber);
+
+	// Creer un copie temporaire du neighbourDataGridMerger pour tester la surtokenisation: neighbourDataGridMergerTest
+	// - copie pointant sur les meme inner attributes
+	// - mis en place de nouveaux inner attributes issus de la surtokenisation
+	// - export; affichage pour mise au point
+	// - nettoyage
+
+	// Potentiellement a faire
+	// - Creer un copie temporaire du neighbourDataGridMerger pour tester la surtokenisation: neighbourDataGridMergerPROTO
+	// - creer prealablement un copie de optimizedDataGrid: surtokenizedOptimizedDataGrid
+	//   - surtokenizer son attribut VarPart via InitializeVarPartAttributeWithNewInnerAttributes
+	// - ajout des parties:
+	//     dataGridManager.AddRandomParts(neighbourDataGridMergerPROTO, surtokenizedOptimizedDataGrid,
+	//                                   nRequestedContinuousPartNumber, nRequestedSymbolPartNumber, 1.0);
+
+	// Exports d'attributs supplementaires
+	// Pour un dNoiseRate de 1, tous les attributs sont ajoutes a concurrence de nMaxAttributeNumber
+	dataGridManager.SetSourceDataGrid(initialDataGrid);
+	neighbourDataGridMerger->DeleteAll();
+	dataGridManager.AddRandomAttributes(neighbourDataGridMerger, &mandatoryDataGrid, nAttributeNumber);
+
+	// Export des parties
+	dataGridManager.AddRandomParts(neighbourDataGridMerger, optimizedDataGrid, nRequestedContinuousPartNumber,
+				       nRequestedSymbolPartNumber, 1.0);
+	TaskProgression::DisplayProgression(25);
+
+	// Export des cellules
+	dataGridManager.ExportCells(neighbourDataGridMerger);
+
+	// Fin de tache
+	TaskProgression::EndTask();
+}
+
 void KWDataGridVNSOptimizer::GenerateNeighbourSolution(const KWDataGrid* initialDataGrid,
 						       const KWDataGrid* optimizedDataGrid, double dNoiseRate,
 						       KWDataGridMerger* neighbourDataGridMerger) const
@@ -2296,25 +2402,91 @@ void KWDataGridVNSOptimizer::GenerateNeighbourSolution(const KWDataGrid* initial
 	int nRequestedContinuousPartNumber;
 	int nRequestedSymbolPartNumber;
 	int nAttributeNumber;
-	ALString sTmp;
-	// CH RefontePrior2
 	int nGridSize;
-	// Fin CH RefontePrior2
+	ALString sTmp;
 
 	require(initialDataGrid != NULL);
 	require(optimizedDataGrid != NULL);
 	require(neighbourDataGridMerger != NULL);
 	require(0 <= dNoiseRate and dNoiseRate <= 1);
 
+	// CH IV Refactoring : DDDDD
+	// Test du remplacement de la methode actuelle, par son proto
+	boolean bNewPROTO = true;
+	static int nCount = 0;
+	nCount++;
+	if (initialDataGrid->IsVarPartDataGrid() and bNewPROTO and nCount == 1)
+	//if (bNewPROTO)
+	{
+		// Appel de PROTOGenerateNeighbourSolution, permettant de tester les nouvelle methodes sans les activer vraiment
+		//PROTOGenerateNeighbourSolution(initialDataGrid, optimizedDataGrid, dNoiseRate, neighbourDataGridMerger);
+
+		// CH IV Surtokenisation
+		// Code a reprendre pour construire PROTOGenerateNeighbourSolution
+		KWDataGrid* surtokenizedDataGrid;
+		int nTargetTokenNumber = 100;
+		boolean bDisplayResults = false;
+		int nInitialSeed;
+
+		// Memorisation de la graine initiale
+		nInitialSeed = GetRandomSeed();
+
+		dataGridManager.SetSourceDataGrid(GetDataGridOptimizer()->GetInitialVarPartDataGrid());
+
+		surtokenizedDataGrid = new KWDataGrid;
+
+		dataGridManager.ExportDataGridWithRandomizedInnerAttributes(
+		    optimizedDataGrid, GetDataGridOptimizer()->GetInitialVarPartDataGrid()->GetInnerAttributes(),
+		    surtokenizedDataGrid, nTargetTokenNumber);
+
+		if (bDisplayResults)
+		{
+			cout << "nTargetTokenNumber\t" << nTargetTokenNumber << endl;
+			surtokenizedDataGrid->Write(cout);
+		}
+
+		surtokenizedDataGrid->DeleteAll();
+		delete surtokenizedDataGrid;
+
+		nTargetTokenNumber = 5;
+		surtokenizedDataGrid = new KWDataGrid;
+
+		dataGridManager.ExportDataGridWithRandomizedInnerAttributes(
+		    optimizedDataGrid, GetDataGridOptimizer()->GetInitialVarPartDataGrid()->GetInnerAttributes(),
+		    surtokenizedDataGrid, nTargetTokenNumber);
+
+		if (bDisplayResults)
+		{
+			cout << "nTargetTokenNumber\t" << nTargetTokenNumber << endl;
+			surtokenizedDataGrid->Write(cout);
+		}
+
+		surtokenizedDataGrid->DeleteAll();
+		delete surtokenizedDataGrid;
+
+		// Restitution de la graine initiale
+		SetRandomSeed(nInitialSeed);
+	}
+
 	// Debut de tache
 	TaskProgression::BeginTask();
 	TaskProgression::DisplayMainLabel(sTmp + "New initial solution (" + DoubleToString(dNoiseRate) + ")");
 
 	// Initialisation de la taille de la grille prise en compte
-	// Cas avec granularite
+	// La taille de la grille est initialise avec le nombre de cellules non vides de la grille initiale
+	// pour une granularite donnee.
+	// - a noter: on a toujours GetCellNumber <= GetGridFrequency.
+	// - pour la granularite max, cela permet d'avoir un indicateur de sparsite de la grille plus fiable
+	//   que le nombre d'individus (GetGridFrequency), qui reflete la proportion de cellules non vides.
+	// - pour les granularites intermediaires, ce nombre est plus petit, ce qui entrainera la generation
+	//   de grilles voisines aleatoires plus petites, et donc plus rapides a optimiser:
+	//   - dans le cas non supervise, c'est ce que l'on souhaite pour obtenir des premieres solutions rapidement
+	//   - dans le cas supervise, cette taille reduite limite l'espace de recherche avec un impact
+	//     pontiellement negatif sur la qualite des solutions: on considere ce probleme comme negligeable
 	nGridSize = initialDataGrid->GetCellNumber();
 
 	// Calcul du nombre d'attributs a exporter
+	// CH IV Surtokenisation: dans la cas VarPart, considerer tous les attributs comme obligatoires
 	nMaxAttributeNumber = 1 + (int)(log(nGridSize * 1.0) / log(2.0));
 	nAttributeNumber = (int)(dNoiseRate * nMaxAttributeNumber);
 	if (nAttributeNumber < 2)
diff --git a/src/Learning/KWDataPreparation/KWDataGridOptimizer.h b/src/Learning/KWDataPreparation/KWDataGridOptimizer.h
index 4e66a90c7..00b61ced6 100644
--- a/src/Learning/KWDataPreparation/KWDataGridOptimizer.h
+++ b/src/Learning/KWDataPreparation/KWDataGridOptimizer.h
@@ -288,6 +288,14 @@ class KWDataGridVNSOptimizer : public Object
 	void GenerateNeighbourSolution(const KWDataGrid* initialDataGrid, const KWDataGrid* optimizedDataGrid,
 				       double dNoiseRate, KWDataGridMerger* neighbourDataGridMerger) const;
 
+	// CH IV Refactoring surtokenisation
+	// Creation d'une solution voisine d'une solution optimisee avec perturbation de la tokenisation des innerAttributes dans le car VarPart
+	// On passe en parametre un pourcentage de perturbation compris
+	// entre 0 (pas de perturbation) et 1 (solution aleatoire)
+	void PROTOGenerateNeighbourSolution(const KWDataGrid* initialDataGrid, const KWDataGrid* optimizedDataGrid,
+					    double dNoiseRate, KWDataGridMerger* neighbourDataGridMerger) const;
+	// Fin CH IV
+
 	// Affichage des caracteristiques d'optimisation (selon le niveau d'affichage demande)
 	void DisplayOptimizationHeaderLine() const;
 	void DisplayOptimizationDetails(const KWDataGrid* optimizedDataGrid, boolean bOptimized) const;
diff --git a/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.cpp b/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.cpp
index efad7c96f..aaff6f9bc 100644
--- a/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.cpp
+++ b/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.cpp
@@ -283,6 +283,17 @@ double NEWKWDataGridOptimizer::OptimizeDataGrid(const KWDataGrid* initialDataGri
 					    IntToString(
 						optimizedDataGrid->GetInnerAttributes()->GetVarPartGranularity()));
 
+				// CH IV VNS
+				if (bDisplayGranularities)
+				{
+					cout << "OptimizeDataGrid\tGranularite\t" << nGranularityIndex << "\n";
+					if (granularizedDataGrid.IsVarPartDataGrid())
+						cout << "attribut VarPart granularise : initial value number\t"
+						     << granularizedDataGrid.GetVarPartAttribute()
+							    ->GetInitialValueNumber()
+						     << endl;
+				}
+
 				// Optimisation de la grille granularisee
 				// Cas non supervise pour les granularites intermediaires: optimisation legere
 				if (not IsSupervisedDataGrid(initialDataGrid) and not bIsLastGranularity)
@@ -649,7 +660,7 @@ double NEWKWDataGridOptimizer::SlightOptimizeGranularizedDataGrid(const KWDataGr
 	// Parametrage des couts
 	neighbourDataGrid.SetDataGridCosts(GetDataGridCosts());
 
-	// Generation d'une solution dans un voisinnage de la meilleure solution
+	// Generation d'une solution dans un voisinage de la meilleure solution
 	NEWKWDataGridOptimizer::GetProfiler()->BeginMethod("Generate neighbour solution");
 	NEWKWDataGridOptimizer::GetProfiler()->WriteKeyString("Neighbourhood size", "1");
 	GenerateNeighbourSolution(initialDataGrid, optimizedDataGrid, 1, &neighbourDataGrid);
@@ -1763,6 +1774,63 @@ void NEWKWDataGridOptimizer::GenerateNeighbourSolution(const KWDataGrid* initial
 	require(neighbourDataGridMerger != NULL);
 	require(0 <= dNoiseRate and dNoiseRate <= 1);
 
+	// CH IV Refactoring : DDDDD
+	// Test du remplacement de la methode actuelle, par son proto
+	boolean bNewPROTO = true;
+	static int nCount = 0;
+	nCount++;
+	if (initialDataGrid->IsVarPartDataGrid() and bNewPROTO and nCount == 1)
+	{
+		// Appel de PROTOGenerateNeighbourSolution, permettant de tester les nouvelle methodes sans les activer vraiment
+		//PROTOGenerateNeighbourSolution(initialDataGrid, optimizedDataGrid, dNoiseRate, neighbourDataGridMerger);
+
+		// CH IV Surtokenisation
+		// Code a reprendre pour construire PROTOGenerateNeighbourSolution
+		KWDataGrid* surtokenizedDataGrid;
+		int nTargetTokenNumber = 100;
+		boolean bDisplayResults = false;
+		int nInitialSeed;
+
+		// Memorisation de la graine initiale
+		nInitialSeed = GetRandomSeed();
+
+		dataGridManager.SetSourceDataGrid(GetInitialVarPartDataGrid());
+
+		surtokenizedDataGrid = new KWDataGrid;
+
+		dataGridManager.ExportDataGridWithRandomizedInnerAttributes(
+		    optimizedDataGrid, GetInitialVarPartDataGrid()->GetInnerAttributes(), surtokenizedDataGrid,
+		    nTargetTokenNumber);
+
+		if (bDisplayResults)
+		{
+			cout << "nTargetTokenNumber\t" << nTargetTokenNumber << endl;
+			surtokenizedDataGrid->Write(cout);
+		}
+
+		surtokenizedDataGrid->DeleteAll();
+		delete surtokenizedDataGrid;
+
+		nTargetTokenNumber = 5;
+		surtokenizedDataGrid = new KWDataGrid;
+
+		dataGridManager.ExportDataGridWithRandomizedInnerAttributes(
+		    optimizedDataGrid, GetInitialVarPartDataGrid()->GetInnerAttributes(), surtokenizedDataGrid,
+		    nTargetTokenNumber);
+
+		if (bDisplayResults)
+		{
+			cout << "nTargetTokenNumber\t" << nTargetTokenNumber << endl;
+			surtokenizedDataGrid->Write(cout);
+		}
+
+		surtokenizedDataGrid->DeleteAll();
+		delete surtokenizedDataGrid;
+
+		// Restitution de la graine initiale
+		SetRandomSeed(nInitialSeed);
+	}
+
 	// Debut de tache
 	TaskProgression::BeginTask();
 	TaskProgression::DisplayMainLabel(sTmp + "New initial solution (" + DoubleToString(dNoiseRate) + ")");
@@ -1781,6 +1849,7 @@ void NEWKWDataGridOptimizer::GenerateNeighbourSolution(const KWDataGrid* initial
 	nGridSize = initialDataGrid->GetCellNumber();
 
 	// Calcul du nombre d'attributs a exporter
+	// CH IV Surtokenisation: dans la cas VarPart, considerer tous les attributs comme obligatoires
 	nMaxAttributeNumber = 1 + (int)(log(nGridSize * 1.0) / log(2.0));
 	nAttributeNumber = (int)(dNoiseRate * nMaxAttributeNumber);
 	if (nAttributeNumber < 2)
@@ -1841,6 +1910,101 @@ void NEWKWDataGridOptimizer::GenerateNeighbourSolution(const KWDataGrid* initial
 	TaskProgression::EndTask();
 }
 
+void NEWKWDataGridOptimizer::PROTOGenerateNeighbourSolution(const KWDataGrid* initialDataGrid,
+							    const KWDataGrid* optimizedDataGrid, double dNoiseRate,
+							    KWDataGridMerger* neighbourDataGridMerger) const
+{
+	KWDataGridManager dataGridManager;
+	KWDataGrid mandatoryDataGrid;
+	int nMandatoryAttributeNumber;
+	int nMaxAttributeNumber;
+	int nMaxPartNumber;
+	int nMaxContinuousPartNumber;
+	int nMaxSymbolPartNumber;
+	int nRequestedContinuousPartNumber;
+	int nRequestedSymbolPartNumber;
+	int nAttributeNumber;
+	int nGridSize;
+	ALString sTmp;
+
+	require(initialDataGrid != NULL);
+	require(optimizedDataGrid != NULL);
+	require(neighbourDataGridMerger != NULL);
+	require(0 <= dNoiseRate and dNoiseRate <= 1);
+
+	// Debut de tache
+	TaskProgression::BeginTask();
+	TaskProgression::DisplayMainLabel(sTmp + "New surtokenized initial solution (" + DoubleToString(dNoiseRate) +
+					  ")");
+
+	// Initialisation de la taille de la grille prise en compte
+	// La taille de la grille est initialise avec le nombre de cellules non vides de la grille initiale
+	// pour une granularite donnee.
+	// - a noter: on a toujours GetCellNumber <= GetGridFrequency.
+	// - pour la granularite max, cela permet d'avoir un indicateur de sparsite de la grille plus fiable
+	//   que le nombre d'individus (GetGridFrequency), qui reflete la proportion de cellules non vides.
+	// - pour les granularites intermediaires, ce nombre est plus petit, ce qui entrainera la generation
+	//   de grilles voisines aleatoires plus petites, et donc plus rapides a optimiser:
+	//   - dans le cas non supervise, c'est ce que l'on souhaite pour obtenir des premieres solutions rapidement
+	//   - dans le cas supervise, cette taille reduite limite l'espace de recherche avec un impact
+	//     pontiellement negatif sur la qualite des solutions: on considere ce probleme comme negligeable
+	nGridSize = initialDataGrid->GetCellNumber();
+
+	// Calcul du nombre d'attributs a exporter
+	// -> dans le cas VarPart, considerer tous les attributs comme obligatoires
+	nAttributeNumber = optimizedDataGrid->GetAttributeNumber();
+
+	// Calcul des nombres de parties a exporter
+	nMaxContinuousPartNumber = (int)(nGridSize / log(nGridSize + 1.0));
+	nMaxSymbolPartNumber = (int)sqrt(nGridSize * 1.0);
+	nMaxPartNumber = (int)pow(nGridSize * 1.0, 1.0 / nAttributeNumber);
+	if (nMaxPartNumber > nGridSize)
+		nMaxPartNumber = nGridSize;
+	if (nMaxPartNumber < 2)
+		nMaxPartNumber = 2;
+	if (nMaxContinuousPartNumber > nMaxPartNumber)
+		nMaxContinuousPartNumber = nMaxPartNumber;
+	if (nMaxSymbolPartNumber > nMaxPartNumber)
+		nMaxSymbolPartNumber = nMaxPartNumber;
+	nRequestedContinuousPartNumber = 1 + (int)(dNoiseRate * nMaxContinuousPartNumber);
+	nRequestedSymbolPartNumber = 1 + (int)(dNoiseRate * nMaxSymbolPartNumber);
+
+	// Cas VarPart : export de l'ensemble des attributs en tant qu'attributs obligatoires
+	dataGridManager.SetSourceDataGrid(optimizedDataGrid);
+	dataGridManager.ExportRandomAttributes(&mandatoryDataGrid, nAttributeNumber);
+
+	// Creer un copie temporaire du neighbourDataGridMerger pour tester la surtokenisation: neighbourDataGridMergerTest
+	// - copie pointant sur les meme inner attributes
+	// - mis en place de nouveaux inner attributes issus de la surtokenisation
+	// - export; affichage pour mise au point
+	// - nettoyage
+
+	// Potentiellement a faire
+	// - Creer un copie temporaire du neighbourDataGridMerger pour tester la surtokenisation: neighbourDataGridMergerPROTO
+	// - creer prealablement un copie de optimizedDataGrid: surtokenizedOptimizedDataGrid
+	//   - surtokenizer son attribut VarPart via InitializeVarPartAttributeWithNewInnerAttributes
+	// - ajout des parties:
+	//     dataGridManager.AddRandomParts(neighbourDataGridMergerPROTO, surtokenizedOptimizedDataGrid,
+	//                                   nRequestedContinuousPartNumber, nRequestedSymbolPartNumber, 1.0);
+
+	// Exports d'attributs supplementaires
+	// Pour un dNoiseRate de 1, tous les attributs sont ajoutes a concurrence de nMaxAttributeNumber
+	dataGridManager.SetSourceDataGrid(initialDataGrid);
+	neighbourDataGridMerger->DeleteAll();
+	dataGridManager.AddRandomAttributes(neighbourDataGridMerger, &mandatoryDataGrid, nAttributeNumber);
+
+	// Export des parties
+	dataGridManager.AddRandomParts(neighbourDataGridMerger, optimizedDataGrid, nRequestedContinuousPartNumber,
+				       nRequestedSymbolPartNumber, 1.0);
+	TaskProgression::DisplayProgression(25);
+
+	// Export des cellules
+	dataGridManager.ExportCells(neighbourDataGridMerger);
+
+	// Fin de tache
+	TaskProgression::EndTask();
+}
+
 void NEWKWDataGridOptimizer::SaveDataGrid(const KWDataGrid* sourceDataGrid, KWDataGrid* targetDataGrid) const
 {
 	KWDataGridManager dataGridManager;
diff --git a/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.h b/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.h
index 6b3cfa570..f590dfc69 100644
--- a/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.h
+++ b/src/Learning/KWDataPreparation/NEWKWDataGridOptimizer.h
@@ -240,6 +240,14 @@ class NEWKWDataGridOptimizer : public Object
 	void GenerateNeighbourSolution(const KWDataGrid* initialDataGrid, const KWDataGrid* optimizedDataGrid,
 				       double dNoiseRate, KWDataGridMerger* neighbourDataGridMerger) const;
 
+	// CH IV Refactoring surtokenisation
+	// Creation d'une solution voisine d'une solution optimisee avec perturbation de la tokenisation des innerAttributes dans le car VarPart
+	// On passe en parametre un pourcentage de perturbation compris
+	// entre 0 (pas de perturbation) et 1 (solution aleatoire)
+	void PROTOGenerateNeighbourSolution(const KWDataGrid* initialDataGrid, const KWDataGrid* optimizedDataGrid,
+					    double dNoiseRate, KWDataGridMerger* neighbourDataGridMerger) const;
+	// Fin CH IV
+
 	//////////////////////////////////////////////////////////////////////////////////
 	// Methodes utilitaires