import abc import json import math import pathlib import re from collections import defaultdict from dataclasses import asdict, dataclass from typing import Any, Dict, List, Optional, Tuple, TypedDict import datasets as ds import numpy as np import pandas as pd from datasets.utils.logging import get_logger from PIL import Image from PIL.Image import Image as PilImage logger = get_logger(__name__) JsonDict = Dict[str, Any] _DESCRIPTION = """ THE DATASET: We mined over 9.3k free Android apps from 27 categories to create the Rico dataset. Apps in the dataset had an average user rating of 4.1. The Rico dataset contains visual, textual, structural, and interactive design properties of more than 66k unique UI screens and 3M UI elements. """ _CITATION = """\ @inproceedings{deka2017rico, title={Rico: A mobile app dataset for building data-driven design applications}, author={Deka, Biplab and Huang, Zifeng and Franzen, Chad and Hibschman, Joshua and Afergan, Daniel and Li, Yang and Nichols, Jeffrey and Kumar, Ranjitha}, booktitle={Proceedings of the 30th annual ACM symposium on user interface software and technology}, pages={845--854}, year={2017} } """ _HOMEPAGE = "http://www.interactionmining.org/rico.html" _LICENSE = "Unknown" def to_snake_case(name): name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name) name = re.sub("__([A-Z])", r"_\1", name) name = re.sub("([a-z0-9])([A-Z])", r"\1_\2", name) return name.lower() class TrainValidationTestSplit(TypedDict): train: List[Any] validation: List[Any] test: List[Any] class UiLayoutVectorSample(TypedDict): vector: np.ndarray name: str @dataclass(eq=True) class RicoProcessor(object, metaclass=abc.ABCMeta): @abc.abstractmethod def get_features(self) -> ds.Features: raise NotImplementedError @abc.abstractmethod def load_examples(self, *args, **kwargs) -> List[Any]: raise NotImplementedError @abc.abstractmethod def split_generators(self, *args, **kwargs) -> List[ds.SplitGenerator]: raise NotImplementedError @abc.abstractmethod def generate_examples(self, examples: List[Any]): raise NotImplementedError class RicoTaskProcessor(RicoProcessor, metaclass=abc.ABCMeta): def _flatten_children( self, children, children_id: Optional[int] = None, result: Optional[Dict[str, Any]] = None, ): result = result or defaultdict(list) if children is None: return result children_id = children_id or 0 for child in children: if not child: continue if "children" not in child: continue result = self._flatten_children( children=child.pop("children"), children_id=children_id + 1, result=result, ) assert result is not None result[f"children_{children_id}"].append(child) return result def _load_image(self, file_path: pathlib.Path) -> PilImage: logger.debug(f"Load from {file_path}") return Image.open(file_path) def _load_json(self, file_path: pathlib.Path) -> JsonDict: logger.debug(f"Load from {file_path}") with file_path.open("r") as rf: json_dict = json.load(rf) return json_dict def _split_dataset( self, examples: List[Any], train_ratio: float, validation_ratio: float, test_ratio: float, ) -> TrainValidationTestSplit: assert train_ratio + validation_ratio + test_ratio == 1.0 num_examples = len(examples) num_tng = math.ceil(num_examples * train_ratio) # type: ignore num_val = math.ceil(num_examples * validation_ratio) # type: ignore num_tst = math.ceil(num_examples * test_ratio) # type: ignore tng_examples = examples[:num_tng] val_examples = examples[num_tng : num_tng + num_val] tst_examples = examples[num_tng + num_val : num_tng + num_val + num_tst] assert len(tng_examples) + len(val_examples) + len(tst_examples) == num_examples return { "train": tng_examples, "validation": val_examples, "test": tst_examples, } def _load_and_split_dataset( self, base_dir: pathlib.Path, train_ratio: float, validation_ratio: float, test_ratio: float, ) -> TrainValidationTestSplit: examples = self.load_examples(base_dir) return self._split_dataset( examples=examples, train_ratio=train_ratio, validation_ratio=validation_ratio, test_ratio=test_ratio, ) def split_generators( self, base_dir: pathlib.Path, train_ratio: float, validation_ratio: float, test_ratio: float, ) -> List[ds.SplitGenerator]: split_examples = self._load_and_split_dataset( base_dir=pathlib.Path(base_dir), train_ratio=train_ratio, validation_ratio=validation_ratio, test_ratio=test_ratio, ) return [ ds.SplitGenerator( name=ds.Split.TRAIN, # type: ignore gen_kwargs={"examples": split_examples["train"]}, ), ds.SplitGenerator( name=ds.Split.VALIDATION, # type: ignore gen_kwargs={"examples": split_examples["validation"]}, ), ds.SplitGenerator( name=ds.Split.TEST, # type: ignore gen_kwargs={"examples": split_examples["test"]}, ), ] @abc.abstractmethod def load_examples(self, base_dir: pathlib.Path) -> List[Any]: raise NotImplementedError class RicoMetadataProcessor(RicoProcessor, metaclass=abc.ABCMeta): @abc.abstractmethod def load_examples(self, csv_file: pathlib.Path) -> List[Any]: raise NotImplementedError @abc.abstractmethod def split_generators(self, csv_file: pathlib.Path) -> List[ds.SplitGenerator]: raise NotImplementedError @dataclass class ActivityClass(object): abs_pos: bool adapter_view: bool ancestors: List[str] bounds: Tuple[int, int, int, int] clickable: bool content_desc: List[str] draw: bool enabled: bool focused: bool focusable: bool klass: str long_clickable: bool pressed: bool pointer: str scrollable_horizontal: bool scrollable_vertical: bool selected: bool visibility: str visible_to_user: bool package: Optional[str] = None resource_id: Optional[str] = None rel_bounds: Optional[Tuple[int, int, int, int]] = None @classmethod def from_dict(cls, json_dict: JsonDict) -> "ActivityClass": json_dict = {k.replace("-", "_"): v for k, v in json_dict.items()} json_dict["klass"] = json_dict.pop("class") return cls(**json_dict) @dataclass class UiComponent(object): ancestors: List[str] bounds: Tuple[int, int, int, int] component_label: str clickable: bool klass: str icon_class: Optional[str] = None resource_id: Optional[str] = None @classmethod def from_dict(cls, json_dict: JsonDict) -> "UiComponent": json_dict = { to_snake_case(k.replace("-", "_")): v for k, v in json_dict.items() } json_dict["klass"] = json_dict.pop("class") return cls(**json_dict) @dataclass class Activity(object): root: ActivityClass children: List[List[ActivityClass]] added_fragments: List[str] active_fragments: List[str] @classmethod def from_dict(cls, json_dict: JsonDict) -> "Activity": root = ActivityClass.from_dict(json_dict.pop("root")) children = [ [ ActivityClass.from_dict(activity_class) for activity_class in activity_classes ] for activity_classes in json_dict.pop("children") ] return cls(root=root, children=children, **json_dict) @dataclass class InteractionTracesData(object): activity_name: str activity: Activity is_keyboard_deployed: str request_id: str @classmethod def from_dict(cls, json_dict: JsonDict) -> "InteractionTracesData": activity_dict = json_dict.pop("activity") activity = Activity.from_dict(activity_dict) return cls(activity=activity, **json_dict) @dataclass class UiScreenshotsAndViewHierarchiesData(InteractionTracesData): screenshot: PilImage @classmethod def from_dict(cls, json_dict: JsonDict) -> "UiScreenshotsAndViewHierarchiesData": activity_dict = json_dict.pop("activity") activity = Activity.from_dict(activity_dict) return cls(activity=activity, **json_dict) @dataclass class UiScreenshotsAndHierarchiesWithSemanticAnnotationsData(object): ancestors: List[str] klass: str bounds: Tuple[int, int, int, int] clickable: bool children: List[List[UiComponent]] screenshot: PilImage @classmethod def from_dict( cls, json_dict: JsonDict ) -> "UiScreenshotsAndHierarchiesWithSemanticAnnotationsData": json_dict["klass"] = json_dict.pop("class") children = [ [UiComponent.from_dict(ui_component) for ui_component in ui_components] for ui_components in json_dict.pop("children") ] return cls(children=children, **json_dict) @dataclass class Gesture(object): ui_id: int xy: List[Tuple[float, float]] @classmethod def from_dict_to_gestures(cls, json_dict: JsonDict) -> List["Gesture"]: return [Gesture(ui_id=int(k), xy=v) for k, v in json_dict.items()] class InteractionTracesProcessor(RicoTaskProcessor): def get_activity_class_features_dict(self): return { "abs_pos": ds.Value("bool"), "adapter_view": ds.Value("bool"), "ancestors": ds.Sequence(ds.Value("string")), "bounds": ds.Sequence(ds.Value("int64")), "clickable": ds.Value("bool"), "content_desc": ds.Sequence(ds.Value("string")), "draw": ds.Value("bool"), "enabled": ds.Value("bool"), "focusable": ds.Value("bool"), "focused": ds.Value("bool"), "klass": ds.Value("string"), "long_clickable": ds.Value("bool"), "package": ds.Value("string"), "pressed": ds.Value("string"), "pointer": ds.Value("string"), "rel_bounds": ds.Sequence(ds.Value("int64")), "resource_id": ds.Value("string"), "scrollable_horizontal": ds.Value("bool"), "scrollable_vertical": ds.Value("bool"), "selected": ds.Value("bool"), "visibility": ds.Value("string"), "visible_to_user": ds.Value("bool"), } def get_activity_features_dict(self, activity_class): return { "activity_name": ds.Value("string"), "activity": { "root": activity_class, "children": ds.Sequence(ds.Sequence(activity_class)), "added_fragments": ds.Sequence(ds.Value("string")), "active_fragments": ds.Sequence(ds.Value("string")), }, "is_keyboard_deployed": ds.Value("bool"), "request_id": ds.Value("string"), } def get_features(self) -> ds.Features: activity_class = self.get_activity_class_features_dict() activity = self.get_activity_features_dict(activity_class) return ds.Features( { "screenshots": ds.Sequence(ds.Image()), "view_hierarchies": ds.Sequence(activity), "gestures": ds.Sequence( { "ui_id": ds.Value("int32"), "xy": ds.Sequence(ds.Sequence(ds.Value("float32"))), } ), } ) def load_examples(self, base_dir: pathlib.Path) -> List[pathlib.Path]: task_dir = base_dir / "filtered_traces" return [d for d in task_dir.iterdir() if d.is_dir()] def generate_examples(self, examples: List[pathlib.Path]): idx = 0 for trace_base_dir in examples: for trace_dir in trace_base_dir.iterdir(): screenshots_dir = trace_dir / "screenshots" screenshots = [ self._load_image(f) for f in screenshots_dir.iterdir() if not f.name.startswith("._") ] view_hierarchies_dir = trace_dir / "view_hierarchies" view_hierarchies_json_files = [ f for f in view_hierarchies_dir.iterdir() if f.suffix == ".json" and not f.name.startswith("._") ] view_hierarchies_jsons = [] for json_file in view_hierarchies_json_files: json_dict = self._load_json(json_file) if json_dict is None: logger.warning(f"Invalid json file: {json_file}") continue children = self._flatten_children( children=json_dict["activity"]["root"].pop("children") ) json_dict["activity"]["children"] = [v for v in children.values()] data = InteractionTracesData.from_dict(json_dict) view_hierarchies_jsons.append(asdict(data)) gestures_json = trace_dir / "gestures.json" with gestures_json.open("r") as rf: gestures_dict = json.load(rf) gestures = Gesture.from_dict_to_gestures(gestures_dict) example = { "screenshots": screenshots, "view_hierarchies": view_hierarchies_jsons, "gestures": [asdict(gesture) for gesture in gestures], } yield idx, example idx += 1 class UiScreenshotsAndViewHierarchiesProcessor(InteractionTracesProcessor): def get_features(self) -> ds.Features: activity_class = self.get_activity_class_features_dict() activity = { "screenshot": ds.Image(), **self.get_activity_features_dict(activity_class), } return ds.Features(activity) def load_examples(self, base_dir: pathlib.Path) -> List[Any]: task_dir = base_dir / "combined" json_files = [f for f in task_dir.iterdir() if f.suffix == ".json"] return json_files def generate_examples(self, examples: List[pathlib.Path]): for i, json_file in enumerate(examples): with json_file.open("r") as rf: json_dict = json.load(rf) children = self._flatten_children( children=json_dict["activity"]["root"].pop("children") ) json_dict["activity"]["children"] = [v for v in children.values()] json_dict["screenshot"] = self._load_image( json_file.parent / f"{json_file.stem}.jpg" ) data = UiScreenshotsAndViewHierarchiesData.from_dict(json_dict) example = asdict(data) yield i, example class UiLayoutVectorsProcessor(RicoTaskProcessor): def get_features(self) -> ds.Features: return ds.Features( {"vector": ds.Sequence(ds.Value("float32")), "name": ds.Value("string")} ) def _load_ui_vectors(self, file_path: pathlib.Path) -> np.ndarray: logger.debug(f"Load from {file_path}") ui_vectors = np.load(file_path) assert ui_vectors.shape[1] == 64 return ui_vectors def _load_ui_names(self, file_path: pathlib.Path) -> List[str]: with file_path.open("r") as rf: json_dict = json.load(rf) return json_dict["ui_names"] def load_examples(self, base_dir: pathlib.Path) -> List[UiLayoutVectorSample]: task_dir = base_dir / "ui_layout_vectors" ui_vectors = self._load_ui_vectors(file_path=task_dir / "ui_vectors.npy") ui_names = self._load_ui_names(file_path=task_dir / "ui_names.json") assert len(ui_vectors) == len(ui_names) return [ {"vector": vector, "name": name} for vector, name in zip(ui_vectors, ui_names) ] def generate_examples(self, examples: List[UiLayoutVectorSample]): for i, sample in enumerate(examples): sample["vector"] = sample["vector"].tolist() yield i, sample class AnimationsProcessor(RicoTaskProcessor): def get_features(self) -> ds.Features: raise NotImplementedError def load_examples(self, base_dir: pathlib.Path) -> List[Any]: raise NotImplementedError def generate_examples(self, examples: List[Any]): raise NotImplementedError class UiScreenshotsAndHierarchiesWithSemanticAnnotationsProcessor(RicoTaskProcessor): def get_features(self) -> ds.Features: ui_component = { "ancestors": ds.Sequence(ds.Value("string")), "bounds": ds.Sequence(ds.Value("int64")), "component_label": ds.ClassLabel( num_classes=25, names=[ "Text", "Image", "Icon", "Text Button", "List Item", "Input", "Background Image", "Card", "Web View", "Radio Button", "Drawer", "Checkbox", "Advertisement", "Modal", "Pager Indicator", "Slider", "On/Off Switch", "Button Bar", "Toolbar", "Number Stepper", "Multi-Tab", "Date Picker", "Map View", "Video", "Bottom Navigation", ], ), "clickable": ds.Value("bool"), "klass": ds.Value("string"), "icon_class": ds.Value("string"), "resource_id": ds.Value("string"), } return ds.Features( { "ancestors": ds.Sequence(ds.Value("string")), "klass": ds.Value("string"), "bounds": ds.Sequence(ds.Value("int64")), "clickable": ds.Value("bool"), "children": ds.Sequence(ds.Sequence(ui_component)), "screenshot": ds.Image(), } ) def load_examples(self, base_dir: pathlib.Path) -> List[Any]: task_dir = base_dir / "semantic_annotations" json_files = [f for f in task_dir.iterdir() if f.suffix == ".json"] return json_files def generate_examples(self, examples: List[pathlib.Path]): for i, json_file in enumerate(examples): with json_file.open("r") as rf: json_dict = json.load(rf) children = self._flatten_children(children=json_dict.pop("children")) json_dict["children"] = [v for v in children.values()] json_dict["screenshot"] = self._load_image( json_file.parent / f"{json_file.stem}.png" ) data = UiScreenshotsAndHierarchiesWithSemanticAnnotationsData.from_dict( json_dict ) yield i, asdict(data) class UiMetadataProcessor(RicoMetadataProcessor): def get_features(self) -> ds.Features: return ds.Features( { "ui_number": ds.Value("int32"), "app_package_name": ds.Value("string"), "interaction_trace_number": ds.Value("string"), "ui_number_in_trace": ds.Value("string"), } ) def load_examples(self, csv_file: pathlib.Path) -> List[Any]: df = pd.read_csv(csv_file) # 66261 col df.columns = ["_".join(col.split()) for col in df.columns.str.lower()] return df.to_dict(orient="records") def split_generators( self, csv_file: pathlib.Path, **kwargs ) -> List[ds.SplitGenerator]: metadata = self.load_examples(csv_file) return [ds.SplitGenerator(name="metadata", gen_kwargs={"examples": metadata})] def generate_examples(self, examples: List[Any]): for i, metadata in enumerate(examples): yield i, metadata class PlayStoreMetadataProcessor(RicoMetadataProcessor): def get_features(self) -> ds.Features: return ds.Features( { "app_package_name": ds.Value("string"), "play_store_name": ds.Value("string"), "category": ds.ClassLabel( num_classes=27, names=[ "Books & Reference", "Comics", "Health & Fitness", "Social", "Entertainment", "Weather", "Communication", "Sports", "News & Magazines", "Finance", "Shopping", "Education", "Travel & Local", "Business", "Medical", "Beauty", "Food & Drink", "Dating", "Auto & Vehicles", "Music & Audio", "House & Home", "Maps & Navigation", "Lifestyle", "Art & Design", "Parenting", "Events", "Video Players & Editors", ], ), "average_rating": ds.Value("float32"), "number_of_ratings": ds.Value("int32"), "number_of_downloads": ds.ClassLabel( num_classes=15, names=[ "100,000 - 500,000", "10,000 - 50,000", "50,000,000 - 100,000,000", "50,000 - 100,000", "1,000,000 - 5,000,000", "5,000,000 - 10,000,000", "500,000 - 1,000,000", "1,000 - 5,000", "10,000,000 - 50,000,000", "5,000 - 10,000", "100,000,000 - 500,000,000", "500,000,000 - 1,000,000,000", "500 - 1,000", "1,000,000,000 - 5,000,000,000", "100 - 500", ], ), "date_updated": ds.Value("string"), "icon_url": ds.Value("string"), } ) def cleanup_metadata(self, df: pd.DataFrame) -> pd.DataFrame: df = df.assign( number_of_downloads=df["number_of_downloads"].str.strip(), number_of_ratings=df["number_of_ratings"] .str.replace('"', "") .str.strip() .astype(int), ) def remove_noisy_data(df: pd.DataFrame) -> pd.DataFrame: old_num = len(df) df = df[ (df["category"] != "000 - 1") | (df["number_of_downloads"] != "January 10, 2015") ] new_num = len(df) assert new_num == old_num - 1 return df df = remove_noisy_data(df) return df def load_examples(self, csv_file: pathlib.Path) -> List[Any]: df = pd.read_csv(csv_file) df.columns = ["_".join(col.split()) for col in df.columns.str.lower()] df = self.cleanup_metadata(df) return df.to_dict(orient="records") def split_generators( self, csv_file: pathlib.Path, **kwargs ) -> List[ds.SplitGenerator]: metadata = self.load_examples(csv_file) return [ds.SplitGenerator(name="metadata", gen_kwargs={"examples": metadata})] def generate_examples(self, examples: List[Any]): for i, metadata in enumerate(examples): yield i, metadata @dataclass class RicoConfig(ds.BuilderConfig): train_ratio: float = 0.85 validation_ratio: float = 0.05 test_ratio: float = 0.10 random_state: int = 0 data_url: Optional[str] = None processor: Optional[RicoProcessor] = None def __post_init__(self): assert self.data_url is not None assert self.processor is not None assert self.train_ratio + self.validation_ratio + self.test_ratio == 1.0 class RicoDataset(ds.GeneratorBasedBuilder): VERSION = ds.Version("1.0.0") BUILDER_CONFIGS = [ RicoConfig( name="ui-screenshots-and-view-hierarchies", version=VERSION, description="Contains 66k+ unique UI screens", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/unique_uis.tar.gz", processor=UiScreenshotsAndViewHierarchiesProcessor(), ), RicoConfig( name="ui-layout-vectors", version=VERSION, description="Contains 64-dimensional vector representations for each UI screen that encode layout based on the distribution of text and images.", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/ui_layout_vectors.zip", processor=UiLayoutVectorsProcessor(), ), RicoConfig( name="interaction-traces", version=VERSION, description="Contains user interaction traces organized by app.", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/traces.tar.gz", processor=InteractionTracesProcessor(), ), RicoConfig( name="animations", version=VERSION, description="Contains GIFs that demonstrate how screens animated in response to a user interaction; follows the same folder structure introduced for interaction traces.", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/animations.tar.gz", processor=AnimationsProcessor(), ), RicoConfig( name="ui-screenshots-and-hierarchies-with-semantic-annotations", version=VERSION, description="Contains 66k+ UI screens and hierarchies augmented with semantic annotations that describe what elements on the screen mean and how they are used.", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/semantic_annotations.zip", processor=UiScreenshotsAndHierarchiesWithSemanticAnnotationsProcessor(), ), RicoConfig( name="ui-metadata", version=VERSION, description="Contains metadata about each UI screen: the name of the app it came from, the user interaction trace within that app.", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/ui_details.csv", processor=UiMetadataProcessor(), ), RicoConfig( name="play-store-metadata", version=VERSION, description="Contains metadata about the apps in the dataset including an app’s category, average rating, number of ratings, and number of downloads.", data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/app_details.csv", processor=PlayStoreMetadataProcessor(), ), ] def _info(self) -> ds.DatasetInfo: processor: RicoProcessor = self.config.processor return ds.DatasetInfo( description=_DESCRIPTION, citation=_CITATION, homepage=_HOMEPAGE, license=_LICENSE, features=processor.get_features(), ) def _split_generators(self, dl_manager: ds.DownloadManager): config: RicoConfig = self.config assert config.processor is not None processor: RicoProcessor = config.processor return processor.split_generators( dl_manager.download_and_extract(self.config.data_url), train_ratio=config.train_ratio, validation_ratio=config.validation_ratio, test_ratio=config.test_ratio, ) def _generate_examples(self, **kwargs): config: RicoConfig = self.config assert config.processor is not None processor: RicoProcessor = config.processor yield from processor.generate_examples(**kwargs)