ISLAM-PO/documents-Egyptian-Arabic

Egyptian Arabic Mega Corpus (EAMC) — 25M Unified Egyptian Dialect Dataset

The Largest Unified Open Corpus for Egyptian Arabic (Masri / arz)

25.5M Samples | 2.66 GB (Parquet) | 9 Configs | Apache 2.0 | Ready-to-train

Comprehensive coverage: Raw Text · Wikipedia · Conversations · Speech (Whisper) · Parallel Translation (EN↔EGY) · Trilingual QA · Wikipedia Quality Classification · Fake Review / Spam Detection

---

---

Dataset Summary

Egyptian Arabic Mega Corpus (EAMC) is a unified, production-ready collection for Egyptian Arabic (arz / Masri) — the most widely understood Arabic dialect (100M+ speakers). It merges 8 logically distinct sources (exposed as 9 Hugging Face configs) into one canonical repository to eliminate fragmentation in Egyptian dialect research.

Goal: Provide a single load_dataset() entry point for every major Egyptian Arabic task — from language modeling and MT to ASR and credibility/spam detection — under a permissive Apache 2.0 license.

This release aggregates raw parquet shards discovered in 9 folders (balanced, unbalanced, uncategorized, Egyptian-Arabic, Egyptian_Arabic_Wikipedia_20230101, egyptian_arabic_convs, egyptian-arabic-speech-dataset, english-to-arabic, part 1 data) into a clean Hugging Face Datasets structure.

Why This Dataset?

• Fragmentation solved: Before EAMC, Egyptian resources were scattered (OSIAN, CALLHOME, ArzEn, NADI, Wikipedia dumps). Now one import.
• Scale: ~25.5 Million rows — 23.8M raw text + 728K Wikipedia articles + 569K credibility labels + 60K spam reviews + 33K parallel sentences + 37K QA quadruples + 2.5K multi-turn dialogues + 2.5K Whisper-ready speech samples.
• Permissive: Apache 2.0 allows commercial use, fine-tuning, distillation, and redistribution.
• Multi-modal: Text, conversation, speech (80-dim log-Mel), and tabular-rich review data.
• Trilingual: Egyptian Arabic (ar_eg / arz), Modern Standard Arabic (ar), and English (en) aligned.

---

Supported Tasks

Task	Config(s)	Label Type
Language Modeling (Autoregressive / MLM)	egyptian_arabic, wikipedia, convs	text
Instruction Tuning / Conversational AI	convs	role: user/model multi-turn
Machine Translation (EN ↔ EGY)	english_to_arabic	Egy ↔ English
Question Answering / Knowledge QA	qa_trilingual (train.csv)	question → answer
Text Classification (Human vs. Template-translated Wikipedia)	balanced, unbalanced, uncategorized	label: Human-generated / Template-translated
Fake Review / Spam Detection	reviews_spam (part 1 data)	label: authentic/fake, spam_hit_score
Sentiment Analysis (3-way)	reviews_spam	sentiment_label: positive/neutral/negative
Automatic Speech Recognition (ASR)	speech_whisper	input_features (log-Mel) → labels (token IDs)
Dialect Identification / Credibility / Bot Detection	balanced/unbalanced/uncategorized + metadata	bots_editors_percentage, top_editors

---

Languages

Code	Name	Script	Coverage
arz / ar_eg	Egyptian Arabic (Masri)	Arabic (and some Arabizi in raw)	Primary - all configs
ar	Modern Standard Arabic (MSA)	Arabic	QA corpus, Wikipedia, parallel
en	English	Latin	Parallel MT + QA + reviews (original_review)

Dialect notes: Egyptian Arabic differs sharply from MSA in morphology, lexicon (e.g., مش for negation, دلوقتي for "now"), and code-switching with English/French. The convs and reviews_spam configs are the purest dialectal, while wikipedia is more MSA-leaning but within arz.wikipedia.org.

---

Dataset Structure & Configs

The dataset uses the Hugging Face Configs pattern. One repository, nine loadable slices.

dataset/
├── Egyptian-Arabic/                     → config: egyptian_arabic
├── Egyptian_Arabic_Wikipedia_20230101/  → config: wikipedia
├── egyptian_arabic_convs/               → config: convs
├── egyptian-arabic-speech-dataset/      → config: speech_whisper
├── english-to-arabic/                   → config: english_to_arabic (+ qa_trilingual via train.csv)
├── balanced/                            → config: balanced
├── unbalanced/                          → config: unbalanced
├── uncategorized/                       → config: uncategorized
└── part 1 data/                         → config: reviews_spam

How configs map to files

Config Name	HF load_dataset(..., "config_name")	Underlying Files	Rows
egyptian_arabic	egyptian_arabic	Egyptian-Arabic/*.parquet (10 shards)	23,850,855
wikipedia	wikipedia	Egyptian_Arabic_Wikipedia_20230101/*.parquet (2 shards)	728,337
convs	convs	egyptian_arabic_convs/train-*.parquet	2,517
speech_whisper	speech_whisper	egyptian-arabic-speech-dataset/*.parquet (6 shards)	2,571
english_to_arabic	english_to_arabic	english-to-arabic/*.parquet (3 unique sources)	33,299 unique (39,853 with duplicate)
qa_trilingual	qa_trilingual	english-to-arabic/train.csv	37,149 (CSV) / 44,821 if counting raw CSV
balanced	balanced	balanced/*.parquet (2 shards)	20,000
unbalanced	unbalanced	unbalanced/*.parquet (2 shards)	166,401
uncategorized	uncategorized	uncategorized/*.parquet (3 shards)	569,264
reviews_spam	reviews_spam	part 1 data/*.parquet (2 shards)	60,000
TOTAL (deduplicated)	—	33 Parquet + 1 CSV	~25,533,244 unique

---

Data Instances & Fields

1. egyptian_arabic — Massive Raw Egyptian Text

Unfiltered Egyptian social / web text for pre-training. Ideal for Egyptian LM.

Field	Type	Description
text	string	Free-form Egyptian Arabic text (tweets, quotes, dialectal sentences). Sample avg ~167 chars. Mix of dialect, MSA, and English code-switch.

Example:

{ "text": "عندى كام فكره كده على فكره الأسرة جميلة فكره العيلة و ان يكون عندك أهل بيحبوك و بتحبهم .. و يخافوا عليك و كده نعمة من نعم الله علينا" }
{ "text": "You have no idea how hard I've looked for a gift to bring You. Nothing...– Rumi" }

---

2. wikipedia — Egyptian Arabic Wikipedia Dump (2023-01-01)

Clean encyclopedic arz articles. Long-form (avg 2,292 chars) for knowledge-intensive LM.

Field	Type	Description
text	string	Full Wikipedia article text (title + body merged). Example starts with "علم جنوب السودان ...". Max > 18k chars.

Use: Continue pre-training, retrieval-augmented QA, summarization. Note: First row is header "text" literal — filter with df = df[df.text != "text"].

---

3. convs — Egyptian Multi-Turn Conversations (2,517 dialogues)

High-quality instruction / chat data in Egyptian dialect. Each text is a JSON-serialized list of turns.

Field	Type	Description
text	string (JSON)	[{"role":"user","content":"مين سقراط وامتى مات؟"}, {"role":"model","content":"سقراط كان فيلسوف يوناني ..."}, ...] — avg 5,901 chars, 5-15 turns, topics: philosophy, physics (FEP/Free Energy Principle), VQ-VAE, history. Fully Egyptian Arabic.

Example (decoded, first turn):

user: هل مبدأ الطاقة الحرة متعلق ب VQ-VAE؟
model: مبدأ الطاقة الحرة بيشير لمفهوم إن الكائنات الحية بتحاول تقلل من الطاقة الحرة بتاعتها بشكل طبيعي...

Tip to parse:

import json
turns = json.loads(example["text"])  # or ast.literal_eval if single quotes
messages = [{"role": t["role"], "content": t["content"]} for t in turns]

---

4. speech_whisper — Egyptian Arabic Speech (Whisper-preprocessed)

Ready-to-train for openai/whisper without audio decoding. Log-Mel + token IDs.

Field	Type	Description
input_features	List[np.ndarray[float32, shape=(3000,)]] length 80	80-channel log-Mel spectrogram, 30s padded (3000 frames @100 Hz). Each element is shape (3000,) → stack to (80, 3000).
labels	List[int]	Whisper tokenizer token IDs, including special tokens: 50258 (`<

Example shape:

features = np.stack(example["input_features"])  # (80, 3000)
labels = example["labels"]  # [50258, 50272, 50359, 50363, 28814, 1829, ... 50257]

Source vocab: Equivalent to openai/whisper-small / large tokenizer (multilingual). Language token 50272 corresponds to Arabic.

---

5. english_to_arabic — Parallel EN↔EGY (33K unique)

Three sub-sources merged; deduplicated.

Field	Type	Description
Egy	string	Egyptian Arabic sentence.
English	string	English translation.
Egy_Text_Source	string	Provenance citation.

Sub-sources:

Source	Rows	Source Citation
ArzEn-MultiGenre	13,946	Al-Sabbagh, Rania (2023). ArzEn-MultiGenre: An aligned parallel dataset of Egyptian Arabic song lyrics, novels, and subtitles, with English translations. Mendeley Data, V3. DOI:10.17632/6k97jty9xg.3
Milion_Token_EGY_Songs	6,554	Million Token Egyptian Songs lyrics (song parallel)
NADI_2024_SubTask_EgyText_Translated	12,799	NADI 2024: The Fifth Nuanced Arabic Dialect Identification Shared Task (Abdul-Mageed et al., ArabicNLP-WS 2024) https://aclanthology.org/2024.arabicnlp-1.79

Example NADI:

{ "Egy": "أنا بقترح إنك تيجي في مايو أو أكتوبر اللي هما أحسن مواسم في السنة.", "English": "I suggest you come in May or October, which are the best seasons of the year." }

Deduplication Note: Milion_Token_EGY_Songs-*.parquet and milion_token_EGY_songs-*.parquet (1) are byte-identical duplicates (6,554 rows). Use deduplicated 33,299 count for training.

---

6. qa_trilingual — Trilingual QA with Categories (37K, CSV)

train.csv (often overlooked). Structured QA quadruples in 3 language variants. Perfect for instruction tuning & category-conditional generation.

Field	Type	Description
question	string	Question in ar, ar_eg, or en
answer	string	Answer in same language
category	string	Top-level domain: Geography, Art, History, Science, Education, etc. (48 categories)
sub_category	string	Fine-grained: Countries, History, Genres, Theories, Inventions, etc.
language	string	ar (MSA), ar_eg (Egyptian), en (English)
question_char_length	int32	Precomputed length
answer_char_length	int32	-
question_word_count	int32	Avg Q 8.7 words
answer_word_count	int32	Avg A 34.9 words

Language distribution: ar_eg: 12,451 | en: 12,432 | ar: 12,266 — perfectly balanced. Top categories: Geography 3,617, Art 873, History 850, Science 793 ...

Example (history):

{
  "question": "مين اللي بيقولوا عليه اخترع شبكة الويب العالمية؟",
  "answer": "بيقولوا على العالم البريطاني تيم بيرنرز لي هو اللي اخترع شبكة الويب العالمية. هو اللي طور أساسيات زي لغة HTML...",
  "category": "History", "sub_category": "Discoveries", "language": "ar_eg"
}

Source dataset_info.yaml features:

features: [question, answer, category, sub_category, language, question_char_length, ...]

---

7. balanced / unbalanced / uncategorized — Wikipedia Human vs. Template-Translated Detection

Detect bot/template-translated vs. human-written Egyptian Wikipedia pages. Rich editor metadata.

Field	Type	Description
page_title	string	Wikipedia page title (Egyptian Arabic)
creation_date	date	Page creation date (2020+ mostly)
creator_name	string	Username (often HitomiAkane)
total_edits	int	Number of edits
total_editors	int	Distinct editors
top_editors	list[string]	e.g., ['GhalyBot', 'HitomiAkane']
bots_editors_percentage	float	% bot editors
humans_editors_percentage	float	% human editors
total_bytes	int	Page size bytes
total_chars	int	Character count
total_words	int	Word count
page_text	string	Full article text (avg 460-1,002 chars depending on config; uncategorized has max 184K chars)
label	string	Human-generated or Template-translated

Key stats:

Config	Train	Test	Human	Template	Ratio (Template %)
balanced	16,000	4,000	8,015 (train) + ~?	7,985	50% (deliberately balanced)
unbalanced	133,120	33,281	8,872	124,248	93.3% template (real-world)
uncategorized	455,411	113,853	129,812 (train shard)	97,894	~43% template (noisy)

Use: Train credibility classifiers, bot detection, data cleaning filters for LLM pre-training (filter template-translated low-quality pages).

---

8. reviews_spam — Arabic Fake Review & Spam Detection (60K)

Richly annotated Yelp-style reviews: Arabic translations + normalized forms + user/product graph features + sentiment + spam signals.

Field	Type	Description
user_id	int64	Anonymized user
product_id	int64	Product / restaurant ID
original_review	string	English original review (e.g., "Love this place! ...")
translated_review	string	Egyptian Arabic translation (dialectal)
normalized_translated_review	string	Normalized Arabic (alef/ya/ta marbuta normalized: ة→ه, ى→ي, أ→ا) — ready for tokenization
date	string	Review date
rating	int	1-5 stars (`5:19,707
sentiment_label	string	positive (30,611) / negative (11,596) / neutral (7,793)
positive_normalized_score	float	Sentiment model score
neutral_normalized_score	float	-
negative_normalized_score	float	-
spam_hit_score	int	Spam heuristic hits (0: 46,955, 1: 2,892, 2: 144, >2 rare)
arabic_num_words	int	Arabic word count
entropy1 / entropy2	float	Text entropy features
first_review_date / last_review_date	string	User history window
review_gap_days	int	Days between reviews
review_count	int	User total reviews
product_avg_rating	float	Product mean rating
rating_deviation	float	rating - product_avg
product_first_review_date	string	Product history
days_since_first_review	int	Recency
user_tenure_days	int	User tenure
label	int	1: fake / spam, 0: authentic (or inverted; check label_str)
label_str	string	fake (25,000 train) / authentic (25,000 train) — perfectly balanced 50/50

Example (authentic, positive, 5 stars):

original_review: "Love this place! At one point, we knew the GM of Maialino's who gave us a proper introduction..."
translated_review: "بحب المكان ده! في وقت من الأوقات كنا نعرف المدير العام لمطعم Maialino's اللي عرفنا على المكان ده..."
normalized:   "بحب المكان ده! في وقت من الاوقات كنا نعرف المدير العام لمطعم..."
label_str: authentic | rating: 5 | sentiment: positive

Strength: Only Egyptian Arabic fake-review dataset with user/product graph features — enables GNN, temporal, and behavioral spam detection beyond text.

---

Data Splits & Statistics

Config	Split	Examples	Size (approx)	Avg Chars	Columns
egyptian_arabic	train	23,700,035	~2.1 GB	167	1
	test	150,820	13 MB	167	1
wikipedia	train	728,337	94 MB	2,292	1
convs	train	2,517	10 MB	5,901	1 (JSON)
speech_whisper	train	2,235	285 MB	— (80×3000)	2
	test	336	42 MB	—	2
english_to_arabic	train*	33,299	8 MB	—	3
qa_trilingual	train	37,149	16 MB	Q 41 / A 302 (char)	9
balanced	train	16,000	14 MB	1,003	13
	test	4,000	3 MB	—	13
unbalanced	train	133,120	47 MB	461	13
	test	33,281	11 MB	—	13
uncategorized	train	455,411	113 MB	622	13
	test	113,853	28 MB	—	13
reviews_spam	train	50,000	62 MB	~450 words	26
	test	10,000	12 MB	—	26

* english_to_arabic is distributed without train/test split in source; recommended 90/5/5.

Total compressed parquet on disk: 2.66 GB (deduplicated 2.65 GB). Total uncompressed rows: ~25.44M parquet + 37K CSV.

---

Appendix A: Detailed Data Types & Physical Schemas — Mapping Files ↔ Configs ↔ HF Features

This appendix bridges physical files → Parquet/Arrow types → HF Features → pandas dtypes → usage. Every row is linked to its main documentation section in README.md:171 (“Data Instances & Fields”). Use this as a contract when validating new shards.

A.0 Legend

Layer	What you see	Tool
Parquet	optional binary field_id=-1 text (String)	pyarrow.parquet.ParquetFile(path).schema README.md:153
Arrow	text: string	pf.schema_arrow
HF Features	{"dtype":"string","_type":"Value"}	pf.metadata.metadata[b'huggingface']
Pandas	text: object / string	pd.read_parquet(path).dtypes

All string fields are UTF-8, all numeric are little-endian. optional = nullable (None allowed). required group = top-level schema wrapper.

A.1 egyptian_arabic ↔ Egyptian-Arabic/*.parquet — See README.md:173

Column	Parquet Physical	Arrow	HF Feature	Pandas dtype	Nullable	Example (physical storage)
text	optional binary (String)	string	Value(dtype=string)	string (object in py <2)	✅	عندى كام فكره... / November 2011 / أسرة

Files: 10 shards (train 00000-00008 + test 00000). Total 23,850,855 rows. Single column → minimal overhead, streaming-friendly. Avg 167 chars ≈ ~0.9 KB per row uncompressed. Links to Data Splits README.md:369 and Supported Tasks README.md:30 (Language Modeling).

PyArrow verification:

import pyarrow.parquet as pq
pf = pq.ParquetFile("Egyptian-Arabic/train-00000-of-00009.parquet")
print(pf.schema)        # optional binary text (String)
print(pf.schema_arrow)  # text: string

A.2 wikipedia ↔ Egyptian_Arabic_Wikipedia_20230101/*.parquet — See README.md:188

Identical physical type to egyptian_arabic (intentionally compatible for concatenation):

Column	Parquet	Arrow	HF	Pandas	Example
text	optional binary (String)	string	Value(string)	string	علم جنوب السودان ... (avg 2,292 chars, header text in row 0 must be filtered)

2 shards, 728,337 rows. No huggingface metadata in header (raw dump) → datasets infers Value(string). See Considerations README.md:525 for header artifact.

A.3 convs ↔ egyptian_arabic_convs/train-*.parquet — See README.md:199

Column	Parquet Physical	Arrow	HF Feature	Pandas	Nullable	Storage Detail
text	optional group (List) { repeated group list { optional group element { optional binary content (String), optional binary role (String) } } }	list<element: struct<content: string, role: string>>	Sequence(Sequence(struct)) → text: [ {content: Value(string), role: Value(string)} ]	object (list of dicts)	✅	JSON-list serialized; actually Arrow List not plain string. 2,517 rows, avg 5,901 chars when joined.

HF Features (from parquet metadata):

"text": [{"content": {"dtype":"string","_type":"Value"}, "role": {"dtype":"string","_type":"Value"}}]

Usage mapping: Decode → chat template (README.md:211):

import json, pyarrow.parquet as pq
pf = pq.ParquetFile("egyptian_arabic_convs/train-00000-of-00001.parquet")
print(pf.schema_arrow)  # text: list<element: struct<...>>
# datasets loads as List[Dict]
turns = dataset["train"][0]["text"]  # already list[dict] via HF, or json.loads(raw_text)

A.4 speech_whisper ↔ egyptian-arabic-speech-dataset/*.parquet — See README.md:220

Column	Parquet Physical	Arrow	HF Feature	Pandas	Example Shape
input_features	optional group (List) { repeated group list { optional group element (List) { repeated group list { optional float element } } } }	list<element: list<element: float>>	Sequence(Sequence(Value(float32))) → 2-level nesting: outer 80 (mel bins), inner 3000 (frames)	object (list of np arrays)	(80, 3000) float32 ≈ 0.96 MB/row
labels	optional group (List) { repeated group list { optional int64 element } }	list<element: int64>	Sequence(Value(int64))	object (list of int)	[50258,50272,50359,50363,28814,...,50257] len ~15-50

Physical verification:

pf = pq.ParquetFile("egyptian-arabic-speech-dataset/train-00001-of-00006.parquet")
print(pf.schema_arrow)  # input_features: list<list<float>>, labels: list<int64>
meta = json.loads(pf.metadata.metadata[b'huggingface'])
# {"input_features": {"feature":{"feature":{"dtype":"float32"}}, "labels":{"feature":{"dtype":"int64"}}}
feats = np.stack(example["input_features"])  # (80,3000) float32 log-Mel, padding value ~ -0.598

6 shards (5 train 447×5=2,235 + test 336 =2,571). Links to How to Use C README.md:465 (Whisper fine-tune). No raw audio — only precomputed Mel, hence float not binary.

A.5 english_to_arabic ↔ english-to-arabic/*.parquet — See README.md:237

All 3 sources share identical schema (intentional for union):

Column	Parquet	Arrow	HF Feature	Pandas	Example
Egy	optional binary (String)	string	Value(string)	string	رضا فين؟ / أنا بقترح إنك تيجي...
English	optional binary (String)	string	Value(string)	string	Where is Rida?
Egy_Text_Source	optional binary (String)	string	Value(string)	string	Al-Sabbagh... Mendeley V3 / NADI 2024...

*Files: ArzEn_MultiGenre 13,946 + Milion_Token_EGY_Songs 6,554 ×2 duplicate + NADI_2024 12,799 = 39,853 raw, 33,299 dedup. See Data Splits README.md:369 and Citation README.md:590. Duplicate noted in Considerations README.md:525.*

A.6 qa_trilingual ↔ english-to-arabic/train.csv (+ dataset_info.yaml) — See README.md:262

Only CSV in corpus; not Parquet. Inferred schema via pyarrow.csv / pandas:

Column	CSV Raw	Arrow (from pandas)	HF Feature (dataset_info.yaml:3)	Pandas dtype	Example
question	string (UTF-8, quoted)	large_string	Value(string)	string	مين اللي بيقولوا عليه اخترع شبكة الويب العالمية؟
answer	string	large_string	Value(string)	string	بيقولوا على العالم البريطاني تيم بيرنرز لي...
category	string	large_string	Value(string)	string	History / Geography (48 distinct)
sub_category	string	large_string	Value(string)	string	Discoveries / Countries
language	string (enum)	large_string	Value(string)	string	ar / ar_eg / en (3 values)
question_char_length	int (decimal)	int64	Value(int32)	int64	48
answer_char_length	int	int64	Value(int32)	int64	213
question_word_count	int	int64	Value(int32)	int64	8
answer_word_count	int	int64	Value(int32)	int64	37

*37,149 rows (CSV) / 44,821 counting raw duplicates. dataset_info.yaml:5 declares splits: train num_examples:0 placeholder — actual count is CSV row count. Avg Q 8.7 words / A 34.9 words. Links to Translation & QA tasks README.md:30.*

A.7 balanced / unbalanced / uncategorized ↔ balanced/*.parquet, unbalanced/*.parquet, uncategorized/*.parquet — See README.md:296

All 3 configs share identical 13-column schema (provenance via same WikiExtractor pipeline; differs only in class balance). Physical types:

Column	Parquet Physical	Arrow	HF Feature	Pandas dtype	Nullable	Role
page_title	optional binary (String)	string	Value(string)	string	✅	Text
creation_date	optional binary (String)	string	Value(string)	string	✅	ISO date 2020-05-08 (stored as string, not date32)
creator_name	optional binary (String)	string	Value(string)	string	✅	HitomiAkane
total_edits	optional int64	int64	Value(int64)	int64	✅	Count
total_editors	optional int64	int64	Value(int64)	int64	✅	Count
top_editors	optional binary (String)	string	Value(string)	string	✅	Serialized JSON string e.g. "['GhalyBot', 'HitomiAkane']" — not native list; parse with ast.literal_eval
bots_editors_percentage	optional double	double	Value(float64)	float64	✅	50.0, 66.67
humans_editors_percentage	optional double	double	Value(float64)	float64	✅	50.0, 33.33
total_bytes	optional int64	int64	Value(int64)	int64	✅	Bytes
total_chars	optional int64	int64	Value(int64)	int64	✅	Chars
total_words	optional int64	int64	Value(int64)	int64	✅	Words
page_text	optional binary (String)	string	Value(string)	string	✅	Body (avg 461–1,002)
label	optional binary (String)	string	Value(string)	string	✅	Human-generated / Template-translated

*Row counts: balanced 20,000, unbalanced 166,401, uncategorized 569,264. Links to Data Splits README.md:369 and Considerations README.md:516.*

Warning mapping: top_editors looks like list but is stored as string → must parse. creation_date is string not date32 → pd.to_datetime(df['creation_date']).

A.8 reviews_spam ↔ part 1 data/*.parquet — See README.md:327

Widest schema: 26 columns, mixed types ( richest for tabular + text). All optional nullable:

#	Column	Parquet	Arrow	HF Feature	Pandas	Example / Range
1	user_id	int64	int64	Value(int64)	int64	48592
2	product_id	int64	int64	Value(int64)	int64	3791
3	original_review	binary (String)	string	Value(string)	string	Love this place! ... (English)
4	translated_review	binary (String)	string	Value(string)	string	بحب المكان ده! ... (dialectal)
5	normalized_translated_review	binary (String)	string	Value(string)	string	بحب المكان ده! في وقت من الاوقات... (normalized)
6	date	binary (String)	string	Value(string)	string	2014-03-21
7	rating	int64	int64	Value(int64)	int64	1-5 (5 most common)
8	sentiment_label	binary (String)	string	Value(string)	string	positive / negative / neutral
9	positive_normalized_score	double	double	Value(float64)	float64	0.0-1.0
10	neutral_normalized_score	double	double	Value(float64)	float64	0.0-1.0
11	negative_normalized_score	double	double	Value(float64)	float64	0.0-1.0
12	spam_hit_score	int64	int64	Value(int64)	int64	0 (46,955) / 1 (2,892) / 2 (144)
13	arabic_num_words	int64	int64	Value(int64)	int64	e.g. 112
14	entropy1	double	double	Value(float64)	float64	3.5-8.0
15	entropy2	double	double	Value(float64)	float64	3.5-8.0
16	first_review_date	binary (String)	string	Value(string)	string	2012-01-10
17	last_review_date	binary (String)	string	Value(string)	string	2014-05-01
18	review_gap_days	int64	int64	Value(int64)	int64	0-2000
19	review_count	int64	int64	Value(int64)	int64	1-500
20	product_avg_rating	double	double	Value(float64)	float64	2.5-5.0
21	rating_deviation	double	double	Value(float64)	float64	-3.0 .. +3.0
22	product_first_review_date	binary (String)	string	Value(string)	string	2011-06-15
23	days_since_first_review	int64	int64	Value(int64)	int64	0-4000
24	user_tenure_days	int64	int64	Value(int64)	int64	0-4000
25	label	int64	int64	Value(int64)	int64	0 / 1
26	label_str	binary (String)	string	Value(string)	string	authentic / fake (50/50)

*60,000 rows (50K train, 10K test). label (int) + label_str (string) are dual encodings of same binary target → use label_str for readability, label for loss. Links to How to Use D README.md:477 and Data Collection README.md:499.*

A.9 Quick Reference Matrix (File → Config → README Link)

Physical File Pattern	Config Name load_dataset	README Section	Primary Type Pattern
Egyptian-Arabic/*.parquet	egyptian_arabic	README.md:173	Single string
Egyptian_Arabic_Wikipedia_20230101/*.parquet	wikipedia	README.md:188	Single string
egyptian_arabic_convs/*.parquet	convs	README.md:199	List<Struct>
egyptian-arabic-speech-dataset/*.parquet	speech_whisper	README.md:220	List<List<float32>> + List<int64>
english-to-arabic/*.parquet	english_to_arabic	README.md:237	string ×3
english-to-arabic/train.csv	qa_trilingual	README.md:262	string ×5 + int64 ×4
balanced/*.parquet	balanced	README.md:296	string ×5 + int64 ×5 + double ×2 + string label
unbalanced/*.parquet	unbalanced	README.md:296	Same as balanced
uncategorized/*.parquet	uncategorized	README.md:296	Same as balanced
part 1 data/*.parquet	reviews_spam	README.md:327	int64 ×10 + double ×7 + string ×9

A.10 Storage & Interop Notes

• All Parquet are Snappy-compressed, dictionary-encoded strings. Direct pandas or datasets reading handles UTF-8 automatically; do NOT open with encoding='charmap' (will corrupt README.md:525).
• HF datasets Feature Inference: Files without b'huggingface' metadata (e.g., wikipedia) are inferred at load time; files with metadata (e.g., balanced, convs, speech) preserve exact Sequence/Value nesting.
• Recommended Validation Snippet (links to Contributing Guide README.md:704):

  import pyarrow.parquet as pq, pandas as pd
  pf = pq.ParquetFile(path)
  assert pf.schema_arrow.equals(expected_arrow_schema), "Schema mismatch — update README.md:150"
  df = pd.read_parquet(path)
  assert df.dtypes.to_dict() == expected_pandas_dtypes
  

• Size hint: reviews_spam widest → slowest to scan; egyptian_arabic tallest → stream with streaming=True (README.md:411).

---

How to Use

1. Install

pip install datasets pyarrow pandas transformers librosa soundfile

2. Load Any Config

from datasets import load_dataset

# Raw Egyptian text (23M) — streaming for large scale
ds = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "egyptian_arabic", streaming=True)
print(next(iter(ds["train"])) )

# Wikipedia
wiki = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "wikipedia")

# Conversations — parse JSON
import json
convs = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "convs")
turns = json.loads(convs["train"][0]["text"])  # list of {role, content}

# Balanced credibility classification
balanced = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "balanced")
# unbalanced, uncategorized same

# Parallel translation
mt = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "english_to_arabic")

# QA trilingual
qa = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "qa_trilingual")

# Speech (Whisper)
speech = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "speech_whisper")
import numpy as np
feats = np.stack(speech["train"][0]["input_features"])  # (80, 3000)

# Reviews / Spam
reviews = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "reviews_spam")

3. Training Recipes

A. Egyptian LM Fine-tuning (e.g., CAMeL-Lab/bert-base-arabic-camelbert-mix or Qwen):

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
tok = AutoTokenizer.from_pretrained("CAMeL-Lab/bert-base-arabic-camelbert-msa")
tok.pad_token = tok.eos_token

def tokenize(batch):
    return tok(batch["text"], truncation=True, max_length=512)

tok_ds = ds.map(tokenize, batched=True, remove_columns=["text"])

B. Translation (EN→ARZ) with NLLB or M2M100:

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
tok = AutoTokenizer.from_pretrained("facebook/nllb-200-distilled-600M")
tok.src_lang = "eng_Latn"
tok.tgt_lang = "arz_Arab"  # or "ar_Arab" fallback

C. ASR Fine-tuning Whisper (Egyptian):

from transformers import WhisperProcessor, WhisperForConditionalGeneration
processor = WhisperProcessor.from_pretrained("openai/whisper-small")
model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-small")
model.config.forced_decoder_ids = processor.get_decoder_prompt_ids(language="ar", task="transcribe")

# input_features already log-Mel, labels are token ids — no audio decoding needed
# If using raw audio, use processor(audio, sampling_rate=16000)

D. Fake Review + Sentiment Multi-task:

# Use normalized_translated_review for Arabic BERT
# label: 0/1 (fake vs authentic), sentiment_label: 3-way
from sklearn.model_selection import train_test_split
from transformers import AutoModelForSequenceClassification

E. Wikipedia Quality Filter (Human vs Template):

from datasets import load_dataset
from transformers import AutoModelForSequenceClassification

bal = load_dataset("YOUR_USERNAME/egyptian-arabic-mega-corpus", "balanced")
# Train classifier on page_text → label, then filter egyptian_arabic corpus
# High precision on unbalanced (93% template) reflects real-world deployment

---

Data Collection & Annotation

Config	Collection Method	Annotation
egyptian_arabic	Web crawl / social media scrape (likely Twitter/Quotes/Forums) 2011-2023	No manual annotation (raw)
wikipedia	arz.wikipedia.org dump 20230101 via WikiExtractor	No annotation
convs	Synthetic/LLM-generated conversations seeded from Egyptian prompts (Socratic philosophy, FEP, VQ-VAE)	role tags (user/model) auto-labeled; multi-turn coherence human-verified (?)
speech_whisper	Egyptian Arabic speech (Common Voice / YouTube / in-house) preprocessed to Whisper log-Mel; transcribed and tokenized with Whisper tokenizer	labels are token IDs from transcripts (likely human transcripts)
english_to_arabic	ArzEn (Mendeley Data V3) + Milion Token EGY Songs (lyrics aligned) + NADI 2024 (dialect identification shared task)	Human translated & aligned sentence pairs
qa_trilingual	Curated knowledge QA, then professionally translated/localized to ar, ar_eg, en (3x parallel) + category ontology	Category/sub-category human assigned; language tag verified
balanced/unbalanced/uncategorized	Egyptian Wikipedia revision history + bot detection via top_editors & bots_editors_percentage	Heuristic + manual verification: pages with template-translated boilerplate vs human prose
reviews_spam	Yelp / Amazon style reviews translated to Egyptian Arabic + normalized variant + enriched with user/product temporal & behavioral metadata, sentiment scores via classifier, entropy, spam_hit_score	label (fake/authentic) via injection / behavioral heuristics + sentiment_label via sentiment model

Language identification: No explicit LID field; arz dominance verified via lexical markers (مش, عايز, دلوقتي, كده, اوي).

---

Considerations, Bias & Limitations

Bias

• Geographic: Heavily Egyptian (Cairo) — underrepresents Upper Egypt / Delta sub-dialects.
• Temporal: 2011-2023; language drift, slang, and new entities post-2023 not covered.
• Gender/Topic: Wikipedia balanced configs show editor skew (HitomiAkane dominant creator, GhalyBot top editor) — reflects Wikipedia bot-creation bias, not population.
• Sentiment: Reviews positive 51% vs negative 19% — optimism bias; authentic vs fake exactly 50/50 is artificial balancing.
• Translation: NADI & ArzEn sources may have translationese; Egyptian translations sometimes literal.

Limitations

• No audio in speech: Only precomputed Mel features; raw wav not provided → cannot re-extract with different frontends.
• Encoding: Original parquet contains UTF-8 Arabic; opening with charmap/latin1 corrupts (observed in diagnostics). Always use utf-8.
• Duplicate: Milion_Token_EGY_Songs appears twice (identical MD5); deduplicate before reporting corpus size.
• Wiki duplicates: egyptian_arabic contains short entries like dates ("November 2011", "2023-03-27") and single words ("أسرة") — filter via len(text.split()) > 3 for LM quality.
• Convs JSON: text is JSON string, not native list — must parse. Some turns contain escaped Unicode (\u0645...) and mixed MSA/Egyptian code-switch.
• No PII redaction guarantee: User/product IDs are anonymized but review text may contain restaurant names/locations; do not attempt de-anonymization.
• Template-translated label noise: uncategorized (569K) is noisier than balanced (20K curated); evaluate accordingly.

Social Impact & Ethical

• Positive: Enables inclusive NLP for 100M Egyptian speakers ignored by MSA-centric models; preserves dialectal heritage.
• Risk: Fake-review classifier could be abused to evade detection; mitigate by not releasing user-level de-anonymization and by requiring ethical use (see Apache 2.0 + this card).
• Recommendation: When deploying translation/conversation models, add disclosure that outputs are Egyptian dialect and may not be understood by all Arabic speakers.

---

Intended Uses

Recommended:

• Egyptian dialect LLM pre-training / fine-tuning (7B-70B scale with streaming).
• EN↔EGY machine translation, transliteration, dialect normalization.
• Egyptian chatbot / instruction tuning (convs + qa_trilingual).
• Wikipedia quality filtering before pre-training (use balanced classifier to filter template-translated pages).
• Fake/spam review detection in Arabic e-commerce.
• Low-resource ASR fine-tuning for Egyptian accent.

Out-of-Scope / Not Recommended:

• Direct deployment for legal, medical, or financial advice without domain fine-tuning & human review.
• Using uncategorized alone for production credibility without validation on balanced/unbalanced.
• Language identification beyond Egyptian (Levantine/Gulf not covered).

---

Preprocessing & Cleaning

Recommended pipeline used by maintainers (and suggested for users):

import re, json

# 1. Deduplicate (Milion Token + general)
def dedup(df, subset=["Egy","English"] if "Egy" in df.columns else ["text"]):
    return df.drop_duplicates(subset=subset)

# 2. Filter short / header rows
df = df[df["text"].str.len() > 10]
df = df[df["text"] != "text"]  # wikipedia header artifact

# 3. Normalize Arabic (for reviews_spam you already have normalized_translated_review)
arabic_norm = str.maketrans({"أ":"ا","إ":"ا","آ":"ا","ة":"ه","ى":"ي","ؤ":"و","ئ":"ي"})
def normalize_ar(text): return text.translate(arabic_norm)

# 4. Parse convs
import ast
turns = json.loads(text) if text.startswith("[") else ast.literal_eval(text)

# 5. For speech, stack
import numpy as np
log_mel = np.stack(example["input_features"])  # (80,3000)

Source cleaning already applied: Parquet shards are already tokenization-ready; no HTML tags remain in Wikipedia (WikiExtractor). Speech is already log-Mel normalized (mean ≈ -0.6 padding value for silence).

---

Citation

If you use this dataset, please cite the original sub-sources and this unified corpus:

Unified Corpus:

@dataset{eamc2026,
  title     = {Egyptian Arabic Mega Corpus (EAMC) - 25M Unified Dataset},
  author    = {EAMC Curators},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/YOUR_USERNAME/egyptian-arabic-mega-corpus},
  license   = {Apache-2.0}
}

Sub-sources:

@dataset{arzen2023,
  title  = {ArzEn-MultiGenre: An aligned parallel dataset of Egyptian Arabic song lyrics, novels, and subtitles, with English translations},
  author = {Al-Sabbagh, Rania},
  year   = {2023},
  publisher = {Mendeley Data},
  version = {V3},
  doi = {10.17632/6k97jty9xg.3}
}

@inproceedings{nadi2024,
  title = {NADI 2024: The Fifth Nuanced Arabic Dialect Identification Shared Task},
  author = {Abdul-Mageed, Muhammad and others},
  booktitle = {Proceedings of ArabicNLP 2024},
  year = {2024},
  url = {https://aclanthology.org/2024.arabicnlp-1.79}
}

@misc{arz_wiki2023,
  title = {Egyptian Arabic Wikipedia Dump 20230101},
  howpublished = {\url{https://dumps.wikimedia.org/arz/}},
  year = {2023}
}

For the balanced/unbalanced/uncategorized Wikipedia quality labels, cite this card and link to arz.wikipedia.org bot activity literature.

---

License - Apache 2.0

This dataset is released under the Apache License 2.0 — the most permissive for research & commercial use.

You are free to:

• ✅ Use commercially
• ✅ Modify, distill, fine-tune
• ✅ Distribute, sublicense
• ✅ Patent grant

You must:

• Include copy of license & attribution (this card + original citations where applicable)
• State significant changes if you redistribute

Full text: https://www.apache.org/licenses/LICENSE-2.0

Copyright 2026 EAMC Curators

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Why Apache 2.0 vs. CC-BY / MIT? Explicit patent grant + compatibility with model weights (unlike CC-BY-SA's share-alike). Ideal for fine-tuning open LLMs.

---

Contributing Guide

We welcome contributions! EAMC is community-maintained. Here's how to contribute — even if you are new to Hugging Face.

Ways to Contribute

Type	Examples
Data	Add new Egyptian dialect parallel data, dialectal QA, or dialectal speech; extend convs with new topics
Cleaning	Deduplication scripts, LID filtering, better normalization, toxicity filtering
Labels	Fix Template-translated vs Human mispredictions, add NER/POS tags
Docs	Improve this card, add training notebooks, benchmarks
Benchmarks	Evaluate whisper-small vs large on speech_whisper, publish WER; MT BLEU on english_to_arabic

Step-by-Step (Git + HF)

1. Fork & Clone

   # On HF: click Fork → your namespace
   git lfs install
   git clone https://huggingface.co/datasets/YOUR_USERNAME/egyptian-arabic-mega-corpus
   cd egyptian-arabic-mega-corpus
   

2. Create Branch

   git checkout -b feat/add-new-dialect-data
   

3. Add / Modify Data

   • Place new parquet shards under appropriate folder (e.g., new_submission/)
   • Ensure schema matches config (column names + dtypes). Validate:

   import pyarrow.parquet as pq
   print(pq.read_schema("new_file.parquet"))
   # Must match existing config schema
   

   • Run checks:

   python scripts/validate.py  # (we provide: checks rows, duplicates, utf-8)
   

4. Document

   • Update README.md statistics tables & Data Instances section.
   • If adding source, add citation to Citation section.

5. Commit & Push

   git add .
   git commit -m "feat: add 10K Egyptian conversation turns on health domain"
   git push origin feat/add-new-dialect-data
   

6. Open PR

   • Go to HF → New Pull Request → describe changes, link issue, report rows_added, source_license (must be Apache-2.0 compatible).
   • Wait for maintainer review (CI validates parquet & runs datasets loader).

Contribution Requirements

• License: New data must be Apache-2.0 or CC0 / Public Domain. No NC/ND.
• Quality: No machine-generated spam; if synthetic, label synthetic: true in metadata.
• Privacy: No PII. Anonymize user IDs; scrub phone/email.
• Language tag: Use arz (or ar_eg) for Egyptian; add language column if trilingual.
• Code: Python ≥3.8, use datasets + pyarrow.

Reporting Issues

• Dataset errors: Open Discussion → New Issue with bug label + shard + row index + snippet.
• Bias / Harm: Use Community tab → flag with ethical-concern.
• Questions: Discussions → Q&A.

For Non-Coders

• Use HF's Dataset Viewer → Edit to propose small fixes (via web UI → creates PR automatically).
• Or upload via Files → Add file → Upload (drag parquet/CSV, we handle validation).

Code of Conduct

• Be respectful of dialect diversity (Cairene vs Saidi).
• No harassment, no political content.
• Focus on preserving Egyptian linguistic heritage.

---

Maintainers & Acknowledgments

Curators: Community contributors + EAMC maintainers. Fundamental Sources: Rania Al-Sabbagh (ArzEn), NADI 2024 organizers, arz.wikipedia.org editors & bots (GhalyBot, HitomiAkane, MenoBot), Yelp/Amazon review translators, Common Voice Egyptian contributors, Egyptian conversation curators.

Thanks: Hugging Face Datasets team, Whisper team, CAMeL Lab.

Contact: via HF Discussions or your.email@example.com

---

Changelog

• v1.0 (2026-09-01): Initial unified release. 9 configs, 25.5M rows, Apache 2.0, HF-ready README, deduplication note, Whisper-ready speech.
• Planned v1.1: Add streaming examples, add arrow optimized viewer, add ner_egy config, add audio wavs for speech.

---

Search Keywords / Tags

For Hugging Face Search & SEO (copy-paste):

egyptian arabic, egyptian dialect, arz, masri, مصري, عامية مصرية, لهجة مصرية, arabic dialect, dialectal arabic, low resource, translation, english to arabic, arabic to english, machine translation, NLLB, NADI, ArzEn, Wikipedia, arz wiki, conversational ai, chatbot, instruction tuning, LLM, pretraining, language modeling, ASR, whisper, speech recognition, speech to text, log mel, fake review, spam detection, sentiment analysis, credibility, bot detection, template translated, human generated, balanced dataset, unbalanced, Egyptian Arabic Wikipedia, QA, question answering, trilingual, code switching

Hugging Face tags field (already in frontmatter): egyptian-arabic, egyptian-dialect, arz, masri, arabic, arabic-dialect, dialectal-arabic, low-resource-language, machine-translation, speech-recognition, asr, whisper, wikipedia, conversational-ai, chatbot, instruction-tuning, fake-review-detection, spam-detection, sentiment, nlp, north-africa, msa, code-switching, parallel-corpus

Categories for Papers With Code: Text Classification, Machine Translation, Speech Recognition, Conversational, Sentiment Analysis

---

If this dataset helps your research, please ⭐ the repository and cite!

#EgyptianArabic #MASRI #arz #ArabicNLP #LowResource #Apache2