Upload config.py

config.py

@@ -0,0 +1,487 @@
+import os
+import argparse
+
+###################################### configuration ######################################
+class Config(object):
+
+    typeFilters = [[], ["1_query_size_",
+                "1_query_material_",
+                "2_equal_color_",
+                "2_equal_shape_"],
+                ["1_query_color_",
+                "1_query_shape_",
+                "2_equal_size_",
+                "2_equal_material_"]]
+
+    #### files interface
+    ## data files
+    dataPath = "" # dataset specific
+    datasetFilename = "" # dataset specific
+
+    # file names
+    imagesFilename = "{tier}.h5" # Images
+    instancesFilename = "{tier}Instances.json"
+    # symbols dictionaries
+    questionDictFilename = "questionDict.pkl"
+    answerDictFilename = "answerDict.pkl"
+    qaDictFilename = "qaDict.pkl"
+    
+    ## experiment files
+    expPathname = "{expName}"
+    expName = "" #  will be assigned through argparse
+
+    weightsPath = "./weights"
+    weightsFilename = "weights{epoch}.ckpt"
+
+    # model predictions and optionally attention maps
+    predsPath = "./preds"
+    predsFilename = "{tier}Predictions-{expName}.json"
+    answersFilename = "{tier}Answers-{expName}.txt"
+
+    # logging of accuracy, loss etc. per epoch
+    logPath = "./results"
+    logFilename = "results-{expName}.csv"
+
+    # configuration file of the used flags to run the experiment
+    configPath = "./results"
+    configFilename = "config-{expName}.json"
+
+    def toString(self):
+        return self.expName
+
+    # make directories of experiment if not exist yet
+    def makedirs(self, directory):
+        directory = os.path.join(directory, self.expPath())
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+        return directory
+
+    ### filename builders
+    ## data files
+    def dataFile(self, filename): 
+        return os.path.join(self.dataPath, filename)
+
+    def generatedFile(self, filename): 
+        return self.dataFile(self.generatedPrefix + filename)
+
+    datasetFile     = lambda self, tier: self.dataFile(self.datasetFilename.format(tier = tier))
+    imagesIdsFile   = lambda self, tier: self.dataFile(self.imgIdsFilename.format(tier = tier)) #
+    imagesFile      = lambda self, tier: self.dataFile(self.imagesFilename.format(tier = tier))
+    instancesFile   = lambda self, tier: self.generatedFile(self.instancesFilename.format(tier = tier))
+
+    questionDictFile    = lambda self: self.generatedFile(self.questionDictFilename)
+    answerDictFile      = lambda self: self.generatedFile(self.answerDictFilename)
+    qaDictFile          = lambda self: self.generatedFile(self.qaDictFilename)
+
+    ## experiment files
+    expPath     = lambda self: self.expPathname.format(expName = self.toString())
+    
+    weightsDir  = lambda self: self.makedirs(self.weightsPath)
+    predsDir    = lambda self: self.makedirs(self.predsPath)
+    logDir      = lambda self: self.makedirs(self.logPath)
+    configDir   = lambda self: self.makedirs(self.configPath)
+
+    weightsFile     = lambda self, epoch: os.path.join(self.weightsDir(), self.weightsFilename.format(epoch = str(epoch)))
+    predsFile       = lambda self, tier: os.path.join(self.predsDir(), self.predsFilename.format(tier = tier, expName = self.expName))
+    answersFile     = lambda self, tier: os.path.join(self.predsDir(), self.answersFilename.format(tier = tier, expName = self.expName))
+    logFile         = lambda self: os.path.join(self.logDir(), self.logFilename.format(expName = self.expName))
+    configFile      = lambda self: os.path.join(self.configDir(), self.configFilename.format(expName = self.expName))
+
+
+# global configuration variable. Holds file paths and program parameters
+config = Config()
+
+###################################### arguments ######################################
+def parseArgs():
+    parser = argparse.ArgumentParser(fromfile_prefix_chars = "@")
+
+    ################ systems
+
+    #custom args
+    parser.add_argument('--train_image_length', default=500, type=int, )
+    parser.add_argument('--test_image_length', default=100, type=int, )
+    parser.add_argument('--val_image_length', default=50, type=int, )
+
+    # gpus and memory
+    parser.add_argument("--gpus",           default = "", type = str,       help = "comma-separated list of gpus to use")
+    parser.add_argument("--gpusNum",        default = 1, type = int,        help = "number of gpus to use")
+    
+    parser.add_argument("--allowGrowth",    action = "store_true",          help = "allow gpu memory growth")
+    parser.add_argument("--maxMemory",      default = 1.0, type = float,    help = "set maximum gpu memory usage")
+    
+    parser.add_argument("--parallel",       action = "store_true",          help = "load images in parallel to batch running")
+    parser.add_argument("--workers",        default = 1, type = int,        help = "number of workers to load images")
+    parser.add_argument("--taskSize",       default = 8, type = int,        help = "number of image batches to load in advance") # 40
+    # parser.add_argument("--tasksNum",       default = 20, type = int,       help = "maximal queue size for tasks (to constrain ram usage)") # 2
+
+    parser.add_argument("--useCPU",         action = "store_true",          help = "put word embeddings on cpu")
+
+    # weight loading and training
+    parser.add_argument("-r", "--restore",  action = "store_true",          help = "restore last epoch (based on results file)") 
+    parser.add_argument("--restoreEpoch",   default = 0, type = int,        help = "if positive, specific epoch to restore")
+    parser.add_argument("--weightsToKeep",  default = 2, type = int,        help = "number of previous epochs' weights keep")
+    parser.add_argument("--saveEvery",     default = 3000, type = int,      help = "number of iterations to save weights after")
+    parser.add_argument("--calleEvery",     default = 1500, type = int,     help = "number of iterations to call custom function after")
+
+    parser.add_argument("--saveSubset",     action = "store_true",          help = "save only subset of the weights")
+    parser.add_argument("--trainSubset",    action = "store_true",          help = "train only subset of the weights")
+    parser.add_argument("--varSubset",      default = [], nargs = "*",      type = str, help = "list of namespaces to train on")    
+    
+    # trainReader = ["questionEmbeddings", "questionReader"]
+    # saveControl = ["questionEmbeddings", "programEmbeddings", "seqReader", "programControl"]
+    
+    # experiment files
+    parser.add_argument("--expName",        default = "PDF_exp_extra", type = str,    help = "experiment name") 
+
+    # data files
+    parser.add_argument("--dataset",         default = "PDF", choices = ["PDF", "CLEVR", "NLVR"], type = str) #
+    parser.add_argument("--dataBasedir",     default = "./", type = str,            help = "data base directory") # /jagupard14/scr1/dorarad/
+    parser.add_argument("--generatedPrefix", default = "gennew", type = str,           help = "prefix for generated data files") 
+    parser.add_argument("--featureType",     default = "norm_128x32", type = str,   help = "features type") #   
+    # resnet101_512x128, norm_400x100, none_80x20, normPerImage_80x20, norm_80x20
+    
+    ################ optimization
+
+    # training/testing
+    parser.add_argument("--train",          action = "store_true",      help = "run training")
+    parser.add_argument("--evalTrain",      action = "store_true",      help = "run eval with ema on train dataset") #   
+    parser.add_argument("--test",           action = "store_true",      help = "run testing every epoch and generate predictions file") #
+    parser.add_argument("--finalTest",      action = "store_true",      help = "run testing on final epoch")
+    parser.add_argument("--retainVal",      action = "store_true",      help = "retain validation order between runs") #     
+
+    parser.add_argument("--getPreds",       action = "store_true",      help = "store prediction")
+    parser.add_argument("--getAtt",         action = "store_true",      help = "store attention maps")
+    parser.add_argument("--analysisType",   default = "", type = str,   choices = ["", "questionLength, programLength","type", "arity"], help = "show breakdown of results according to type") #
+
+    parser.add_argument("--trainedNum",     default = 0, type = int,    help = "if positive, train on subset of the data")    
+    parser.add_argument("--testedNum",      default = 0, type = int,    help = "if positive, test on subset of the data")  
+    
+    # bucketing
+    parser.add_argument("--noBucket",       action = "store_true",      help = "bucket data according to question length")        
+    parser.add_argument("--noRebucket",     action = "store_true",      help = "bucket data according to question and program length") #
+    
+    # filtering
+    parser.add_argument("--tOnlyChain",     action = "store_true",      help = "train only chain questions")
+    parser.add_argument("--vOnlyChain",     action = "store_true",      help = "test only chain questions")
+    parser.add_argument("--tMaxQ",          default = 0, type = int,    help = "if positive, train on questions up to this length")
+    parser.add_argument("--tMaxP",          default = 0, type = int,    help = "if positive, test on questions up to this length")
+    parser.add_argument("--vMaxQ",          default = 0, type = int,    help = "if positive, train on questions with programs up to this length")
+    parser.add_argument("--vMaxP",          default = 0, type = int,    help = "if positive, test on questions with programs up to this length")
+    parser.add_argument("--tFilterOp",      default = 0, type = int,    help = "train questions by to be included in the types listed")
+    parser.add_argument("--vFilterOp",      default = 0, type = int,    help = "test questions by to be included in the types listed")
+
+    # extra and extraVal
+    parser.add_argument("--extra",          action = "store_true",      help = "prepare extra data (add to vocabulary") #
+    parser.add_argument("--trainExtra",     action = "store_true",      help = "train (only) on extra data") #
+    parser.add_argument("--alterExtra",     action = "store_true",      help = "alter main data training with extra dataset") # 
+    parser.add_argument("--alterNum",       default = 1, type = int,    help = "alteration rate") #
+    parser.add_argument("--extraVal",       action = "store_true",      help = "only extra validation data (for compositional clevr)") # 
+    parser.add_argument("--finetuneNum",    default = 0, type = int,    help = "if positive, finetune on that subset of val (for compositional clevr)") #
+
+    # exponential moving average
+    parser.add_argument("--useEMA",         action = "store_true",           help = "use exponential moving average for weights")
+    parser.add_argument("--emaDecayRate",   default = 0.999, type = float,   help = "decay rate for exponential moving average")
+    
+    # sgd optimizer
+    parser.add_argument("--batchSize",      default = 64, type = int,       help = "batch size")    
+    parser.add_argument("--epochs",         default = 100, type = int,      help = "number of epochs to run")    
+    parser.add_argument("--lr",             default = 0.0001, type = float, help = "learning rate")
+    parser.add_argument("--lrReduce",       action = "store_true",          help = "reduce learning rate if training loss doesn't go down (manual annealing)")    
+    parser.add_argument("--lrDecayRate",    default = 0.5, type = float,    help = "learning decay rate if training loss doesn't go down")
+    parser.add_argument("--earlyStopping",  default = 0, type = int,        help = "if positive, stop if no improvement for that number of epochs")
+
+    parser.add_argument("--adam",           action = "store_true",          help = "use adam")   
+    parser.add_argument("--l2",             default = 0, type = float,      help = "if positive, add l2 loss term")    
+    parser.add_argument("--clipGradients",  action = "store_true",          help = "clip gradients")
+    parser.add_argument("--gradMaxNorm",    default = 8, type = int,        help = "clipping value") 
+
+    # batch normalization
+    parser.add_argument("--memoryBN",   action = "store_true",              help = "use batch normalization on the recurrent memory")
+    parser.add_argument("--stemBN",     action = "store_true",              help = "use batch normalization in the image input unit (stem)")
+    parser.add_argument("--outputBN",   action = "store_true",              help = "use batch normalization in the output unit")
+    parser.add_argument("--bnDecay",    default = 0.999, type = float,      help = "batch norm decay rate")
+    parser.add_argument("--bnCenter",   action = "store_true",              help = "batch norm with centering")
+    parser.add_argument("--bnScale",    action = "store_true",              help = "batch norm with scaling")
+
+    ## dropouts
+    parser.add_argument("--encInputDropout", default = 0.85, type = float,   help = "dropout of the rnn inputs to the Question Input Unit") 
+    parser.add_argument("--encStateDropout", default = 1.0, type = float,   help = "dropout of the rnn states of the Question Input Unit") 
+    parser.add_argument("--stemDropout",     default = 0.82, type = float,  help = "dropout of the Image Input Unit (the stem)")
+
+    parser.add_argument("--qDropout",       default = 0.92, type = float,    help = "dropout on the question vector") 
+    # parser.add_argument("--qDropoutOut",    default = 1.0, type = float,    help = "dropout on the question vector the goes to the output unit") 
+    # parser.add_argument("--qDropoutMAC",    default = 1.0, type = float,    help = "dropout on the question vector the goes to MAC") 
+
+    parser.add_argument("--memoryDropout",  default = 0.85, type = float,    help = "dropout on the recurrent memory") 
+    parser.add_argument("--readDropout",    default = 0.85, type = float,    help = "dropout of the read unit")     
+    parser.add_argument("--writeDropout",   default = 1.0, type = float,    help = "dropout of the write unit") 
+    parser.add_argument("--outputDropout",  default = 0.85, type = float,   help = "dropout of the output unit") 
+    
+    parser.add_argument("--parametricDropout",        action = "store_true", help = "use parametric dropout") #
+    parser.add_argument("--encVariationalDropout",    action = "store_true", help = "use variational dropout in the RNN input unit") 
+    parser.add_argument("--memoryVariationalDropout", action = "store_true", help = "use variational dropout across the MAC network") 
+
+    ## nonlinearities
+    parser.add_argument("--relu",       default = "STD", choices = ["STD", "PRM", "ELU", "LKY", "SELU"], type = str, help = "type of ReLU to use: standard, parametric, ELU, or leaky")
+    # parser.add_argument("--reluAlpha",  default = 0.2, type = float,    help = "alpha value for the leaky ReLU")
+
+    parser.add_argument("--mulBias",    default = 0.0, type = float,   help = "bias to add in multiplications (x + b) * (y + b) for better training") #
+
+    parser.add_argument("--imageLinPool",   default = 2, type = int,   help = "pooling for image linearizion") 
+
+    ################ baseline model parameters
+    
+    parser.add_argument("--useBaseline",    action = "store_true",     help = "run the baseline model")    
+    parser.add_argument("--baselineLSTM",   action = "store_true",     help = "use LSTM in baseline")    
+    parser.add_argument("--baselineCNN",    action = "store_true",     help = "use CNN in baseline")       
+    parser.add_argument("--baselineAtt",    action = "store_true",     help = "use stacked attention baseline")
+    
+    parser.add_argument("--baselineProjDim", default = 64, type = int, help = "projection dimension for image linearizion")    
+
+    parser.add_argument("--baselineAttNumLayers", default = 2, type = int, help = "number of stacked attention layers") 
+    parser.add_argument("--baselineAttType", default = "ADD", type = str, choices = ["MUL", "DIAG", "BL", "ADD"], help = "attention type (multiplicative, additive, etc)") 
+
+    ################ image input unit (the "stem")
+
+    parser.add_argument("--stemDim",         default = 512, type = int,               help = "dimension of stem CNNs") 
+    parser.add_argument("--stemNumLayers",   default = 2, type = int,                 help = "number of stem layers")
+    parser.add_argument("--stemKernelSize",  default = 3, type = int,                 help = "kernel size for stem (same for all the stem layers)")
+    parser.add_argument("--stemKernelSizes", default = None, nargs = "*", type = int, help = "kernel sizes for stem (per layer)")
+    parser.add_argument("--stemStrideSizes", default = None, nargs = "*", type = int, help = "stride sizes for stem (per layer)")
+
+    parser.add_argument("--stemLinear",             action = "store_true",          help = "use a linear stem (instead of CNNs)") #
+    # parser.add_argument("--stemProjDim",          default = 64, type = int,       help = "projection dimension of in image linearization") #
+    # parser.add_argument("--stemProjPooling",      default = 2, type = int,        help = "pooling for the image linearization") #
+
+    parser.add_argument("--stemGridRnn",            action = "store_true",          help = "use grid RNN layer") #
+    parser.add_argument("--stemGridRnnMod",         default = "RNN", type = str,    choices = ["RNN", "GRU"], help = "RNN type for grid") #
+    parser.add_argument("--stemGridAct",            default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "nonlinearity type for grid") #
+
+    ## location
+    parser.add_argument("--locationAware",          action = "store_true",          help = "add positional features to image representation (linear meshgrid by default)") 
+    parser.add_argument("--locationType",           default = "L", type = str,      choices = ["L", "PE"], help = "L: linear features, PE: Positional Encoding") 
+    parser.add_argument("--locationBias",           default = 1.0, type = float,    help = "the scale of the positional features")
+    parser.add_argument("--locationDim",            default = 32, type = int,       help = "the number of PE dimensions")
+
+    ################ question input unit (the "encoder")
+    parser.add_argument("--encType",                default = "LSTM",               choices = ["RNN", "GRU", "LSTM", "MiGRU", "MiLSTM"], help = "encoder RNN type")
+    parser.add_argument("--encDim",                 default = 512, type = int,      help = "dimension of encoder RNN")    
+    parser.add_argument("--encNumLayers",           default = 1, type = int,        help = "number of encoder RNN layers")  
+    parser.add_argument("--encBi",                  action = "store_true",          help = "use bi-directional encoder")    
+    # parser.add_argument("--encOutProj",           action = "store_true",          help = "add projection layer for encoder outputs") 
+    # parser.add_argument("--encOutProjDim",        default = 256, type = int,      help = "dimension of the encoder projection layer") 
+    # parser.add_argument("--encQProj",             action = "store_true",          help = "add projection for the question representation")
+    parser.add_argument("--encProj",                action = "store_true",          help = "project encoder outputs and question")
+    parser.add_argument("--encProjQAct",            default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "project question vector with this activation")
+
+    ##### word embeddings 
+    parser.add_argument("--wrdEmbDim",              default = 300, type = int,      help = "word embeddings dimension") 
+    parser.add_argument("--wrdEmbRandom",           action = "store_true",          help = "initialize word embeddings to random (normal)")
+    parser.add_argument("--wrdEmbUniform",          action = "store_true",          help = "initialize with uniform distribution")
+    parser.add_argument("--wrdEmbScale",            default = 1.0, type = float,    help = "word embeddings initialization scale")
+    parser.add_argument("--wrdEmbFixed",            action = "store_true",          help = "set word embeddings fixed (don't train)")
+    parser.add_argument("--wrdEmbUnknown",          action = "store_true",          help = "set words outside of training set to <UNK>")
+
+    parser.add_argument("--ansEmbMod",              default = "NON", choices = ["NON", "SHARED", "BOTH"], type = str,   help = "BOTH: create word embeddings for answers. SHARED: share them with question embeddings.") #
+    parser.add_argument("--answerMod",              default = "NON", choices = ["NON", "MUL", "DIAG", "BL"], type = str, help = "operation for multiplication with answer embeddings: direct multiplication, scalar weighting, or bilinear") #
+
+    ################ output unit (classifier)
+    parser.add_argument("--outClassifierDims",      default = [512], nargs = "*",   type = int, help = "dimensions of the classifier") 
+    parser.add_argument("--outImage",               action = "store_true",          help = "feed the image to the output unit") 
+    parser.add_argument("--outImageDim",            default = 1024, type = int,     help = "dimension of linearized image fed to the output unit") 
+    parser.add_argument("--outQuestion",            action = "store_true",          help = "feed the question to the output unit") 
+    parser.add_argument("--outQuestionMul",         action = "store_true",          help = "feed the multiplication of question and memory to the output unit") 
+
+    ################ network
+    
+    parser.add_argument("--netLength",              default = 16, type = int,        help = "network length (number of cells)")      
+    # parser.add_argument("--netDim", default = 512, type = int)
+    parser.add_argument("--memDim",                 default = 512, type = int,      help = "dimension of memory state")
+    parser.add_argument("--ctrlDim",                default = 512, type = int,      help = "dimension of control state")
+    parser.add_argument("--attDim",                 default = 512, type = int,      help = "dimension of pre-attention interactions space")
+    parser.add_argument("--unsharedCells",          default = False, type = bool,   help = "unshare weights between cells ") 
+
+    # initialization
+    parser.add_argument("--initCtrl",               default = "PRM", type = str,    choices = ["PRM", "ZERO", "Q"], help = "initialization mod for control")
+    parser.add_argument("--initMem",                default = "PRM", type = str,    choices = ["PRM", "ZERO", "Q"], help = "initialization mod for memory")
+    parser.add_argument("--initKBwithQ",            default = "NON", type = str,    choices = ["NON", "CNCT", "MUL"], help = "merge question with knowledge base")
+    parser.add_argument("--addNullWord",            action = "store_true",          help = "add parametric word in the beginning of the question") 
+
+    ################ control unit
+    # control ablations (use whole question or pre-attention continuous vectors as control)
+    parser.add_argument("--controlWholeQ",          action = "store_true",          help = "use whole question vector as control") 
+    parser.add_argument("--controlContinuous",      action = "store_true",          help = "use continuous representation of control (without attention)")
+
+    # step 0: inputs to control unit (word embeddings or encoder outputs, with optional projection)  
+    parser.add_argument("--controlContextual",      action = "store_true",          help = "use contextual words for attention (otherwise will use word embeddings)")
+    parser.add_argument("--controlInWordsProj",     action = "store_true",          help = "apply linear projection over words for attention computation") 
+    parser.add_argument("--controlOutWordsProj",    action = "store_true",          help = "apply linear projection over words for summary computation") 
+
+    parser.add_argument("--controlInputUnshared",   action = "store_true",          help = "use different question representation for each cell") 
+    parser.add_argument("--controlInputAct",        default = "TANH", type = str,   choices = ["NON", "RELU", "TANH"], help = "activation for question projection")
+
+    # step 1: merging previous control and whole question  
+    parser.add_argument("--controlFeedPrev",        action = "store_true",          help = "feed previous control state") 
+    parser.add_argument("--controlFeedPrevAtt",     action = "store_true",          help = "feed previous control post word attention (otherwise will feed continuous control)")
+    parser.add_argument("--controlFeedInputs",      action = "store_true",          help = "feed question representation")
+    parser.add_argument("--controlContAct",         default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "activation on the words interactions")
+    
+    # step 2: word attention and optional projection 
+    parser.add_argument("--controlConcatWords",     action = "store_true",          help = "concatenate words to interaction when computing attention") 
+    parser.add_argument("--controlProj",            action = "store_true",          help = "apply linear projection on words interactions")
+    parser.add_argument("--controlProjAct",         default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "activation for control interactions")
+
+    # parser.add_argument("--controlSelfAtt", default = False, type = bool) 
+
+    # parser.add_argument("--controlCoverage", default = False, type = bool)
+    # parser.add_argument("--controlCoverageBias", default = 1.0, type = float)
+
+    # parser.add_argument("--controlPostRNN", default = False, type = bool) 
+    # parser.add_argument("--controlPostRNNmod", default = "RNN", type = str) # GRU
+
+    # parser.add_argument("--selfAttShareInter", default = False, type = bool)
+
+    # parser.add_argument("--wordControl", default = False, type = bool)
+    # parser.add_argument("--gradualControl", default = False, type = bool)
+
+    ################ read unit
+    # step 1: KB-memory interactions
+    parser.add_argument("--readProjInputs",         action = "store_true",         help = "project read unit inputs")
+    parser.add_argument("--readProjShared",         action = "store_true",         help = "use shared projection for all read unit inputs")
+
+    parser.add_argument("--readMemAttType",         default = "MUL", type = str,   choices = ["MUL", "DIAG", "BL", "ADD"], help = "attention type for interaction with memory")
+    parser.add_argument("--readMemConcatKB",        action = "store_true",         help = "concatenate KB elements to memory interaction")
+    parser.add_argument("--readMemConcatProj",      action = "store_true",         help = "concatenate projected values instead or original to memory interaction")
+    parser.add_argument("--readMemProj",            action = "store_true",         help = "project interactions with memory")
+    parser.add_argument("--readMemAct",             default = "RELU", type = str,  choices = ["NON", "RELU", "TANH"], help = "activation for memory interaction")
+
+    # step 2: interaction with control
+    parser.add_argument("--readCtrl",               action = "store_true",         help = "compare KB-memory interactions to control")
+    parser.add_argument("--readCtrlAttType",        default = "MUL", type = str,   choices = ["MUL", "DIAG", "BL", "ADD"], help = "attention type for interaction with control")
+    parser.add_argument("--readCtrlConcatKB",       action = "store_true",         help = "concatenate KB elements to control interaction")
+    parser.add_argument("--readCtrlConcatProj",     action = "store_true",         help = "concatenate projected values instead or original to control interaction")
+    parser.add_argument("--readCtrlConcatInter",    action = "store_true",         help = "concatenate memory interactions to control interactions")
+    parser.add_argument("--readCtrlAct",            default = "RELU", type = str,  choices = ["NON", "RELU", "TANH"], help = "activation for control interaction")
+
+    # step 3: summarize attention over knowledge base
+    parser.add_argument("--readSmryKBProj",       action = "store_true",        help = "use knowledge base projections when summing attention up (should be used only if KB is projected.")
+    
+    # parser.add_argument("--saAllMultiplicative", default = False, type = bool) 
+    # parser.add_argument("--saSumMultiplicative", default = False, type = bool)
+
+    ################ write unit
+    # step 1: input to the write unit (only previous memory, or new information, or both)
+    parser.add_argument("--writeInputs",            default = "BOTH", type = str,   choices = ["MEM", "INFO", "BOTH", "SUM"], help = "inputs to the write unit")
+    parser.add_argument("--writeConcatMul",         action = "store_true",          help = "add multiplicative integration between inputs")
+    
+    parser.add_argument("--writeInfoProj",          action = "store_true",          help = "project retrieved info")
+    parser.add_argument("--writeInfoAct",           default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "new info activation")
+
+    # step 2: self attention and following projection
+    parser.add_argument("--writeSelfAtt",           action = "store_true",          help = "use self attention") 
+    parser.add_argument("--writeSelfAttMod",        default = "NON", type = str,    choices = ["NON", "CONT"], help = "control version to compare to")
+
+    parser.add_argument("--writeMergeCtrl",           action = "store_true",          help = "merge control with memory") 
+
+    parser.add_argument("--writeMemProj",           action = "store_true",          help = "project new memory")
+    parser.add_argument("--writeMemAct",            default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "new memory activation")
+
+    # step 3: gate between new memory and previous value 
+    parser.add_argument("--writeGate",              action = "store_true",          help = "add gate to write unit") 
+    parser.add_argument("--writeGateShared",        action = "store_true",          help = "use one gate value for all dimensions of the memory state") 
+    parser.add_argument("--writeGateBias",          default = 1.0, type = float,    help = "bias for the write unit gate (positive to bias for taking new memory)") 
+
+    ## modular
+    # parser.add_argument("--modulesNum", default = 10, type = int) 
+    # parser.add_argument("--controlBoth", default = False, type = bool)
+    # parser.add_argument("--addZeroModule", default = False, type = bool) 
+    # parser.add_argument("--endModule", default = False, type = bool) 
+
+    ## hybrid
+    # parser.add_argument("--hybrid",      default = False, type = bool, help = "hybrid attention cnn model") 
+    # parser.add_argument("--earlyHybrid", default = False, type = bool) 
+    # parser.add_argument("--lateHybrid",  default = False, type = bool) 
+
+    ## autoencoders
+    # parser.add_argument("--autoEncMem",         action = "store_true",          help = "add memory2control auto-encoder loss")
+    # parser.add_argument("--autoEncMemW",        default = 0.0001, type = float, help = "weight for auto-encoder loss")
+    # parser.add_argument("--autoEncMemInputs",   default = "INFO", type = str,   choices = ["MEM", "INFO"], help = "inputs to auto-encoder")
+    # parser.add_argument("--autoEncMemAct",      default = "NON", type = str,    choices = ["NON", "RELU", "TANH"], help = "activation type in the auto-encoder")
+    # parser.add_argument("--autoEncMemLoss",     default = "CONT", type = str,   choices = ["CONT", "PROB", "SMRY"], help = "target for the auto-encoder loss")
+    # parser.add_argument("--autoEncMemCnct",     action = "store_true",          help = "concat word attentions to auto-encoder features")
+
+    # parser.add_argument("--autoEncCtrl",        action = "store_true")
+    # parser.add_argument("--autoEncCtrlW",       default = 0.0001, type = float)
+    # parser.add_argument("--autoEncCtrlGRU",     action = "store_true")
+ 
+    ## temperature
+    # parser.add_argument("--temperature",    default = 1.0, type = float,        help = "temperature for modules softmax") #
+    # parser.add_argument("--tempParametric", action = "store_true",              help = "parametric temperature") #
+    # parser.add_argument("--tempDynamic",    action = "store_true",              help = "dynamic temperature") #
+    # parser.add_argument("--tempAnnealRate", default = 0.000004, type = float,   help = "temperature annealing rate") #
+    # parser.add_argument("--tempMin",        default = 0.5, type = float,        help = "minimum temperature") #
+
+    ## gumbel
+    # parser.add_argument("--gumbelSoftmax",      action = "store_true", help = "use gumbel for the module softmax (soft for training and hard for testing)") #
+    # parser.add_argument("--gumbelSoftmaxBoth",  action = "store_true", help = "use softmax for training and testing") #
+    # parser.add_argument("--gumbelArgmaxBoth",   action = "store_true", help = "use argmax for training and testing") #
+    
+    parser.parse_args(namespace = config) 
+
+###################################### dataset configuration ######################################
+
+def configPDF():
+    config.dataPath = "{dataBasedir}/PDF_v1/data".format(dataBasedir = config.dataBasedir)
+    config.datasetFilename = "PDF_{tier}_questions.json"
+    config.wordVectorsFile = "./PDF_v1/data/glove/glove.6B.{dim}d.txt".format(dim = config.wrdEmbDim) #
+
+    config.imageDims = [14, 14, 1024]
+    config.programLims = [5, 10, 15, 20]
+    config.questionLims = [10, 15, 20, 25]
+
+def configCLEVR():
+    config.dataPath = "{dataBasedir}/CLEVR_v1/data".format(dataBasedir = config.dataBasedir)
+    config.datasetFilename = "CLEVR_{tier}_questions.json"
+    config.wordVectorsFile = "./CLEVR_v1/data/glove/glove.6B.{dim}d.txt".format(dim = config.wrdEmbDim) #
+
+    config.imageDims = [14, 14, 1024]
+    config.programLims = [5, 10, 15, 20]
+    config.questionLims = [10, 15, 20, 25]        
+
+def configNLVR():
+    config.dataPath = "{dataBasedir}/nlvr".format(dataBasedir = config.dataBasedir)
+    config.datasetFilename = "{tier}.json"
+    config.imagesFilename = "{{tier}}_{featureType}.h5".format(featureType = config.featureType)
+    config.imgIdsFilename = "{tier}ImgIds.json"
+    config.wordVectorsFile = "./CLEVR_v1/data/glove/glove.6B.{dim}d.txt".format(dim = config.wrdEmbDim) #
+
+    config.questionLims = [12]
+    # config.noRebucket = True 
+
+    # if config.stemKernelSizes == []:
+    #     if config.featureType.endsWith("128x32"):
+    #         config.stemKernelSizes = [8, 4, 4]
+    #         config.stemStrideSizes = [2, 2, 1]
+    #         config.stemNumLayers = 3
+    #     if config.featureType.endsWith("512x128"): 
+    #         config.stemKernelSizes = [8, 4, 4, 2]
+    #         config.stemStrideSizes = [4, 2, 2, 1]
+    #         config.stemNumLayers = 4
+    # config.stemDim = 64
+
+    if config.featureType == "resnet101_512x128":
+        config.imageDims = [8, 32, 1024]
+    else:
+        stridesOverall = 1
+        if stemStrideSizes is not None:
+            for s in config.stemStrideSizes:
+                stridesOverall *= int(s)
+        size = config.featureType.split("_")[-1].split("x")
+        config.imageDims = [int(size[1]) / stridesOverall, int(size[0]) / stridesOverall, 3]
+
+## dataset specific configs
+loadDatasetConfig = {
+    "CLEVR": configCLEVR,
+    "NLVR": configNLVR,
+    "PDF": configPDF
+}