File size: 5,456 Bytes
b2beb8e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
import json, os, hashlib, logging
from pathlib import Path

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


def load(data_dir):
    
    files = list(Path(data_dir).glob('*.jsonl'))
    if not files:
        files = list(Path(data_dir).glob('*.json'))
    samples = []
    for f in files:
        with open(f) as fp:
            if f.suffix == '.json':
                d = json.load(fp)
                samples.extend(d if isinstance(d, list) else [d])
            else:
                samples.extend(json.loads(l) for l in fp if l.strip())
    return samples

def filter_quality(samples, min_score=0.5):
    
    results = []
    for s in samples:
        text = s.get('code', s.get('text', ''))
        if len(text.split()) >= 3:
            results.append(s)
    return results

def dedup(samples):
    seen = set()
    out = []
    for s in 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)
        out.append(s)
    return out

def preprocess(samples, out_dir, img_size=224):
    
    os.makedirs(out_dir, exist_ok=True)
    processed = []
    for s in samples:
        item = {}
        if 'image' in s:
            try:
                from PIL import Image as IM
                img = IM.open(s['image']).convert('RGB')
                img = img.resize((img_size, img_size))
                p = os.path.join(out_dir, os.path.basename(s['image']))
                img.save(p, 'JPEG', quality=95)
                item['image'] = p
            except Exception:
                continue
        text = s.get('code', s.get('text', ''))
        item['text'] = text
        item['domain'] = 'code'
        processed.append(item)
    return processed

def save_jsonl(data, path):
    with open(path, 'w') as f:
        for d in data:
            f.write(json.dumps(d, ensure_ascii=False) + '\n')

def main():
    import sys
    data_dir = sys.argv[1] if len(sys.argv) > 1 else './data'
    out = sys.argv[2] if len(sys.argv) > 2 else './output'
    samples = load(data_dir) or fetch_real_samples()
    samples = filter_quality(samples)
    samples = dedup(samples)
    result = preprocess(samples, out)
    save_jsonl(result, os.path.join(out, 'dataset.jsonl'))
    print(f'Done: {len(result)} samples')

if __name__ == '__main__':
    main()