Dataset card and loading code

README.md

@@ -1,3 +1,113 @@
 ---
+# For reference on dataset card metadata, see the spec: https://github.com/huggingface/hub-docs/blob/main/datasetcard.md?plain=1
+# Doc / guide: https://huggingface.co/docs/hub/datasets-cards
 license: cc-by-4.0
+viewer: false
+tags:
+- security
+- malware-detection
+- android
+- graph-machine-learning
+- distribution-shift
+- function-call-graph
 ---
+
+# Dataset Card for MalNet-Tiny Distribution Shift Benchmarks
+
+This dataset contains three datasets, **MalNet-Tiny**, **MalNet-Tiny-Common** and **MalNet-Tiny-Distinct**, designed to evaluate the robustness of graph-based Android malware classifiers under distribution shift. Derived from the [MalNet-Tiny](https://malnet.cs.gatech.edu/) dataset, these benchmarks introduce specific partitions to simulate realistic covariate shift (intra-family) and domain (cross-family) shifts by enriching Function Call Graphs (FCGs) with semantic function metadata and LLM-based code embeddings.
+
+## Dataset Details
+
+### Dataset Description
+
+The dataset consists of Android Function Call Graphs (FCGs) where nodes represent functions and edges represent invocations. Unlike the original MalNet-Tiny, which relies on structure-only representations, this dataset enriches the graphs with:
+1.  **Function Metadata:** Lightweight features such as function names, method signatures, and access flags.
+2.  **LLM Embeddings:** Dense semantic representations of function bodies derived from Large Language Models (LLMs), extracted when source code is available.
+
+The available datasets are defined as follows:
+* **MalNet-Tiny:** The original MalNet-Tiny dataset with semantic features for nodes in the FCGs.
+* **MalNet-Tiny-Common:** Evaluates generalization of the model under covariate shift.
+* **MalNet-Tiny-Distinct:** Evaluates generalization of the model under domain shift.
+
+### Dataset Specification
+- **License:** Creative Commons Attribution 4.0 International (CC-BY 4.0)
+
+## Uses
+
+### Direct Use
+
+* **Robust Malware Detection:** Developing and benchmarking Graph Neural Networks (GNNs) that are resilient to evolving malware variants.
+* **Distribution Shift Evaluation:** Testing model performance under covariate shift (Common) and domain shift (Distinct).
+* **Graph Representation Learning:** Studying the integration of structural (graph) and semantic (LLM/Metadata) features in learning tasks.
+
+### Out-of-Scope Use
+
+* This dataset is intended for research purposes (defense) and should not be used to generate or obfuscate malware.
+* The semantic features rely on static analysis; dynamic execution traces are not included.
+
+## Dataset Structure
+
+To improve usability, we have reworked the precomputed data structure such that there are no duplicate weights across the files, broken down large files into smaller ones for easy storage, and improved code to not unnecessarily allocate memory during the data loading process. Meanwhile, we retain the user's ability to download specific files needed for any requested split. The dataloading code is provided in `mntf.py` within this repository, with example usage:
+
+```python
+from mntf import MNTF
+from torch_geometric.loader import DataLoader
+from torch_geometric.transforms import LocalDegreeProfile
+
+dataset = MNTF(
+    collator="zero", ablation="all", variant="tiny", llm_name="cxe",
+    remove_isolated=True, transform=LocalDegreeProfile()
+)
+trainloader = DataLoader(
+    dataset[dataset.splits["train"]], batch_size=32, shuffle=True
+)
+```
+
+The code has been upgraded to work with the newer PyTorch Geometric 2.3+, whereas the original code extending from Exphormer used the now-defunct PyG 2.0.4. While we strongly recommend installing PyG 2.3+ for seamless installation (as it removes various hard component requirements such as `torch_scatter`) and set our minimum requirement as such, this code can be minimally adjusted to work with earlier versions. Another requirement is `safetensors` for loading graph features, replacing `.pt` checkpoints that requires `torch.load(weights_only=False)` in newer versions of PyTorch; and its default `mmap` backend eliminates the need to allocate each sub-tensor twice during concatenation.
+
+Additionally, `huggingface_hub` is an optional dependency, which automatically downloads the required files to load the dataset. If not installed, these files need to be manually downloaded before dataset creation.
+
+## Dataset Creation
+
+### Curation Rationale
+
+Existing graph-based classifiers achieve high accuracy on standard benchmarks (like MalNet-Tiny) but suffer noticeable performance drops on unseen families. These benchmarks were created to rigorously evaluate and improve the generalization capabilities of malware detectors in realistic, evolving threat environments.
+
+### Source Data
+
+The data are processed from raw APK files from [AndroZoo](https://androzoo.uni.lu/), a repository of real-world Android packages.
+Labels are derived from [MalNet](https://malnet.cs.gatech.edu/), a large-scale dataset containing Android Function Call Graphs and their malware classifications.
+
+#### Data Collection and Processing
+
+1.  **Base Data:** Samples and labels were selected from MalNet, then corresponding raw APK were downloaded from AndroZoo.
+    * *MalNet-Tiny:* The split from the original MalNet.
+    * *MalNet-Tiny-Common:* Samples from **same** malware *families* but different malware *types*.
+    * *MalNet-Tiny-Distinct:* Samples from **completely unseen** families of malwares.
+2.  **Feature Extraction:**
+    * *Metadata Extraction:* Function names, signatures, and flags were extracted to provide lightweight semantic context.
+    * *LLM Embedding:* Source code (decompiled Smali/Java) of function bodies was processed using Large Language Models to generate dense code embeddings.
+
+Accompanied code on dataset construction can be found at [this project page](https://ngoc.io/malnet-features).
+
+## Bias, Risks, and Limitations
+
+* **Static Analysis Limitations:** The graphs are based on static analysis and may be vulnerable to obfuscation techniques that alter call graphs (e.g., reflection, dynamic loading) without changing behavior.
+* **Feature Availability:** LLM embeddings depend on the successful decompilation and availability of function bodies.
+
+### Recommendations
+
+Users should be made aware of the risks, biases, and limitations of the dataset. Models trained on this dataset should be evaluated in conjunction with dynamic analysis methods for deployment in critical security environments.
+
+## Citation
+```latex
+@misc{tran2026evaluating,
+      title={Evaluating Out-of-Distribution Robustness in Graph-Based Android Malware Classification: A New Principled Benchmark}, 
+      author={Ngoc N. Tran and Anwar Said and Waseem Abbas and Tyler Derr and Xenofon D. Koutsoukos},
+      year={2026},
+      eprint={2508.06734},
+      archivePrefix={arXiv},
+      primaryClass={cs.CR},
+      url={https://arxiv.org/abs/2508.06734}, 
+}
+```

mntf.py

@@ -0,0 +1,351 @@
+import glob
+import json
+import os
+from pathlib import Path
+from typing import Callable, Dict, List, Optional
+
+import safetensors.torch as st
+import torch
+from torch_geometric.data import Data, InMemoryDataset
+
+shard_counts = {
+    'tiny': {'cxe': 3, 'qwen': 1, 'rest': 1, 'trim': 1, 'unix': 1},
+    'common': {'cxe': 4, 'qwen': 2, 'rest': 2, 'trim': 1, 'unix': 2},
+    'distinct': {'cxe': 5, 'qwen': 2, 'rest': 2, 'trim': 1, 'unix': 2},
+}
+
+try:
+    import huggingface_hub as hf
+except ImportError:
+    hf = None
+repo_id = "ngoctnq/malnet-features"
+
+
+def _llc_bytes(default=32 << 20):
+    """
+    Size of the last-level cache visible to cpu0 in bytes, capped at L3.
+        Defaults to 32Mb if the information is not available.
+    Used for determining the optimal chunk size for loading large feature
+        matrices in the MNTF dataset.
+    """
+    best = (0, default)
+    for d in glob.glob('/sys/devices/system/cpu/cpu0/cache/index*'):
+        try:
+            with open(os.path.join(d, 'level')) as f: level = int(f.read())
+            with open(os.path.join(d, 'type')) as f:  kind = f.read().strip()
+            with open(os.path.join(d, 'size')) as f:  s = f.read().strip()
+        except OSError:
+            continue
+        if kind not in ('Unified', 'Data') or level > 3:
+            continue # skip L1i, and memory-side L4
+        mult = {'K': 1 << 10, 'M': 1 << 20, 'G': 1 << 30}.get(s[-1:], 1)
+        nbytes = int(s[:-1] if mult > 1 else s) * mult
+        if level > best[0]:
+            best = (level, nbytes)
+    return best[1]
+
+
+class MNTF(InMemoryDataset):
+    """
+    A custom dataset class for the MNTF dataset.
+    The splits are stored in a `splits` field, containing a dictionary
+        with keys "train", "valid", and "test", each mapping to a list of
+        indices for the corresponding split.
+
+    Example usage:
+    ```python
+    from torch_geometric.loader import DataLoader
+    from torch_geometric.transforms import LocalDegreeProfile
+    
+    dataset = MNTF(
+        collator="zero", ablation="all", variant="tiny", llm_name="cxe",
+        remove_isolated=True, transform=LocalDegreeProfile()
+    )
+    trainloader = DataLoader(
+        dataset[dataset.splits["train"]], batch_size=32, shuffle=True
+    )
+    ```
+
+    Args:
+        collator (str): The collator type to use for processing the dataset.
+            Valid options are "trim", "prune", "zero", or "none".
+        ablation (str): The ablation type to use for processing the dataset.
+            Valid options are "base", "llm", or "all".
+        variant (str): The variant of the dataset to use.
+            Valid options are "tiny", "common", or "distinct".
+        llm_name (str, optional): The name of the LLM to use for processing the dataset.
+            Valid options are None, "unix", "qwen", or "cxe". Default is None.
+        root (str, optional): The root directory where the dataset is stored.
+            Default is './data/mntf' if `huggingface_hub` is not installed;
+            otherwise None uses the default HuggingFace cache directory.
+        remove_isolated (bool, optional): Whether to remove isolated nodes from the dataset.
+            Default is True.
+        transform (callable, optional): An optional transform function to apply to the dataset,
+            passed directly to the parent class' constructor. Default is None.
+    """
+    def __init__(
+        self,
+        collator: str,
+        ablation: str,
+        variant: str = "tiny",
+        llm_name: Optional[str] = None,
+        root: Optional[str] = None,
+        remove_isolated: bool = True,
+        transform: Optional[Callable] = None,
+    ):
+        self._validate_parameters(variant, collator, ablation, llm_name, remove_isolated)
+        
+        # field assignment needs to come before super() to make processed_dir work
+        self.collator = collator
+        self.ablation = ablation
+        self.remove_isolated = remove_isolated
+        self.variant = variant
+        self.llm_name = llm_name
+
+        # for resolving real file directories when using hf_hub_download
+        self._resolved: Dict[str, str] = {}
+
+        if root is None and hf is None:
+            root = './data/mntf'
+
+        super().__init__(root, transform, pre_transform=None, pre_filter=None)
+        # override the default root set by super().__init__() to avoid creating a local '???' folder
+        if root is None:
+            self.root = None
+
+        base_data = st.load_file(self.processed_paths[0])
+        self._data = Data(**{k[len('data.'):]: v for k, v in base_data.items() if k.startswith('data.')})
+        # clone() to make sure future writes succeed, since the underlying storage is read-only
+        self.slices = {k[len('slices.'):]: v.clone() for k, v in base_data.items() if k.startswith('slices.')}
+        with open(self.processed_paths[-1]) as f:
+            self.splits = json.load(f)
+
+        node_mask = None
+        if remove_isolated:
+            node_mask = self.remove_isolated_nodes()
+        self.populate_features(connected_node_mask=node_mask)
+
+
+    @classmethod
+    def _validate_parameters(cls, variant, collator, ablation, llm_name, remove_isolated):
+        # validate inputs
+        assert variant in ('tiny', 'common', 'distinct'), f"Invalid variant: {variant}"
+        assert collator in ('trim', 'prune', 'zero', 'none'), f"Invalid collator: {collator}"
+        assert ablation in ('base', 'llm', 'all'), f"Invalid ablation: {ablation}"
+        assert llm_name is None or llm_name in ('cxe', 'qwen', 'unix'), f"Invalid llm_name: {llm_name}"
+        assert (ablation == 'base') ^ (llm_name is not None), f"Invalid combination: {ablation=} and {llm_name=}"
+        assert collator != 'trim' or ablation == 'base', "Cannot use trim with LLM features"
+        assert collator != 'prune' or not remove_isolated, "Cannot use prune with remove_isolated=True"
+
+
+    def populate_features(self, connected_node_mask: Optional[torch.Tensor] = None):
+        """ Note that all assignments have to be done in store! """
+        if connected_node_mask is not None:
+            assert connected_node_mask.shape[0] == self.x.shape[0], \
+                f"connected_node_mask shape {connected_node_mask.shape} does not match x shape {self.x.shape}"
+        # silence the linter
+        assert self._data is not None, "No base dataset loaded"
+
+        universal_node_mask = self.x.bool().squeeze()
+        # use mmap to avoid loading all features into memory at once (default safetensors)
+        # safetensors 0.8.0 introduced pread, which blows up AnonRSS -- if in
+        # the future the default changes, add an explicit backend='mmap' here.
+        # It's omitted now for backwards compatibility.
+        feature_tensors = [st.load_file(p)[Path(p).stem] for p in self.processed_paths[1:-1]]
+        feature_counts = [x.shape[1] for x in feature_tensors]
+        feature_count_cumsum = torch.cumsum(torch.tensor([0] + feature_counts), dim=0).tolist()
+
+        if self.collator == 'prune':
+            self.select_edges_from_node_mask(universal_node_mask)
+            assert connected_node_mask is None, "Cannot use prune with remove_isolated=True"
+            node_mask = universal_node_mask
+        else:
+            node_mask = connected_node_mask
+
+        num_nodes = self.x.shape[0]
+        new_num_nodes = num_nodes if node_mask is None else node_mask.sum().item()
+        assert isinstance(new_num_nodes, int) and new_num_nodes > 0, "No nodes in Storage, cannot assign features"
+
+        # create storage for x and populate with truncated features
+        self._data.stores[0].x = torch.zeros(
+            (new_num_nodes, feature_count_cumsum[-1]),
+            dtype=torch.float,
+            device=self.x.device,
+        )
+    
+        for subfeature_idx, subfeature_matrix in enumerate(feature_tensors):
+            if subfeature_matrix.shape[1] == 0:
+                continue
+
+            # feature sets: trim, rest, llm
+            # node_mask: connected_node_mask [+ universal_node_mask], always on x_base
+            # universal_node_mask: which of x_base correspond to the current subfeature_matrix
+
+            # get a slice view of the destination subtensor
+            dest_tensor = self._data.stores[0].x[:, feature_count_cumsum[subfeature_idx]:feature_count_cumsum[subfeature_idx+1]]
+
+            # simple x_trim case
+            if subfeature_matrix.shape[0] == num_nodes:
+                if num_nodes == new_num_nodes:
+                    # no nodes were removed, so we can just copy the entire subfeature_matrix
+                    dest_tensor.copy_(subfeature_matrix)
+                else:
+                    # if x_trim and mismatch dimension, connected_node_mask must have been provided
+                    subfeature_idxs = torch.arange(num_nodes, device=self.x.device)[node_mask]
+                    assert subfeature_idxs.numel() == new_num_nodes, \
+                        f"subfeature_idxs count {subfeature_idxs.numel()} != {new_num_nodes} rows; index_select would resize the view"
+                    # equivalent to: dst.copy_(src[mask])
+                    torch.index_select(subfeature_matrix, 0, subfeature_idxs, out=dest_tensor)
+
+            # simple remove_isolated=False case, x_rest/x_llm only
+            elif connected_node_mask is None:
+                # prune + x_rest/x_llm
+                if dest_tensor.shape[0] == subfeature_matrix.shape[0]:
+                    dest_tensor.copy_(subfeature_matrix)
+                # zero + x_rest/x_llm
+                else:
+                    dest_tensor_idxs = torch.arange(num_nodes, device=self.x.device)[universal_node_mask]
+                    # equivalent to: dst[mask].copy_(src)
+                    dest_tensor.index_copy_(0, dest_tensor_idxs, subfeature_matrix)
+
+            # remove_isolated=True + x_rest/x_llm -> zero
+            else:
+                # remove_isolated=True implies not prune, thus node_mask = connected_node_mask
+                assert node_mask is not None, "sanity check: connected_node_mask is not None but node_mask is None"
+                subfeature_idxs = torch.arange(subfeature_matrix.shape[0], device=self.x.device)[node_mask[universal_node_mask]]
+                dest_tensor_idxs = torch.arange(new_num_nodes, device=self.x.device)[universal_node_mask[node_mask]]
+                # true by construction but doesn't hurt to check
+                assert subfeature_idxs.numel() == dest_tensor_idxs.numel(), \
+                    f"subfeature_idxs count {subfeature_idxs.numel()} != dest_tensor_idxs count {dest_tensor_idxs.numel()}"
+                # quick check happy path shortcuts
+                if dest_tensor_idxs.numel() == new_num_nodes:
+                    if new_num_nodes == subfeature_matrix.shape[0]:
+                        # no nodes were removed, so we can just copy the entire subfeature_matrix
+                        dest_tensor.copy_(subfeature_matrix)
+                    else:
+                        # equivalent to: dst.copy_(src[mask])
+                        torch.index_select(subfeature_matrix, 0, subfeature_idxs, out=dest_tensor)
+                elif subfeature_idxs.numel() == subfeature_matrix.shape[0]:
+                    # equivalent to: dst[mask].copy_(src)
+                    dest_tensor.index_copy_(0, dest_tensor_idxs, subfeature_matrix)
+                else:
+                    # chunking is faster than contiguous-block reads, since the overhead is dominated by PyTorch calls
+                    chunk_size = max(1, _llc_bytes() // (subfeature_matrix.shape[1] * subfeature_matrix.element_size()))
+                    for i in range(0, dest_tensor_idxs.numel(), chunk_size):
+                        chunk_dest_idxs = dest_tensor_idxs[i : i + chunk_size]
+                        chunk_subfeature_idxs = subfeature_idxs[i : i + chunk_size]
+                        dest_tensor.index_copy_(0, chunk_dest_idxs, subfeature_matrix[chunk_subfeature_idxs])
+
+
+    def remove_isolated_nodes(self):
+        '''
+        Note: This function does not actually remove the isolated nodes from
+        the dataset, but _do_ remove the corresponding edges. Returns a boolean
+        mask indicating which nodes are _not_ isolated for later compaction.
+        '''
+        # silence the linter
+        assert self.slices is not None, "No dataset slices loaded"
+        assert self._data is not None, "No base dataset loaded"
+
+        # edge_index is local, lift to global to correctly identify non-isolated nodes
+        edge_counts = self.slices['edge_index'][1:] - self.slices['edge_index'][:-1]
+        per_edge_offset = torch.repeat_interleave(self.slices['x'][:-1], edge_counts)
+        global_ei = self._data.edge_index + per_edge_offset.unsqueeze(0)
+
+        mask = torch.zeros(self.x.shape[0], dtype=torch.bool, device=self.x.device)
+        not_self_loop = global_ei[0] != global_ei[1]
+        mask[global_ei[:, not_self_loop].view(-1)] = True
+        self.select_edges_from_node_mask(mask)
+
+        # return mask to defer tensor compaction
+        return mask
+
+
+    def select_edges_from_node_mask(self, node_mask: torch.Tensor):
+        # silence the linter
+        assert self.slices is not None, "No dataset slices loaded"
+        assert self._data is not None, "No base dataset loaded"
+
+        # edge_index is local, lift to global to correctly identify non-isolated nodes
+        edge_counts = self.slices['edge_index'][1:] - self.slices['edge_index'][:-1]
+        per_edge_offset = torch.repeat_interleave(self.slices['x'][:-1], edge_counts)
+        global_ei = self._data.edge_index + per_edge_offset.unsqueeze(0)
+
+        node_map = torch.full((self.x.shape[0],), -1, dtype=torch.long, device=node_mask.device)
+        node_map[node_mask] = torch.arange(node_mask.sum().item(), device=node_mask.device)
+        valid_edges = node_mask[global_ei[0]] & node_mask[global_ei[1]]
+        new_global_ei = node_map[global_ei[:, valid_edges]]
+
+        # defer to later to prevent unnecessary copies of x
+        # self._data.stores[0].x = self.x[node_mask]
+
+        # rebuild slices
+        x_slice_cumsum = torch.cumsum(node_mask, dim=0)
+        self.slices['x'][1:] = x_slice_cumsum[self.slices['x'][1:] - 1]
+
+        edge_slice_cumsum = torch.cumsum(valid_edges, dim=0)
+        self.slices['edge_index'][1:] = edge_slice_cumsum[self.slices['edge_index'][1:] - 1]
+
+        # convert back to local using updated slices
+        new_edge_counts = self.slices['edge_index'][1:] - self.slices['edge_index'][:-1]
+        new_per_edge_offset = torch.repeat_interleave(self.slices['x'][:-1], new_edge_counts)
+        self._data.stores[0].edge_index = new_global_ei - new_per_edge_offset.unsqueeze(0)
+
+
+    @property
+    def processed_file_names(self) -> List[str]:
+        components = ['base.safetensors']
+
+        def add_component(name: str):
+            # handle adding sharded components based on shard_counts
+            shard_count = shard_counts.get(self.variant, {}).get(name)
+            if shard_count is None or shard_count == 1:
+                components.append(f'x_{name}.safetensors')
+            else:
+                for i in range(shard_count):
+                    components.append(f'x_{name}_{i}.safetensors')
+
+        if self.collator != 'none':
+            if self.ablation != 'llm':
+                add_component('trim')
+                if self.collator != 'trim':
+                    add_component('rest')
+            if self.ablation != 'base':
+                assert self.llm_name is not None, "llm_name must be specified for LLM ablation"
+                add_component(self.llm_name)
+
+        return components + ["splits.json"]
+
+
+    @property
+    def processed_paths(self) -> List[str]:
+        files = self.processed_file_names
+        try:
+            return [self._resolve(f) for f in files]
+        except Exception:
+            print(
+                "[!] An error occurred while trying to load this dataset. "
+                f"Manually download the following files: {files} "
+                f"from https://huggingface.co/datasets/{repo_id}/{self.variant}"
+                + (f" into {self.root}/{self.variant}." if self.root is not None else ".")
+            )
+            raise
+
+
+    def _resolve(self, name: str) -> str:
+        if name in self._resolved:
+            return self._resolved[name]
+        
+        if self.root is not None:
+            resolved_path = Path(self.root) / self.variant / name
+            if resolved_path.exists():
+                self._resolved[name] = str(resolved_path)
+                return self._resolved[name]
+
+        # Download the required files
+        if hf is None:
+            raise RuntimeError("Dataset not found and huggingface_hub is not installed.")
+        resolved = hf.hf_hub_download(repo_id, f'{self.variant}/{name}', repo_type="dataset", local_dir=self.root)
+        self._resolved[name] = resolved
+        return resolved
+