return data_tuple, aux_tuple # method for changing the maximum length, used mainly during curriculum # learning def set_max_length(self, max_length): self.max_sequence_length = max_length if __name__ == "__main__": """ Tests sequence generator - generates and displays a random sample""" # "Loaded parameters". from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'control_bits': 4, 'data_bits': 8, 'batch_size': 2, # 'randomize_control_lines': True, 'min_sequence_length': 1, 'max_sequence_length': 10 }) # Create problem object. problem = DualSerialReverseRecallCommandLines(params) # Get generator generator = problem.return_generator() # Get batch. data_tuple, aux_tuple = next(generator) # Display single sample (0) from batch. problem.show_sample(data_tuple, aux_tuple)
x = F.relu(self.fc2(x)) x = F.dropout(x) x = self.fc3(x) return F.log_softmax(x, dim=-1) if __name__ == '__main__': # Set visualization. from utils.app_state import AppState AppState().visualize = True # Test base model. from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({}) # model model = MultiHopsAttention(params) while True: # Generate new sequence. # "Image" - batch x channels x width x height input_np = np.random.binomial(1, 0.5, (1, 3, 128, 128)) image = torch.from_numpy(input_np).type(torch.FloatTensor) # Question questions_np = np.random.binomial(1, 0.5, (1, 3, 7)) questions = torch.from_numpy(questions_np).type(torch.FloatTensor) # Target.
x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = F.dropout(x) x = self.fc3(x) return F.log_softmax(x, dim=-1) if __name__ == '__main__': # Set visualization. AppState().visualize = True # Test base model. params = ParamInterface() params.add_custom_params({'use_question_encoding': False, 'pretrained_cnn_model': 'resnet18', 'num_blocks': 2, 'use_pretrained_cnn': True, 'word_embedded_size': 7}) # model model = StackedAttentionVQA(params) while True: # Generate new sequence. # "Image" - batch x channels x width x height input_np = np.random.binomial(1, 0.5, (2, 3, 128, 128)) image = torch.from_numpy(input_np).type(torch.FloatTensor) # Question if params['use_question_encoding']: questions_np = np.random.binomial(1, 0.5, (2, 13, 7))
return data_tuple, aux_tuple # method for changing the maximum length, used mainly during curriculum # learning def set_max_length(self, max_length): self.max_sequence_length = max_length if __name__ == "__main__": """ Tests sequence generator - generates and displays a random sample""" # "Loaded parameters". from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({'control_bits': 4, 'data_bits': 8, 'batch_size': 1, 'min_sequence_length': 1, 'max_sequence_length': 10, 'num_subseq_min': 1, 'num_subseq_max': 4}) # Create problem object. problem = InterruptionReverseRecall(params) # Get generator generator = problem.return_generator() # Get batch. data_tuple, aux_tuple = next(generator) # Display single sample (0) from batch. problem.show_sample(data_tuple, aux_tuple)
aux_tuple = AlgSeqAuxTuple(mask, seq_length, 1) return data_tuple, aux_tuple # method for changing the maximum length, used mainly during curriculum # learning def set_max_length(self, max_length): self.max_sequence_length = max_length if __name__ == "__main__": """ Tests sequence generator - generates and displays a random sample""" # "Loaded parameters". from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({'control_bits': 2, 'data_bits': 8, 'batch_size': 1, 'min_sequence_length': 1, 'max_sequence_length': 10, 'num_bits': 0.5}) # Create problem object. problem = ManipulationSpatialRotation(params) # Get generator generator = problem.return_generator() # Get batch. data_tuple, aux_tuple = next(generator) # Display single sample (0) from batch. problem.show_sample(data_tuple, aux_tuple)
# method for changing the maximum length, used mainly during curriculum # learning def set_max_length(self, max_length): self.max_sequence_length = max_length if __name__ == "__main__": """ Tests sequence generator - generates and displays a random sample""" # "Loaded parameters". from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'control_bits': 4, 'data_bits': 8, 'batch_size': 1, 'min_sequence_length': 1, 'max_sequence_length': 10, 'seq_start': 0, 'skip_step': 2 }) # Create problem object. problem = SkipRecallCommandLines(params) # Get generator generator = problem.return_generator() # Get batch. data_tuple, aux_tuple = next(generator) # Display single sample (0) from batch. problem.show_sample(data_tuple, aux_tuple)
'context_input_size': 32, 'input_size': input_size, 'output_size': 10, 'center_size': 1, 'center_size_per_module': 32, 'num_modules': 4 } # Initialize the application state singleton. from utils.app_state import AppState app_state = AppState() app_state.visualize = True from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params(params_dict) model = ThalNetModel(params) seq_length = 10 batch_size = 2 # Check for different seq_lengts and batch_sizes. for i in range(1): # Create random Tensors to hold inputs and outputs x = torch.randn(batch_size, 1, input_size, input_size) logits = torch.randn(batch_size, 1, params_dict['output_size']) y = x data_tuple = (x, y) # Test forward pass. y_pred = model(data_tuple)
max_step = 12 self_attention = True memory_gate = True nb_classes = 28 dropout = 0.15 from utils.app_state import AppState app_state = AppState() from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'dim': dim, 'embed_hidden': embed_hidden, 'max_step': 12, 'self_attention': self_attention, 'memory_gate': memory_gate, 'nb_classes': nb_classes, 'dropout': dropout }) net = MACNetwork(params) import torch import numpy as np from problems.image_text_to_class.clevr import DataTuple, ImageTextTuple batch_size = 64 embedded_dim = 300 images = torch.from_numpy( np.random.binomial(n=1, p=0.5, size=(batch_size, 1024, 14,
if FLAGS.config == '': print('Please pass configuration file(s) as --c parameter') exit(-1) # Get list of configs that need to be loaded. configs_to_load = recurrent_config_parse(FLAGS.config, []) # Create param interface object. param_interface = ParamInterface() # Read the YAML files one by one - but in reverse order! for config in reversed(configs_to_load): # Open file and try to add that to list of parameter dictionaries. with open(config, 'r') as stream: # Load param dictionaries in reverse order. param_interface.add_custom_params(yaml.load(stream)) print('Loaded configuration from file {}'.format(config)) # Add to list of loaded configs. configs_to_load.append(config) # Done. In here Param Registry contains configuration loaded (and # overwritten) from several files. # Get problem and model names. try: task_name = param_interface['training']['problem']['name'] except BaseException: print( "Error: Couldn't retrieve problem name from the loaded configuration" ) exit(-1)
x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = F.dropout(x) x = self.fc3(x) return F.log_softmax(x, dim=-1) if __name__ == '__main__': # Set visualization. from utils.app_state import AppState AppState().visualize = True # Test base model. # "Loaded parameters". params = ParamInterface() params.add_custom_params({'use_question_encoding': False}) # model model = CNNLSTMVQA(params) while True: # Generate new sequence. # "Image" - batch x channels x width x height input_np = np.random.binomial(1, 0.5, (2, 3, 128, 128)) image = torch.from_numpy(input_np).type(torch.FloatTensor) # Question if params['use_question_encoding']: questions_np = np.random.binomial(1, 0.5, (2, 13, 7)) else: questions_np = np.random.binomial(1, 0.5, (2, 13))
os.path.normpath( os.path.join(os.getcwd(), '../../problems/seq_to_seq/text2text'))) import translation as pb # instantiate problem eng_prefixes = ("i am ", "i m ", "he is", "he s ", "she is", "she s", "you are", "you re ", "we are", "we re ", "they are", "they re ") from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'batch_size': 64, 'training_size': 0.90, 'output_lang_name': 'fra', 'max_sequence_length': 15, 'eng_prefixes': eng_prefixes, 'use_train_data': True, 'data_folder': '~/data/language', 'reverse': False }) problem = pb.Translation(params) print('Problem successfully created.\n') # get size of vocabulary for input & output language input_voc_size = problem.input_lang.n_words output_voc_size = problem.output_lang.n_words # instantiate model with credible parameters from utils.param_interface import ParamInterface
# method for changing the maximum length, used mainly during curriculum # learning def set_max_length(self, max_length): self.max_sequence_length = max_length if __name__ == "__main__": """ Tests sequence generator - generates and displays a random sample""" # "Loaded parameters". from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'name': 'serial_recall_original', 'control_bits': 4, 'data_bits': 8, 'batch_size': 1, 'min_sequence_length': 1, 'max_sequence_length': 10, 'num_subseq_min': 1, 'num_subseq_max': 4 }) # Create problem object. problem = InterruptionNot(params) # Get generator generator = problem.return_generator() # Get batch. data_tuple, aux_tuple = next(generator) # Display single sample (0) from batch. problem.show_sample(data_tuple, aux_tuple)
# method for changing the maximum length, used mainly during curriculum # learning def set_max_length(self, max_length): self.max_sequence_length = max_length if __name__ == "__main__": """ Tests sequence generator - generates and displays a random sample""" # "Loaded parameters". from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'control_bits': 4, 'data_bits': 8, 'batch_size': 1, # 'predict_inverse': False, 'min_sequence_length': 3, 'max_sequence_length': 5 }) # Create problem object. problem = SequenceSymmetryCommandLines(params) # Get generator generator = problem.return_generator() # Get batch. data_tuple, aux_tuple = next(generator) # Display single sample (0) from batch. problem.show_sample(data_tuple, aux_tuple)
if __name__ == '__main__': # Set visualization. from utils.app_state import AppState AppState().visualize = True # Test base model. from utils.param_interface import ParamInterface params = ParamInterface() params.add_custom_params({ 'depth_conv1': 10, 'depth_conv2': 20, 'filter_size_conv1': 5, 'filter_size_conv2': 5, 'num_pooling': 2, 'num_channels': 1, 'up_scaling': None, 'height': 28, 'width': 28, 'padding': (0, 0, 0, 0) }) # model model = SimpleConvNet(params) while True: # Generate new sequence. # "Image" - batch x channels x width x height input_np = np.random.binomial(1, 0.5, (1, 1, 28, 28)) input = torch.from_numpy(input_np).type(torch.FloatTensor) # Target.