Add clean_dataset.py

tools/dataview/clean_dataset.py

@@ -0,0 +1,376 @@
+"""
+clean_dataset.py — Extract clean prompts from Telegram AI image dataset.
+Groups consecutive images by prompt, strips ads/model names/hashtags,
+and outputs a VLM-training-ready JSONL file.
+
+Usage:
+  python tools/dataview/clean_dataset.py \
+    --input telegram-channel-dataset/dataset.parquet \
+    --output telegram-channel-dataset/cleaned.jsonl
+"""
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+# ── Patterns to strip ──────────────────────────────────────────────────
+STRIP_PATTERNS = [
+    # Hashtags
+    r'#[\w\u4e00-\u9fff]+',
+    # Bot links / Telegram links
+    r'\[.*?\]\(https?://t\.me/[^\)]+\)',
+    r'https?://t\.me/\S+',
+    r'https?://\S+',
+    # Source/author lines
+    r'来源：.*',
+    r'作者：.*',
+    r'Source:.*',
+    r'Author:.*',
+    # Ad / promo lines
+    r'🚀.*',
+    r'📚\s*教程目录.*',
+    r'━━+',
+    r'🤖.*我们的 Bot.*',
+    r'🔥.*邪修频道.*',
+    r'VPN推荐.*',
+    r'NanoGPT.*',
+    r'免费赠送.*',
+    r'快来体验.*',
+    r'Dubis.*',
+    r'Bot 机器人.*',
+    # Model name prefixes in titles
+    r'^(✨|🔥|🧩|🖼️|🎞️|🎬|🏮|🎨|📷|📸|🌟|💡|🎭|🎪|🎬|🌙|🌅|🌸|🎭|🖌️)\s*',
+    r'^GPT-?Image[-\s]*2?[｜|]',
+    r'^GPTImage2?[｜|]',
+    # Title lines (Chinese titles with emoji)
+    r'^.*?[｜|].*?(prompt|模板|技巧|构图|写真|人像|海报|封面).*?$',
+]
+
+# Fields that contain prompt-relevant information
+PROMPT_FIELDS = [
+    '任务', '主体', '服装', '场景', '光线', '镜头', '风格', '构图',
+    '约束', '画幅', '关键特征', '变体', '重点', '角色感', '妆造',
+    '动作', '调色', '反差', '结构', '适用', '示例',
+    'Task', 'Subject', 'Style', 'Lighting', 'Camera', 'Composition',
+    'Prompt skeleton',
+]
+
+# Chinese field labels to English mapping
+FIELD_MAP = {
+    '任务': 'task',
+    '主体': 'subject',
+    '服装': 'clothing',
+    '场景': 'scene',
+    '光线': 'lighting',
+    '镜头': 'camera',
+    '风格': 'style',
+    '构图': 'composition',
+    '约束': 'avoid',
+    '画幅': 'aspect_ratio',
+    '关键特征': 'key_features',
+    '变体': 'variants',
+    '重点': 'focus',
+    '角色感': 'character',
+    '妆造': 'makeup',
+    '动作': 'pose',
+    '调色': 'color_grading',
+    '反差': 'contrast',
+    '结构': 'layout',
+    '适用': 'use_case',
+    '示例': 'examples',
+    'Task': 'task',
+    'Subject': 'subject',
+    'Style': 'style',
+    'Lighting': 'lighting',
+    'Camera': 'camera',
+    'Composition': 'composition',
+    'Prompt skeleton': 'prompt_skeleton',
+}
+
+
+def clean_text(text: str) -> str:
+    """Remove ads, links, hashtags, model names, and other noise."""
+    if not text or pd.isna(text):
+        return ''
+    text = str(text)
+
+    # Apply strip patterns
+    for pattern in STRIP_PATTERNS:
+        text = re.sub(pattern, '', text, flags=re.MULTILINE | re.IGNORECASE)
+
+    # Remove lines that are just emojis or very short
+    lines = text.split('\n')
+    cleaned_lines = []
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        # Skip very short lines (likely noise)
+        if len(line) < 3:
+            continue
+        # Skip lines that are mostly emojis
+        emoji_chars = len(re.findall(r'[\U0001F300-\U0001F9FF]', line))
+        if emoji_chars > len(line) * 0.5:
+            continue
+        cleaned_lines.append(line)
+
+    return '\n'.join(cleaned_lines).strip()
+
+
+def extract_structured_fields(text: str) -> dict:
+    """Extract structured prompt fields from Chinese text."""
+    if not text:
+        return {}
+
+    fields = {}
+    # Match patterns like "字段名：值" or "字段名: value"
+    field_names = '|'.join(re.escape(f) for f in PROMPT_FIELDS)
+    field_pattern = re.compile(
+        rf'^(?:[-•]\s*)?({field_names})[:：]\s*(.+?)(?:\n|$)',
+        re.MULTILINE
+    )
+
+    for match in field_pattern.finditer(text):
+        field_name = match.group(1).strip()
+        value = match.group(2).strip()
+        if value and len(value) > 2:
+            eng_name = FIELD_MAP.get(field_name, field_name)
+            fields[eng_name] = value
+
+    return fields
+
+
+def extract_prompt_skeleton(text: str) -> str:
+    """Extract 'Prompt skeleton' section if present."""
+    if not text:
+        return ''
+    match = re.search(r'Prompt skeleton[:\s]*\n(.+?)(?:\n\n|\n备注|\Z)', text, re.DOTALL)
+    if match:
+        return match.group(1).strip()
+    return ''
+
+
+def build_prompt(text: str) -> str:
+    """Build a clean prompt from the structured fields."""
+    if not text:
+        return ''
+
+    # Try to get prompt skeleton first (most direct)
+    skeleton = extract_prompt_skeleton(text)
+    if skeleton and len(skeleton) > 20:
+        return skeleton
+
+    # Extract structured fields
+    fields = extract_structured_fields(text)
+
+    if not fields:
+        # Fallback: try to extract any English prompt-like content
+        lines = text.split('\n')
+        prompt_parts = []
+        for line in lines:
+            line = line.strip()
+            # Skip Chinese-only lines
+            chinese_chars = len(re.findall(r'[\u4e00-\u9fff]', line))
+            if chinese_chars > len(line) * 0.3:
+                continue
+            # Skip very short lines
+            if len(line) < 10:
+                continue
+            # Skip known noise
+            if any(skip in line.lower() for skip in ['bot', 'http', '#', '来源', '作者', 'source', 'author']):
+                continue
+            prompt_parts.append(line)
+        if prompt_parts:
+            return '; '.join(prompt_parts)
+        return ''
+
+    # Build prompt from fields in logical order
+    order = ['task', 'subject', 'character', 'makeup', 'clothing', 'pose',
+             'scene', 'lighting', 'camera', 'composition', 'aspect_ratio',
+             'key_features', 'style', 'color_grading', 'contrast', 'layout',
+             'avoid', 'use_case', 'prompt_skeleton']
+
+    parts = []
+    for key in order:
+        if key in fields:
+            parts.append(fields[key])
+
+    # Add any remaining fields not in order
+    for key, val in fields.items():
+        if key not in order and val:
+            parts.append(val)
+
+    return '; '.join(parts) if parts else ''
+
+
+def group_images(df: pd.DataFrame) -> list:
+    """Group consecutive images by prompt (same dimensions = same generation)."""
+    groups = []
+    current_group = None
+
+    for idx, row in df.iterrows():
+        has_text = row['text'] and str(row['text']).strip()
+        has_image = row['image'] is not None and isinstance(row['image'], bytes) and len(row['image']) > 100
+
+        if has_text and has_image:
+            # Start new group
+            if current_group:
+                groups.append(current_group)
+            current_group = {
+                'message_id': row['message_id'],
+                'datetime': row['datetime'],
+                'raw_text': row['text'],
+                'images': [{
+                    'row_idx': idx,
+                    'message_id': row['message_id'],
+                    'width': row['width'],
+                    'height': row['height'],
+                    'image_bytes': row['image'],
+                }]
+            }
+        elif current_group and has_image:
+            # Check if dimensions match (same generation batch)
+            last_img = current_group['images'][-1]
+            if row['width'] == last_img['width'] and row['height'] == last_img['height']:
+                current_group['images'].append({
+                    'row_idx': idx,
+                    'message_id': row['message_id'],
+                    'width': row['width'],
+                    'height': row['height'],
+                    'image_bytes': row['image'],
+                })
+
+    if current_group:
+        groups.append(current_group)
+
+    return groups
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Clean Telegram AI image dataset')
+    parser.add_argument('--input', '-i', required=True, help='Input parquet file')
+    parser.add_argument('--output', '-o', default=None, help='Output JSONL file')
+    parser.add_argument('--parquet', default=None, help='Output cleaned parquet (with only useful columns)')
+    parser.add_argument('--min-images', type=int, default=1, help='Min images per group')
+    parser.add_argument('--min-prompt-len', type=int, default=10, help='Min prompt length')
+    parser.add_argument('--stats', action='store_true', help='Print stats only')
+    args = parser.parse_args()
+
+    # Read parquet
+    print(f"Reading {args.input}...")
+    df = pq.read_table(args.input).to_pandas()
+    print(f"  Total rows: {len(df)}")
+
+    # Optionally output cleaned parquet (strip noise columns)
+    if args.parquet:
+        KEEP = ['message_id', 'datetime', 'media_type', 'text', 'width', 'height', 'image']
+        available = [c for c in KEEP if c in df.columns]
+        clean = df[available].copy()
+        if 'media_type' in clean.columns:
+            clean = clean[clean['media_type'] == 'photo'].copy()
+        clean.reset_index(drop=True, inplace=True)
+        pq.write_table(pa.Table.from_pandas(clean), args.parquet)
+        print(f"  Cleaned parquet: {len(clean)} rows, {len(clean.columns)} cols -> {args.parquet}")
+
+    # Group images
+    groups = group_images(df)
+    print(f"  Prompt groups: {len(groups)}")
+
+    # Clean and filter
+    cleaned = []
+    for group in groups:
+        prompt = build_prompt(group['raw_text'])
+        if len(prompt) < args.min_prompt_len:
+            continue
+        if len(group['images']) < args.min_images:
+            continue
+
+        cleaned.append({
+            'prompt': prompt,
+            'raw_text': group['raw_text'],
+            'num_images': len(group['images']),
+            'message_id': group['message_id'],
+            'datetime': group['datetime'],
+            'images': group['images'],
+        })
+
+    print(f"  Cleaned groups: {len(cleaned)}")
+    print(f"  Total images: {sum(g['num_images'] for g in cleaned)}")
+
+    if args.stats:
+        # Print distribution
+        from collections import Counter
+        sizes = Counter(g['num_images'] for g in cleaned)
+        print("\n  Group size distribution:")
+        for size, count in sorted(sizes.items()):
+            print(f"    {size} images: {count} groups")
+
+        # Show sample prompts
+        print("\n  Sample prompts:")
+        for g in cleaned[:5]:
+            print(f"    [{g['num_images']} imgs] {g['prompt'][:120]}...")
+        return
+
+    # Output
+    if args.output:
+        output_path = Path(args.output)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, 'w', encoding='utf-8') as f:
+            for group in cleaned:
+                record = {
+                    'prompt': group['prompt'],
+                    'num_images': group['num_images'],
+                    'message_id': group['message_id'],
+                    'datetime': group['datetime'],
+                    'image_paths': [
+                        f"images/msg_{img['message_id']}_row_{img['row_idx']}.webp"
+                        for img in group['images']
+                    ],
+                }
+                f.write(json.dumps(record, ensure_ascii=False) + '\n')
+
+        print(f"\n  Written to {output_path}")
+
+        # Also save images
+        img_dir = output_path.parent / 'images'
+        img_dir.mkdir(exist_ok=True)
+
+        from PIL import Image
+        import io
+
+        print("  Extracting images...")
+        saved = 0
+        for group in cleaned:
+            for img_data in group['images']:
+                try:
+                    img = Image.open(io.BytesIO(img_data['image_bytes']))
+                    img_path = img_dir / f"msg_{img_data['message_id']}_row_{img_data['row_idx']}.webp"
+                    img.save(img_path, format='WEBP', quality=90)
+                    saved += 1
+                except Exception as e:
+                    print(f"    Warning: Failed to save image {img_data['message_id']}: {e}")
+
+        print(f"  Saved {saved} images to {img_dir}")
+    else:
+        # Just print stats
+        from collections import Counter
+        sizes = Counter(g['num_images'] for g in cleaned)
+        print("\n  Group size distribution:")
+        for size, count in sorted(sizes.items()):
+            print(f"    {size} images: {count} groups")
+
+        print("\n  Sample prompts:")
+        for g in cleaned[:10]:
+            print(f"    [{g['num_images']} imgs] {g['prompt'][:150]}...")
+
+
+if __name__ == '__main__':
+    main()