def __init__(self, input_size, kernel_size, stride): self.input_size = input_size self.kernel_size = kernel_size self.stride = stride self.indices = None self.X = None self.out_h = get_dim(input_size[1], kernel_size[0], 0, stride) self.out_w = get_dim(input_size[2], kernel_size[1], 0, stride)
if args.train_file is None: raise ValueError('train_file is not specified.') if args.dev_file is None: raise ValueError('dev_file is not specified.') if args.rnn_type == 'lstm': args.rnn_layer = lasagne.layers.LSTMLayer elif args.rnn_type == 'gru': args.rnn_layer = lasagne.layers.GRULayer else: raise NotImplementedError('rnn_type = %s' % args.rnn_type) if args.embedding_file is not None: dim = utils.get_dim(args.embedding_file) if (args.embedding_size is not None) and (args.embedding_size != dim): raise ValueError('embedding_size = %d, but %s has %d dims.' % (args.embedding_size, args.embedding_file, dim)) args.embedding_size = dim elif args.embedding_size is None: raise RuntimeError( 'Either embedding_file or embedding_size needs to be specified.') if args.log_file is None: logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M') else: logging.basicConfig(filename=args.log_file, filemode='w',
if args.train_file is None: raise ValueError('train_file is not specified.') if args.dev_file is None: raise ValueError('dev_file is not specified.') if args.rnn_type == 'lstm': args.rnn_layer = lasagne.layers.LSTMLayer elif args.rnn_type == 'gru': args.rnn_layer = lasagne.layers.GRULayer else: raise NotImplementedError('rnn_type = %s' % args.rnn_type) if args.embedding_file is not None: dim = utils.get_dim(args.embedding_file) if (args.embedding_size is not None) and (args.embedding_size != dim): raise ValueError('embedding_size = %d, but %s has %d dims.' % (args.embedding_size, args.embedding_file, dim)) args.embedding_size = dim elif args.embedding_size is None: raise RuntimeError('Either embedding_file or embedding_size needs to be specified.') if args.log_file is None: logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M') else: logging.basicConfig(filename=args.log_file, filemode='w', level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M')
def qa_model(debug=False, test_only=False, prepare_model=False, random_seed=1013, train_file=None, dev_file=None, pre_trained=None, model_file='model.pkl.gz', log_file=None, embedding_file=None, max_dev=None, relabeling=True, embedding_size=None, hidden_size=128, bidir=True, num_layers=1, rnn_type='gru', att_func='bilinear', batch_size=32, num_epoches=100, eval_iter=100, dropout_rate=0.2, optimizer='sgd', learning_rate=0.1, grad_clipping=10.0): args = namedtuple( "args", "debug, test_only, prepare_model, random_seed, train_file, dev_file, pre_trained, model_file, log_file, embedding_file, max_dev, relabeling, embedding_size, hidden_size, bidir, num_layers, rnn_type, att_func, batch_size, num_epoches, eval_iter, dropout_rate, optimizer, learning_rate, grad_clipping" ) args.debug = debug args.test_only = test_only args.prepare_model = prepare_model args.random_seed = random_seed args.train_file = train_file args.dev_file = dev_file args.pre_trained = pre_trained args.model_file = model_file args.log_file = log_file args.embedding_file = embedding_file args.max_dev = max_dev args.relabeling = relabeling args.embedding_size = embedding_size args.hidden_size = hidden_size args.bidir = bidir args.num_layers = num_layers args.rnn_type = rnn_type args.att_func = att_func args.batch_size = batch_size args.num_epoches = num_epoches args.eval_iter = eval_iter args.dropout_rate = dropout_rate args.optimizer = optimizer args.learning_rate = learning_rate args.grad_clipping = grad_clipping # args = config.get_args() np.random.seed(args.random_seed) lasagne.random.set_rng(np.random.RandomState(args.random_seed)) if args.train_file is None: raise ValueError('train_file is not specified.') if args.dev_file is None: raise ValueError('dev_file is not specified.') if args.rnn_type == 'lstm': args.rnn_layer = lasagne.layers.LSTMLayer elif args.rnn_type == 'gru': args.rnn_layer = lasagne.layers.GRULayer else: raise NotImplementedError('rnn_type = %s' % args.rnn_type) if args.embedding_file is not None: dim = utils.get_dim(args.embedding_file) if (args.embedding_size is not None) and (args.embedding_size != dim): raise ValueError('embedding_size = %d, but %s has %d dims.' % (args.embedding_size, args.embedding_file, dim)) args.embedding_size = dim elif args.embedding_size is None: raise RuntimeError( 'Either embedding_file or embedding_size needs to be specified.') if args.log_file is None: logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M') else: logging.basicConfig(filename=args.log_file, filemode='w', level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M') logging.info(' '.join(sys.argv)) return main(args)
layers = [] total_time = 15 layer_1 = conv1().to('cuda') layers.append(init_layers(total_time=total_time, C=4, H=400, W=400)) layer_2 = pool1().to('cuda') layers.append(init_layers(total_time=total_time, C=4, H=66, W=66)) layer_3 = conv2().to('cuda') layers.append(init_layers(total_time=total_time, C=20, H=54, W=54)) layer_4 = pool2().to('cuda') layers.append(init_layers(total_time=total_time, C=20, H=10, W=10)) layer_5 = conv3().to('cuda') layers.append(init_layers(total_time=total_time, C=20, H=6, W=6)) network = [layer_1, layer_2, layer_3, layer_4, layer_5] network_len = len(network) layer_filt_dimension = get_dim(network[0::2]) thresh = torch.Tensor([.5, .5, .5]) image_names = os.listdir(train_data) data_len = len(image_names) thds_per_dim = 10 for j in trange(data_len): image = DoG(image_name=image_names[j]) image = np.reshape(image, (160000, )) image = freq(15, image, 0.05) image = torch.from_numpy(image).to('cuda') image = image.float() for i in range(stdp_params['max_iter']): for t in range(total_time):
def load_dataset(dataset, train_size, valid_size, test_size): """Load the dataset passed in argument with the corresponding sizes for the training, validation and testing set.""" if dataset == 'mnist_012': root = './data/mnist' num_classes = 3 trans = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.ToTensor(), transforms.Normalize(mean=MNIST_MEAN, std=MNIST_STD)]) train_valid_set = datasets.MNIST(root=root, train=True, transform=trans) test_set = datasets.MNIST(root=root, train=False, transform=trans) train_valid_set = MNIST_bis(dataset=train_valid_set, size=train_size+valid_size, digits_to_keep=[0,1,2]) test_set = MNIST_bis(dataset=test_set, size=test_size, digits_to_keep=[0,1,2]) train_sampler, valid_sampler = train_valid_split(dataset=train_valid_set, train_size=train_size) train_loader = DataLoader(dataset=train_valid_set, batch_size=BATCH_SIZE, sampler=train_sampler, num_workers=4, pin_memory=True, drop_last=True) valid_loader = DataLoader(dataset=train_valid_set, batch_size=BATCH_SIZE, sampler=valid_sampler, num_workers=4, pin_memory=True, drop_last=True) test_loader = DataLoader(dataset=test_set, batch_size=BATCH_SIZE, num_workers=4, pin_memory=True, drop_last=True) elif dataset == 'mnist_rot': root = './data/mnist' num_classes = 9 train_trans = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize((26,26)), transforms.ToTensor(), transforms.Normalize(mean=MNIST_MEAN, std=MNIST_STD)]) test_trans = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize((26,26)), transforms.RandomRotation((0,360)), transforms.ToTensor(), transforms.Normalize(mean=MNIST_MEAN, std=MNIST_STD)]) train_valid_set = datasets.MNIST(root=root, train=True, transform=train_trans) test_set = datasets.MNIST(root=root, train=False, transform=test_trans) train_valid_set_bis = MNIST_bis(dataset=train_valid_set, size=train_size+valid_size, digits_to_keep=[0,1,2,3,4,5,6,7,8]) test_set = MNIST_bis(dataset=test_set, size=test_size, digits_to_keep=[0,1,2,3,4,5,6,7,8]) train_sampler, valid_sampler = train_valid_split(dataset=train_valid_set_bis, train_size=train_size) train_loader = DataLoader(dataset=train_valid_set_bis, batch_size=BATCH_SIZE, sampler=train_sampler, num_workers=4, pin_memory=True, drop_last=True) valid_loader = DataLoader(dataset=train_valid_set_bis, batch_size=BATCH_SIZE, sampler=valid_sampler, num_workers=4, pin_memory=True, drop_last=True) test_loader = DataLoader(dataset=test_set, batch_size=BATCH_SIZE, num_workers=4, pin_memory=True, drop_last=True) elif dataset == 'mnist_trans': root = './data/mnist' num_classes = 9 train_trans = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize((26,26)), transforms.ToTensor(), transforms.Normalize(mean=MNIST_MEAN, std=MNIST_STD)]) test_trans = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize((26,26)), RandomTranslation(horizontal=6, vertical=6), transforms.ToTensor(), transforms.Normalize(mean=MNIST_MEAN, std=MNIST_STD)]) train_valid_set = datasets.MNIST(root=root, train=True, transform=train_trans) test_set = datasets.MNIST(root=root, train=False, transform=test_trans) train_valid_set_bis = MNIST_bis(dataset=train_valid_set, size=train_size+valid_size, digits_to_keep=[0,1,2,3,4,5,6,7,8]) test_set = MNIST_bis(dataset=test_set, size=test_size, digits_to_keep=[0,1,2,3,4,5,6,7,8]) train_sampler, valid_sampler = train_valid_split(dataset=train_valid_set_bis, train_size=train_size) train_loader = DataLoader(dataset=train_valid_set_bis, batch_size=BATCH_SIZE, sampler=train_sampler, num_workers=4, pin_memory=True, drop_last=True) valid_loader = DataLoader(dataset=train_valid_set_bis, batch_size=BATCH_SIZE, sampler=valid_sampler, num_workers=4, pin_memory=True, drop_last=True) test_loader = DataLoader(dataset=test_set, batch_size=BATCH_SIZE, num_workers=4, pin_memory=True, drop_last=True) elif dataset == 'eth80': root = './data/eth80' num_classes = 8 trans = transforms.Compose([transforms.Grayscale(num_output_channels=1), transforms.Resize((50,50)), transforms.ToTensor(), transforms.Normalize(mean=ETH80_MEAN, std=ETH80_STD)]) complete_set = datasets.ImageFolder(root=root, transform=trans) class_names = complete_set.classes train_sampler, valid_sampler, test_sampler = train_valid_test_split(dataset=complete_set, train_size=train_size, valid_size=valid_size) train_loader = DataLoader(dataset=complete_set, batch_size=BATCH_SIZE, sampler=train_sampler, num_workers=4, pin_memory=True, drop_last=True) valid_loader = DataLoader(dataset=complete_set, batch_size=BATCH_SIZE, sampler=valid_sampler, num_workers=4, pin_memory=True, drop_last=True) test_loader = DataLoader(dataset=complete_set, batch_size=BATCH_SIZE, sampler=test_sampler, num_workers=4, pin_memory=True, drop_last=True) else: raise ValueError('Specified dataset does not exist.') logger.debug('Class frequency train loader: {} validation loader: {} test loader: {}'.format( count_class_freq(train_loader, num_classes),count_class_freq(valid_loader, num_classes), count_class_freq(test_loader, num_classes)) ) logging.info('Loaded {} dataset with the split {}-{}-{} for the [train]-[valid]-[test] setup.'.format(dataset, len(train_loader)*BATCH_SIZE, len(valid_loader)*BATCH_SIZE, len(test_loader)*BATCH_SIZE)) return train_loader, valid_loader, test_loader, get_dim(train_loader)
def linear(inputs, output_size, trainable): in_dim = get_dim(inputs) w = get_rand_variable([in_dim, output_size], 1/np.sqrt(in_dim), trainable=trainable) b = get_const_variable([output_size], 0.0, trainable=trainable) return tf.matmul(inputs, w) + b
def init(): path = config.data_path config.embedding_file = os.path.join(path, config.embedding_file) config.train_file = os.path.join(path, config.train_file) config.dev_file = os.path.join(path, config.dev_file) config.test_file = os.path.join(path, config.test_file) dim = utils.get_dim(config.embedding_file) config.embedding_size = dim # Config log if config.log_file is None: logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M') else: logging.basicConfig(filename=config.log_file, filemode='w', level=logging.DEBUG, format='%(asctime)s %(message)s', datefmt='%m-%d %H:%M') # Load data logging.info('-' * 50) logging.info('Load data files..') if config.debug: logging.info('*' * 10 + ' Train') train_examples = utils.load_data(config.train_file, 1000) logging.info('*' * 10 + ' Dev') dev_examples = utils.load_data(config.dev_file, 100) else: logging.info('*' * 10 + ' Train') train_examples = utils.load_data(config.train_file) logging.info('*' * 10 + ' Dev') dev_examples = utils.load_data(config.dev_file) config.num_train = len(train_examples[0]) config.num_dev = len(dev_examples[0]) # Build dictionary logging.info('-' * 50) logging.info('Build dictionary..') word_dict = utils.build_dict(train_examples[0] + train_examples[1]) entity_markers = list(set( [w for w in word_dict.keys() if w.startswith('@entity')] + train_examples[2] )) entity_markers = ['<unk_entity>'] + entity_markers entity_dict = {w: index for (index, w) in enumerate(entity_markers)} logging.info('Entity markers: %d' % len(entity_dict)) config.num_labels = len(entity_dict) logging.info('-' * 50) logging.info('Load embedding file..') embeddings = utils.gen_embeddings(word_dict, config.embedding_size, config.embedding_file) (config.vocab_size, config.embedding_size) = embeddings.shape # Log parameters flags = config.__dict__['__flags'] flag_str = "\n" for k in flags: flag_str += "\t%s:\t%s\n" % (k, flags[k]) logging.info(flag_str) # Vectorize test data logging.info('-' * 50) logging.info('Vectorize test data..') # d: document, q: question, a:answer # l: whether the entity label occurs in the document dev_d, dev_q, dev_l, dev_a = utils.vectorize(dev_examples, word_dict, entity_dict) assert len(dev_d) == config.num_dev all_dev = utils.gen_examples(dev_d, dev_q, dev_l, dev_a, config.batch_size) if config.test_only: return embeddings, all_dev, None # Vectorize training data logging.info('-' * 50) logging.info('Vectorize training data..') train_d, train_q, train_l, train_a = utils.vectorize(train_examples, word_dict, entity_dict) assert len(train_d) == config.num_train all_train = utils.gen_examples(train_d, train_q, train_l, train_a, config.batch_size) return embeddings, all_dev, all_train
def load_saved_dataset(name, data_path=SAVED_DATA): """Load the saved data.""" train_data = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_train_signals.npy'))).float() valid_data = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_val_signals.npy'))).float() test_data = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_test_signals.npy'))).float() train_labels = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_train_labels.npy'))).long() valid_labels = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_val_labels.npy'))).long() test_labels = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_test_labels.npy'))).long() train_dataset = TensorDataset(train_data, train_labels) valid_dataset = TensorDataset(valid_data, valid_labels) test_dataset = TensorDataset(test_data, test_labels) train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, drop_last=True) valid_loader = DataLoader(dataset=valid_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=4, drop_last=True) test_loader = DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=4, drop_last=True) dim = int(np.sqrt(get_dim(train_data))) laplacian_matrix = torch.from_numpy( np.load( os.path.join(data_path, name, 'dataset', name + '_laplacian.npy'))).float() shifted_laplacian_matrix = shift_laplacian(laplacian_matrix, dim).to(DEVICE) if name == 'mnist_012': num_classes = 3 elif name == 'eth80': num_classes = 8 else: num_classes = 9 logger.info( 'Class frequency \ntrain loader: {} \nvalidation loader: {} \ntest loader: {}' .format(count_class_freq(train_loader, num_classes), count_class_freq(valid_loader, num_classes), count_class_freq(test_loader, num_classes))) logging.info( 'Loaded saved {} dataset with the split {}-{}-{} for the [train]-[valid]-[test] setup.' .format(name, len(train_loader) * BATCH_SIZE, len(valid_loader) * BATCH_SIZE, len(test_loader) * BATCH_SIZE)) return train_loader, valid_loader, test_loader, dim, laplacian_matrix, shifted_laplacian_matrix