Upload 2 files

README.md

@@ -0,0 +1,42 @@
+---
+license: cc-by-4.0
+tags:
+- active
+- adaptive
+- code
+- domain-specific
+- manual
+- randaugment
+- stratified-90-10
+- video-text
+- webdataset
+---
+
+# dataset_135359330_code_video_text.py
+
+## Dataset Summary
+
+A **code** dataset with **video text** modality, stored in **webdataset** format.
+
+## Preprocessing & Augmentation
+
+- **Preprocessing**: domain specific
+- **Augmentation**: randaugment
+
+## Splits & Sampling
+
+- **Split strategy**: stratified 90 10
+- **Sampling**: active
+
+## Quality & Labeling
+
+- **Quality filtering**: adaptive
+- **Labeling**: manual
+
+## Files
+
+- `dataset_135359330_code_video_text.py` — main artifact of this repository
+
+## License
+
+See the license field above.

dataset_135359330_code_video_text.py

@@ -0,0 +1,160 @@
+import json, os, hashlib, logging
+from typing import List, Dict, Optional
+
+log = logging.getLogger(__name__)
+
+# --- real data source: code ---
+TV_DATASET = None
+HF_CANDIDATES = ['code_search_net', 'codeparrot/github-code']
+IMAGE_FIELD = None
+TEXT_FIELD = 'func_code_string'
+LABEL_FIELD = 'func_documentation_string'
+PROMPT_TEMPLATE = 'a photo of a {label}'
+DATASET_URL = 'https://huggingface.co/datasets/code_search_net'
+
+def fetch_real_samples(max_samples=5000, cache_dir='./_cache'):
+    # 本地没有数据时自动下载真实公开数据集: torchvision -> HuggingFace -> 手动说明
+    out = []
+    if TV_DATASET is not None:
+        try:
+            import torchvision
+            ctor = getattr(torchvision.datasets, TV_DATASET)
+            try:
+                ds = ctor(root=cache_dir, split='train', download=True)
+            except TypeError:
+                try:
+                    ds = ctor(root=cache_dir, train=True, download=True)
+                except TypeError:
+                    ds = ctor(root=cache_dir, download=True)
+            classes = getattr(ds, 'classes', None)
+            os.makedirs(os.path.join(cache_dir, 'tv'), exist_ok=True)
+            for i, item in enumerate(ds):
+                if len(out) >= max_samples:
+                    break
+                img, label = item[0], item[1]
+                name = classes[label] if classes else str(label)
+                p = os.path.join(cache_dir, 'tv', str(i) + '.png')
+                try:
+                    img.save(p)
+                except Exception:
+                    continue
+                out.append({'image': p, 'text': PROMPT_TEMPLATE.format(label=name)})
+            if out:
+                return out
+        except Exception as e:
+            print('torchvision load failed:', e)
+    for repo in HF_CANDIDATES:
+        try:
+            from datasets import load_dataset
+            try:
+                ds = load_dataset(repo, split='train', streaming=True)
+            except Exception:
+                ds = load_dataset(repo, split='train')
+            img_dir = os.path.join(cache_dir, 'hf_images')
+            os.makedirs(img_dir, exist_ok=True)
+            for i, ex in enumerate(ds):
+                if len(out) >= max_samples:
+                    break
+                txt = None
+                if TEXT_FIELD is not None and TEXT_FIELD in ex:
+                    v = ex[TEXT_FIELD]
+                    txt = v if isinstance(v, str) else ' '.join(map(str, v if isinstance(v, (list, tuple)) else [v]))
+                if txt is None and LABEL_FIELD in ex:
+                    txt = PROMPT_TEMPLATE.format(label=ex[LABEL_FIELD])
+                if txt is None:
+                    continue
+                out.append({'text': txt})
+            if out:
+                return out
+        except Exception as e:
+            print('HF load failed for', repo, ':', e)
+    print('Automatic download failed. Please get the data manually from:')
+    print('   ' + DATASET_URL)
+    return out
+
+
+class CodeDataset:
+    def __init__(self, data_dir: str, output_dir: str, img_size: int = 224):
+        self.data_dir = data_dir
+        self.output_dir = output_dir
+        self.img_size = img_size
+        self.samples = []
+        self.processed = []
+
+    def load(self) -> List[Dict]:
+        
+        from pathlib import Path
+        for f in Path(self.data_dir).glob('*.jsonl'):
+            with open(f) as fp:
+                for line in fp:
+                    if line.strip():
+                        self.samples.append(json.loads(line))
+        log.info(f'Loaded {len(self.samples)} samples')
+        return self.samples
+
+    def filter(self) -> List[Dict]:
+        
+        filtered = []
+        for s in self.samples:
+            text = s.get('code', s.get('text', ''))
+            if len(text.split()) >= 3:
+                filtered.append(s)
+        self.samples = filtered
+        return filtered
+
+    def deduplicate(self) -> List[Dict]:
+        seen = set()
+        result = []
+        for s in self.samples:
+            fp = s.get('image', s.get('audio', ''))
+            if fp and os.path.exists(fp):
+                h = hashlib.md5(open(fp, 'rb').read()).hexdigest()
+                if h in seen:
+                    continue
+                seen.add(h)
+            result.append(s)
+        self.samples = result
+        return result
+
+    def process(self) -> List[Dict]:
+        os.makedirs(self.output_dir, exist_ok=True)
+        for s in self.samples:
+            item = {}
+            if 'image' in s:
+                try:
+                    from PIL import Image
+                    img = Image.open(s['image']).convert('RGB')
+                    img = img.resize((self.img_size, self.img_size))
+                    p = os.path.join(self.output_dir, os.path.basename(s['image']))
+                    img.save(p, 'JPEG', quality=95)
+                    item['image'] = p
+                except Exception as e:
+                    log.warning(f'Failed: {e}')
+                    continue
+            item['text'] = s.get('code', s.get('text', ''))
+            item['domain'] = 'code'
+            self.processed.append(item)
+        return self.processed
+
+    def save(self):
+        path = os.path.join(self.output_dir, 'dataset.jsonl')
+        with open(path, 'w') as f:
+            for d in self.processed:
+                f.write(json.dumps(d, ensure_ascii=False) + '\n')
+        log.info(f'Saved {len(self.processed)} samples to {path}')
+
+    def run(self):
+        self.load()
+        if not self.samples:
+            self.samples = fetch_real_samples()
+        self.filter()
+        self.deduplicate()
+        self.process()
+        self.save()
+
+
+if __name__ == '__main__':
+    import sys
+    ds = CodeDataset(sys.argv[1] if len(sys.argv) > 1 else './data',
+                  sys.argv[2] if len(sys.argv) > 2 else './output')
+    ds.run()