Upload README.md with huggingface_hub

README.md

@@ -1,79 +1,548 @@
 ---
-dataset_info:
-  features:
-  - name: file_id
-    dtype: string
-  - name: file_path
-    dtype: string
-  - name: file_name
-    dtype: string
-  - name: sha256
-    dtype: string
-  - name: md5
-    dtype: string
-  - name: file_size
-    dtype: int64
-  - name: platform
-    dtype: string
-  - name: os_family
-    dtype: string
-  - name: os_version
-    dtype: string
-  - name: distribution
-    dtype: string
-  - name: file_format
-    dtype: string
-  - name: architecture
-    dtype: string
-  - name: binary_type
-    dtype: string
-  - name: is_stripped
-    dtype: bool
-  - name: is_packed
-    dtype: bool
-  - name: is_signed
-    dtype: bool
-  - name: sections
-    struct:
-    - name: name
-      list: string
-    - name: size
-      list: int64
-    - name: entropy
-      list: float32
-  - name: num_sections
-    dtype: int32
-  - name: code_size
-    dtype: int64
-  - name: data_size
-    dtype: int64
-  - name: imports
-    list: string
-  - name: num_imports
-    dtype: int32
-  - name: exports
-    list: string
-  - name: num_exports
-    dtype: int32
-  - name: entropy
-    dtype: float32
-  - name: tokens
-    list: int32
-  - name: token_count
-    dtype: int32
-  - name: compression_ratio
-    dtype: float32
-  - name: unique_tokens
-    dtype: int32
-  splits:
-  - name: train
-    num_bytes: 18774884823
-    num_examples: 30745
-  download_size: 7941649176
-  dataset_size: 18774884823
-configs:
-- config_name: default
-  data_files:
-  - split: train
-    path: data/train-*
+license: cc-by-4.0
+task_categories:
+- other
+tags:
+- binary-analysis
+- malware-detection
+- executable-analysis
+- binary-tokenization
+- cybersecurity
+- reverse-engineering
+- program-analysis
+- cross-platform
+size_categories:
+- 10K<n<100K
+pretty_name: "Binary-30K: A Large-Scale Multi-Platform Binary Dataset"
 ---
+
+# Dataset Card for Binary-30K
+
+## Table of Contents
+- [Dataset Description](#dataset-description)
+  - [Dataset Summary](#dataset-summary)
+  - [Supported Tasks](#supported-tasks)
+  - [Languages](#languages)
+- [Dataset Structure](#dataset-structure)
+  - [Data Instances](#data-instances)
+  - [Data Fields](#data-fields)
+  - [Data Splits](#data-splits)
+- [Dataset Creation](#dataset-creation)
+  - [Curation Rationale](#curation-rationale)
+  - [Source Data](#source-data)
+- [Considerations for Using the Data](#considerations-for-using-the-data)
+  - [Social Impact of Dataset](#social-impact-of-dataset)
+  - [Discussion of Biases](#discussion-of-biases)
+- [Additional Information](#additional-information)
+  - [Dataset Curators](#dataset-curators)
+  - [Licensing Information](#licensing-information)
+  - [Citation Information](#citation-information)
+
+## Dataset Description
+
+- **Homepage:** [https://michaelbommarito.com/](https://michaelbommarito.com/)
+- **Repository:** [https://github.com/mjbommar/binary-bpe-paper](https://github.com/mjbommar/binary-bpe-paper)
+- **Paper:** Binary-30K: A Large-Scale Multi-Platform Binary Dataset for Machine Learning Research
+- **Point of Contact:** michael@bommaritollc.com
+
+### Dataset Summary
+
+Binary-30K is a comprehensive, multi-platform binary executable dataset designed for machine learning research in binary analysis, malware detection, and program understanding. The dataset contains **30,841 binary executables** totaling **12.90 GB**, collected from diverse sources including Linux distributions, Windows operating systems, and the SOREL-20M malware dataset.
+
+Each binary in the dataset has been pre-processed with:
+- **Pre-computed BPE tokenization** using the `mjbommar/glaurung-binary-tokenizer-001` tokenizer
+- **Comprehensive metadata extraction** including file format, architecture, sections, imports/exports
+- **Entropy analysis** for complexity measurement
+- **Platform and OS detection** from file paths
+- **Binary analysis** via LIEF library (ELF/PE parsing)
+
+The dataset is stratified across:
+- **Linux binaries** (51%): Alpine 3.18, Debian 11/12, Ubuntu 20.04/22.04, BusyBox
+- **Windows binaries** (48%): Windows 8, 10, 11, Windows Update Catalog
+- **Malware samples** (1%): From SOREL-20M dataset
+
+This dataset enables research in malware detection, architecture recognition, function boundary detection, compiler identification, binary similarity analysis, and cross-platform binary understanding.
+
+### Supported Tasks
+
+**Binary Malware Detection**
+- Task: Binary classification (benign vs malicious)
+- Metrics: Accuracy, Precision, Recall, F1-score, AUC-ROC
+- Suggested Models: Transformer-based sequence models, CNN-based models
+- Use Case: Detect malicious executables using token sequences and metadata features
+
+**Architecture Recognition**
+- Task: Multi-class classification (x86, x86-64, ARM, ARM64, etc.)
+- Metrics: Top-1 accuracy, confusion matrix
+- Suggested Models: CNN, Transformer encoder
+- Use Case: Identify target architecture from binary content
+
+**Platform/OS Detection**
+- Task: Multi-class classification (Linux/Windows/malware, OS versions)
+- Metrics: Hierarchical accuracy (platform, OS family, version)
+- Suggested Models: Hierarchical classifiers, multi-task learning
+- Use Case: Determine origin platform and OS version
+
+**Function Boundary Detection**
+- Task: Sequence labeling (token-level classification)
+- Metrics: Precision/Recall at function boundaries, Intersection over Union
+- Suggested Models: BiLSTM-CRF, Transformer with token classification head
+- Use Case: Identify function boundaries in stripped binaries
+
+**Compiler Identification**
+- Task: Multi-class classification
+- Metrics: Per-compiler accuracy
+- Suggested Models: Feature-based classifiers, attention-based models
+- Use Case: Determine compiler and optimization level
+
+**Binary Similarity Search**
+- Task: Embedding learning, similarity ranking
+- Metrics: Mean Average Precision (MAP), Recall@K
+- Suggested Models: Siamese networks, contrastive learning
+- Use Case: Find similar binaries for library identification or code reuse detection
+
+### Languages
+
+This dataset contains compiled binary executables (machine code), not natural language text. The binaries were compiled from source code originally written in various programming languages (C, C++, Rust, Go, etc.), but the dataset itself consists of binary executable formats (ELF and PE).
+
+## Dataset Structure
+
+### Data Instances
+
+Each instance represents one binary executable with comprehensive metadata and pre-computed tokenization:
+
+```python
+{
+  # File Identification (6 fields)
+  'file_id': 'alpine3.18_linux-amd64_busybox_1.36.1-r0_busybox',
+  'file_path': 'alpine3.18/linux-amd64/busybox_1.36.1-r0/busybox',
+  'file_name': 'busybox',
+  'sha256': 'a1b2c3d4e5f6...',
+  'md5': 'f1e2d3c4b5a6...',
+  'file_size': 1048576,
+
+  # Platform Detection (4 fields)
+  'platform': 'linux',
+  'os_family': 'alpine',
+  'os_version': '3.18',
+  'distribution': 'alpine3.18',
+
+  # Binary Characteristics (6 fields)
+  'file_format': 'ELF64',
+  'architecture': 'x86-64',
+  'binary_type': 'executable',
+  'is_stripped': True,
+  'is_packed': False,
+  'is_signed': False,
+
+  # Structural Analysis (4 fields + sections)
+  'sections': [
+    {'name': '.text', 'size': 524288, 'entropy': 7.892},
+    {'name': '.data', 'size': 65536, 'entropy': 3.245},
+    ...
+  ],
+  'num_sections': 12,
+  'code_size': 524288,
+  'data_size': 131072,
+
+  # Dependencies (4 fields + imports/exports)
+  'imports': ['printf', 'malloc', 'free', ...],
+  'num_imports': 245,
+  'exports': ['main', 'init_function', ...],
+  'num_exports': 18,
+
+  # Complexity Metrics (1 field)
+  'entropy': 7.234,
+
+  # Tokenization (4 fields)
+  'tokens': [1234, 5678, 9012, ...],  # BPE token IDs
+  'token_count': 8192,
+  'compression_ratio': 2.45,  # bytes per token
+  'unique_tokens': 1523
+}
+```
+
+### Data Fields
+
+The dataset contains **29 metadata fields** organized into 7 categories:
+
+#### File Identification
+- `file_id` (string): Unique identifier constructed from path components
+- `file_path` (string): Relative path from dataset root
+- `file_name` (string): Binary filename
+- `sha256` (string): SHA-256 hash of file contents
+- `md5` (string): MD5 hash of file contents
+- `file_size` (int64): File size in bytes
+
+#### Platform Information
+- `platform` (string): Platform category: 'linux', 'windows', or 'malware'
+- `os_family` (string): OS family (alpine, debian, ubuntu, busybox, windows, sorel-20m)
+- `os_version` (string): OS version string (e.g., '3.18', '11', '20.04', '10')
+- `distribution` (string): Full distribution identifier
+
+#### Binary Characteristics
+- `file_format` (string): Binary format (ELF32, ELF64, PE32, PE32+, or 'unknown')
+- `architecture` (string): Target architecture (x86, x86-64, ARM, ARM64, MIPS, etc.)
+- `binary_type` (string): Binary type (executable, library, driver, object, or 'unknown')
+- `is_stripped` (bool): Whether debug symbols are stripped
+- `is_packed` (bool): Whether binary appears packed/compressed
+- `is_signed` (bool): Whether binary has code signature
+
+#### Structural Analysis
+- `sections` (list of dicts): List of binary sections with:
+  - `name` (string): Section name (.text, .data, .rodata, etc.)
+  - `size` (int64): Section size in bytes
+  - `entropy` (float32): Shannon entropy of section contents
+- `num_sections` (int32): Total number of sections
+- `code_size` (int64): Total size of executable code sections
+- `data_size` (int64): Total size of data sections
+
+#### Dependencies
+- `imports` (list of strings): Imported function names
+- `num_imports` (int32): Count of imported functions
+- `exports` (list of strings): Exported function names
+- `num_exports` (int32): Count of exported functions
+
+#### Complexity Metrics
+- `entropy` (float32): Shannon entropy of entire binary (0.0 to 8.0)
+
+#### Pre-computed Tokenization
+- `tokens` (list of int32): BPE token IDs from `mjbommar/glaurung-binary-tokenizer-001`
+- `token_count` (int32): Total number of tokens
+- `compression_ratio` (float32): Bytes per token (file_size / token_count)
+- `unique_tokens` (int32): Count of unique token IDs in sequence
+
+### Data Splits
+
+The dataset is provided as a single collection of 30,841 binaries. Users should create their own train/validation/test splits based on their research needs. We recommend stratified splitting to maintain platform distribution:
+
+**Recommended Split (70/15/15):**
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("mjbommar/binary-30k-tokenized")
+
+# Stratified split maintaining platform balance
+train_test = dataset['train'].train_test_split(test_size=0.3, seed=42, stratify_by_column='platform')
+train_val = train_test['train'].train_test_split(test_size=0.214, seed=42, stratify_by_column='platform')
+
+train = train_val['train']      # ~21,588 samples (70%)
+val = train_val['test']          # ~4,626 samples (15%)
+test = train_test['test']        # ~4,627 samples (15%)
+```
+
+**Distribution Statistics:**
+- Linux binaries: ~15,659 (51%)
+- Windows binaries: ~14,815 (48%)
+- Malware samples: ~367 (1%)
+
+## Dataset Creation
+
+### Curation Rationale
+
+Binary-30K was created to address the lack of large-scale, multi-platform binary datasets for machine learning research. Existing binary analysis datasets often suffer from:
+- Limited platform coverage (single OS)
+- Small scale (hundreds or thousands of samples)
+- Lack of metadata and pre-processing
+- Closed/proprietary access
+
+This dataset provides:
+1. **Cross-platform representation**: Both Linux and Windows binaries from multiple distributions
+2. **Diverse architectures**: x86, x86-64, ARM, ARM64 coverage
+3. **Rich metadata**: 29 fields per binary for fine-grained analysis
+4. **Pre-computed tokenization**: Ready for transformer-based models
+5. **Open access**: CC-BY-4.0 license with public availability
+
+The dataset enables research in:
+- Cross-platform malware detection
+- Architecture-agnostic binary analysis
+- Transfer learning between platforms
+- Tokenization-based binary understanding
+- Large-scale binary similarity analysis
+
+### Source Data
+
+#### Initial Data Collection and Normalization
+
+**Linux Binaries (51% of dataset)**
+
+Collected from official package repositories:
+- **Alpine Linux 3.18**: Lightweight distribution, static binaries
+- **Debian 11 (Bullseye)** and **Debian 12 (Bookworm)**: Stable releases
+- **Ubuntu 20.04 LTS** and **Ubuntu 22.04 LTS**: Long-term support releases
+- **BusyBox**: Embedded systems binaries
+
+Binaries extracted from .deb packages and Alpine APK packages using standard package management tools.
+
+**Windows Binaries (48% of dataset)**
+
+Collected from multiple Windows versions to capture compiler evolution:
+- **Windows 8**: System binaries and common applications
+- **Windows 10**: Multiple builds covering several years
+- **Windows 11**: Latest OS release
+- **Windows Update Catalog**: System updates and drivers
+
+Binaries extracted from official Microsoft sources using update catalog and system file extraction.
+
+**Malware Samples (1% of dataset)**
+
+Drawn from SOREL-20M dataset:
+- **SOREL-20M**: Sophos-ReversingLabs 20 million sample malware dataset
+- Subset selection: Representative samples across malware families
+- Deduplication: SHA-256 based to avoid duplicates
+
+All samples handled in isolated environment following malware analysis best practices.
+
+#### Source Language Producers
+
+The binaries were originally compiled from source code written by:
+- **Open source developers**: Linux distribution maintainers and package maintainers
+- **Microsoft engineers**: Windows operating system and system tool developers
+- **Malware authors**: For malicious samples in SOREL-20M subset
+
+The source code languages include C, C++, Rust, Go, Assembly, and others, though the dataset contains only the compiled binary forms.
+
+### Annotations
+
+#### Annotation Process
+
+The dataset includes two types of metadata:
+
+**Automatic Metadata Extraction:**
+- Platform/OS detection: Inferred from directory structure and file paths
+- Binary format analysis: Extracted using LIEF library
+- Architecture detection: From binary headers (ELF/PE)
+- Section analysis: Parsed from binary structure
+- Import/export extraction: From symbol tables and import tables
+- Entropy calculation: Shannon entropy computed on raw bytes
+- Tokenization: Pre-computed using BPE tokenizer
+
+**Manual Curation:**
+- Dataset organization: Files organized by platform, OS, and distribution
+- Quality control: Verification of parseable formats
+- Deduplication: SHA-256 based duplicate removal
+
+No human annotations for labels (malware/benign, function boundaries, etc.) are included. The `platform` field provides ground truth for Linux/Windows/malware categories based on source.
+
+#### Who are the Annotators?
+
+The automatic metadata was extracted programmatically using:
+- **LIEF library** (v0.14.0+): Binary parsing and analysis
+- **Custom extraction scripts**: Platform detection, entropy calculation
+- **HuggingFace tokenizers** (v0.15.0+): BPE tokenization with `mjbommar/glaurung-binary-tokenizer-001`
+
+Dataset curation and organization performed by the dataset authors.
+
+### Personal and Sensitive Information
+
+The dataset contains compiled binary executables. Potential sensitive information:
+
+**System Paths:**
+- Some binaries may contain embedded paths from build systems
+- Debug information (if not stripped) may include developer usernames/paths
+- These are typical artifacts of compilation and not considered sensitive
+
+**Function Names:**
+- Exported function names are included in metadata
+- These are standard API/system calls, not sensitive
+
+**Malware Samples:**
+- Malware binaries included are from public SOREL-20M dataset
+- No personal victim data included
+- Samples are widely analyzed in security research community
+
+**No User Data:**
+- No user-generated content or personal documents
+- No login credentials, API keys, or secrets
+- No personally identifiable information (PII)
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+**Positive Impacts:**
+
+1. **Defensive Security**: Enables development of better malware detection systems
+2. **Binary Analysis Research**: Accelerates research in program analysis and reverse engineering
+3. **Cross-platform Understanding**: Facilitates development of platform-agnostic analysis tools
+4. **Open Science**: Provides open dataset where previously proprietary/closed datasets dominated
+5. **Educational Value**: Supports teaching of binary analysis, cybersecurity, and ML applications
+
+**Potential Concerns:**
+
+1. **Dual-Use Nature**: Techniques developed could potentially be used by malicious actors
+   - Mitigation: Dataset focuses on detection/analysis, not creation of malware
+
+2. **Malware Inclusion**: Contains real malware samples
+   - Mitigation: Small subset (1%), from public SOREL-20M, no execution required for ML use
+   - Users should handle malware samples with appropriate security precautions
+
+3. **Adversarial Learning**: Could be used to develop evasion techniques
+   - Mitigation: Open datasets enable defensive research to stay ahead of attacks
+
+### Discussion of Biases
+
+**Platform Bias:**
+- Linux (51%) and Windows (48%) are balanced, but represent only two major platforms
+- MacOS, mobile platforms (iOS/Android), and embedded systems not represented
+- This may limit generalization to other platforms
+
+**Architecture Bias:**
+- Dominated by x86-64 architecture
+- Limited ARM samples despite ARM's growing importance (mobile, IoT, Apple Silicon)
+- Other architectures (MIPS, RISC-V) minimally represented
+
+**Temporal Bias:**
+- Windows samples span Windows 8-11 (2012-2023)
+- Linux samples from 2020-2024 distributions
+- May not represent historical (pre-2010) or future compilation patterns
+
+**Distribution Bias:**
+- Linux samples from Debian-based distributions (Debian, Ubuntu) and Alpine
+- Other distributions (RedHat, Arch, Gentoo) not represented
+- May not capture distribution-specific toolchain differences
+
+**Malware Bias:**
+- Malware samples only 1% of dataset (class imbalance)
+- Malware from SOREL-20M (2020 collection) may not represent current threats
+- Geographic/language bias in malware samples from original SOREL-20M
+
+**Size Bias:**
+- File sizes vary widely; very large binaries may be underrepresented
+- Tokenization truncation may affect very large files (>1MB)
+
+**Researchers should:**
+- Be aware of these biases when drawing conclusions
+- Validate findings on additional out-of-distribution datasets
+- Consider stratified sampling based on platform/architecture for balanced experiments
+
+### Other Known Limitations
+
+**Technical Limitations:**
+
+1. **Static Analysis Only**: Dataset contains binaries without runtime behavior
+   - No dynamic analysis features (API calls, network activity, file operations)
+
+2. **Tokenization Context Window**: Very large binaries truncated during tokenization
+   - May lose information from files >1-2MB after tokenization
+
+3. **Parsing Failures**: Some binaries cannot be parsed by LIEF
+   - Corrupted files, unusual formats, or packers may result in missing metadata
+
+4. **Architecture Detection**: Based on headers, may be incorrect for obfuscated binaries
+
+5. **Stripped Binaries**: Many binaries have debug symbols removed
+   - Limits metadata extraction (fewer function names, no source line info)
+
+**Usage Limitations:**
+
+1. **Malware Handling**: Users must follow security best practices
+   - Isolated environments, no execution required for dataset use
+
+2. **Legal Considerations**: Windows binaries subject to Microsoft licensing
+   - Research/educational use should be covered under fair use
+   - Users should verify compliance with local laws
+
+3. **Computational Requirements**: Full dataset requires significant resources
+   - 12.90 GB raw data + 15-20 GB tokenized dataset
+   - Token sequences can be very long (10K+ tokens)
+
+4. **Not a Benchmark**: No standardized train/test splits or evaluation protocol
+   - Users should define splits and protocols appropriate for their research
+
+## Additional Information
+
+### Dataset Curators
+
+This dataset was curated by:
+
+**Michael J. Bommarito II**
+- Email: michael@bommaritollc.com
+- Affiliation: Bommarito Consulting, LLC
+
+With contributions from collaborators in the binary analysis and machine learning research communities.
+
+### Licensing Information
+
+This dataset is released under **Creative Commons Attribution 4.0 International (CC-BY-4.0)** license.
+
+**Summary:**
+- ✅ Share: Copy and redistribute in any medium or format
+- ✅ Adapt: Remix, transform, and build upon the material for any purpose
+- ✅ Commercial use allowed
+- ⚠️ Attribution required: Must give appropriate credit and indicate if changes were made
+
+**Component Licenses:**
+
+1. **Linux Binaries**: Various open source licenses (GPL, LGPL, MIT, BSD, Apache)
+   - Original software licenses remain in effect for the binaries themselves
+   - Dataset compilation and metadata under CC-BY-4.0
+
+2. **Windows Binaries**: Microsoft software licenses
+   - Research and educational use covered under fair use
+   - Users responsible for compliance with Microsoft terms
+
+3. **Malware Samples**: From SOREL-20M dataset (Sophos-ReversingLabs)
+   - SOREL-20M released for research purposes
+   - No copyright claimed on malware samples themselves
+
+**Attribution:**
+When using this dataset, please cite the associated paper (see Citation Information below).
+
+### Citation Information
+
+If you use this dataset in your research, please cite:
+
+```bibtex
+@article{bommarito2025binary30k,
+  title={Binary-30K: A Large-Scale Multi-Platform Binary Dataset for Machine Learning Research},
+  author={Bommarito, Michael J., II},
+  journal={arXiv preprint},
+  year={2025},
+  url={https://github.com/mjbommar/binary-bpe-paper}
+}
+```
+
+**Related Publications:**
+
+For information about the BPE tokenizer used for pre-processing:
+
+```bibtex
+@article{bommarito2025binarybpe,
+  title={Byte Pair Encoding for Binary Executables: A Large-Scale Analysis},
+  author={Bommarito, Michael J., II},
+  journal={arXiv preprint},
+  year={2025},
+  url={https://github.com/mjbommar/binary-bpe-paper}
+}
+```
+
+### Dataset Access
+
+**HuggingFace Hub:**
+```python
+from datasets import load_dataset
+dataset = load_dataset("mjbommar/binary-30k-tokenized")
+```
+
+**Direct Download:**
+- HTTP: https://michaelbommarito.com/resources/glaurung/data/glaurung-model-binaries-20251028.tar.gz
+- S3: s3://michaelbommarito.com/resources/glaurung/data/glaurung-model-binaries-20251028.tar.gz
+- Size: 12.90 GB (compressed)
+
+### Contributions
+
+Thanks to the open source community, Linux distribution maintainers, and the SOREL-20M team for making their data available for research.
+
+Special thanks to:
+- HuggingFace for datasets and tokenizers libraries
+- LIEF project for binary parsing tools
+- The binary analysis and malware research communities
+
+**Contributing:**
+- Report issues or suggest improvements via GitHub: https://github.com/mjbommar/binary-bpe-paper
+- Contact: michael@bommaritollc.com
+
+---
+
+**Last Updated:** October 28, 2025