def __init__(self, shared_value, final_value, epochs_to_saturation): assert_is_instance(shared_value, theano.tensor.sharedvar.SharedVariable) assert_is_subdtype(shared_value.dtype, numpy.floating) assert_equal(shared_value.ndim == 0, numpy.isscalar(final_value)) if numpy.isscalar(final_value): assert_floating(final_value) else: assert_is_subdtype(final_value.dtype, numpy.floating) assert_equal(final_value.shape, shared_value.get_value().shape) assert_integer(epochs_to_saturation) assert_greater(epochs_to_saturation, 0) self.shared_value = shared_value cast = numpy.cast[shared_value.dtype] self._final_value = cast(final_value) self._epochs_to_saturation = epochs_to_saturation self._num_epochs_seen = None self._initial_value = None
def __init__(self, dataset, batch_size): super(DatasetIterator, self).__init__() assert_is_instance(dataset, Dataset) assert_greater(len(dataset.tensors), 0) assert_greater(batch_size, 0) assert_integer(batch_size) self.dataset = dataset self.batch_size = batch_size
def _getitem_arg_to_slice(arg): ''' Turns arg into a slice, if it isn't one. ''' if numpy.isscalar(arg): assert_integer(arg) if arg == -1: return slice(arg, None) else: return slice(arg, arg + 1) else: assert_is_instance(arg, slice) return arg
def get_expected_values(start_row, end_row=None): if end_row is None: assert_is_instance(start_row, numpy.ndarray) values = start_row else: assert_integer(start_row) assert_integer(end_row) values = numpy.arange(start_row, end_row) values = values % dtype_max values = values.reshape((values.shape[0], ) + ((1, ) * (len(shape) - 1))) return numpy.tile(values, shape[1:])
def get_iters(yaml_dict, seed): assert_is_instance(yaml_dict, dict) assert_integer(seed) training_set, validation_set = _get_datasets(yaml_dict) hyperparams_dict = yaml_dict['hyperparams'] training_iter = training_set.iterator( 'random_vec3', hyperparams_dict['training_batch_size'], rng=RandomState(seed)) validation_iter = validation_set.iterator( 'random_vec3', hyperparams_dict['validation_batch_size'], rng=RandomState(seed)) return training_iter, validation_iter
def __init__(self, shared_value, final_scale, epochs_to_saturation): assert_is_instance(shared_value, theano.tensor.sharedvar.SharedVariable) assert_floating(final_scale) assert_greater_equal(final_scale, 0.0) assert_less_equal(final_scale, 1.0) assert_integer(epochs_to_saturation) assert_greater(epochs_to_saturation, 0) self.shared_value = shared_value self._final_scale = final_scale self._epochs_to_saturation = epochs_to_saturation # initialized in on_start_training() self._initial_value = None self._num_epochs_seen = None
def get_example_image(self, object_id, camera_dir): assert_integer(object_id) assert_equal(len(camera_dir.shape), 1) def normalize(vec): return vec / numpy.sqrt((vec * vec).sum()) camera_dir = normalize(camera_dir) xy_projection_length = numpy.sqrt((camera_dir[:2] ** 2).sum()) elevation = numpy.arctan2(camera_dir[2], # z xy_projection_length) # atan2 args need not be on the unit circle; otherwise the following # would be wrong. azimuth = numpy.arctan2(camera_dir[1], # y camera_dir[0]) # x if azimuth < 0.0: azimuth += (2 * numpy.pi) assert_greater_equal(azimuth, 0.0) def rad_to_deg(rad): return rad / numpy.pi * 180.0 elevation = rad_to_deg(elevation) azimuth = rad_to_deg(azimuth) def round_to_int(floating): return int(numpy.round(floating)) elevation_label = round_to_int((elevation - 30.0) / 5.0) azimuth_label = round_to_int(azimuth / 20.0) * 2 result = self.id_elev_azim_to_example.get((object_id, elevation_label, azimuth_label), None) return result
def __check_arg_types(input_node, yaml_dict, use_dropout, numpy_rng, theano_rng, output_list, output_size=None): assert_is_instance(input_node, Node) assert_is_instance(yaml_dict, dict) assert_is_instance(use_dropout, bool) assert_is_instance(numpy_rng, numpy.random.RandomState) if use_dropout: assert_is_instance(theano_rng, RandomStreams) else: assert_true(theano_rng is None or isinstance(theano_rng, RandomStreams)) assert_is_instance(output_list, list) assert_all_is_instance(output_list, Node) if output_size is not None: assert_integer(output_size)
def __init__(self, model_id_node, model_cam_dir_node, # label_id_node, # label_cam_dir_node, iterator_input_nodes, blank_id): assert_equal(model_id_node.output_format.axes, ('b', 'f')) assert_equal(model_id_node.output_symbol.dtype, floatX) assert_equal(model_cam_dir_node.output_format.axes, ('b', 'f')) assert_equal(model_cam_dir_node.output_format.shape[1], 3) assert_equal(model_cam_dir_node.output_symbol.dtype, floatX) label_id_node = iterator_input_nodes.id label_cam_dir_node = iterator_input_nodes.camera_dir assert_equal(label_id_node.output_format.axes, ('b',)) assert_equal(str(label_id_node.output_format.dtype), 'int32') assert_equal(label_cam_dir_node.output_format.axes, ('b', 'f')) assert_equal(label_cam_dir_node.output_format.dtype, floatX) # assert_in('id_layers', model.__dict__) # assert_in('cam_dir_layers', model.__dict__) # assert_is_instance(model, IdAndCameraDirModel) assert_integer(blank_id) # def assert_formats_equal(fmt_0, fmt_1): # assert_equal(fmt_0.axes, fmt_1.axes) # assert_equal(fmt_0.shape, fmt_1.shape) # assert_equal(fmt_0.dtype, fmt_1.dtype) # assert_formats_equal(model.input_node.output_format, # iterator_input_nodes[0].output_format) assert_equal(blank_id, model_id_node.output_format.shape[1] - 1) id_loss = CrossEntropy(model_id_node, label_id_node) #model.id_layers[-1], iterator_input_nodes.id) def to_floatX(arg): return numpy.cast[floatX](arg) # This is a bit different from the other scales, in that it # normalizes the initial expected loss to 1.0, whereas # the regression scales normalize the initial max loss to 1.0. # So id loss will initially be ~ 2x the regression losses, which # suits me fine. def get_id_scale(model_id_node): # id_node = model.id_layers[-1] assert_equal(model_id_node.output_format.axes, ('b', 'f')) num_ids = model_id_node.output_format.shape[1] assert_equal(num_ids, 7) return to_floatX((1.0 / -numpy.log(1.0 / num_ids)) ** 2.0) id_scale = get_id_scale(model_id_node) cam_dir_loss = UnitVectorSqNorm(model_cam_dir_node, #model.cam_dir_layers[-1], label_cam_dir_node) #iterator_input_nodes.camera_dir) cam_dir_scale = to_floatX((1.0 / 2.0) ** 2.0) id_loss_symbol = id_loss.output_symbol * id_scale cam_dir_loss_symbol = cam_dir_loss.output_symbol * cam_dir_scale id_label_symbol = label_id_node.output_symbol #iterator_input_nodes.id.output_symbol # A vector along the 'b' axis. Has 0.0 for bkg images and 1.0 elsewhere self.non_bkg_mask = T.cast(T.neq(id_label_symbol, blank_id), floatX) total_loss_symbol = (id_loss_symbol + self.non_bkg_mask * cam_dir_loss_symbol) # total_loss_symbol = T.switch(T.eq(id_label_symbol, blank_id), # id_loss_symbol, # id_loss_symbol + cam_dir_loss_symbol) # loss_symbol = (id_loss.output_symbol * to_floatX(id_scale) + # cam_dir_loss.output_symbol * to_floatX(cam_dir_scale)) assert_equal(str(total_loss_symbol.dtype), floatX) super(IdAndCameraDirLoss, self).__init__( input_nodes=iterator_input_nodes, # not all of these are used output_symbol=total_loss_symbol, output_format=copy.deepcopy(id_loss.output_format)) self.id_loss = id_loss self.cam_dir_loss = cam_dir_loss
def __init__(self, model, foreground_dataset, video_frame, smoothing, input_scale, output_dir=None): ''' model: simplelearn.io.SerializeableModel foreground_dataset: simplelearn.data.Dataset A Dataset with NORB-style label vectors. Used to compute a mapping from object ID to example images. video_frame: numpy.ndarray A frame from the input video stream. Used to initialize display pixel buffer's size and dtype. smoothing: float A float in the range [0.0, 1.0). The displayed pose and softmax z_t is computed as: z_t = k * z_(t-1) + (1.0 - k) * y(t) Where: t is the timestep z is the displayed value y is the model output value k is this smoothing argument input_scale: int The ratio of the input reticule to the model's actual input size. output_dir: string or None The directory to save frame images to. If omitted, no frame images will be saved. ''' def get_input_size(model): image_format = model.input_node.output_format assert_equal(image_format.axes, ('b', '0', '1', 'c')) return image_format.shape[1:3] super(ReticuleDisplay, self).__init__(model, foreground_dataset, video_frame, get_input_size(model), output_dir) assert_is_instance(model, IdAndCameraDirModel) assert_integer(input_scale) assert_greater_equal(input_scale, 1) assert_greater_equal(smoothing, 0.0) assert_less(smoothing, 1.0) self.smoothing = smoothing self._displayed_camera_dir = None self._displayed_softmax = None input_format = model.input_node.output_format input_shape = numpy.asarray( [input_format.shape[input_format.axes.index(a)] for a in ('0', '1')]) reticule_shape = input_shape * input_scale self.reticule_min_corner = (numpy.asarray(self.video_pixels.shape[:2]) - reticule_shape) // 2 self.reticule_max_corner = self.reticule_min_corner + reticule_shape self.input_pixels = self._get_example_window(0, 0) self.preprocessed_pixels = self._get_example_window(0, 1) model_output_nodes = [model.id_layers[-1], model.cam_dir_layers[-1]] self.model_function = theano.function( [model.input_node.output_symbol], [n.output_symbol for n in model_output_nodes]) # outputs bc01 self.preprocess_function = theano.function( [model.input_node.output_symbol], _find_lcn_node(model).output_symbol) num_candidates = 3 self.example_pixels_windows = [self._get_example_window(1, c) for c in range(num_candidates)] self.caption_pixels_windows = [self._get_example_window(2, c) for c in range(num_candidates)]
def make_instance_dataset(norb_name, a_norb, b_norb, test_elevation_stride, test_azimuth_stride, objects=None): ''' Creates instance recognition datasets from category recognition datasets. Merges two category recognition datasets (with disjoint object instances), and re-partitions them into instance recognition datasets (with disjoint camera views). The instance recognition dataset consists of a train and test set. All objects not selected by <objects> are ignored. Of the remaining images, he test set consists of all images that satisfy both the test_elevation_stride and test_azimuth_stride. The other images are used for the training set. If the category datset is in stereo, only the left stereo images are used. Parameters ---------- norb_name: str The name of the category recognition dataset (e.g. 'big_norb'). Used to build the name of the instance recognition dataset. Alphanumeric characters and '_' only. a_norb: NORB Dataset One of the category recognition datasets (i.e. training set). b_norb: NORB Dataset The other category recognition dataset (i.e. testing set). test_elevation_stride: int Use every M'th elevation as a test image. test_azimuth_stride: int Use every N'th azimuth as a test image. objects: Sequence [(c0, i0), (c1, i1), ..., (cN, iN)] Each (cx, ix) pair specifies an object to include, by their class and instance labels cx and ix. Returns ------- rval: str The path to the newly created .h5 file. ''' assert_is_instance(norb_name, basestring) assert_all_true(c.isalnum() or c == '_' for c in norb_name) assert_is_instance(a_norb, Dataset) assert_is_instance(b_norb, Dataset) assert_all_equal(a_norb.names, b_norb.names) assert_all_equal(a_norb.formats, b_norb.formats) assert_integer(test_elevation_stride) assert_greater(test_elevation_stride, 0) assert_integer(test_azimuth_stride) assert_greater(test_azimuth_stride, 0) if objects is not None: assert_is_instance(objects, Sequence) for id_pair in objects: assert_equal(len(id_pair), 2) assert_all_integer(id_pair) assert_all_greater_equal(id_pair, 0) # # Done sanity-checking args # (category_index, instance_index, azimuth_index, elevation_index) = range(4) # no need for lighting_index (= 4) def get_row_indices(labels, test_elevation_stride, test_azimuth_stride, objects): ''' Returns row indices or training and testing sets. ''' logical_and = numpy.logical_and if objects is not None: objects = numpy.asarray(objects) obj_cols = (category_index, instance_index) object_mask = (labels[:, obj_cols] == objects).all(axis=1) else: object_mask = numpy.ones(labels.shape[0], dtype=bool) test_mask = logical_and( object_mask, (labels[:, elevation_index] % test_elevation_stride) == 0) test_mask = logical_and( test_mask, (labels[:, azimuth_index] % (test_azimuth_stride * 2)) == 0) train_mask = logical_and(object_mask, numpy.logical_not(test_mask)) return tuple(numpy.nonzero(m)[0] for m in (train_mask, test_mask)) a_train_indices, a_test_indices = get_row_indices(a_norb.tensors[1], test_elevation_stride, test_azimuth_stride, objects) b_train_indices, b_test_indices = get_row_indices(b_norb.tensors[1], test_elevation_stride, test_azimuth_stride, objects) def create_h5_filepath(norb_name, test_elevation_stride, test_azimuth_stride, objects): ''' Creates an hdf filepath based on the args. For which-norb: "big_norb", elevation_stride: 2, azimuth_stride: 1: <data_dir>/big_norb_instance/e2_a1_all.h5 For same as above, but with objects: [[1, 2], [3, 7], [4, 1]] <data_dir>/big_norb_instance/e2_a1_1-2_3-7_4-1.h5 ''' output_dir = os.path.join(simplelearn.data.data_path, '{}_instance'.format(norb_name)) if not os.path.isdir(output_dir): os.mkdir(output_dir) filename = "e{:02d}_a{:02d}_o_".format(test_elevation_stride, test_azimuth_stride) if objects is None: filename = filename + 'all' else: for id_pair in objects: filename = filename + "%d-%d" % tuple(id_pair) filename = filename + '.h5' return os.path.join(output_dir, filename) h5_path = create_h5_filepath(norb_name, test_elevation_stride, test_azimuth_stride, objects) def get_mono_format(input_image_format): axes = input_image_format.axes shape = input_image_format.shape if 's' in axes: s_index = axes.index('s') axes = list(axes) del axes[s_index] shape = list(shape) del shape[s_index] return DenseFormat(axes=axes, shape=shape, dtype=input_image_format.dtype) mono_image_format = get_mono_format(a_norb.formats[0]) label_format = a_norb.formats[1] partition_names = ['train', 'test'] partition_sizes = [len(a_train_indices) + len(b_train_indices), len(a_test_indices) + len(b_test_indices)] train_indices = (a_train_indices, b_train_indices) test_indices = (a_test_indices, b_test_indices) # Creates a .h5 file and copies repartitioned data into it. with make_h5_file(h5_path, partition_names, partition_sizes, a_norb.names, [mono_image_format, label_format]) as h5_file: partitions = h5_file['partitions'] for partition_name, (a_indices, b_indices) \ in safe_izip(partition_names, [train_indices, test_indices]): partition = partitions[partition_name] a_images = a_norb.tensors[0] b_images = b_norb.tensors[0] out_images = partition['images'] print("Copying {} partition.".format(partition_name)) if 's' in a_norb.formats[0].axes: assert_equal(a_norb.formats[0].axes.index('s'), 1) out_images[:len(a_indices), ...] = a_images[a_indices, 0, ...] out_images[len(a_indices):, ...] = b_images[b_indices, 0, ...] else: out_images[:len(a_indices), ...] = a_images[a_indices, ...] out_images[len(a_indices):, ...] = b_images[b_indices, ...] a_labels = a_norb.tensors[1] b_labels = b_norb.tensors[1] out_labels = partition['labels'] out_labels[:len(a_indices), :] = a_labels[a_indices, :] out_labels[len(a_indices):, :] = b_labels[b_indices, :] # Don't shuffle the data; that's the iterator's job. return h5_path
def make_batch(self, is_symbolic, batch_size=None, dtype=None, name=None): ''' Makes a numeric or symbolic batch. May later split this into two functions: make_numeric_batch and make_symbolic_batch. Keep it like this for now. If implementations of _make_batch end up not sharing much logic between is_symbolic=True and is_symbolic=False, then maybe split it. Parameters ---------- is_symbolic: bool if True, return a symbolic batch. Otherwise return a numeric batch. batch_size: int Number of examples in numeric batch. Omit if is_symbolic is True or if there is no batch axis. dtype: str/numpy.dtype, or NoneType A numpy/theano dtype. Required if self.dtype is None. Prohibited otherwise. name: str, or NoneType Name of the symbolic batch. Optional when is_symbolic is True. Omit if is_symbolic is False. ''' assert_is_instance(is_symbolic, bool) # checks is_symbolic vs batch_size assert_equal(is_symbolic, batch_size is None, "Must not supply a batch_size when is_symbolic is True." if is_symbolic else "Must supply a batch_size when is_symbolic is False.") # Sanity-checks batch_size if not is_symbolic: assert_integer(batch_size) assert_greater_equal(batch_size, 0) # checks is_symbolic vs name if not is_symbolic and name is not None: raise ValueError("Can't supply a name when is_symbolic is False.") # Checks dtype vs self.dtype if dtype is None: if self.dtype is None: raise TypeError("Must supply a dtype argument, because this " "%s has no dtype of its own." % type(self)) else: dtype = self.dtype elif self.dtype is not None: raise TypeError("Can't supply a dtype argument because this %s's " "dtype is not None (it's %s)." % (type(self), self.dtype)) elif dtype == 'floatX': dtype = theano.config.floatX else: dtype = numpy.dtype(dtype) result = self._make_batch(is_symbolic, batch_size, dtype, name) self.check(result) return result