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
}