Upload README.md with huggingface_hub

README.md

@@ -1,27 +1,277 @@
 ---
-configs:
-- config_name: default
-  data_files:
-  - split: data
-    path: data/data-*
-dataset_info:
-  features:
-  - name: subject
-    dtype: string
-  - name: predicate
-    dtype: string
-  - name: object
-    dtype: string
-  - name: object_type
-    dtype: string
-  - name: object_datatype
-    dtype: string
-  - name: object_language
-    dtype: string
-  splits:
-  - name: data
-    num_bytes: 481806552802
-    num_examples: 3130753066
-  download_size: 32476432840
-  dataset_size: 481806552802
+license: cc-by-2.5
+task_categories:
+- text-generation
+- feature-extraction
+language:
+- en
+tags:
+- rdf
+- knowledge-graph
+- semantic-web
+- triples
+size_categories:
+- 1M<n<10M
 ---
+
+# Freebase
+
+## Dataset Description
+
+Large-scale knowledge base (archived by Google)
+
+**Original Source:** http://commondatastorage.googleapis.com/freebase-public/rdf/freebase-rdf-latest.gz
+
+### Dataset Summary
+
+This dataset contains RDF triples from Freebase converted to HuggingFace
+dataset format for easy use in machine learning pipelines.
+
+- **Format:** Originally ntriples, converted to HuggingFace Dataset
+- **Size:** 300.0 GB (extracted)
+- **Entities:** ~50M
+- **Triples:** ~3B
+- **Original License:**
+    CC BY 2.5
+
+### Recommended Use
+
+Historical knowledge base, large-scale training
+
+### Notes: Archived dataset from 2014, very comprehensive but historical
+
+
+## Dataset Format: Lossless RDF Representation
+
+This dataset uses a **standard lossless format** for representing RDF (Resource Description Framework)
+data in HuggingFace Datasets. All semantic information from the original RDF knowledge graph is preserved,
+enabling perfect round-trip conversion between RDF and HuggingFace formats.
+
+### Schema
+
+Each RDF triple is represented as a row with **6 fields**:
+
+| Field | Type | Description | Example |
+|-------|------|-------------|---------|
+| `subject` | string | Subject of the triple (URI or blank node) | `"http://schema.org/Person"` |
+| `predicate` | string | Predicate URI | `"http://www.w3.org/1999/02/22-rdf-syntax-ns#type"` |
+| `object` | string | Object of the triple | `"John Doe"` or `"http://schema.org/Thing"` |
+| `object_type` | string | Type of object: `"uri"`, `"literal"`, or `"blank_node"` | `"literal"` |
+| `object_datatype` | string | XSD datatype URI (for typed literals) | `"http://www.w3.org/2001/XMLSchema#integer"` |
+| `object_language` | string | Language tag (for language-tagged literals) | `"en"` |
+
+### Example: RDF Triple Representation
+
+**Original RDF (Turtle)**:
+```turtle
+<http://example.org/John> <http://schema.org/name> "John Doe"@en .
+```
+
+**HuggingFace Dataset Row**:
+```python
+{
+  "subject": "http://example.org/John",
+  "predicate": "http://schema.org/name",
+  "object": "John Doe",
+  "object_type": "literal",
+  "object_datatype": None,
+  "object_language": "en"
+}
+```
+
+### Loading the Dataset
+
+```python
+from datasets import load_dataset
+
+# Load the dataset
+dataset = load_dataset("CleverThis/freebase")
+
+# Access the data
+data = dataset["data"]
+
+# Iterate over triples
+for row in data:
+    subject = row["subject"]
+    predicate = row["predicate"]
+    obj = row["object"]
+    obj_type = row["object_type"]
+
+    print(f"Triple: ({subject}, {predicate}, {obj})")
+    print(f"  Object type: {obj_type}")
+    if row["object_language"]:
+        print(f"  Language: {row['object_language']}")
+    if row["object_datatype"]:
+        print(f"  Datatype: {row['object_datatype']}")
+```
+
+### Converting Back to RDF
+
+The dataset can be converted back to any RDF format (Turtle, N-Triples, RDF/XML,
+etc.) with **zero information loss**:
+
+```python
+from datasets import load_dataset
+from rdflib import Graph, URIRef, Literal, BNode
+
+def convert_to_rdf(dataset_name, output_file="output.ttl", split="data"):
+    """Convert HuggingFace dataset back to RDF Turtle format."""
+    # Load dataset
+    dataset = load_dataset(dataset_name)
+
+    # Create RDF graph
+    graph = Graph()
+
+    # Convert each row to RDF triple
+    for row in dataset[split]:
+        # Subject
+        if row["subject"].startswith("_:"):
+            subject = BNode(row["subject"][2:])
+        else:
+            subject = URIRef(row["subject"])
+
+        # Predicate (always URI)
+        predicate = URIRef(row["predicate"])
+
+        # Object (depends on object_type)
+        if row["object_type"] == "uri":
+            obj = URIRef(row["object"])
+        elif row["object_type"] == "blank_node":
+            obj = BNode(row["object"][2:])
+        elif row["object_type"] == "literal":
+            if row["object_datatype"]:
+                obj = Literal(row["object"], datatype=URIRef(row["object_datatype"]))
+            elif row["object_language"]:
+                obj = Literal(row["object"], lang=row["object_language"])
+            else:
+                obj = Literal(row["object"])
+
+        graph.add((subject, predicate, obj))
+
+    # Serialize to Turtle (or any RDF format)
+    graph.serialize(output_file, format="turtle")
+    print(f"Exported {len(graph)} triples to {output_file}")
+    return graph
+
+# Usage
+graph = convert_to_rdf("CleverThis/freebase", "reconstructed.ttl")
+```
+
+### Information Preservation Guarantee
+
+This format preserves **100% of RDF information**:
+
+- ✅ **URIs**: Exact string representation preserved
+- ✅ **Literals**: Full text content preserved
+- ✅ **Datatypes**: XSD and custom datatypes preserved
+    (e.g., `xsd:integer`, `xsd:dateTime`)
+- ✅ **Language Tags**: BCP 47 language tags preserved (e.g., `@en`, `@fr`, `@ja`)
+- ✅ **Blank Nodes**: Node structure preserved (identifiers may change but
+    graph isomorphism maintained)
+
+**Round-trip guarantee**: Original RDF → HuggingFace → Reconstructed RDF
+produces **semantically identical** graphs.
+
+### Querying the Dataset
+
+You can filter and query the dataset like any HuggingFace dataset:
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset("CleverThis/freebase")
+
+# Find all triples with English literals
+english_literals = dataset["data"].filter(
+    lambda x: x["object_type"] == "literal" and x["object_language"] == "en"
+)
+print(f"Found {len(english_literals)} English literals")
+
+# Find all rdf:type statements
+type_statements = dataset["data"].filter(
+    lambda x: "rdf-syntax-ns#type" in x["predicate"]
+)
+print(f"Found {len(type_statements)} type statements")
+
+# Convert to Pandas for analysis
+import pandas as pd
+df = dataset["data"].to_pandas()
+
+# Analyze predicate distribution
+print(df["predicate"].value_counts())
+```
+
+### Dataset Format
+
+The dataset contains all triples in a single **data** split, suitable for
+machine learning tasks such as:
+
+- Knowledge graph completion
+- Link prediction
+- Entity embedding
+- Relation extraction
+- Graph neural networks
+
+### Format Specification
+
+For complete technical documentation of the RDF-to-HuggingFace format, see:
+
+📖 [RDF to HuggingFace Format Specification](https://github.com/CleverThis/cleverernie/blob/master/docs/rdf_huggingface_format_specification.md)
+
+The specification includes:
+- Detailed schema definition
+- All RDF node type mappings
+- Performance benchmarks
+- Edge cases and limitations
+- Complete code examples
+
+### Conversion Metadata
+
+- **Source Format**: ntriples
+- **Original Size**: 300.0 GB
+- **Conversion Tool**: [CleverErnie RDF Pipeline](https://github.com/CleverThis/cleverernie)
+- **Format Version**: 1.0
+- **Conversion Date**: 2025-12-08
+
+
+## Citation
+
+If you use this dataset, please cite the original source:
+
+**Original Dataset:** Freebase
+**URL:** http://commondatastorage.googleapis.com/freebase-public/rdf/freebase-rdf-latest.gz
+**License:** CC BY 2.5
+
+## Dataset Preparation
+
+This dataset was prepared using the CleverErnie GISM framework:
+
+```bash
+# Download original dataset
+python scripts/rdf_dataset_downloader.py freebase -o datasets/
+
+# Convert to HuggingFace format
+python scripts/convert_rdf_to_hf_dataset.py \
+    datasets/freebase/[file] \
+    hf_datasets/freebase \
+    --format nt
+
+# Upload to HuggingFace Hub
+python scripts/upload_all_datasets.py --dataset freebase
+```
+
+## Additional Information
+
+### Original Source
+
+http://commondatastorage.googleapis.com/freebase-public/rdf/freebase-rdf-latest.gz
+
+### Conversion Details
+
+- Converted using: [CleverErnie GISM](https://github.com/cleverthis/cleverernie)
+- Conversion script: `scripts/convert_rdf_to_hf_dataset.py`
+- Dataset format: Single 'data' split with all triples
+
+### Maintenance
+
+This dataset is maintained by the CleverThis organization.