Spaces:
Runtime error
Runtime error
| 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 | |
| } | |