def eval_acts(self, inp): """ Evaluate Tagger on given inp data Here we are only evaluating the clean path.""" clean_path_kv = [[k, v] for k, v in self.clean.iteritems()] givens = {} givens.update({self.x: inp['features_labeled']}) givens.update({self.y: inp['targets_labeled']}) givens.update({self.x_only: inp['features_unlabeled']}) givens.update( {self.masks_unlabeled: np.float32(inp['masks_unlabeled'])}) params, args = zip(*givens.iteritems()) # on_unused_input is set to ignore to omit some warning prints. It can be changed accordingly base on your use # cases. function = theano.function(params, [k[1] for k in clean_path_kv], on_unused_input='ignore') clean_path_v_outputs = function(*args) acts = AttributeDict(clean=AttributeDict( zip([k[0] for k in clean_path_kv], clean_path_v_outputs))) return acts
def encoder(input_, path_name, input_noise_std=0, noise_std=[]): h = input_ logger.info(' 0: noise %g' % input_noise_std) if input_noise_std > 0.: h = h + self.noise_like(h) * input_noise_std d = AttributeDict() d.unlabeled = self.new_activation_dict() d.labeled = self.new_activation_dict() d.labeled.z[0] = self.labeled(h) d.unlabeled.z[0] = self.unlabeled(h) prev_dim = input_dim for i, (spec, _, act_f) in layers[1:]: d.labeled.h[i - 1], d.unlabeled.h[i - 1] = self.split_lu(h) noise = noise_std[i] if i < len(noise_std) else 0. curr_dim, z, m, s, h = self.f(h, prev_dim, spec, i, act_f, path_name=path_name, noise_std=noise) assert self.layer_dims.get(i) in (None, curr_dim) self.layer_dims[i] = curr_dim d.labeled.z[i], d.unlabeled.z[i] = self.split_lu(z) d.unlabeled.s[i] = s d.unlabeled.m[i] = m prev_dim = curr_dim d.labeled.h[i], d.unlabeled.h[i] = self.split_lu(h) return d
def build_datasets(self, dataset_class, p): train_split = ['train'] train_set = dataset_class(which_sets=train_split) # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) rng = numpy.random.RandomState(seed=p.seed) rng.shuffle(all_ind) valid_set = dataset_class(which_sets=["valid"]) valid_ind = numpy.arange(valid_set.num_examples) trn_set_size = p.get('train_set_size', None) train_ind = all_ind[:trn_set_size] test_split = ['test'] test_set = dataset_class(which_sets=test_split) test_ind = numpy.arange(test_set.num_examples) trn = AttributeDict(set=train_set, ind=train_ind, batch_size=p.batch_size) val = AttributeDict(set=valid_set, ind=valid_ind, batch_size=p.valid_batch_size) tst = AttributeDict(set=test_set, ind=test_ind, batch_size=p.valid_batch_size) return trn, val, tst
def load_and_log_params(cli_params): cli_params = AttributeDict(cli_params) if cli_params.get('load_from'): p = load_df(cli_params.load_from, 'params').to_dict()[0] p = AttributeDict(p) for key in cli_params.keys(): if key not in p: p[key] = None new_params = cli_params loaded = True else: p = cli_params new_params = {} loaded = False # Make dseed seed unless specified explicitly if p.get('dseed') is None and p.get('seed') is not None: p['dseed'] = p['seed'] logger.info('== COMMAND LINE ==') logger.info(' '.join(sys.argv)) logger.info('== PARAMETERS ==') for k, v in p.items(): if new_params.get(k) is not None: p[k] = new_params[k] replace_str = "<- " + str(new_params.get(k)) else: replace_str = "" logger.info(" {!s:20s}: {!s:<20s} {}".format(k, v, replace_str)) return p, loaded
def decoder(self, clean, corr, batch_size): get_unlabeled = lambda x: x[batch_size:] if x is not None else x est = self.new_activation_dict() costs = AttributeDict() costs.denois = AttributeDict() for i, ((_, spec), act_f) in self.layers[::-1]: z_corr = get_unlabeled(corr.z[i]) z_clean = get_unlabeled(clean.z[i]) z_clean_s = get_unlabeled(clean.s.get(i)) z_clean_m = get_unlabeled(clean.m.get(i)) # It's the last layer if i == len(self.layers) - 1: fspec = (None, None) ver = get_unlabeled(corr.h[i]) ver_dim = self.layer_dims[i] top_g = True else: fspec = self.layers[i + 1][1][0] ver = est.z.get(i + 1) ver_dim = self.layer_dims.get(i + 1) top_g = False z_est = self.g(z_lat=z_corr, z_ver=ver, in_dims=ver_dim, out_dims=self.layer_dims[i], num=i, fspec=fspec, top_g=top_g) # For semi-supervised version if z_clean_s: z_est_norm = (z_est - z_clean_m) / z_clean_s else: z_est_norm = z_est z_est_norm = z_est se = SquaredError('denois' + str(i)) costs.denois[i] = se.apply(z_est_norm.flatten(2), z_clean.flatten(2)) \ / np.prod(self.layer_dims[i], dtype=floatX) costs.denois[i].name = 'denois' + str(i) # Store references for later use est.z[i] = z_est est.h[i] = apply_act(z_est, act_f) est.s[i] = None est.m[i] = None return est, costs
def decoder(self, clean, corr): est = self.new_activation_dict() costs = AttributeDict() costs.denois = AttributeDict() for i, ((_, spec), act_f) in self.layers[::-1]: z_corr = corr.unlabeled.z[i] z_clean = clean.unlabeled.z[i] z_clean_s = clean.unlabeled.s.get(i) z_clean_m = clean.unlabeled.m.get(i) # It's the last layer if i == len(self.layers) - 1: fspec = (None, None) ver = corr.unlabeled.h[i] ver_dim = self.layer_dims[i] top_g = True else: fspec = self.layers[i + 1][1][0] ver = est.z.get(i + 1) ver_dim = self.layer_dims.get(i + 1) top_g = False z_est = self.g(z_lat=z_corr, z_ver=ver, in_dims=ver_dim, out_dims=self.layer_dims[i], num=i, fspec=fspec, top_g=top_g) # The first layer if z_clean_s: z_est_norm = (z_est - z_clean_m) / z_clean_s else: z_est_norm = z_est se = SquaredError('denois' + str(i)) costs.denois[i] = se.apply(z_est_norm.flatten(2), z_clean.flatten(2)) \ / np.prod(self.layer_dims[i], dtype=floatX) costs.denois[i].name = 'denois' + str(i) # Store references for later use est.z[i] = z_est est.h[i] = apply_act(z_est, act_f) est.s[i] = None est.m[i] = None return est, costs
def setup_data(p, test_set=False): dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), 'reddit': (SubredditTopPhotosFeatures22, 20000) }[p.dataset] # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples train_set = dataset_class(("train", )) # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class(("test", )) d.test_ind = numpy.arange(d.test.num_examples) # Setup optional whitening, only used for Cifar-10 in_dim = train_set.data_sources[train_set.sources.index( 'features')].shape[1:] if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, \ 'Need %d whitening dimensions, not %d' % (numpy.product(in_dim), p.whiten_zca) cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info('Whitening using %d ZCA components' % p.whiten_zca) whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def mnist_load(train_size=50000, dseed=1): # borrowed from https://github.com/Lasagne/Lasagne/blob/master/examples/mnist.py # We can now download and read the training and test set images and labels. X_train = load_mnist_images('train-images-idx3-ubyte.gz') y_train = load_mnist_labels('train-labels-idx1-ubyte.gz') X_test = load_mnist_images('t10k-images-idx3-ubyte.gz') y_test = load_mnist_labels('t10k-labels-idx1-ubyte.gz') # We reserve the last 10000 training examples for validation. rng = np.random.RandomState(dseed) randix = rng.permutation(X_train.shape[0]) X_train, X_val = X_train[randix[:train_size]], X_train[randix[train_size:]] y_train, y_val = y_train[randix[:train_size]], y_train[randix[train_size:]] logger.debug('%d examples in training dataset' % X_train.shape[0]) logger.debug('%d examples in validation dataset' % X_val.shape[0]) logger.debug('%d examples in testing dataset' % X_test.shape[0]) return AttributeDict({ 'X_train': X_train, 'y_train': y_train, 'X_val': X_val, 'y_val': y_val, 'X_test': X_test, 'y_test': y_test })
def decoder(self, clean, corr, batch_size): get_unlabeled = lambda x: x[batch_size:] if x is not None else x est = self.new_activation_dict() costs = AttributeDict() costs.denois = AttributeDict() for i, ((_, spec), act_f) in self.layers[::-1]: z_corr = get_unlabeled(corr.z[i]) z_clean = get_unlabeled(clean.z[i]) z_clean_s = get_unlabeled(clean.s.get(i)) z_clean_m = get_unlabeled(clean.m.get(i)) # It's the last layer if i == len(self.layers) - 1: fspec = (None, None) ver = get_unlabeled(corr.h[i]) ver_dim = self.layer_dims[i] top_g = True else: fspec = self.layers[i + 1][1][0] ver = est.z.get(i + 1) ver_dim = self.layer_dims.get(i + 1) top_g = False z_est = self.g( z_lat=z_corr, z_ver=ver, in_dims=ver_dim, out_dims=self.layer_dims[i], num=i, fspec=fspec, top_g=top_g ) # For semi-supervised version if z_clean_s: z_est_norm = (z_est - z_clean_m) / z_clean_s else: z_est_norm = z_est z_est_norm = z_est se = SquaredError("denois" + str(i)) costs.denois[i] = se.apply(z_est_norm.flatten(2), z_clean.flatten(2)) / np.prod( self.layer_dims[i], dtype=floatX ) costs.denois[i].name = "denois" + str(i) # Store references for later use est.z[i] = z_est est.h[i] = apply_act(z_est, act_f) est.s[i] = None est.m[i] = None return est, costs
def load_and_log_params(cli_params): cli_params = AttributeDict(cli_params) if cli_params.get('load_from'): p = load_df(cli_params.load_from, 'params').to_dict()[0] p = AttributeDict(p) for key in cli_params.iterkeys(): if key not in p: p[key] = None new_params = cli_params loaded = True else: p = cli_params new_params = {} loaded = False # Make dseed seed unless specified explicitly if p.get('dseed') is None and p.get('seed') is not None: p['dseed'] = p['seed'] logger.info('== COMMAND LINE ==') logger.info(' '.join(sys.argv)) logger.info('== PARAMETERS ==') for k, v in p.iteritems(): if new_params.get(k) is not None: p[k] = new_params[k] replace_str = "<- " + str(new_params.get(k)) else: replace_str = "" logger.info(" {:20}: {:<20} {}".format(k, v, replace_str)) return p, loaded
def get_mnist_data_dict(unlabeled_samples, valid_set_size, test_set=False): train_set = MNIST(("train",)) # Make sure the MNIST data is in right format train_set.data_sources = ( (train_set.data_sources[0] / 255.).astype(numpy.float32), train_set.data_sources[1]) # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) rng = numpy.random.RandomState(seed=1) rng.shuffle(all_ind) data = AttributeDict() # Choose the training set data.train = train_set data.train_ind = all_ind[:unlabeled_samples] # Then choose validation set from the remaining indices data.valid = train_set data.valid_ind = numpy.setdiff1d(all_ind, data.train_ind)[:valid_set_size] logger.info('Using %d examples for validation' % len(data.valid_ind)) # Only touch test data if requested if test_set: data.test = MNIST(("test",)) data.test_ind = numpy.arange(data.test.num_examples) return data
def __init__(self, params): super().__init__() if not isinstance(params, AttributeDict): params = AttributeDict(params) self.hparams = params self.model = TransformerModel(params)
def setup_data(p, test_set=False): dataset_class, training_set_size = {"cifar10": (CIFAR10, 40000), "mnist": (MNIST, 50000)}[p.dataset] # Allow overriding the default from command line if p.get("unlabeled_samples") is not None: training_set_size = p.unlabeled_samples train_set = dataset_class("train") # Make sure the MNIST data is in right format if p.dataset == "mnist": d = train_set.data_sources[train_set.sources.index("features")] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), "Make sure data is in float format and in range 0 to 1" # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get("dseed"): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[: p.valid_set_size] logger.info("Using %d examples for validation" % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class("test") d.test_ind = numpy.arange(d.test.num_examples) # Setup optional whitening, only used for Cifar-10 in_dim = train_set.data_sources[train_set.sources.index("features")].shape[1:] if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, "Need %d whitening dimensions, not %d" % ( numpy.product(in_dim), p.whiten_zca, ) cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=i)[d.sources.index("features")] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info("Whitening using %d ZCA components" % p.whiten_zca) whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def metrics(indexes=['data_objects', 'data_bundles']): """ return document counts """ return [ AttributeDict({ 'name': index, 'count': len(store.get(index, [])) }) for index in indexes ]
def setup_data(p, test_set=False): dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), 'reddit': (SubredditTopPhotosFeatures22, 20000) }[p.dataset] # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples train_set = dataset_class(("train",)) # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class(("test",)) d.test_ind = numpy.arange(d.test.num_examples) # Setup optional whitening, only used for Cifar-10 in_dim = train_set.data_sources[train_set.sources.index('features')].shape[1:] if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, \ 'Need %d whitening dimensions, not %d' % (numpy.product(in_dim), p.whiten_zca) cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info('Whitening using %d ZCA components' % p.whiten_zca) whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def setup_data(p, test_set=False): dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), }[p.dataset] # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples train_set = dataset_class("train") # Make sure the MNIST data is in right format if p.dataset == 'mnist': d = train_set.data_sources[train_set.sources.index('features')] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), \ 'Make sure data is in float format and in range 0 to 1' # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class("test") d.test_ind = numpy.arange(d.test.num_examples) in_dim = train_set.data_sources[train_set.sources.index( 'features')].shape[1:] def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) return in_dim, d
def doPreprocessing(self): results = AttributeDict() results.dataset = [] for i in range(len(self.params.dataset)): # shall we just load it? filename = '%s/preprocessing-%s%s.mat' % ( self.params.dataset[i].savePath, self.params.dataset[i].saveFile, self.params.saveSuffix) if self.params.dataset[i].preprocessing.load and os.path.isfile( filename): r = loadmat(filename) print('Loading file %s ...' % filename) results.dataset[i].preprocessing = r.results_preprocessing else: # or shall we actually calculate it? p = deepcopy(self.params) p.dataset = self.params.dataset[i] d = AttributeDict() d.preprocessing = np.copy(SeqSLAM.preprocessing(p)) results.dataset.append(d) if self.params.dataset[i].preprocessing.save: results_preprocessing = results.dataset[i].preprocessing savemat(filename, {'results_preprocessing': results_preprocessing}) return results
def _load_extends_settings(self, section_name, store): """ Loads all settings from other template(s) specified by a section's 'extends' setting. This method walks a dependency tree of sections from bottom up. Each step is a group of settings for a section in the form of a dictionary. A 'master' dictionary is updated with the settings at each step. This causes the next group of settings to override the previous, and so on. The 'section_name' settings are at the top of the dependency tree. """ section = store[section_name] extends = section.get('extends') if extends is None: return if DEBUG_CONFIG: log.debug('%s extends %s' % (section_name, extends)) extensions = [section] while True: extends = section.get('extends', None) if not extends: break try: section = store[extends] if section in extensions: exts = ', '.join([self._get_section_name(x['__name__']) for x in extensions]) raise exception.ConfigError( "Cyclical dependency between sections %s. " "Check your EXTENDS settings." % exts) extensions.insert(0, section) except KeyError: raise exception.ConfigError( "%s can't extend non-existent section %s" % (section_name, extends)) transform = AttributeDict() for extension in extensions: transform.update(extension) store[section_name] = transform
def __init__(self, p): logger.debug(theano.config) self.p = p self.params = OrderedDict() self.rstream = RandomStreams(seed=p.seed) self.rng = np.random.RandomState(seed=p.seed) self.in_dim = data_dim(p) # input dimensionality input_type = T.type.TensorType('float32', [False] * (len(self.in_dim) + 1)) input_plus_one_type = T.type.TensorType('float32', [False] * (len(self.in_dim) + 2)) self.x_only = input_type('features_unlabeled') self.x = input_type('features_labeled') self.y = theano.tensor.lmatrix('targets_labeled') self.masks_unlabeled = input_plus_one_type('masks_unlabeled') # We noticed that continuous case becomes more stable if we # have stable v, i.e. put Ladder's v through a sigmoid if p.input_type == 'continuous': decoder_spec = ('gauss_stable_v', ) else: decoder_spec = ('gauss', ) # Ladder Network, a.k.a Parametric Mapping ladder_p = AttributeDict({ 'seed': p.seed, 'encoder_layers': p.encoder_proj, 'decoder_spec': decoder_spec, 'denoising_cost_x': (0.0, ) * len(p.encoder_proj), 'act': 'relu', # Ladder doesn't add noise to its layers. Tagger handles all corruption. 'f_local_noise_std': 0., 'super_noise_std': 0., 'zestbn': 'no', 'top_c': True, 'lr': 0., }) self.ladder = LadderAE(ladder_p) # disable logging from ladder logging.getLogger('main.model').setLevel(logging.WARNING)
def merge_with_yaml(yaml_filename): """Load a yaml config file and merge it into the global config object""" global _g_conf with open(yaml_filename, 'r') as f: yaml_file = yaml.load(f) yaml_cfg = AttributeDict(yaml_file) _merge_a_into_b(yaml_cfg, _g_conf) path_parts = os.path.split(yaml_filename) _g_conf.EXPERIMENT_BATCH_NAME = os.path.split(path_parts[-2])[-1] _g_conf.EXPERIMENT_NAME = path_parts[-1].split('.')[-2]
def doPreprocessing(self): results = AttributeDict() results.dataset = [] for i in range(len(self.params.dataset)): # shall we just load it? filename = '%s/preprocessing-%s%s.mat' % (self.params.dataset[i].savePath, self.params.dataset[i].saveFile, self.params.saveSuffix) if self.params.dataset[i].preprocessing.load and os.path.isfile(filename): r = loadmat(filename) print('Loading file %s ...' % filename) results.dataset[i].preprocessing = r.results_preprocessing else: # or shall we actually calculate it? p = deepcopy(self.params) p.dataset = self.params.dataset[i] d = AttributeDict() d.preprocessing = np.copy(SeqSLAM.preprocessing(p)) results.dataset.append(d) if self.params.dataset[i].preprocessing.save: results_preprocessing = results.dataset[i].preprocessing savemat(filename, {'results_preprocessing': results_preprocessing}) return results
def __init__(self, params): super().__init__() if not isinstance(params, AttributeDict): params = AttributeDict(params) self.hparams = params self.model = VQVCModel(params) self.spec_augmenter = SpecAugmentation(time_drop_width=3, time_stripes_num=2, freq_drop_width=3, freq_stripes_num=2)
def encoder(self, input_, path_name, input_noise_std, noise_std): h = input_ h = h + (self.rstream.normal(size=h.shape).astype(floatX) * input_noise_std) d = AttributeDict() d.unlabeled = self.new_activation_dict() d.labeled = self.new_activation_dict() d.labeled.z[0], d.unlabeled.z[0] = self.split_lu(h) prev_dim = self.input_dim for i, (spec, act_f) in self.layers[1:]: d.labeled.h[i - 1], d.unlabeled.h[i - 1] = self.split_lu(h) noise = noise_std[i] if i < len(noise_std) else 0. curr_dim, z, m, s, h = self.f(h, prev_dim, spec, i, act_f, path_name=path_name, noise_std=noise) self.layer_dims[i] = curr_dim d.labeled.z[i], d.unlabeled.z[i] = self.split_lu(z) d.unlabeled.s[i] = s d.unlabeled.m[i] = m prev_dim = curr_dim d.labeled.h[i], d.unlabeled.h[i] = self.split_lu(h) return d
def get_dataset(root: str = DATASETS_PATH, train_size: float = .8, shuffle=True, seed=None) -> AttributeDict: dtype_dict = { x: np.float_ if x in CATEGORICAL_FEATURES else np.float_ for x in ALL_FEATURES } dataset = AttributeDict( train=AttributeDict(X=pd.read_csv(os.path.join(root, 'X1.csv'), dtype=dtype_dict), y=pd.read_csv(os.path.join(root, 'Y1.csv'), header=None, dtype={"shares": np.float_}, names=["shares"])), validation=AttributeDict(X=None, y=None), test=AttributeDict(X=pd.read_csv(os.path.join(root, 'X2.csv'), dtype=dtype_dict), y=None)) if train_size < 1: dataset.train.X, dataset.validation.X, dataset.train.y, dataset.validation.y = train_test_split( dataset.train.X, dataset.train.y, train_size=train_size, shuffle=shuffle, random_state=seed) else: dataset.validation.X = pd.DataFrame( {c: [] for c in dataset.train.X.columns.values}) dataset.validation.y = pd.DataFrame( {c: [] for c in dataset.train.y.columns.values}) return dataset
def setup_data(p, test_set=False): dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), }[p.dataset] # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples train_set = dataset_class("train") # Make sure the MNIST data is in right format if p.dataset == 'mnist': d = train_set.data_sources[train_set.sources.index('features')] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), \ 'Make sure data is in float format and in range 0 to 1' # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class("test") d.test_ind = numpy.arange(d.test.num_examples) in_dim = train_set.data_sources[train_set.sources.index('features')].shape[1:] def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) return in_dim, d
def metrics(indexes=['data_objects', 'data_bundles']): """ return document counts """ def _count(index): try: s = Search(using=client, index=index, doc_type=index[:-1]) return s.count() except elasticsearch.exceptions.NotFoundError as no_found: log.info('NotFoundError {} (expected on empty db)'.format(index)) return 0 except Exception as e: log.error('error getting count of documents in {}'.format(index)) log.exception(e) raise e return [ AttributeDict( {'name': index, 'count': _count(index)} ) for index in indexes ]
def merge_with_yaml(yaml_filename): """Load a yaml config file and merge it into the global config object""" global _g_conf with open(yaml_filename, 'r') as f: yaml_file = yaml.load(f) yaml_cfg = AttributeDict(yaml_file) print("yaml here", yaml_cfg) print("batch size ", yaml_cfg.BATCH_SIZE) _merge_a_into_b(yaml_cfg, _g_conf) #TODO: Merging is missing path_parts = os.path.split(yaml_filename) _g_conf.EXPERIMENT_BATCH_NAME = os.path.split(path_parts[-2])[-1] _g_conf.EXPERIMENT_NAME = path_parts[-1].split('.')[-2]
def load_and_log_params(cli_params): cli_params = AttributeDict(cli_params) # 如果有load_from参数,说明参数是有文件里面读取的,文件格式为hdf if cli_params.get('load_from'): # load_from值 + params组成完整地址 # string => dict p = load_df(cli_params.load_from, 'params').to_dict()[0] # dict => AttributeDict p = AttributeDict(p) for key in cli_params.iterkeys(): if key not in p: p[key] = None new_params = cli_params loaded = True # 如果没有load from参数,直接封装一下cli_params else: p = cli_params new_params = {} loaded = False # Make dseed seed unless specified explicitly # dseed为空而seed不为空时,dseed复制为seed if p.get('dseed') is None and p.get('seed') is not None: p['dseed'] = p['seed'] # log相关 logger.info('== COMMAND LINE ==') logger.info(' '.join(sys.argv)) logger.info('== PARAMETERS ==') for k, v in p.iteritems(): if new_params.get(k) is not None: p[k] = new_params[k] replace_str = "<- " + str(new_params.get(k)) else: replace_str = "" logger.info(" {:20}: {:<20} {}".format(k, v, replace_str)) return p, loaded
def update(_id, doc, index='data_objects'): """ partial update using the contructed _id """ def merge(a, b, path=None): "merges b into a" if path is None: path = [] for key in b: if key in a: if isinstance(a[key], dict) and isinstance(b[key], dict): merge(a[key], b[key], path + [str(key)]) elif a[key] == b[key]: pass # same leaf value else: a[key] = b[key] # update with new else: a[key] = b[key] return a store[index].append( AttributeDict(merge(_get(_id, index=index, current=True), doc))) # noqa
def manage_review_view(request, review_id=None): if not request.user.id: return HttpResponseRedirect('/login') if request.method in CREATE_OR_UPDATE_METHODS: data = request.POST if data.get('action') == 'delete': Review.objects.filter(user=request.user, id=review_id).delete() next_url = '/' elif data.get('action') == 'autofill': fill_missing_review_data(review_id) next_url = request.path else: review, created = Review.create_or_update(request.user, data, id=review_id) if created: fill_missing_review_data(review.id) next_url = '/?submittedReview={}'.format(review.id) return HttpResponseRedirect(next_url) else: if review_id: review = Review.objects.get(user=request.user, id=review_id) else: # pre-populate fields from url parameters. review = AttributeDict({ k: v for k, v in request.GET.items() if k in {'url', 'rating', 'text'} }) return render_with_globals(request, 'manage_review.html', { 'review': review, 'review_id': review_id })
def save(doc, index='data_objects'): """ save the body in the index, ensure version and id set """ doc = AttributeDict(doc) version = doc.get('version', None) if not version: doc['version'] = now() if not doc.get('id', None): temp_id = str(uuid.uuid4()) doc['id'] = temp_id if _is_duplicate(doc, index): raise Exception("duplicate document") if index not in store: store[index] = [] doc.meta = AttributeDict({'id': doc.id}) store[index].append(doc) log.info(doc.id) return doc
def setup_data(p, use_unlabeled=True, use_labeled=True): assert use_unlabeled or use_labeled, 'Cannot train without cost' dataset_class = DATASETS[p.dataset] dataset = dataset_class(p) train_ind = dataset.trn.ind if 'labeled_samples' not in p or p.labeled_samples == 0: n_labeled = len(train_ind) else: n_labeled = p.labeled_samples if 'unlabeled_samples' not in p: n_unlabeled = len(train_ind) else: n_unlabeled = p.unlabeled_samples assert p.batch_size <= n_labeled, "batch size too large" assert len(train_ind) >= n_labeled assert len(train_ind) >= n_unlabeled, "not enough training samples" assert n_labeled <= n_unlabeled, \ "at least as many unlabeled samples as number of labeled samples" # If not using all labels, let's balance classes balance_classes = n_labeled < len(train_ind) if balance_classes and use_labeled: # Ensure each label is equally represented y = dataset.get_train_labels() n_classes = numpy.max(y) + 1 n_from_each_class = n_labeled / n_classes logger.info('n_sample_from_each_class {0}'.format(n_from_each_class)) assert n_labeled % n_classes == 0 i_labeled = [] for c in xrange(n_classes): i = (train_ind[y[:, 0] == c])[:n_from_each_class] if len(i) < n_from_each_class: logger.warning('Class {0} : only got {1}'.format(c, len(i))) i_labeled += list(i) else: i_labeled = train_ind[:n_labeled] def make_unlabeled_set(train_ind, i_labeled, n_unlabeled): """ i_unused_labeled: the labels that are not used in i_labeled. n_unlabeled_needed: the number of need for i_unlabeled beyond len(i_labeled) """ i_unused_labeled = list(set(train_ind) - set(i_labeled)) n_unlabeled_needed = n_unlabeled - len(i_labeled) i_unlabeled = i_unused_labeled[:n_unlabeled_needed] i_unlabeled.extend(i_labeled) return i_unlabeled i_unlabeled = make_unlabeled_set(train_ind, i_labeled, n_unlabeled) logger.info('Creating data set with %d labeled and %d total samples' % (len(i_labeled), len(i_unlabeled))) streams = AttributeDict() def make(kind, ind_labeled, ind_unlabeled): ds_labeled, ds_unlabeled = None, None if use_labeled: ds_labeled = dataset.get_datastream(kind, ind_labeled) if use_unlabeled: ds_unlabeled = dataset.get_datastream(kind, ind_unlabeled) return combine_datastreams(ds_labeled, ds_unlabeled) streams.train = make('trn', i_labeled, i_unlabeled) streams.valid = make('val', None, None) # use all indices streams.test = make('tst', None, None) # use all indices return streams
def apply(self, input_labeled, target_labeled, input_unlabeled): self.layer_counter = 0 input_dim = self.p.encoder_layers[0] # Store the dimension tuples in the same order as layers. layers = self.layers self.layer_dims = {0: input_dim} self.lr = self.shared(self.default_lr, 'learning_rate', role=None) self.costs = costs = AttributeDict() self.costs.denois = AttributeDict() self.act = AttributeDict() self.error = AttributeDict() self.oos = AttributeDict() top = len(layers) - 1 N = input_labeled.shape[0] self.join = lambda l, u: T.concatenate([l, u], axis=0) self.labeled = lambda x: x[:N] if x is not None else x self.unlabeled = lambda x: x[N:] if x is not None else x self.split_lu = lambda x: (self.labeled(x), self.unlabeled(x)) input_concat = self.join(input_labeled, input_unlabeled) def encoder(input_, path_name, input_noise_std=0, noise_std=[]): h = input_ logger.info(' 0: noise %g' % input_noise_std) if input_noise_std > 0.: h = h + self.noise_like(h) * input_noise_std d = AttributeDict() d.unlabeled = self.new_activation_dict() d.labeled = self.new_activation_dict() d.labeled.z[0] = self.labeled(h) d.unlabeled.z[0] = self.unlabeled(h) prev_dim = input_dim for i, (spec, _, act_f) in layers[1:]: d.labeled.h[i - 1], d.unlabeled.h[i - 1] = self.split_lu(h) noise = noise_std[i] if i < len(noise_std) else 0. curr_dim, z, m, s, h = self.f(h, prev_dim, spec, i, act_f, path_name=path_name, noise_std=noise) assert self.layer_dims.get(i) in (None, curr_dim) self.layer_dims[i] = curr_dim d.labeled.z[i], d.unlabeled.z[i] = self.split_lu(z) d.unlabeled.s[i] = s d.unlabeled.m[i] = m prev_dim = curr_dim d.labeled.h[i], d.unlabeled.h[i] = self.split_lu(h) return d # Clean, supervised logger.info('Encoder: clean, labeled') clean = self.act.clean = encoder(input_concat, 'clean') # Corrupted, supervised logger.info('Encoder: corr, labeled') corr = self.act.corr = encoder(input_concat, 'corr', input_noise_std=self.p.super_noise_std, noise_std=self.p.f_local_noise_std) est = self.act.est = self.new_activation_dict() # Decoder path in opposite order logger.info('Decoder: z_corr -> z_est') for i, ((_, spec), l_type, act_f) in layers[::-1]: z_corr = corr.unlabeled.z[i] z_clean = clean.unlabeled.z[i] z_clean_s = clean.unlabeled.s.get(i) z_clean_m = clean.unlabeled.m.get(i) fspec = layers[i + 1][1][0] if len(layers) > i + 1 else (None, None) if i == top: ver = corr.unlabeled.h[i] ver_dim = self.layer_dims[i] top_g = True else: ver = est.z.get(i + 1) ver_dim = self.layer_dims.get(i + 1) top_g = False z_est = self.g(z_lat=z_corr, z_ver=ver, in_dims=ver_dim, out_dims=self.layer_dims[i], l_type=l_type, num=i, fspec=fspec, top_g=top_g) if z_est is not None: # Denoising cost if z_clean_s and self.p.zestbn == 'bugfix': z_est_norm = (z_est - z_clean_m ) / T.sqrt(z_clean_s + np.float32(1e-10)) elif z_clean_s is None or self.p.zestbn == 'no': z_est_norm = z_est else: assert False, 'Not supported path' se = SquaredError('denois' + str(i)) costs.denois[i] = se.apply(z_est_norm.flatten(2), z_clean.flatten(2)) \ / np.prod(self.layer_dims[i], dtype=floatX) costs.denois[i].name = 'denois' + str(i) denois_print = 'denois %.2f' % self.p.denoising_cost_x[i] else: denois_print = '' # Store references for later use est.h[i] = self.apply_act(z_est, act_f) est.z[i] = z_est est.s[i] = None est.m[i] = None logger.info(' g%d: %10s, %s, dim %s -> %s' % (i, l_type, denois_print, self.layer_dims.get(i + 1), self.layer_dims.get(i))) # Costs y = target_labeled.flatten() Q = int(self.layer_dims[top][0]) - 1 logger.info('Q=%d' % Q) costs.class_clean = CategoricalCrossEntropyIV( Q=Q, alpha=self.p.alpha, beta=self.p.beta, dbeta=self.p.dbeta, gamma=self.p.gamma, gamma1=self.p.gamma1).apply(y, clean.labeled.h[top]) costs.class_clean.name = 'cost_class_clean' costs.class_corr = CategoricalCrossEntropyIV( Q=Q, alpha=self.p.alpha, beta=self.p.beta, dbeta=self.p.dbeta, gamma=self.p.gamma, gamma1=self.p.gamma1, ).apply(y, corr.labeled.h[top]) costs.class_corr.name = 'cost_class_corr' # This will be used for training costs.total = costs.class_corr * 1.0 for i in range(top + 1): if costs.denois.get(i) and self.p.denoising_cost_x[i] > 0: costs.total += costs.denois[i] * self.p.denoising_cost_x[i] if self.p.alpha_clean: y_true = y eps = np.float32(1e-6) # scale preds so that the class probas of each sample sum to 1 y_pred = clean.labeled.h[top] + eps y_pred /= y_pred.sum(axis=-1, keepdims=True) y0 = T.or_(T.eq(y_true, 0), T.gt(y_true, Q)) # out-of-set or unlabeled y0sum = y0.sum() + eps # number of oos cost1 = T.nnet.categorical_crossentropy(y_pred, y_pred) cost1 = T.dot(y0, cost1) / y0sum # average cost per labeled example costs.total += self.p.alpha_clean * cost1 costs.total.name = 'cost_total' # Classification error mr = MisclassificationRateIV(oos_thr=self.p.oos_thr) self.error.clean = mr.apply(y, clean.labeled.h[top]) * np.float32(100.) self.error.clean.name = 'error_rate_clean' oosr = OOSRateIV() self.oos.clean = oosr.apply(y, clean.labeled.h[top]) * np.float32(100.) self.oos.clean.name = 'oos_rate_clean'
# -*- encoding: utf-8 -*- # customize/override for your backend import logging import os import uuid from utils import AttributeDict, now, add_created_timestamps, \ add_updated_timestamps log = logging.getLogger(__name__) DEFAULT_PAGE_SIZE = 100 store = AttributeDict({}) def save(doc, index='data_objects'): """ save the body in the index, ensure version and id set """ doc = AttributeDict(doc) version = doc.get('version', None) if not version: doc['version'] = now() if not doc.get('id', None): temp_id = str(uuid.uuid4()) doc['id'] = temp_id if _is_duplicate(doc, index):
def defaultParameters(): params = AttributeDict() # switches params.DO_PREPROCESSING = 1 params.DO_RESIZE = 0 params.DO_GRAYLEVEL = 1 params.DO_PATCHNORMALIZATION = 1 #!!!! 1 params.DO_SAVE_PREPROCESSED_IMG = 0 params.DO_DIFF_MATRIX = 1 params.DO_CONTRAST_ENHANCEMENT = 1 params.DO_FIND_MATCHES = 1 # parameters for preprocessing params.downsample = AttributeDict() params.downsample.size = [32, 64] # height, width try: params.downsample.method = Image.LANCZOS except: params.downsample.method = Image.ANTIALIAS params.normalization = AttributeDict() params.normalization.sideLength = 8 params.normalization.mode = 1 # parameters regarding the matching between images params.matching = AttributeDict() params.matching.ds = 10 params.matching.Rrecent=5 params.matching.vmin = 0.8 params.matching.vskip = 0.1 params.matching.vmax = 1.2 params.matching.Rwindow = 10 params.matching.save = 1 params.matching.load = 0 #1 # parameters for contrast enhancement on difference matrix params.contrastEnhancement = AttributeDict() params.contrastEnhancement.R = 10 # load old results or re-calculate? save results? params.differenceMatrix = AttributeDict() params.differenceMatrix.save = 1 params.differenceMatrix.load = 0 #1 params.contrastEnhanced = AttributeDict() params.contrastEnhanced.save = 1 params.contrastEnhanced.load = 0 #1 # suffix appended on files containing the results params.saveSuffix='' return params
def new_activation_dict(self): return AttributeDict({'z': {}, 'h': {}, 's': {}, 'm': {}})
def demo(): # set the parameters # start with default parameters params = defaultParameters() # Nordland spring dataset ds = AttributeDict() ds.name = 'spring' path = os.environ['DATASET_1_PATH'] ds.imagePath = path ds.prefix = 'images-' ds.extension = '.png' ds.suffix = '' ds.imageSkip = 1 # use every n-nth image ds.imageIndices = range(1, 26, ds.imageSkip) ds.savePath = 'results' ds.saveFile = '%s-%d-%d-%d' % (ds.name, ds.imageIndices[0], ds.imageSkip, ds.imageIndices[-1]) ds.preprocessing = AttributeDict() ds.preprocessing.save = 1 ds.preprocessing.load = 0 #1 ds.crop = [] spring = ds ds2 = deepcopy(ds) # Nordland winter dataset ds2.name = 'winter' #ds.imagePath = '../datasets/nordland/64x32-grayscale-1fps/winter' path = os.environ['DATASET_2_PATH'] ds2.saveFile = '%s-%d-%d-%d' % (ds2.name, ds2.imageIndices[0], ds2.imageSkip, ds2.imageIndices[-1]) ds2.crop = [] winter = ds2 params.dataset = [spring, winter] # load old results or re-calculate? params.differenceMatrix.load = 0 params.contrastEnhanced.load = 0 params.matching.load = 0 # where to save / load the results params.savePath = 'results' ## now process the dataset ss = SeqSLAM(params) t1 = time.time() results = ss.run() t2 = time.time() print "time taken: " + str(t2 - t1) ## show some results if len(results.matches) > 0: m = results.matches[:, 0] # The LARGER the score, the WEAKER the match. thresh = 0.90 # you can calculate a precision-recall plot by varying this threshold m[results.matches[:, 1] > thresh] = np.nan # remove the weakest matches plt.plot(m, '.') # ideally, this would only be the diagonal plt.title('Matchings') plt.show() else: print "Zero matches"
from __future__ import unicode_literals from ast import literal_eval from utils import AttributeDict import copy import numpy as np import os import os.path as osp import yaml from configs.namer import generate_name from logger.coil_logger import create_log, add_message # TODO: NAMing conventions ? _g_conf = AttributeDict() """#### GENERAL CONFIGURATION PARAMETERS ####""" _g_conf.NUMBER_OF_LOADING_WORKERS = 12 _g_conf.SENSORS = {'rgb': (3, 128, 128)} _g_conf.MEASUREMENTS = {'targets': (31)} _g_conf.TARGETS = ['steer', 'throttle', 'brake'] _g_conf.INPUTS = ['speed_module'] _g_conf.BALANCE_DATA = True _g_conf.STEERING_DIVISION = [0.05, 0.05, 0.1, 0.3, 0.3, 0.1, 0.05, 0.05] #_g_conf.STEERING_DIVISION = [0.01, 0.02, 0.07, 0.4, 0.4, 0.07, 0.02, 0.01] # Forcing curves alot _g_conf.LABELS_DIVISION = [[0, 2, 5], [3], [4]] _g_conf.BATCH_SIZE = 120 #_g_conf.AUGMENTATION_SUITE = [iag.ToGPU()]#, iag.Add((0, 0)), iag.Dropout(0, 0), iag.Multiply((1, 1.04)), # #iag.GaussianBlur(sigma=(0.0, 3.0)), # iag.ContrastNormalization((0.5, 1.5))
def demo(): # set the parameters # start with default parameters params = defaultParameters() # Nordland spring dataset ds = AttributeDict() ds.name = 'spring' try: path = os.environ['DATASET_1_PATH'] except: path = '../datasets/nordland/64x32-grayscale-1fps/spring' print "Warning: Environment variable DATASET_1_PATH not found! Trying '"+path+"'" ds.imagePath = path ds.prefix='images-' ds.extension='.png' ds.suffix='' ds.imageSkip = 100 # use every n-nth image ds.imageIndices = range(1, 35700, ds.imageSkip) ds.savePath = 'results' ds.saveFile = '%s-%d-%d-%d' % (ds.name, ds.imageIndices[0], ds.imageSkip, ds.imageIndices[-1]) ds.preprocessing = AttributeDict() ds.preprocessing.save = 1 ds.preprocessing.load = 0 #1 #ds.crop=[1 1 60 32] # x0 y0 x1 y1 cropping will be done AFTER resizing! ds.crop=[] spring=ds ds2 = deepcopy(ds) # Nordland winter dataset ds2.name = 'winter' #ds.imagePath = '../datasets/nordland/64x32-grayscale-1fps/winter' try: path = os.environ['DATASET_2_PATH'] except: path = '../datasets/nordland/64x32-grayscale-1fps/winter' print "Warning: Environment variable DATASET_2_PATH not found! Trying '"+path+"'" ds2.saveFile = '%s-%d-%d-%d' % (ds2.name, ds2.imageIndices[0], ds2.imageSkip, ds2.imageIndices[-1]) # ds.crop=[5 1 64 32] ds2.crop=[] winter=ds2 params.dataset = [spring, winter] # load old results or re-calculate? params.differenceMatrix.load = 0 params.contrastEnhanced.load = 0 params.matching.load = 0 # where to save / load the results params.savePath='results' ## now process the dataset ss = SeqSLAM(params) t1=time.time() results = ss.run() t2=time.time() print "time taken: "+str(t2-t1) ## show some results if len(results.matches) > 0: m = results.matches[:,0] # The LARGER the score, the WEAKER the match. thresh=0.9 # you can calculate a precision-recall plot by varying this threshold m[results.matches[:,1]>thresh] = np.nan # remove the weakest matches plt.plot(m,'.') # ideally, this would only be the diagonal plt.title('Matchings') plt.show() else: print "Zero matches"
def defaultParameters(): params = AttributeDict() # switches params.DO_PREPROCESSING = 1 params.DO_RESIZE = 1 params.DO_GRAYLEVEL = 1 params.DO_PATCHNORMALIZATION = 0 #!!!! 1 params.DO_SAVE_PREPROCESSED_IMG = 1 params.DO_DIFF_MATRIX = 1 params.DO_CONTRAST_ENHANCEMENT = 1 params.DO_FIND_MATCHES = 1 # parameters for preprocessing params.downsample = AttributeDict() params.downsample.size = [48, 64] # height, width try: params.downsample.method = Image.LANCZOS except: params.downsample.method = Image.ANTIALIAS params.normalization = AttributeDict() params.normalization.sideLength = 8 params.normalization.mode = 1 # parameters regarding the matching between images params.matching = AttributeDict() params.matching.ds = 10 params.matching.Rrecent = 5 params.matching.vmin = 0.01 params.matching.vskip = 0.1 params.matching.vmax = 1.2 params.matching.Rwindow = 8 params.matching.save = 1 params.matching.load = 0 #1 # parameters for contrast enhancement on difference matrix params.contrastEnhancement = AttributeDict() params.contrastEnhancement.R = 10 # load old results or re-calculate? save results? params.differenceMatrix = AttributeDict() params.differenceMatrix.save = 1 params.differenceMatrix.load = 0 #1 params.contrastEnhanced = AttributeDict() params.contrastEnhanced.save = 1 params.contrastEnhanced.load = 0 #1 # suffix appended on files containing the results params.saveSuffix = '' return params
def apply_tagger(self, x, apply_noise, y=None): """ Build one path of Tagger """ mb_size = x.shape[1] input_shape = (self.p.n_groups, mb_size) + self.in_dim in_dim = np.prod(self.in_dim) # Add noise x_corr = self.corrupt(x) if apply_noise else x # Repeat input x_corr = T.repeat(x_corr, self.p.n_groups, 0) # Compute v if self.p.input_type == 'binary': v = None elif self.p.input_type == 'continuous': v = self.weight(1., 'v') v = v * T.alloc(1., *input_shape) # Cap to positive range v = nn.exp_inv_sinh(v) d = AttributeDict() if y: d.pred = [] d.class_error, d.class_cost = [], [] # here we have the book-keeping of z and m for the visualizations. d.z = [] d.m = [] else: d.denoising_cost, d.ami_score, d.ami_score_per_sample = [], [], [] assert self.p.n_iterations >= 1 # z_hat is the value for the next iteration of tagger. # z is the current iteration tagger input # m is the current iteration mask input # m_hat is the value for the next iteration of tagger. # m_lh is the mask likelihood. # z_delta is the gradient of z, which depends on x, z and m. for step in xrange(self.p.n_iterations): # Encoder # ======= # Compute m, z and z_hat_pre_bin if step == 0: # No values from previous iteration, so let's make them up m, z = self.init_m_z(input_shape) z_hat_pre_bin = None # let's keep in the bookkeeping for the visualizations. if y: d.z.append(z) d.m.append(m) else: # Feed in the previous iteration's estimates z = z_hat m = m_hat # Compute m_lh m_lh = self.m_lh(x_corr, z, v) z_delta = self.f_z_deriv(x_corr, z, m) z_tilde = z_hat_pre_bin if z_hat_pre_bin is not None else z # Concatenate all inputs inputs = [z_tilde, z_delta, m, m_lh] inputs = T.concatenate(inputs, axis=2) # Projection, batch-normalization and activation to a hidden layer z = self.proj(inputs, in_dim * 4, self.p.encoder_proj[0]) z -= z.mean((0, 1), keepdims=True) z /= T.sqrt(z.var((0, 1), keepdims=True) + np.float32(1e-10)) z += self.bias(0.0 * np.ones(self.p.encoder_proj[0]), 'b') h = self.apply_act(z, 'relu') # The first dimension is the group. Let's flatten together with # minibatch in order to have parametric mapping compute all groups # in parallel h, undo_flatten = flatten_first_two_dims(h) # Parametric Mapping # ================== self.ladder.apply(None, self.y, h) ladder_encoder_output = undo_flatten( self.ladder.act.corr.unlabeled.h[len(self.p.encoder_proj) - 1]) ladder_decoder_output = undo_flatten(self.ladder.act.est.z[0]) # Decoder # ======= # compute z_hat z_u = self.proj(ladder_decoder_output, self.p.encoder_proj[0], in_dim, scope='z_u') z_u -= z_u.mean((0, 1), keepdims=True) z_u /= T.sqrt(z_u.var((0, 1), keepdims=True) + np.float32(1e-10)) z_hat = self.weight(np.ones(in_dim), 'c1') * z_u + self.bias( np.zeros(in_dim), 'b1') z_hat = z_hat.reshape(input_shape) # compute m_hat m_u = self.proj(ladder_decoder_output, self.p.encoder_proj[0], in_dim, scope='m_u') m_u -= m_u.mean((0, 1), keepdims=True) m_u /= T.sqrt(m_u.var((0, 1), keepdims=True) + np.float32(1e-10)) c = self.weight(np.float32(1), 'c2') m_hat = nn.softmax_n(m_u * c, axis=0) m_hat = m_hat.reshape(input_shape) # Apply sigmoid activation if input_type is binary if self.p.input_type == 'binary': z_hat_pre_bin = z_hat z_hat = self.apply_act(z_hat, 'sigmoid') # Collapse layer # ============== # Remove the last dim, which is assumed to be class 'None' pred = ladder_encoder_output[:, :, :-1] # Normalize pred /= T.sum(T.sum(pred, axis=2, keepdims=True), axis=0, keepdims=True) # Denoising and Classification costs # ================================== if y: class_cost, class_error = self.compute_classification_cost_and_error( pred, y) d.pred.append(pred) d.class_cost.append(class_cost) d.class_error.append(class_error) d.m.append(m_hat) d.z.append(z_hat) else: d.denoising_cost.append(self.denoising_cost( z_hat, m_hat, x, v)) ami_score, ami_score_per_sample = self.mask_accuracy( self.masks_unlabeled, m_hat) d.ami_score.append(ami_score) d.ami_score_per_sample.append(ami_score_per_sample) # stack the list of tensors into one d = AttributeDict( {key: T.stacklists(val) for key, val in d.iteritems()}) return d
def setup_data(p, test_set=False): dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), 'conll': (EMBOOT_CONLL, 13900), 'ontonotes': (EMBOOT_ONTO, 67000) }[p.dataset] print("p.dataset = ", p.dataset) # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples print("Training set size : ", training_set_size) train_set = dataset_class(["train"]) print("train_set.num_examples : ", train_set.num_examples) # Make sure the MNIST data is in right format if p.dataset == 'mnist': d = train_set.data_sources[train_set.sources.index('features')] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), \ 'Make sure data is in float format and in range 0 to 1' # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class(["test"]) d.test_ind = numpy.arange(d.test.num_examples) print("d.test.num_examples = ", d.test.num_examples) in_dim = train_set.data_sources[train_set.sources.index( 'features')].shape[1:] if p.dataset == 'conll' or p.dataset == 'ontonotes': whiten = None cnorm = None # Setup optional whitening, only used for Cifar-10 elif p.dataset == 'cifar10': if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, \ 'Need %d whitening dimensions, not %d' % (numpy.product(in_dim), p.whiten_zca) cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=list(i))[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info('Whitening using %d ZCA components' % p.whiten_zca) whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def setup_data(p, test_set=False): # CIFAR10与MNIST都是封装过后的HDF5数据集 # p.dataset为命令行传入的参数,在cifar10与mnist之间选择其一 dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), }[p.dataset] # 可以通过命令行指定为标注样本的大小 # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples # 选出mnist数据集里面的train子集 train_set = dataset_class("train") # Make sure the MNIST data is in right format # 对minst进行数据检查,查看是否所有值都在0-1之间且都为float if p.dataset == 'mnist': # features大小为60000*1*28*28,num_examples*channel*height*weight,minst为灰度图片所以channel=1 d = train_set.data_sources[train_set.sources.index('features')] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), \ 'Make sure data is in float format and in range 0 to 1' # 随机打乱样本顺序 # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): # 通过dseed制作一个随机器,用于打乱样本编号 rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set # 此时index应该都被打乱 # 取出前training_set_size个数的样本做为训练集(的index) d.train_ind = all_ind[:training_set_size] # 选出一部分数据作为验证集 # Then choose validation set from the remaining indices d.valid = train_set # 全部的数据集中去掉训练用的样本,剩下的作为验证集 d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # 如果有测试数据的话,生成测试数据的index # Only touch test data if requested if test_set: d.test = dataset_class("test") d.test_ind = numpy.arange(d.test.num_examples) # Setup optional whitening, only used for Cifar-10 # 计算特征值的维度,shape[1:]:获取第一个样本的维度 in_dim = train_set.data_sources[train_set.sources.index('features')].shape[1:] if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, \ 'Need %d whitening dimensions, not %d' % (numpy.product(in_dim), p.whiten_zca) # 归一化参数如果不为空,创建归一化类 cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 # 检查data集合中的item是否符合float32类型 data = numpy.require(data, dtype=numpy.float32) # TODO ContrastNorm.apply return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info('Whitening using %d ZCA components' % p.whiten_zca) # TODO ZCA whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def setup_data(p, test_set=False): dataset_class = { 'cifar10': (CIFAR10), 'jos' : (JOS), 'mnist': (MNIST), }[p.dataset] training_set_size = p.unlabeled_samples # Allow overriding the default from command line if p.get('unlabeled_samples') is not None: training_set_size = p.unlabeled_samples train_set = dataset_class(["train"]) # Make sure the MNIST data is in right format if p.dataset == 'mnist': d = train_set.data_sources[train_set.sources.index('features')] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), \ 'Make sure data is in float format and in range 0 to 1' # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class(["test"]) d.test_ind = numpy.arange(d.test.num_examples) # Setup optional whitening, only used for Cifar-10 fn = find_in_data_path(train_set.filename) #iprint(fn) s1 = H5PYDataset(fn, ("train",)) handle = s1.open() in_dim = s1.get_data(handle,slice(0,1))[0].shape[1:] s1.close(handle) #in_dim = train_set.data_sources[train_set.sources.index('features')].shape[1:] if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, \ 'Need %d whitening dimensions, not %d' % (numpy.product(in_dim), p.whiten_zca) cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=list(i))[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info('Whitening using %d ZCA components' % p.whiten_zca) whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def setup_data(p, test_set=False): if p.dataset in ['cifar10','mnist']: dataset_class, training_set_size = { 'cifar10': (CIFAR10, 40000), 'mnist': (MNIST, 50000), }[p.dataset] else: from fuel.datasets import H5PYDataset from fuel.utils import find_in_data_path from functools import partial fn=p.dataset fn=os.path.join(fn, fn + '.hdf5') def dataset_class(which_sets): return H5PYDataset(file_or_path=find_in_data_path(fn), which_sets=which_sets, load_in_memory=True) training_set_size = None train_set = dataset_class(["train"]) # Allow overriding the default from command line if p.get('unlabeled_samples') is not None and p.unlabeled_samples >= 0: training_set_size = p.unlabeled_samples elif training_set_size is None: training_set_size = train_set.num_examples # Make sure the MNIST data is in right format if p.dataset == 'mnist': d = train_set.data_sources[train_set.sources.index('features')] assert numpy.all(d <= 1.0) and numpy.all(d >= 0.0), \ 'Make sure data is in float format and in range 0 to 1' # Take all indices and permutate them all_ind = numpy.arange(train_set.num_examples) if p.get('dseed'): rng = numpy.random.RandomState(seed=p.dseed) rng.shuffle(all_ind) d = AttributeDict() # Choose the training set d.train = train_set d.train_ind = all_ind[:training_set_size] # Then choose validation set from the remaining indices d.valid = train_set d.valid_ind = numpy.setdiff1d(all_ind, d.train_ind)[:p.valid_set_size] logger.info('Using %d examples for validation' % len(d.valid_ind)) # Only touch test data if requested if test_set: d.test = dataset_class(["test"]) d.test_ind = numpy.arange(d.test.num_examples) # Setup optional whitening, only used for Cifar-10 in_dim = train_set.data_sources[train_set.sources.index('features')].shape[1:] if len(in_dim) > 1 and p.whiten_zca > 0: assert numpy.product(in_dim) == p.whiten_zca, \ 'Need %d whitening dimensions, not %d' % (numpy.product(in_dim), p.whiten_zca) cnorm = ContrastNorm(p.contrast_norm) if p.contrast_norm != 0 else None def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data) if p.whiten_zca > 0: logger.info('Whitening using %d ZCA components' % p.whiten_zca) whiten = ZCA() whiten.fit(p.whiten_zca, get_data(d.train, d.train_ind)) else: whiten = None return in_dim, d, whiten, cnorm
def apply(self, input_labeled, target_labeled, input_unlabeled): self.layer_counter = 0 input_dim = self.p.encoder_layers[0] # Store the dimension tuples in the same order as layers. layers = self.layers self.layer_dims = {0: input_dim} self.lr = self.shared(self.default_lr, 'learning_rate', role=None) self.costs = costs = AttributeDict() self.costs.denois = AttributeDict() self.act = AttributeDict() self.error = AttributeDict() top = len(layers) - 1 N = input_labeled.shape[0] self.join = lambda l, u: T.concatenate([l, u], axis=0) self.labeled = lambda x: x[:N] if x is not None else x self.unlabeled = lambda x: x[N:] if x is not None else x self.split_lu = lambda x: (self.labeled(x), self.unlabeled(x)) input_concat = self.join(input_labeled, input_unlabeled) def encoder(input_, path_name, input_noise_std=0, noise_std=[]): h = input_ logger.info(' 0: noise %g' % input_noise_std) if input_noise_std > 0.: h = h + self.noise_like(h) * input_noise_std d = AttributeDict() d.unlabeled = self.new_activation_dict() d.labeled = self.new_activation_dict() d.labeled.z[0] = self.labeled(h) d.unlabeled.z[0] = self.unlabeled(h) prev_dim = input_dim for i, (spec, _, act_f) in layers[1:]: d.labeled.h[i - 1], d.unlabeled.h[i - 1] = self.split_lu(h) noise = noise_std[i] if i < len(noise_std) else 0. curr_dim, z, m, s, h = self.f(h, prev_dim, spec, i, act_f, path_name=path_name, noise_std=noise) assert self.layer_dims.get(i) in (None, curr_dim) self.layer_dims[i] = curr_dim d.labeled.z[i], d.unlabeled.z[i] = self.split_lu(z) d.unlabeled.s[i] = s d.unlabeled.m[i] = m prev_dim = curr_dim d.labeled.h[i], d.unlabeled.h[i] = self.split_lu(h) return d # Clean, supervised logger.info('Encoder: clean, labeled') clean = self.act.clean = encoder(input_concat, 'clean') # Corrupted, supervised logger.info('Encoder: corr, labeled') corr = self.act.corr = encoder(input_concat, 'corr', input_noise_std=self.p.super_noise_std, noise_std=self.p.f_local_noise_std) est = self.act.est = self.new_activation_dict() # Decoder path in opposite order logger.info('Decoder: z_corr -> z_est') for i, ((_, spec), l_type, act_f) in layers[::-1]: z_corr = corr.unlabeled.z[i] z_clean = clean.unlabeled.z[i] z_clean_s = clean.unlabeled.s.get(i) z_clean_m = clean.unlabeled.m.get(i) fspec = layers[i + 1][1][0] if len(layers) > i + 1 else (None, None) if i == top: ver = corr.unlabeled.h[i] ver_dim = self.layer_dims[i] top_g = True else: ver = est.z.get(i + 1) ver_dim = self.layer_dims.get(i + 1) top_g = False z_est = self.g(z_lat=z_corr, z_ver=ver, in_dims=ver_dim, out_dims=self.layer_dims[i], l_type=l_type, num=i, fspec=fspec, top_g=top_g) if z_est is not None: # Denoising cost if z_clean_s: z_est_norm = (z_est - z_clean_m) / z_clean_s else: z_est_norm = z_est se = SquaredError('denois' + str(i)) costs.denois[i] = se.apply(z_est_norm.flatten(2), z_clean.flatten(2)) \ / np.prod(self.layer_dims[i], dtype=floatX) costs.denois[i].name = 'denois' + str(i) denois_print = 'denois %.2f' % self.p.denoising_cost_x[i] else: denois_print = '' # Store references for later use est.h[i] = self.apply_act(z_est, act_f) est.z[i] = z_est est.s[i] = None est.m[i] = None logger.info(' g%d: %10s, %s, dim %s -> %s' % (i, l_type, denois_print, self.layer_dims.get(i + 1), self.layer_dims.get(i))) # Costs y = target_labeled.flatten() costs.class_clean = CategoricalCrossEntropy().apply( y, clean.labeled.h[top]) costs.class_clean.name = 'cost_class_clean' costs.class_corr = CategoricalCrossEntropy().apply( y, corr.labeled.h[top]) costs.class_corr.name = 'cost_class_corr' # This will be used for training costs.total = costs.class_corr * 1.0 for i in range(top + 1): if costs.denois.get(i) and self.p.denoising_cost_x[i] > 0: costs.total += costs.denois[i] * self.p.denoising_cost_x[i] costs.total.name = 'cost_total' # Classification error mr = MisclassificationRate() self.error.clean = mr.apply(y, clean.labeled.h[top]) * np.float32(100.) self.error.clean.name = 'error_rate_clean'
import sys from utils import AttributeDict from tagger_exp import TaggerExperiment p = AttributeDict() p.encoder_proj = (3000, 2000, 1000) p.input_noise = 0.2 p.class_cost_x = 0. p.zhat_init_value = 0.5 p.n_iterations = 3 p.n_groups = 4 p.lr = 0.001 p.labeled_samples = 1000 p.save_freq = 50 p.seed = 1 p.num_epochs = 150 p.batch_size = 100 p.valid_batch_size = 100 p.objects_per_sample = 2 p.dataset = 'freq20-2mnist' p.input_type = 'continuous' if __name__ == '__main__': if len(sys.argv) == 2 and sys.argv[1] == '--pretrain': p.save_to = 'freq20-2mnist-pretraining' experiment = TaggerExperiment(p) experiment.train() elif len(sys.argv) == 3 and sys.argv[1] == '--continue':
def __init__(self, *args, **kwargs): AttributeDict.__init__(self) self.env = Environment.getInstance() self.resourceType = self.__class__.__name__ self.isUpdated = False seen = set() if not hasattr(self, '_schema'): raise Fail("Resource failed to define a valid _schema") # union global schema with local schema schema = copy.deepcopy(self._schema) for key in self.s_globalSchema: if not key in schema: schema[key] = self.s_globalSchema[key] resolvedArgs = { } keys = schema.keys() keysLen = len(keys) index = 0 # resolve unnamed arguments with names corresponding to the order # they were passed to Resource's ctor and their relative definitions # in the subclass' ResourceArgumentSchema (which is an OrderedDict, # so as to retain this ordering information). for arg in args: if index < keysLen: key = keys[index] resolvedArgs[keys[index]] = arg else: raise InvalidArgument("Invalid unnamed argument %s provided to resource %s" % (arg, str(self))) index += 1 for arg in kwargs: if arg in resolvedArgs: raise InvalidArgument("Invalid mixture of named and unnamed arguments provided to resource %s, possibly around argument %s" % (str(self), arg)) else: resolvedArgs[arg] = kwargs[arg] utils.log("Initializing resource '%s' with args: %s" % (self.resourceType, resolvedArgs)) # validate resource arguments output = schema.validate(resolvedArgs) for key in output: self[key] = output[key] self.subscriptions = { 'immediate' : set(), 'delayed' : set() } for sub in self.subscribes: if len(sub) == 2: action, resource = sub immediate = False else: action, resource, immediate = sub resource.subscribe(action, self, immediate) for sub in self.notifies: self.subscribe(*sub) self._validate() self._register() utils.log("Added new resource '%s'" % (str(self), ))
def apply_tagger(self, x, apply_noise, y=None): """ Build one path of Tagger """ mb_size = x.shape[1] input_shape = (self.p.n_groups, mb_size) + self.in_dim in_dim = np.prod(self.in_dim) # Add noise x_corr = self.corrupt(x) if apply_noise else x # Repeat input x_corr = T.repeat(x_corr, self.p.n_groups, 0) # Compute v if self.p.input_type == 'binary': v = None elif self.p.input_type == 'continuous': v = self.weight(1., 'v') v = v * T.alloc(1., *input_shape) # Cap to positive range v = nn.exp_inv_sinh(v) d = AttributeDict() if y: d.pred = [] d.class_error, d.class_cost = [], [] # here we have the book-keeping of z and m for the visualizations. d.z = [] d.m = [] else: d.denoising_cost, d.ami_score, d.ami_score_per_sample = [], [], [] assert self.p.n_iterations >= 1 # z_hat is the value for the next iteration of tagger. # z is the current iteration tagger input # m is the current iteration mask input # m_hat is the value for the next iteration of tagger. # m_lh is the mask likelihood. # z_delta is the gradient of z, which depends on x, z and m. for step in xrange(self.p.n_iterations): # Encoder # ======= # Compute m, z and z_hat_pre_bin if step == 0: # No values from previous iteration, so let's make them up m, z = self.init_m_z(input_shape) z_hat_pre_bin = None # let's keep in the bookkeeping for the visualizations. if y: d.z.append(z) d.m.append(m) else: # Feed in the previous iteration's estimates z = z_hat m = m_hat # Compute m_lh m_lh = self.m_lh(x_corr, z, v) z_delta = self.f_z_deriv(x_corr, z, m) z_tilde = z_hat_pre_bin if z_hat_pre_bin is not None else z # Concatenate all inputs inputs = [z_tilde, z_delta, m, m_lh] inputs = T.concatenate(inputs, axis=2) # Projection, batch-normalization and activation to a hidden layer z = self.proj(inputs, in_dim * 4, self.p.encoder_proj[0]) z -= z.mean((0, 1), keepdims=True) z /= T.sqrt(z.var((0, 1), keepdims=True) + np.float32(1e-10)) z += self.bias(0.0 * np.ones(self.p.encoder_proj[0]), 'b') h = self.apply_act(z, 'relu') # The first dimension is the group. Let's flatten together with # minibatch in order to have parametric mapping compute all groups # in parallel h, undo_flatten = flatten_first_two_dims(h) # Parametric Mapping # ================== self.ladder.apply(None, self.y, h) ladder_encoder_output = undo_flatten(self.ladder.act.corr.unlabeled.h[len(self.p.encoder_proj) - 1]) ladder_decoder_output = undo_flatten(self.ladder.act.est.z[0]) # Decoder # ======= # compute z_hat z_u = self.proj(ladder_decoder_output, self.p.encoder_proj[0], in_dim, scope='z_u') z_u -= z_u.mean((0, 1), keepdims=True) z_u /= T.sqrt(z_u.var((0, 1), keepdims=True) + np.float32(1e-10)) z_hat = self.weight(np.ones(in_dim), 'c1') * z_u + self.bias(np.zeros(in_dim), 'b1') z_hat = z_hat.reshape(input_shape) # compute m_hat m_u = self.proj(ladder_decoder_output, self.p.encoder_proj[0], in_dim, scope='m_u') m_u -= m_u.mean((0, 1), keepdims=True) m_u /= T.sqrt(m_u.var((0, 1), keepdims=True) + np.float32(1e-10)) c = self.weight(np.float32(1), 'c2') m_hat = nn.softmax_n(m_u * c, axis=0) m_hat = m_hat.reshape(input_shape) # Apply sigmoid activation if input_type is binary if self.p.input_type == 'binary': z_hat_pre_bin = z_hat z_hat = self.apply_act(z_hat, 'sigmoid') # Collapse layer # ============== # Remove the last dim, which is assumed to be class 'None' pred = ladder_encoder_output[:, :, :-1] # Normalize pred /= T.sum(T.sum(pred, axis=2, keepdims=True), axis=0, keepdims=True) # Denoising and Classification costs # ================================== if y: class_cost, class_error = self.compute_classification_cost_and_error(pred, y) d.pred.append(pred) d.class_cost.append(class_cost) d.class_error.append(class_error) d.m.append(m_hat) d.z.append(z_hat) else: d.denoising_cost.append(self.denoising_cost(z_hat, m_hat, x, v)) ami_score, ami_score_per_sample = self.mask_accuracy(self.masks_unlabeled, m_hat) d.ami_score.append(ami_score) d.ami_score_per_sample.append(ami_score_per_sample) # stack the list of tensors into one d = AttributeDict({key: T.stacklists(val) for key, val in d.iteritems()}) return d
from utils import AttributeDict from tagger_exp import TaggerExperiment p = AttributeDict() p.encoder_proj = (2000, 1000, 500) p.input_noise = 0.2 p.class_cost_x = 0 p.zhat_init_value = 0.26 # mean of the input data. p.n_iterations = 3 p.n_groups = 4 p.lr = 0.0004 p.seed = 10 p.num_epochs = 100 p.batch_size = 100 p.valid_batch_size = 100 p.dataset = 'shapes50k20x20' p.input_type = 'binary' p.save_to = 'shapes50k20x20' if __name__ == '__main__': experiment = TaggerExperiment(p) experiment.train()