diff --git a/main.py b/main.py
index 2561a310bbbc96d088346be0b9f776f5e22b05fe..454d089baef00c2f4c2781fb70f62a573ad98415 100644
--- a/main.py
+++ b/main.py
@@ -335,7 +335,7 @@ def describe_exp_txt(params):
                 tab.append('- Pair training is used \n')
                 tab.append('- Batch size is 2*' + str(params.training_dictionnary[model]['batch_size_classif']) + ' \n')
             if(params.training_dictionnary[model]['CL']=='yes'):
-                tab.append('- Curriculum is used : the embedding rate starts from '+ str(params.training_dictionnary[model]['start_emb_rate']) +' and decreases every two epochs by factor 0.9 to reach target embedding rate '+str(params.emb_rate)+'\n \n')
+                tab.append('- Curriculum is used : the embedding rate starts from '+ str(params.training_dictionnary[model]['start_emb_rate']) +' and decreases every two epochs by -0.1 to reach target embedding rate '+str(params.emb_rate)+'\n \n')
             else:
                 tab.append('- Curriculum is not used : the embedding rate = '+str(params.emb_rate)+' is constant during training \n \n')
 
@@ -356,7 +356,7 @@ if __name__ == '__main__':
     argparser = argparse.ArgumentParser(sys.argv[0])
     argparser.add_argument('--begin_step', type=int)
     argparser.add_argument('--number_steps', type=int, default=10)
-    argparser.add_argument('--folder_model', type=str, help='The path to the folder where the architecture of models are saved')
+    argparser.add_argument('--folder_model', type=str, help='The path to the folder where the architecture of models are saved. ')
     argparser.add_argument('--num_of_threads', type=int, default=10, help='number of cpus') 
 
     # MODEL ARCHITECTURE
diff --git a/readme.md b/readme.md
new file mode 100644
index 0000000000000000000000000000000000000000..b21adbe27ba28105687d037ea9b1f5bd20883c5a
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,89 @@
+The protocol is made to run on a multi-GPU platform, with orders in .slurm files.
+
+# How are trained the classifiers
+The classifiers are trained between cover images, and new stegos are generated in each batch with the corresponding cost map. It allows to train the classifier, if desired (depending on parameters --CL and --start_emb_rate) to use curriculum learning during the training, such as new stegos embedding any size of payload can be generated during the training.
+
+
+
+# Scruture of the results of a run of the protocol
+A run of a protocol is an experiment for given values of QF, emb_rate, intial cost_maps, different steganalysts...
+A run of the protocol will save all values in a folder, which is defined in the parameter --data_dir_prot.
+The organization of this folder is described by the illustration, and in the following.
+At the beginning, it creates file description.txt which resumes all parameters parsed at the beggining of run of main.py. 
+
+Adversarial images are saved in "data_adv_$i/adv_final/" and optimized cost maps in  "data_adv_$i/adv_cost/".
+Evalution of classifier with architecture $model trained at iteration $j on adversarial images generated at iteration $i are saved in "data_adv_$i/eval_$model_$j/". There are two files: "logits.npy" of size (10000,2) containing the raw logits given by the classifier, and "probas.npy" of size (10000,) which are the stego class probability given by the softmax of the logits. The images are ordred are in the file --permutation_files.npy given in input of the protocol.
+
+Here are the steps of the protocol:
+If --begin_step=0, the run of the protocol will begin with initialization which contains the following steps:
+	- training of classifiers (depending of --model) between cover and stego in folder 'train_$model_0/'. 
+	- evaluation of the classifiers and both databases: cover and initial stegos.
+It produces files at iteration $k are:
+	- adversarial stegos stored in a .npy file in the folder "data_adv_$k/adv_final/"
+	- optimized costs maps of shape 3*image_size*image_size stored in the folder "data_adv_$k/adv_cost/"
+	- evaluation of all the classifiers (all possible models trained at all previous iterations) on this new database of stegos in "data_adv_$k/eval_$model_$i/" of i between 0 and k-1.
+	- index of the database of stego images (vector of shape 10000 containing integer between 0 and k) stored in "data_train_$k/index.npy"
+	- train of classifier "model" stored in "train_$model_k/"
+	- evaluation of this new classifier on cover (in "cover/eval_$model_k/") + all the databases of stegos (in "data_adv_$i/eval_$model_k/") saved in "data_adv_$i/adv_final/" for all i between 0 and k.
+
+
+
+Parameters to pass in main.py:
+	- begin_step: first iteration of the protocol. Should be equals to 0 if you never launched it.
+	- number_step: for how many further iteration to lauchn the protocol
+	- folder_model: absolute path leading to the folder './models/' stored in this folder. It contains the model and the architectures of the steganalysts networks. 
+    - data_dir_prot: folder where all the stegos and classifiers produced during the algorithm are saved.
+    - data_dir_cover: folder containing all cover images in the .npy format. One file for each image is required. 
+    - data_dir_stego_0: folder containing stegos at iteration 0, in the same format as cover images. 
+    - cost_dir: folder containing all initial modification maps at iteration 0. Each cost map is saved in a single file for format .npy.  It has the shape 
+    		- 3 x image_size x image_size : in that case, first channel for cost of -1, second for 0 and final for +1 
+    		- or image_size x image_size:  in that case, only channel for symmetric cost of doing -1 or +1
+	- strategy='minmax': one of the three strategies available: 'minmax' (by default), 'random' or 'lastit'
+	- image_size='512': height of the squared images used
+	- QF: quality factor of the images used. For a given QF, the quantification table should be saved in folder 'folder_model/' in the format 'c_quant_$QF.npy'
+	- emb_rate: embedding rate in bpnzAC coefficients for JPEG images, or bpp for spatial images
+	- model: string value of models against Alice optimizes herself. 3 models are implemented: 'xunet', 'srnet' or 'efnet'. For multiple models, the models should be seperated by a coma ','. For example, models='xunet,srnet,efnet'
+	- version_eff: string, which value is from 'b0', 'b1', ... to 'b7'. This is the size of the models of efficient net.
+	- stride: 1 or 2, for the stride of the convolution at the beginning of efficient net.
+	- batch_size_classif_ef, batch_size_classif_sr, batch_size_classif_xu: batch size to use during training of each classifier (efficient net, SRNet or XU-Net)
+	- batch_size_eval_ef, batch_size_eval_sr, batch_size_eval_xu: batch size to use during evaluation of networks.
+	- epoch_num_ef, epoch_num_sr, epoch_num_xu: number of epochs for the training for each classifier
+	- CL_ef, CL_sr, CL_xu: 'yes' for using curriculum learning during training, 'no' for not using it. 
+	- start_emb_rate_ef, start_emb_rate_sr, start_emb_rate_xu: if parameter CL is set to 'yes' for the corresponding classifier, starting value of the embedding rate during the training. It is during training decreased bu substracting value 0.1 every two epochs. It can be modified in class Fitter defined in file train.py in the method fit. 
+	- pair_training_ef, pair_training_sr, pair_training_xu: 'yes' for using pair training during the training of each network, 'no' for not using it.
+	- n_iter_max_backpack: integer for the maximum number of steps to use during the gradient descent of the optimization with backpack
+	- tau_0: starting float value of the temperature controlling the smoothness in the softmax gumbel distribution.
+	- precision: float value for the precision for the stopping condition of the gradient descent, for checking inequalities like f(stego) "<" f(cover), which is replaced by f(stego) "<" f(cover)+precision
+	- N_samples: integer for the number of samples of stego to use during the gradient descent for checking the average detectability of the cost map.
+	- attack: 'SGE', 'DoTanh' or 'DoCoTanh' for softmax gumbel estimation, double tanh or double compact tanh. This is for which differentiable function to use for approximating the discrete changes.
+	- attack_last: 'no' or 'yes', for how many previous classifiers to optimize during the gradient descent. By default equals to 'yes', because the attack needs to load all previous classifiers which might not fit in GPU. If it doesn't fit, you can set this parameter to 'yes' such as it will take classifiers trained in the 3 previous iterations. This can be changed in python file script_attack.py, in the line "n_classifier_min = max(params.iteration_step-3, 0)".
+	- lr: float value for the value of the learning rate to use in ADAM optimizer for the gradient descent. Advices: use 0.5 for QF 75 and 0.05 for QF 100.
+	
+
+
+
+In this folder:
+FOLDER:
+	- models: folder containing some constants, and .py files describing three different models 
+	NUMPY FILES : 
+		- DCT_4.npy : preprocessing kernel of size 4x4 containing DCT coefficients used in XUNet architecture
+		- c_quant_75.npy, c_quant_95.npy, c_quant_100.npy : quantization tables for QF 75, 95 or 100
+		- permutation_files.npy : permutation of files (take the first images to be in train, after in valid and last in test set)
+	PYTHON FILES:
+		- efficientnet.py, srnet.py and xunet.py for describing three steganalysts models
+PYTHON FILES:
+	- main.py: Script to call for launching a protocol. It will itself run during the whole protocol and call other scripts to proceed to some actions. At the beginning, it creates the files description.txt which resumes the parameters of the experiment.
+	- backpack.py: the class Backpack with SGE, which provides the output and the gradient of the output of a classifier w.r.t. costs.
+	- double_tanh.py: the class with Backpack but with Double Tanh or Double Compact Tanh instead of SGE
+	- eval_classifier.py: function which evaluates a classifier on a database
+	- generate_train_db.py: produces the index (files index.npy) of the adversarial stegos picked from the minmax strategy. It stores the result of np.argmin(np.max(probas,axis=1),axis=0).
+	- data_loader.py : contains input_fn to feed the network
+	- script_attack.py: script which launches the gradient descent for each images.
+	- script_evalute_classif.py: script which launches the evaluation of any classifier on any database.
+	- script_train.py: script which launche the training of a classifier
+	- train.py: definition of the class Fitter useful for training a classifier.
+
+
+
+
+
diff --git a/readme.txt b/readme.txt
deleted file mode 100644
index dba3e835de693c5ad13544e3e64519b3a0fa6343..0000000000000000000000000000000000000000
--- a/readme.txt
+++ /dev/null
@@ -1,25 +0,0 @@
-PYTHON FILES : 
-	- data_loader.py : contains input_fn to feed the network
-	- SRNet.py : contains cnn_model_fn to train the network
-	- main.py : script to start the training. 
-
-NUMPY FILES : 
-	- DCT_4.npy : preprocessing kernel of size 4x4 containing DCT coefficients used in XUNet architecture
-	- DCT_8.npy : convolution layer used in SRNet architecture to compute spatial images
-	- c_quant_75.npy, c_quant_95.npy, c_quant_100.npy : quantization tables for QF 75, 95 or 100
-	- permutation_lignes.npy : permutation of indices in [0, 255] to reorder DCT coefficients in the architecture in order to see the inverse DCT operation in the beginning of the network
-	- permutation_files.npy : permutation of files (take the first images to be in train, after in valid and last in test set)
-	
-FOLDERS :
-	- folder_model: folder containing file defining the architecture of the steganalyst and the constants. By default, equals to './models/'.
-    - data_dir_prot: folder where all the stegos and classifiers produced during the algorithm are saved.
-    - data_dir_cover: folder containing all cover images in the .npy format. One file for each image is required. 
-    - data_dir_stego_0: folder containing stegos at iteration 0, in the same format as cover images. 
-    - dir_cost: folder containing all initial modification maps at iteration 0. Each cost map is saved in a single file for format .npy.  It has the shape 
-    		- 3 x image_size x image_size : in that case, first channel for cost of -1, second for 0 and final for +1 
-    		- or image_size x image_size:  in that case, only channel for symmetric cost of doing -1 or +1
-
-	
-
-
-
diff --git a/script_train.py b/script_train.py
index bcef22b6577c5b9741bbd885b2e2a5dcf24e2b0e..1314fec36e5cd7db1618563341aa00b50b427e61 100644
--- a/script_train.py
+++ b/script_train.py
@@ -229,7 +229,7 @@ if __name__ == '__main__':
         _, test = fitter.validation(test_loader)
         print('Pe_err test :', test.avg)
 
-        np.save(save_path+'p_error/accuracy.npy', np.array([train.avg, val.avg, test.avg]))
+        np.save(save_path+'error_rate.npy', np.array([train.avg, val.avg, test.avg]))
 
         return(train.avg, val.avg, test.avg)
 
diff --git a/train.py b/train.py
index 4ebdd4380e6b72fb7260766a30e489efb4e06a99..f4ff5fafb2f4ba57c1f6d9339692fdd0d3a2e37d 100644
--- a/train.py
+++ b/train.py
@@ -77,7 +77,7 @@ class Fitter:
             summary_loss, final_scores = self.train_one_epoch(train_loader)
 
             if(e%2==0 and train_loader.dataset.emb_rate>emb_rate):
-                udpate_emb_rate = max(emb_rate, train_loader.dataset.emb_rate*0.9)
+                udpate_emb_rate = max(emb_rate, train_loader.dataset.emb_rate - 0.1)
                 train_loader.dataset.emb_rate = udpate_emb_rate
 
             self.log(f'[RESULT]: Train. Epoch: {self.epoch}, summary_loss: {summary_loss.avg:.5f}, final_score: {final_scores.avg:.5f}, time: {(time.time() - t):.5f}')