File size: 26,633 Bytes
49654fc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
#!/usr/bin/env python3
"""Query 筛选:规则 → 粗筛 → 双模型细筛 → 意图去重。"""
import argparse
import json
import os
import re
import subprocess
import threading
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from utils import (deduplicate, load_embeddings, load_model_and_processor,
                   read_jsonl, write_jsonl)


# 共用 I/O。
_write_lock = threading.Lock()


def load_done(path):
    """读取已完成的 idx(支持 ok 文件;failed 里的 idx 不算 done,允许重试)。"""
    done = set()
    if not os.path.exists(path):
        return done
    with open(path, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            try:
                done.add(str(json.loads(line)["idx"]))
            except Exception:
                continue
    return done


def append_jsonl(path, obj):
    with _write_lock:
        with open(path, "a", encoding="utf-8") as f:
            f.write(json.dumps(obj, ensure_ascii=False) + "\n")
            f.flush()


def extract_json_obj(text):
    try:
        match = re.search(r"\{.*\}", text, re.DOTALL)
        if match:
            parsed = json.loads(match.group())
            if isinstance(parsed, dict):
                return parsed
    except (json.JSONDecodeError, ValueError):
        pass
    return {}


# 1. 规则筛选。
EXCLUDE_RULES = [
    # ── 品牌/产品识别 ──
    (r'(是|什么|哪个|哪家).*(品牌|牌子)', '品牌识别'),
    (r'(哪些|推荐|有没有|有.*).*(品牌|牌子)', '品牌推荐'),
    (r'是什么(材质|宝石|面料|系列|风格|成分)', '材质识别'),
    (r'(叫什么|叫啥)', '名称识别'),

    # ── 材质选择(非识别,答案是材质不是商品)──
    (r'(用|选|买|换).*(什么|哪种).*(材质|材料|面料)', '材质选择'),
    (r'(哪种|什么样的?|什么).*(材质|材料|面料)', '材质选择'),

    # ── 穿搭搭配(服饰/饰品/鞋帽审美类)──
    (r'(配|搭|穿).*(什么|哪种|哪款|哪个).*'
     r'(衣服|裤子|裙子|外套|鞋子|鞋|内搭|打底|袜子|围巾|包包|帽子|项链|'
     r'戒指|头盔|内衣|手链|耳环|腰带|领带|饰品|发饰|枕套|杯套|'
     r'花边|地毯|桌布|桌旗)', '穿搭搭配'),
    (r'(配|搭配).*(什么|哪种).*'
     r'(茶几|沙发|椅子|灯|窗帘|桌子|柜子|鼠标垫|办公桌|床)', '家居搭配'),
    (r'怎么(搭配|搭|穿).*(好看|显瘦|显高|不臃肿|不单调|不压|显腿长|不显)',
     '穿搭建议'),
    (r'(什么|哪种|哪款).*(比较搭|很搭|更搭|搭$)', '穿搭搭配'),
    (r'(配|搭配).*(什么|哪种).*'
     r'(茶点|饮品|零食|甜品|小吃|饮料|酒)', '食品搭配'),
    (r'.{0,6}(什么|哪种).*(好看|好吃|好喝).*$', '审美主观'),

    # ── 颜色选择 ──
    (r'(什么|哪个|哪种|选|挑).*颜色', '颜色选择'),
    (r'(还有|其他|别的).*(颜色|色$|主题)', '颜色主题'),

    # ── 体型/年龄/肤色适合 ──
    (r'适合(什么|哪种).*(身材|体型|脚型|肤色|体质|人穿|人群|身高|发量|肤质)', '体型适合'),
    (r'适合(多大|几岁|什么|哪个).*(年龄|年龄段|岁|孩子|小朋友|宝宝|女宝|男宝)', '年龄适合'),
    (r'多大.*(年龄|岁).*(可以|能|适合)', '年龄适合'),
    (r'(什么|哪种)(身材|体型|肤质|肤色|发量|体质).*(适合|合适)', '体型适合'),
    (r'适合(什么|哪种).*(鞋型|脸型|发型|户型|腿型|手型)', '类型适合'),
    (r'适合.*(什么|哪种|哪些|哪个).*(场合|场景|季节)', '场合适合'),
    (r'适合(多大|多少).*(平米|平方|面积)', '面积适合'),
    (r'适合.*送(给|什么)', '送礼对象'),
    (r'送.*(选|挑|买|推荐).*(哪种|什么|哪个)', '送礼选择'),
    (r'送.*(人|长辈|朋友|领导|客户|同事|老师|父母).*(买|选|推荐|哪种|什么|哪个)', '送礼选择'),
    (r'适合.*(放在|放到|摆在|摆放)', '摆放位置'),
    (r'(放在|放到|摆在).*(哪里|哪儿|什么位置)', '摆放位置'),

    # ── 价格/定制/性价比 ──
    (r'多少钱|怎么收费|怎么定制|运费险', '价格定制'),
    (r'(平价|便宜|性价比|同价位|低价|高价).*(替代|替换|推荐|平替|款|高的|好的)', '价格比较'),
    (r'(贵不贵|划算|值不值|预算)', '价格咨询'),

    # ── 找同款/来源 ──
    (r'(同款|去哪|在哪|哪里).*(买|找|配|搜)', '找同款'),
    (r'找源头|上哪买', '找渠道'),
    (r'(博主|模特).*(同款|佩戴|穿)', '找同款'),
    (r'怎么(搜|搜索|找到|搜到)', '找同款'),
    (r'一模一样', '找同款'),

    # ── 找类似款式 ──
    (r'类似.*(款式|款|风格|的有|还有|有哪些|有没有)', '找类似款'),

    # ── 尺寸/规格/型号 ──
    (r'(多大|什么|哪种|哪个).*(尺寸|尺码|号码)', '尺寸询问'),
    (r'(适配|兼容|匹配).*(尺寸|型号|规格)', '适配规格'),
    (r'(搭配|配).*(什么|哪个).*(型号|规格)', '适配规格'),
    (r'(买|选|该).*什么.*(型号|规格)', '型号选择'),
    (r'(怎么|如何).*(选|挑|买).*(尺码|尺寸|码数|号)', '尺码选择'),
    (r'(容量|尺寸).*(一般|大概)?(多大|多少)', '规格询问'),
    (r'(多大|多少).*容量', '规格询问'),
    (r'能(装|放|容纳|坐|睡).*多少', '容量询问'),
    (r'多(大码|少瓦|厚|薄|宽|长|高|重)', '规格询问'),
    (r'搭配.*多(厚|薄|宽|长|高|大)', '规格询问'),
    (r'(适合|够).*几(个|口).*(人|口)', '容量规格'),
    (r'(挂|放|装|摆).*几(个|只|盏|盆)', '数量规格'),
    (r'多少(瓦|升|毫升|安|伏|度|克|斤)', '规格询问'),
    (r'能.*(用|跑|玩|撑|续航).*(几|多少).*(个小时|小时|天|分钟|公里)', '续航询问'),

    # ── 使用寿命/更换周期/质保 ──
    (r'(能用|能放|能保存|能跑|能走|能飞|能开|留香|一局).*多(少|久|长|远)', '使用寿命'),
    (r'多久(换|更换)', '更换周期'),
    (r'(质保|保修).*(多久|多长|几年)', '质保询问'),

    # ── 问答/是非类(答案是事实不是商品)──
    (r'.{2,}(效果|质量|手感|口感)(好吗|好不好|怎么样)', '产品评价'),
    (r'.{2,}(要|需要).{0,6}吗$', '使用知识'),
    (r'.{2,}能.{0,10}吗$', '使用知识'),
    (r'.{2,}可以.{1,10}吗$', '使用知识'),
    (r'.{2,}是.*(材质|材料|正品|真皮|纯棉|实木|新米|新茶|新款|全新|原装|国产|进口)吗', '属性确认'),
    (r'(显胖|显黑|显白|显高|显矮|显瘦|显老|显嫩|显壮|压身高|压个子|穿.*透)吗', '穿搭是非'),
    (r'(稳固|牢固|结实|耐用|防滑|耐磨|防水|耐高温)吗', '属性确认'),
    (r'(透气|缩水|漏气|掉钻|勾丝|闷热|粘腻|磨脚|漏水|漏电|生锈|褪色|发霉|防滑|耐磨|扎皮肤|扎手).*吗', '属性缺陷'),
    (r'(噪音|误差|味道|气味|色差|辐射|油烟|口感).*(大|小|重|苦|甜|酸|辣|涩|冲|淡).*吗', '属性程度'),
    (r'(包裹性|支撑性|透气性|稳定性|密封性|弹性).*(好|强|够|差).*吗', '属性评价'),
    (r'(透不透|热不热|重不重|硬不硬|闷不闷|粘不粘|厚不厚|软不软|滑不滑)', '属性是非'),
    (r'够.+吗', '属性够否'),
    (r'真的.+吗', '属性确认'),
    (r'适合.*(用|穿|戴|吃|喝).*吗', '适用确认'),
    (r'适合.{2,}(穿|用|戴|吃|喝)$', '适用确认'),
    (r'会不会.+$', '属性确认'),
    (r'(和|跟|与).*(哪个|哪种).*(好用|好|方便|实用)', '产品比较'),

    # ── 穿搭体型建议 ──
    (r'(小个子|大个子|微胖|矮个|胖|高个子).*(怎么穿|适合穿|穿什么)', '穿搭建议'),
    (r'适合.*(小个子|大个子|微胖|矮个|胖|高个子)', '体型适合'),
    (r'(小个子|微胖|矮个).*(穿|背|戴).*(显|会)', '穿搭是非'),

    # ── 维修/教程/故障诊断 ──
    (r'怎么(修|修理|维修|修复|配新)', '维修教程'),
    (r'(坏了|不良|故障|损坏).*怎么', '故障维修'),
    (r'(失灵|不灵|不好使).*(是|还是)', '故障诊断'),
    (r'(分辨|辨别|鉴别|辨认|区分).*(正品|真假|真伪)', '鉴别知识'),
    (r'(在哪|哪里).{0,4}(听|看|下载|播放|学)', '使用知识'),
    (r'用在.*(哪一步|第几步|哪步|哪个步骤|哪个环节)', '使用知识'),

    # ── 产品属性/区别 ──
    (r'(区别|不同).*(在哪|是什么|有什么)', '产品比较'),

    # ── 适合什么场景/季节 ──
    (r'(适合|针对).*(什么|哪种).*(症状|季节|场景)', '用途场景'),
    (r'什么(季节|时候|场景)(用|穿|戴)', '用途场景'),

    # ── 同系列/同款/同品牌/款式变体 ──
    (r'同系列.*(还有|其他)', '系列探索'),
    (r'同(款|品牌).*(推荐|还有|有哪些|有没有|生产|出品)', '同款探索'),
    (r'还有.*(同款|其他|什么).*(尺码|规格|款)', '同系列探索'),
    (r'(什么|哪些|哪种|哪个).*(口味|包装|版本)', '款式选择'),
    (r'(长袖|短袖|加长|加大|加厚|薄款|厚款|大号|小号).*(款|版|有哪些|有没有)', '款式变体'),
    (r'(更长|更大|更短|更小|更厚|更薄).*(的|尺寸|尺码|版本|款)', '尺寸变体'),

    # ── 人群/机型/症状等非商品类型询问 ──
    (r'(哪些|什么).*(人群|机型|车型).*(可以|能|适合|不建议|不适合|不能)', '类型询问'),
    (r'(症状|病症|副作用|禁忌).*(有哪些|是什么|有什么)', '医疗知识'),

    # ── 食材/早餐搭配 ──
    (r'(加点|加些|配点|配些|放点|放些).*什么', '食材搭配'),
]


def classify(query):
    for pattern, rule in EXCLUDE_RULES:
        if re.search(pattern, query):
            return 'exclude', rule
    return 'pending', ''


def run_rules(args):
    write_jsonl(args.output, [row for row in read_jsonl(args.input)
                             if classify(row["query"])[0] != "exclude"])


# 2. 粗筛:消费已生成的 scene。
STAGE2_PROMPT = """你在筛选多模态用户 query。根据图像内容、用户意图、原始 query,判断这条 query 属于 keep / discard。

【判断步骤】
1. 用户的需求能否用某个商品解决?
   不能(要的是知识/方法/评价/识别/参数)→ discard

2. 这个需求有客观明确的解吗?还是取决于个人审美/喜好?
   取决于个人喜好、没有客观对错的(搭配、配色、风格选择)→ discard
   (如"穿什么好看""用什么颜色适合""配什么风格",答案因人而异)

3. 前两关都过 → keep

【原则】拿不准就 discard。基于用户真实意图判断,不要脑补需求。

【示例】
图片内容: 生锈的菜刀
用户意图: 寻找去除菜刀锈迹的工具或用品
query: 生锈了怎么除锈
输出: {"reason":"可用"除锈剂"商品解决,有明确解","action":"keep"}

图片内容: 牛仔短裙
用户意图: 了解洗涤牛仔短裙的注意事项
query: 洗这种面料要注意什么
输出: {"reason":"要的是洗涤注意事项,属于知识类问答,买商品解决不了该问题","action":"discard"}

图片内容: 白衬衫
用户意图: 寻找搭配白衬衫的裤子
query: 这件衬衫配什么裤子
输出: {"reason":"可用"裤子"商品解决,但搭配取决于个人审美,无客观解","action":"discard"}

图片内容: 保温水杯
用户意图: 寻找可以挂在水杯上方便携带的背带绳
query: 这个水杯出门配个什么绳子好
输出: {"reason":"可用"水杯背带绳"商品解决,有明确解","action":"keep"}

【输入】
图片内容: __CONTENT__
用户意图: __INTENT__
query: __QUERY__
输出:"""


def parse_coarse_decision(text):
    obj = extract_json_obj(text)
    action = str(obj.get("action", "")).lower().strip()
    if action not in ("keep", "discard"):
        action = "discard" if "discard" in text.lower() else "keep"
    return {"action": action, "reason": str(obj.get("reason", "")).strip() or text[:80]}


def run_coarse(model, processor, stage1_path, stage2_path):
    from utils import run_text_only, load_scenes
    scenes = load_scenes(stage1_path)
    done = load_done(stage2_path)
    os.makedirs(os.path.dirname(os.path.abspath(stage2_path)), exist_ok=True)
    n_new = 0
    for idx, row in scenes.items():
        if idx in done:
            continue
        scene = row["scene"]
        prompt = (STAGE2_PROMPT
                  .replace("__CONTENT__", scene["content"])
                  .replace("__INTENT__", scene["intent"])
                  .replace("__QUERY__", row["query"]))
        raw = run_text_only(model, processor, prompt, max_new_tokens=300,
                            enable_thinking=False, do_sample=False, seed=0)
        append_jsonl(stage2_path, {**row, "idx": idx, **parse_coarse_decision(raw)})
        n_new += 1
    print(f"初筛完成:新增 {n_new} 条")
    return n_new


# 3. 细筛:两个模型独立判断,再取交集。
DISCARD_AND_CLASSIFY_PROMPT = '''用户发来一张图片并提出问题,想买商品来解决它。你的任务是判断这条 query 是否适合"图+意图→商品检索"这个任务,如果适合,再对它做分类。

# 任务背景
我们要构建的任务是:用户拍一张图 + 说一句只表达意图、不直接点名商品的短文本,模型需要【看图识别对象 + 理解意图 → 推断出能解决问题的商品】。
好的 query 必须满足:图片提供了关键信息、意图指向一个能用商品解决的明确需求、答案是客观的(有相对确定的商品品类可以对应)。

# 输入说明
你会看到三部分信息:
- 图片内容、用户提问:这两项合起来是用户最原始的真实需求,判断以此为准。
- 用户意图:对用户需求的进一步分析,供你参考,帮助你理解用户想要什么。
注意:用户意图是辅助分析,可能有误或不完整。若它与图片内容/用户提问矛盾,一律以图片内容和用户提问为准。不要因为意图分析把需求"洗白",就放过本该丢弃的 query。

# 第一步:判断 keep 还是 discard
符合下面【任一】丢弃标准,就判为 discard,并给出对应编号。

## A 组:答案主观(没有客观正确的商品)
- A1 搭配/审美类:问搭配什么衣服好看、什么料子/款式好看、怎么穿搭。
    例:"手臂粗适合配什么披肩"、"这种上衣适合配什么裤子"、"日常通勤可以穿什么"、"什么颜色好看"
- A2 对比/优选类:问怎么挑更好的、哪个效果更好,需要主观权衡。
    例:"怎么挑选保温效果好的"、"敏感肌买哪款好"
- A3 相似款/配色类:找相似款式、同款、其他配色,本质是图像相似或审美。
    例:"还有哪些相似款式"、"还有哪些其他配色可选"

## B 组:缺关键参数,无法确定具体商品
- B1 精确规格类:答案依赖精确的尺寸/容量/型号,且【图片和文本都无法直接确定】这个规格。
    注意:如果规格能从图/文直接看出(如 Type-C 接口、可见的电池型号),则不算此项,可以保留。
    例(丢弃):"类似容量的推荐哪些"、"适合装在什么样的笔壳里"、"需要多大尺寸的"
- B2 精确配件类:需要商品的详细参数才能配对的配件。
    例:"原装遥控器丢了怎么重新配"
- B3 价格约束类:需求里带价格限制(我们的商品库没有价格信息,无法满足)。
    例:"一百块以内有哪些平替"

## C 组:不符合任务形式
- C1 清单/成套类:一次要多种不同商品凑成一套/一个清单(多目标,非单一需求)。
    例:"去海边玩还需要准备什么"、"露营还要准备哪些东西"、"有没有成套的材料包"
- C2 纯文本可解类:不看图片、只凭文本就能回答,图片没有提供必要信息。
    例:"夹菜工具买哪种不生锈"、"冬天骑电瓶车配哪种挡风被"

## D 组:数据质量问题
- D1 图片模糊/不匹配:图片非常模糊看不清,或图文明显不匹配。
    例:图片糊到认不出物体

# 第二步:如果 keep,进行分类

## type(功能类型,四选一)
- T1 配套/使能:识别图中对象/接口 → 推断需要的工具、配件、转接器。
    例:螺丝→螺丝刀;Type-C 接口→转接头
- T2 恢复/修复/补给:图中物品处于缺失/损坏/耗尽/脏污状态 → 推断替换件、耗材、清洁/维修用品。
    例:电池仓→电池;瓷砖发霉→除霉剂;小白鞋脏了→清洗剂
- T3 空间/场景约束:图提供空间/尺寸/环境约束 → 检索适配该场景的商品。
    例:厨房窄缝→窄缝收纳架;窄阳台→折叠晾衣架
- T4 替代/升级:图中是旧的/低效的方案 → 推断某个维度更好的替代品。
    例:白炽灯→LED 灯;普通花洒→增压花洒

# 输出格式
只输出 JSON,不要输出其他内容。
- 若 discard:{{"decision": "discard", "discard_reason": "编号", "type": null}}
- 若 keep:   {{"decision": "keep", "discard_reason": null, "type": "T1/T2/T3/T4"}}

# 示例
输入:
图片内容:白色帆布厚底运动鞋(小白鞋),鞋面为白色帆布材质,鞋边有做旧毛边设计,厚底橡胶大底,系带款
用户提问:脏了用什么洗比较好
用户意图:寻找清洗白色帆布运动鞋(小白鞋)的洗鞋剂或清洁用品
输出:
{{"decision": "keep", "discard_reason": null, "type": "T2"}}

输入:
图片内容:墙上钉着一颗铁钉
用户提问:怎么把它拔下来
用户意图:寻找能把墙上的钉子拔出或撬出的工具
输出:
{{"decision": "keep", "discard_reason": null, "type": "T1"}}

输入:
图片内容:粉色无袖连衣裙,A字裙摆,圆领,中长款,挂于衣架展示,面料疑似棉质或混纺
用户提问:手臂粗适合配什么披肩
用户意图:寻找适合手臂较粗人群搭配该款无袖连衣裙的披肩
输出:
{{"decision": "discard", "discard_reason": "A1", "type": null}}

输入:
图片内容:某家用电器(疑似热水器或类似储能/储水类电器)的铭牌标签,标签上印有品牌名称(字迹模糊,疑似"万利达"或类似品牌)、额定电压、额定功率及容量等技术参数,并带有CCC认证标志;因图片模糊,具体容量数值(如升数)无法准确读取
用户提问:类似容量的推荐哪些
用户意图:根据图中铭牌所示的容量规格,寻找同类容量的同类电器产品推荐
输出:
{{"decision": "discard", "discard_reason": "B1", "type": null}}

输入:
图片内容:泳池场景,前景为一名戴着泳帽和泳镜的婴幼儿,背景中有一名穿粉色连体泳衣、戴紫色遮阳帽的小女孩在池中玩耍,旁边可见浮圈、水上玩具等游泳装备
用户提问:去海边玩还需要准备什么
用户意图:图中已有泳帽、泳镜、泳衣等基本装备,用户带小孩去海边玩,想寻找还需补充的海边出行用品(如防晒、安全、娱乐类)
输出:
{{"decision": "discard", "discard_reason": "C1", "type": null}}

输入:
图片内容:踏板式电动自行车(电动车),白色/薄荷绿色车身,配有前置车篮,前部挡泥板区域可见明显龟裂纹路(疑似塑料件老化开裂)
用户提问:冬天骑电瓶车配哪种挡风被
用户意图:寻找适合该踏板式电动车冬季骑行使用的挡风被(腿部防风罩)
输出:
{{"decision": "discard", "discard_reason": "C2", "type": null}}

# 本次输入
图片内容:{content}
用户提问:{query}
用户意图:{intent}

直接输出 JSON。'''


SYSTEM_PROMPT = "你是一个 query 筛选与分类助手。只输出 JSON 对象,不要输出任何解释或其他内容。"


def load_keep_rows(path):
    with open(path, encoding="utf-8") as f:
        rows = [json.loads(line) for line in f if line.strip()]
    return [dict(row, idx=str(row["idx"])) for row in rows if row["action"] == "keep"]


def _clean(v):
    """JSON null -> None;其余去空白。"""
    if v is None:
        return None
    s = str(v).strip()
    return s or None


def parse_result(text):
    """从模型输出提取 {decision, discard_reason, type}。"""
    obj = extract_json_obj(text)
    decision = str(obj.get("decision", "")).lower().strip()
    if decision not in ("keep", "discard"):
        raise ValueError("Invalid eligibility response; an explicit keep/discard is required")
    return {
        "decision": decision,
        "discard_reason": _clean(obj.get("discard_reason")),
        "type": _clean(obj.get("type")),
    }


def call_claude(prompt, model, timeout_seconds):
    result = subprocess.run(
        [
            "claude", "-p", prompt,
            "--system-prompt", SYSTEM_PROMPT,
            "--model", model,
            "--output-format", "text",
            "--no-session-persistence",
            "--bare",
        ],
        stdin=subprocess.DEVNULL,
        capture_output=True,
        text=True,
        timeout=timeout_seconds,
    )
    if result.returncode != 0:
        stderr = (result.stderr or "").strip()
        raise RuntimeError(f"claude -p exit {result.returncode}: {stderr}")
    return result.stdout.strip()


def call_claude_with_retry(prompt, model, max_retries, timeout_seconds):
    for attempt in range(1, max_retries + 1):
        try:
            raw = call_claude(prompt, model, timeout_seconds)
            parse_result(raw)
            return raw, None
        except Exception as exc:
            if attempt == max_retries:
                return None, str(exc)
            time.sleep(min(2 ** attempt, 10))
    return None, "max retries exceeded"


def build_prompt(row):
    return DISCARD_AND_CLASSIFY_PROMPT.format(
        content=row["scene"]["content"], query=row["query"], intent=row["scene"]["intent"])


def run_fine(args):
    rows = load_keep_rows(args.input)
    done = load_done(args.output)
    os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)

    def process_one(row):
        raw, error = call_claude_with_retry(
            build_prompt(row), args.model, args.max_retries, args.timeout)
        if error:
            raise RuntimeError(f"idx={row['idx']}: {error}")
        append_jsonl(args.output, {**row, **parse_result(raw), "raw_response": raw})

    with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
        futures = [pool.submit(process_one, row) for row in rows if row["idx"] not in done]
        for future in as_completed(futures):
            future.result()
    print(f"资格判定完成:{args.output}")


def load_votes(path):
    records = {}
    with open(path, encoding="utf-8") as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            r = json.loads(line)
            records[str(r["idx"])] = r
    return records


def merge_eligibility(glm_path, ds_path, out_path):
    glm, ds = load_votes(glm_path), load_votes(ds_path)
    if set(glm) != set(ds):
        raise ValueError("Eligibility models must cover the same query IDs")
    kept = []
    for idx, row in glm.items():
        other = ds.get(idx)
        if row["decision"] == "keep" and other and other["decision"] == "keep":
            kept.append({"idx": idx, "query": row["query"], "image_url": row["image_url"],
                         "scene": row["scene"], "type": other["type"]})
    with open(out_path, "w", encoding="utf-8") as f:
        for row in kept:
            f.write(json.dumps(row, ensure_ascii=False) + "\n")
    print(f"双模型均通过:{len(kept)} 条,保存到 {out_path}")


# 4. 意图向量去重。


def run_dedup(args):
    items = read_jsonl(args.input)
    if args.emb_path:
        emb = load_embeddings(args.emb_path, [row["idx"] for row in items])
    else:
        from sentence_transformers import SentenceTransformer
        model = SentenceTransformer(args.model, model_kwargs={"torch_dtype": "bfloat16"})
        model.max_seq_length = 512
        emb = model.encode([row["scene"]["intent"] for row in items], batch_size=64,
                           convert_to_numpy=True, normalize_embeddings=True, show_progress_bar=True)
    kept, mapping = deduplicate(items, emb, "query", args.threshold)
    out = Path(args.output_dir)
    write_jsonl(out / "deduplicated.jsonl", kept)
    (out / "id_mapping.json").write_text(json.dumps(mapping, ensure_ascii=False, indent=2), encoding="utf-8")
    print(f"Query 去重:{len(items)} → {len(kept)}")


def main():
    p = argparse.ArgumentParser(description=__doc__)
    sub = p.add_subparsers(dest="stage", required=True)
    for stage in ("rules", "coarse", "fine", "merge", "dedup"):
        command = sub.add_parser(stage)
        if stage == "merge":
            command.add_argument("--glm", required=True)
            command.add_argument("--ds", required=True)
        else:
            command.add_argument("--input", required=True)
        command.add_argument("--output-dir" if stage == "dedup" else "--output", required=True)
        if stage == "coarse":
            command.add_argument("--model-path", required=True)
        elif stage == "fine":
            command.add_argument("--model", required=True, choices=["GLM-5.2", "deepseek-v4-pro"])
            command.add_argument("--concurrency", type=int, default=8)
            command.add_argument("--max-retries", type=int, default=3)
            command.add_argument("--timeout", type=int, default=120)
        elif stage == "dedup":
            command.add_argument("--emb-path", help="NPZ with emb and ids in input order")
            command.add_argument("--model", default="Qwen/Qwen3-Embedding-8B")
            command.add_argument("--threshold", type=float, default=0.70)
    args = p.parse_args()
    if args.stage == "rules":
        run_rules(args)
    elif args.stage == "coarse":
        model, processor = load_model_and_processor(args.model_path)
        run_coarse(model, processor, args.input, args.output)
    elif args.stage == "fine":
        run_fine(args)
    elif args.stage == "merge":
        Path(args.output).parent.mkdir(parents=True, exist_ok=True)
        merge_eligibility(args.glm, args.ds, args.output)
    else:
        run_dedup(args)


if __name__ == "__main__":
    main()