def build(self): super().build() self._class_ids_to_names_mapping = {} self._colors = {} for each_attribute_name, each_mapping in ( self.attributes_class_names_to_labels_mappings.items()): each_mapping = io_utils.maybe_load_json(each_mapping) class_id_to_name_mapping = { each_item["class_id"]: each_class_name for each_class_name, each_item in each_mapping.items() } self._class_ids_to_names_mapping[each_attribute_name] = ( class_id_to_name_mapping) if self._colors is None: continue try: colors = { each_item["class_id"]: each_item["color"] for each_class_name, each_item in each_mapping.items() } self._colors[each_attribute_name] = colors except KeyError: self._colors = None return self
def build(self): super().build() self.rgb_class_mapping = io_utils.maybe_load_json( self.rgb_class_mapping) self._rgb_class_ids_mapping_hashed = dict( zip(map(image_utils.rgb_hash_fun, self.rgb_class_mapping['rgb']), self.rgb_class_mapping['class_ids'])) return self
def build_class_labels_to_names_mapping( num_classes: Optional[int] = None, class_names_to_labels_mapping: Optional[dict] = None, class_id_offset: int = 0): """ Build mapping from class id to its names and vice-verse from that mapping or from num_classes only. If no mapping was provided, class names are "class_{class_id}". Parameters ---------- num_classes number of classes class_names_to_labels_mapping file name or mapping itself; mapping should be in format {"class name": {"class_id": 1}, "other class_name": {"class_id": 2}}, where class_id is an unique integer; if multiple class names have same class id, then the last name inside of json file will be used as class name class_id_offset offset of class id Returns ------- num_classes number of classes class_names_to_labels_mapping mapping in format {"class name": {"class_id": 1}, "other class_name": {"class_id": 2}} class_labels_to_names_mapping mapping from class id to class name """ assert (num_classes is not None or class_names_to_labels_mapping is not None ), "Provide num_classes or class_names_to_labels_mapping!" if not class_names_to_labels_mapping: class_labels_to_names_mapping = { class_label: "class_{}".format(class_label) for class_label in range(class_id_offset, num_classes + class_id_offset) } return (num_classes, class_names_to_labels_mapping, class_labels_to_names_mapping) class_names_to_labels_mapping = io_utils.maybe_load_json( class_names_to_labels_mapping, as_ordereddict=True) class_labels_to_names_mapping = { v['class_id']: k for k, v in reversed(class_names_to_labels_mapping.items()) } num_classes = len(class_labels_to_names_mapping) return (num_classes, class_names_to_labels_mapping, class_labels_to_names_mapping)
def _get_configs_from_single_files(config_dir: str, single_config_fnames: list) -> dict: logger = logging.getLogger(__name__) configs = {} for fname in single_config_fnames: config_fname = os.path.join(config_dir, fname + '.json') if os.path.isfile(config_fname): config_name = fname + '_config' logger.info('Found %s with config %s', config_name, config_fname) configs[config_name] = io_utils.maybe_load_json(config_fname) return configs
def maybe_create_category_index(num_classes: int, class_names_to_labels_mapping: Union[str, dict], class_offset: int = 1) -> Tuple[int, dict]: """ Create category index from num_classes or from class_names to labels mapping. This is the same category index as is used in object_detection API Parameters ---------- num_classes number of classes class_names_to_labels_mapping either str with file name to mapping or dict with mapping itself; mapping should be in format {"class name": {"class_id": 1}, }, where class_id is an unique integer class_offset class id to start it from 0 (for classification) or 1 (for object detection) Returns ------- num_classes number of classes category_index category index in format {"class name": {"id": , {"name": ,}}, ...} """ if class_names_to_labels_mapping is not None: class_names_to_labels_mapping = io_utils.maybe_load_json( class_names_to_labels_mapping, as_ordereddict=True) if isinstance(class_names_to_labels_mapping, OrderedDict): categories = { v['class_id']: k for k, v in reversed(class_names_to_labels_mapping.items()) } else: categories = { v['class_id']: k for k, v in class_names_to_labels_mapping.items() } category_index = { k: { 'id': k, 'name': v } for k, v in sorted(categories.items()) } else: assert num_classes is not None, ( "Either num_classes or class_names_to_labels_mapping " "should be provided!!!") category_index = get_category_index(num_classes, class_offset) num_classes = len(category_index) return num_classes, category_index
def _read_from_json_or_txt(fname_or_data): if not isinstance(fname_or_data, str): return fname_or_data if not os.path.exists(fname_or_data): raise FileNotFoundError("file {} not found!".format( os.path.realpath(fname_or_data))) if os.path.splitext(fname_or_data)[-1] == ".txt": with open(fname_or_data, "r") as file: data = file.read().splitlines() return data data = io_utils.maybe_load_json(fname_or_data) return data
def build(self): super().build() connection_map = io_utils.maybe_load_json(self.connection_map) self._connection_map_only = { each_name: each_item["connection"] for each_name, each_item in connection_map.items() } try: self._colors = { each_name: each_item["color"] for each_name, each_item in connection_map.items() } except KeyError: self._colors = None return self
def __init__(self, *, rgb_class_mapping: Optional[dict] = None, save_file_extension: str = ".png", save_probabilities: bool = False, **callback_kwargs): super(SemanticSegmentationSaver, self).__init__( **callback_kwargs) if save_file_extension.startswith("."): save_file_extension = save_file_extension[1:] self.save_file_extension = save_file_extension self.rgb_class_mapping = io_utils.maybe_load_json(rgb_class_mapping) if (self.rgb_class_mapping is not None and 'class_ids' in self.rgb_class_mapping): self.rgb_class_mapping = dict(zip( self.rgb_class_mapping['class_ids'], self.rgb_class_mapping['rgb'])) self.save_probabilities = save_probabilities
def add_global_project_config_from_file(fname: str): """ Add project configuration from json file Parameters ---------- fname file name of project configuration .json file See Also -------- :func:`add_global_project_config` """ logger = logging.getLogger(__name__) if not os.path.isfile(fname): logger.info("No project configuration file was found") return config = io_utils.maybe_load_json(fname) logger.info("Add project global config from %s", fname) add_global_project_config(config)
def _read_components_configs(config_fnames: list) -> list: """ Read multiple config files Parameters ---------- config_fnames list with file names with config json files Returns ------- config_components list of read configurations from single files """ config_components = [] for config_fname in config_fnames: config_component = io_utils.maybe_load_json(config_fname) if isinstance(config_component, list): config_components.extend(config_component) else: config_components.append(config_component) return config_components