Add original-image LTF Gradio demo

README.md

@@ -62,22 +62,28 @@ The web UI and its `predict` API both call the same original-file inference path
 
 ## Attention and tile inspection
 
-The Detect button additionally requests the model's existing `return_viz`
+The Analyze button additionally requests the model's existing `return_viz`
 outputs during the same forward pass. Temporary observation hooks collect the
 eight L1 across-tile aggregation heads. No model parameters are changed.
 
 - Exact, numbered local crop boxes, including edge-aligned overlap and small-image padding.
 - L1 tile-attention overlay: mean or any of the eight aggregation heads.
 - L2 local-view overlay with the global-view attention weight listed separately.
-- Top four local tiles, original crops paired with their 16×16 MIL patch attention.
+- Four ranked local crop cards; clicking a card selects its patch inspector.
+- Side-by-side original crop, patch overlay and interactive 16×16 weight matrix.
+- Large score card and branch comparison, plus per-view attention ranking charts.
+- Responsive desktop/mobile layout; replacing an image clears previous analysis.
 - A tile selector for inspecting any local tile without rerunning inference.
 - Exact view-weight table, embedding fusion gate and read-only model/inference parameters.
 - Historical training settings from the original saved configuration, explicitly labeled Training only.
 
-Colors use a separate min-max scale for each map (blue→yellow is low→high).
-Overlapping image pixels use the mean of covering tile weights. A patch map is
-normalized within its own tile. Raw normalized view weights are available in
-the table and prediction JSON; colors cannot be compared across images or tiles.
+Colors use a fixed log2 scale relative to uniform attention (`weight × N`):
+0.25×, 0.5×, 1×, 2× and 4×. Neutral gray represents the uniform reference;
+blue is below and orange-red above that reference. Small differences are not
+stretched into strong colors. L2 uses the count of all views, including Global,
+for its reference. Overlap uses mean tile weight. Raw weights are available in
+the ranking charts, weight table and prediction JSON. A displayed percentage is
+an attention share, not a calibrated class probability.
 These are model attention values, not pixel-level forgery probabilities or
 causal explanations. The eight selectable heads belong to the L1 across-tile
 aggregator; L1 patch pooling and L2 view pooling use gated MIL attention.
@@ -85,4 +91,6 @@ aggregator; L1 patch pooling and L2 view pooling use gated MIL attention.
 The original five-output `predict` API is preserved. The new `explain` API
 returns prediction results plus visualization images, tables and attention metadata.
 Changing a head or inspected tile uses per-session cached data, retained for up
-to an hour. The unchanged checkpoint is used for both endpoints.
+to an hour. Changing the decision branch or threshold updates the result from
+the cached scores. Uploading a new image clears previous results. The unchanged
+checkpoint is used for both endpoints.

app.py

@@ -25,6 +25,7 @@ import torch
 sys.path.insert(0, str(Path(__file__).absolute().parent))
 from attention import (capture_prediction, draw_grid, head_view, parameter_rows,
                        patch_view, public_attention, tile_boxes, tile_overlay, top_tiles)
+from presentation import EMPTY_RESULT, HEADER, patch_matrix, result_card, stats_card, weight_chart
 
 LOG = logging.getLogger(__name__)
 MAX_PIXELS = int(os.environ.get('LTF_MAX_PIXELS', '16000000'))
@@ -147,16 +148,13 @@ def _predict_request(image_path, branch='fusion', threshold=0.5, with_attention=
                   elapsed_seconds=round(time.perf_counter() - start, 3))
     assert result['views'] == views, 'Preview and model tile counts disagree'
     scores = result['probabilities'][branch]
-    verdict = 'AI-generated / 生成图' if result['label'] else 'Real / 真实图'
-    summary = (f'### {verdict}\n\n生成分数 / AI-generated score: '
-               f'**{result["score_fake"]:.4f}** · threshold: **{float(threshold):.2f}**\n\n'
-               f'{width:,} × {height:,} pixels · {views} views · '
-               f'{result["elapsed_seconds"]:.2f} s (includes first-time model loading)')
+    summary = result_card(result)
     rows = [[name, result['probabilities'][name]['real'],
              result['probabilities'][name]['fake']]
             for name in ('fusion', 'level1', 'level2')]
     if state:
         result['attention'] = public_attention(state)
+        state['result'] = dict(result)
     return (preview, summary, {'Real': scores['real'], 'AI-generated': scores['fake']}, rows, result), state
 
 
@@ -173,14 +171,12 @@ def explain(image_path, branch='fusion', threshold=0.5):
         raise gr.Error('Attention and original image tile counts disagree.')
     grid = draw_grid(state['path'], state['boxes'])
     l1_image, l1_description = head_view(state, 'mean')
-    l2_image = tile_overlay(state['path'], state['boxes'], attention['l2'][1:])
-    description = (f'**L2 global-view weight: {attention["l2"][0]:.6f}** · '
-                   f'local-view weights sum: {float(attention["l2"][1:].sum()):.6f}.\n\n'
-                   'L2 图仅着色局部分块；全局权重单列，不铺满整张图。'
-                   ' / The L2 overlay shows local views only; the global weight is listed separately.\n\n'
-                   f'Fusion embedding gate: L1 × **{attention["gate"]:.4f}**, '
-                   f'L2 × **{1 - attention["gate"]:.4f}**. '
-                   '这是特征缩放系数，不是分支概率 / These scale embeddings, not branch probabilities.')
+    l2_image = tile_overlay(state['path'], state['boxes'], attention['l2'][1:], reference_count=count+1)
+    description = (f'全局视图权重 **{attention["l2"][0]*100:.2f}%**；局部视图合计 '
+                   f'**{float(attention["l2"][1:].sum())*100:.2f}%**。'
+                   '全局权重单列，叠图仅表示局部分块。\n\n'
+                   f'特征融合系数：L1 × {attention["gate"]:.4f}，L2 × {1-attention["gate"]:.4f}。'
+                   '它们缩放分支特征，不是分支概率。')
     weight_rows = [['Global', 'whole image', None, float(attention['l2'][0])]]
     weight_rows.extend([f'T{i + 1}', str(list(box)), float(attention['l1'][i]), float(attention['l2'][i + 1])]
                        for i, box in enumerate(state['boxes']))
@@ -190,81 +186,151 @@ def explain(image_path, branch='fusion', threshold=0.5):
             state['parameters'], weight_rows, state,
             gr.Dropdown(choices=[str(i + 1) for i in range(count)], value=str(selected)),
             tile, patch, patch_description,
-            gr.Dropdown(choices=['mean'] + [f'head_{i + 1}' for i in range(attention['l1_heads'].shape[0])], value='mean'))
+            gr.Dropdown(choices=[('平均（8 Heads）', 'mean')] + [(f'Head {i + 1}', f'head_{i + 1}')
+                       for i in range(attention['l1_heads'].shape[0])], value='mean'),
+            weight_chart(state), weight_chart(state, level='l2'), patch_matrix(state, str(selected)),
+            stats_card(state), gr.update(visible=True))
+
+
+def inspect_head(state, selection):
+    image, description = head_view(state, selection)
+    return image, description, weight_chart(state, selection)
+
+
+def inspect_patch(state, tile_number):
+    tile, image, description = patch_view(state, tile_number)
+    return tile, image, description, patch_matrix(state, tile_number)
+
+
+def select_top_tile(state, event: gr.SelectData):
+    if not state:
+        return gr.skip()
+    index = event.index[0] if isinstance(event.index, (tuple, list)) else event.index
+    order = sorted(range(len(state['boxes'])), key=lambda i: -float(state['attention']['l1'][i]))[:4]
+    return str(order[int(index)] + 1)
+
+
+def update_decision(state, branch, threshold):
+    """Threshold and branch selection use cached logits, without another forward."""
+    if not state:
+        return tuple(gr.skip() for _ in range(5))
+    result = dict(state['result'])
+    score = result['probabilities'][branch]['fake']
+    label = int(score >= float(threshold))
+    result.update(branch=branch, threshold=float(threshold), score_fake=score,
+                  label=label, prediction='fake' if label else 'real')
+    scores = result['probabilities'][branch]
+    rows = [[name, result['probabilities'][name]['real'], result['probabilities'][name]['fake']]
+            for name in ('fusion', 'level1', 'level2')]
+    parameters = [list(row) for row in state['parameters']]
+    parameters[0][2] = f'{branch} / {float(threshold):.2f}'
+    return result_card(result), {'Real': scores['real'], 'AI-generated': scores['fake']}, rows, result, parameters
+
+
+def reset_upload(path):
+    image = None
+    if path:
+        try:
+            source, *_ = validate_upload(path)
+            with Image.open(source) as original:
+                image = original.convert('RGB')
+            image.thumbnail((1024, 1024))
+        except gr.Error:
+            pass
+    return image, EMPTY_RESULT, None, [], None, [], None, gr.update(visible=False)
 
 
 def build_demo():
-    with gr.Blocks(title='LTF · Image Detector', delete_cache=(3600, 3600)) as demo:
-        gr.Markdown('# LTF · Image Detector\n上传原图，测试 LTF v3.3 / Test your original image with LTF v3.3.')
-        gr.Markdown('默认 Fusion 分支、阈值 0.5。保留原始图像和完整分块。'
-                    ' / Default: fusion, threshold 0.5. Original pixels and all tiles are preserved.')
+    with gr.Blocks(title='LTF · 图像检测与注意力分析', fill_width=True, delete_cache=(3600, 3600)) as demo:
+        gr.HTML(HEADER)
         with gr.Row():
-            with gr.Column():
-                upload = gr.File(label='上传原图 / Original image file', type='filepath',
-                                 file_count='single', file_types=['image'])
-                with gr.Accordion('高级选项 / Advanced', open=False):
-                    branch = gr.Dropdown(['fusion', 'level1', 'level2'], value='fusion', label='Branch')
-                    threshold = gr.Slider(0, 1, value=0.5, step=0.01, label='Decision threshold')
-                button = gr.Button('开始检测 / Detect', variant='primary')
-                gr.Markdown(f'在线测试上限 / Demo limits: {MAX_PIXELS:,} pixels, '
-                            f'{MAX_VIEWS} views. CPU inference may take time for large images.')
-            with gr.Column():
-                preview = gr.Image(label='图片预览 / Preview', interactive=False)
-                summary = gr.Markdown('等待图片 / Ready for an image.')
-                scores = gr.Label(label='模型分数 / Model scores', num_top_classes=2)
-        with gr.Accordion('分支分数与 JSON / Branch scores and JSON', open=False):
-            table = gr.Dataframe(headers=['Branch', 'Real score', 'AI-generated score'],
-                                 datatype=['str', 'number', 'number'], interactive=False)
-            details = gr.JSON(label='Prediction')
+            with gr.Column(scale=3, min_width=260, elem_id='upload-panel'):
+                gr.Markdown('### 01 · 上传原图\n保留原始文件进行推理，预览缩放不影响模型输入。')
+                upload = gr.File(label='图片文件', type='filepath', file_count='single', file_types=['image'], height=150)
+                gr.ClearButton([upload], value='更换图片', size='sm')
+                branch = gr.Dropdown([('Fusion · 融合分支', 'fusion'), ('L1 · 局部分支', 'level1'),
+                                      ('L2 · 视图分支', 'level2')], value='fusion', label='预测分支', elem_id='branch-select')
+                threshold = gr.Slider(0, 1, value=0.5, step=0.01, label='判定阈值', elem_id='threshold-select')
+                button = gr.Button('开始分析', variant='primary', elem_id='run-button')
+                gr.Markdown(f'上限 {MAX_PIXELS/1_000_000:g} MP · {MAX_VIEWS} 个视图 · 30 MB。大图在 CPU 上处理较慢。')
+            with gr.Column(scale=4, min_width=300):
+                preview = gr.Image(label='原图预览', height=390, interactive=False,
+                                   buttons=['download', 'fullscreen'], elem_id='original-preview')
+            with gr.Column(scale=4, min_width=300):
+                summary = gr.HTML(EMPTY_RESULT, label='模型分析结果')
+                scores = gr.Label(label='模型分数', num_top_classes=2, visible=False)
         state = gr.State(value=None, time_to_live=3600)
-        with gr.Accordion('分块与 MIL Attention / Tiles and model attention', open=True):
-            gr.Markdown('以下权重直接来自本次模型前向计算。Attention 是相对关注程度，'
-                        '不能直接作为伪造区域或因果解释。'
-                        ' / These are actual forward-pass weights, not forgery probabilities or causal explanations.')
-            with gr.Tabs():
-                with gr.Tab('原图分块 / Tile grid'):
-                    grid = gr.Image(label='224×224 local tiles · T1…Tn · edge-aligned', interactive=False)
-                    gr.Markdown('分块编号按行排列，边缘对齐时允许重叠。全局视图独立于局部分块。'
-                                ' / Row-major IDs; edge-aligned tiles may overlap. The global view is separate.')
-                with gr.Tab('L1 分块注意力'):
-                    head = gr.Dropdown(['mean'], value='mean', label='Across-tile aggregation head')
-                    l1_image = gr.Image(label='L1 tile attention', interactive=False)
-                    l1_description = gr.Markdown()
-                with gr.Tab('L2 视图注意力'):
-                    l2_image = gr.Image(label='L2 local-view attention', interactive=False)
-                    attention_description = gr.Markdown()
-                    weight_table = gr.Dataframe(headers=['View', 'Original crop box', 'L1 weight', 'L2 weight'],
-                                                datatype=['str', 'str', 'number', 'number'], interactive=False)
-                with gr.Tab('Top-K 与块内 Patch Attention'):
-                    gallery = gr.Gallery(label='Top 4 L1 tiles: original + within-tile patch attention', columns=4,
-                                         object_fit='contain', height='auto')
-                    tile_number = gr.Dropdown(choices=[], label='Inspect local tile / 分块编号', allow_custom_value=False)
+        with gr.Column(visible=False, elem_id='analysis-section') as analysis:
+            statistics = gr.HTML()
+            gr.Markdown('## 02 · 注意力分析\n热图使用统一的「均匀权重」参照；权重接近均匀时，颜色也保持接近。Attention 不代表伪造概率。')
+            with gr.Tabs(selected='l1', elem_id='analysis-tabs'):
+                with gr.Tab('L1 · 分块注意力', id='l1'):
+                    with gr.Row():
+                        with gr.Column(scale=7, min_width=320):
+                            l1_image = gr.Image(label='L1 分块级注意力叠图', height=500, interactive=False,
+                                                buttons=['download', 'fullscreen'], elem_classes='attention-image')
+                            l1_description = gr.Markdown()
+                        with gr.Column(scale=5, min_width=300):
+                            head = gr.Dropdown([('平均（8 Heads）', 'mean')], value='mean', label='聚合 Head', elem_id='head-select')
+                            l1_chart = gr.HTML()
+                with gr.Tab('L2 · 视图权重', id='l2'):
                     with gr.Row():
-                        selected_tile = gr.Image(label='Original 224×224 crop', interactive=False)
-                        selected_patch = gr.Image(label='MIL patch attention (16×16)', interactive=False)
+                        with gr.Column(scale=7, min_width=320):
+                            l2_image = gr.Image(label='L2 局部视图注意力叠图', height=500, interactive=False,
+                                                buttons=['download', 'fullscreen'], elem_classes='attention-image')
+                            attention_description = gr.Markdown()
+                        with gr.Column(scale=5, min_width=300):
+                            l2_chart = gr.HTML()
+                with gr.Tab('原图 · 分块位置', id='grid'):
+                    grid = gr.Image(label='原始 224 × 224 分块边界', height=570, interactive=False,
+                                    buttons=['download', 'fullscreen'], elem_classes='attention-image')
+                    gr.Markdown('编号按行排列，边缘对齐会产生重叠。分块很多时仅标注部分编号，完整坐标见下方数据表。')
+                with gr.Tab('分块 · Patch 细节', id='patch'):
+                    gr.Markdown('### 按 L1 权重排列的前 4 个分块\n点击分块，查看其原始裁剪、注意力叠图和 Patch 权重。Top-4 仅用于展示，不参与预测。')
+                    gallery = gr.Gallery(label='高权重分块', columns=4, object_fit='contain', height=250,
+                                         elem_id='top-crops', show_label=False, preview=False, allow_preview=False,
+                                         interactive=False, buttons=['download_all'])
+                    tile_number = gr.Dropdown(choices=[], label='查看分块编号', allow_custom_value=False, elem_id='tile-select')
+                    with gr.Row():
+                        with gr.Column(min_width=250):
+                            selected_tile = gr.Image(label='原始 224 × 224 裁剪', height=330, interactive=False,
+                                                     buttons=['download', 'fullscreen'])
+                        with gr.Column(min_width=250):
+                            selected_patch = gr.Image(label='Patch 注意力叠图', height=330, interactive=False,
+                                                      buttons=['download', 'fullscreen'])
+                        with gr.Column(min_width=280):
+                            patch_chart = gr.HTML()
                     patch_description = gr.Markdown()
-            gr.Markdown('热图分别归一化：蓝色低、黄色高，不能跨图片按颜色比较。'
-                        '重叠像素显示覆盖分块的平均权重，精确权重见表格。'
-                        ' / Heatmaps use separate min-max scales; overlap uses mean weights.')
-        with gr.Accordion('模型与超参数 / Model and hyperparameters (read only)', open=False):
+        with gr.Accordion('精确权重、参数与原始输出', open=False, elem_id='technical-details'):
+            gr.Markdown('### 分支分数')
+            table = gr.Dataframe(headers=['Branch', 'Real score', 'Generated score'],
+                                 datatype=['str', 'number', 'number'], interactive=False)
+            gr.Markdown('### 视图权重\nL1 列为 8 Heads 平均；L2 的第一项为独立的全局视图。')
+            weight_table = gr.Dataframe(headers=['View', 'Original crop box', 'L1 mean weight', 'L2 weight'],
+                                        datatype=['str', 'str', 'number', 'number'], interactive=False)
+            gr.Markdown('### 模型与超参数\nTraining only 为历史训练配置；推理时不启用随机增强、Cross-shuffle 和 Dropout。')
             parameters = gr.Dataframe(headers=['Scope', 'Parameter', 'Value'],
                                       datatype=['str', 'str', 'str'], interactive=False)
-            gr.Markdown('Training only 是历史训练配置；Cross-shuffle、随机增强和 dropout '
-                        '在本次推理中不启用。Head 数量与网络结构随权重固定。')
-        button.click(explain, [upload, branch, threshold],
-                     [preview, summary, scores, table, details, grid, l1_image, l1_description,
-                      l2_image, attention_description, gallery, parameters, weight_table, state,
-                      tile_number, selected_tile, selected_patch, patch_description, head],
-                     api_name='explain', concurrency_limit=1, concurrency_id='ltf-inference')
-        head.change(head_view, [state, head], [l1_image, l1_description], api_name=False)
-        tile_number.change(patch_view, [state, tile_number],
-                           [selected_tile, selected_patch, patch_description], api_name=False)
-        # Preserve the original prediction endpoint for existing API clients.
+            details = gr.JSON(label='Prediction JSON')
+        run_event = button.click(explain, [upload, branch, threshold],
+                    [preview, summary, scores, table, details, grid, l1_image, l1_description,
+                     l2_image, attention_description, gallery, parameters, weight_table, state,
+                     tile_number, selected_tile, selected_patch, patch_description, head,
+                     l1_chart, l2_chart, patch_chart, statistics, analysis],
+                    api_name='explain', concurrency_limit=1, concurrency_id='ltf-inference')
+        head.change(inspect_head, [state, head], [l1_image, l1_description, l1_chart], api_name=False)
+        tile_number.change(inspect_patch, [state, tile_number],
+                           [selected_tile, selected_patch, patch_description, patch_chart], api_name=False)
+        gallery.select(select_top_tile, [state], [tile_number], api_name=False)
+        for control in (branch, threshold):
+            control.change(update_decision, [state, branch, threshold], [summary, scores, table, details, parameters],
+                           api_name=False, queue=False, trigger_mode='always_last')
+        upload.change(reset_upload, [upload], [preview, summary, scores, table, details, parameters, state, analysis],
+                      api_name=False, queue=False, cancels=[run_event])
         api_button = gr.Button(visible=False)
         api_button.click(predict, [upload, branch, threshold], [preview, summary, scores, table, details],
                          api_name='predict', concurrency_limit=1, concurrency_id='ltf-inference')
-        gr.Markdown('分数是模型输出，不能单独作为图片真伪的证明。'
-                    ' / Model scores are not calibrated probabilities or proof of authenticity.')
+        gr.Markdown('LTF v3.3 · 原始权重与推理流程 · 可视化不改变模型分数', elem_id='footer-note')
     return demo.queue(max_size=16, default_concurrency_limit=1)
 
 
@@ -272,4 +338,7 @@ if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
     build_demo().launch(server_name=os.environ.get('GRADIO_SERVER_NAME', '0.0.0.0'),
                         server_port=int(os.environ.get('PORT', '7860')), share=False,
-                        max_file_size='30mb')
+                        max_file_size='30mb', theme=gr.themes.Soft(primary_hue='teal', neutral_hue='slate',
+                            font=['ui-sans-serif', 'system-ui', 'sans-serif']).set(
+                                block_label_background_fill='#eef3f8', block_label_text_color='#445b72'),
+                        css_paths=Path(__file__).with_name('styles.css'))

attention.py

@@ -73,14 +73,21 @@ def relative_scale(values):
 
 
 def colors(values):
-    """Continuous dark-blue → cyan → yellow scale; no probability semantics."""
+    """Fixed blue → neutral → orange-red scale, centered on uniform attention."""
     x = np.clip(np.asarray(values), 0, 1)
-    stops = np.array([[35, 47, 110], [31, 164, 172], [253, 225, 77]], dtype=np.float32)
-    first = np.minimum((x * 2).astype(int), 1)
-    fraction = (x * 2 - first)[..., None]
+    stops = np.array([[35, 57, 93], [104, 134, 171], [180, 191, 203],
+                      [247, 163, 66], [238, 80, 60]], dtype=np.float32)
+    first = np.minimum((x * 4).astype(int), 3)
+    fraction = (x * 4 - first)[..., None]
     return (stops[first] * (1 - fraction) + stops[first + 1] * fraction).astype(np.uint8)
 
 
+def attention_levels(values, reference_count):
+    """A common reference: 1/N is neutral; clip only outside [0.25×, 4×]."""
+    ratios = np.maximum(np.asarray(values, dtype=np.float32) * reference_count, 1e-12)
+    return np.clip((np.log2(ratios) + 2) / 4, 0, 1)
+
+
 def preview_image(path):
     with Image.open(path) as source:
         image = source.convert('RGB')
@@ -93,17 +100,20 @@ def draw_grid(path, boxes):
     with Image.open(path) as original:
         sx, sy = image.width / original.width, image.height / original.height
     draw = ImageDraw.Draw(image)
-    font = ImageFont.load_default(size=14)
+    font = ImageFont.load_default(size=18)
     labels = []
     for index, (x0, y0, x1, y1) in enumerate(boxes, 1):
         rect = (int(x0 * sx), int(y0 * sy), min(image.width - 1, int(x1 * sx) - 1),
                 min(image.height - 1, int(y1 * sy) - 1))
-        draw.rectangle(rect, outline=(255, 212, 74), width=2)
+        draw.rectangle(rect, outline=(11, 35, 59), width=4)
+        draw.rectangle(rect, outline=(234, 252, 255), width=2)
+        if len(boxes) > 80 and (index - 1) % math.ceil(len(boxes) / 80):
+            continue
         label = f'T{index}'
         left, top = rect[0] + 3, rect[1] + 3
         # Edge alignment can place two rows just one pixel apart. Keep their
         # exact crop borders while moving text labels to avoid hiding earlier IDs.
-        for candidate_top in range(top, max(top + 1, rect[3] - 15), 18):
+        for candidate_top in range(top, max(top + 1, rect[3] - 21), 24):
             extent = draw.textbbox((left, candidate_top), label, font=font)
             if not any(left < old[2] + 3 and extent[2] + 3 > old[0]
                        and candidate_top < old[3] + 3 and extent[3] + 3 > old[1]
@@ -112,12 +122,12 @@ def draw_grid(path, boxes):
                 break
         extent = draw.textbbox((left, top), label, font=font)
         labels.append((left, top, extent[2], extent[3]))
-        draw.rectangle((left - 1, top - 1, extent[2] + 2, extent[3] + 2), fill=(18, 28, 45))
+        draw.rectangle((left - 2, top - 2, extent[2] + 4, extent[3] + 4), fill=(11, 35, 59))
         draw.text((left, top), label, fill='white', font=font)
     return image
 
 
-def tile_overlay(path, boxes, weights):
+def tile_overlay(path, boxes, weights, reference_count=None):
     image = preview_image(path)
     with Image.open(path) as original:
         sx, sy = image.width / original.width, image.height / original.height
@@ -130,8 +140,21 @@ def tile_overlay(path, boxes, weights):
         summed[y0:y1, x0:x1] += float(weight)
         coverage[y0:y1, x0:x1] += 1
     averaged = summed / np.maximum(coverage, 1)
-    heat = Image.fromarray(colors(relative_scale(averaged)))
-    return Image.blend(image, heat, 0.48)
+    count = reference_count or len(weights)
+    ratio = np.maximum(averaged * count, 1e-12)
+    heat = colors(attention_levels(averaged, count)).astype(np.float32)
+    alpha = np.clip(0.15 + np.abs(np.log2(ratio)) * 0.3, 0.15, 0.75)[..., None]
+    pixels = np.asarray(image, dtype=np.float32) * (1 - alpha) + heat * alpha
+    overlay = Image.fromarray(np.clip(pixels, 0, 255).astype(np.uint8))
+    # Rank outlines are useful only when attention differences are meaningful.
+    if float(np.ptp(weights)) * count >= 0.10:
+        draw = ImageDraw.Draw(overlay)
+        for rank, index in enumerate(np.argsort(-np.asarray(weights), kind='stable')[:3], 1):
+            x0, y0, x1, y1 = boxes[index]
+            rect = (int(x0*sx), int(y0*sy), min(image.width-1, int(x1*sx)-1), min(image.height-1, int(y1*sy)-1))
+            draw.rectangle(rect, outline=(12, 26, 42), width=7)
+            draw.rectangle(rect, outline=(255, 198, 65), width=4)
+    return overlay
 
 
 def patch_view(state, tile_number):
@@ -144,14 +167,13 @@ def patch_view(state, tile_number):
     with Image.open(state['path']) as source:
         tile = source.convert('RGB').crop(box)
     weights = state['attention']['patch'][index]
-    heat = Image.fromarray(colors(relative_scale(weights))).resize(tile.size, Image.Resampling.NEAREST)
-    overlay = Image.blend(tile, heat, 0.48)
+    heat = Image.fromarray(colors(attention_levels(weights, weights.size))).resize(tile.size, Image.Resampling.NEAREST)
+    overlay = Image.blend(tile, heat, 0.65)
     description = (f'T{index + 1} · original box {list(box)} · patch grid '
                    f'{weights.shape[0]} × {weights.shape[1]} · '
                    f'patch weights sum = {float(weights.sum()):.6f}. '
-                   '颜色在当前块内归一化；不能按颜色跨块比较。'
-                   ' / Colors are scaled within this tile only. '
-                   'Small images retain the model’s original black padding.')
+                   f' 均匀权重 = {100/weights.size:.4f}%。'
+                   '所有块采用同一色标：相对均匀权重 0.25×–4×。小图保留模型实际使用的黑色补边。')
     return tile, overlay, description
 
 
@@ -159,10 +181,9 @@ def top_tiles(state, k=4):
     order = np.argsort(-state['attention']['l1'], kind='stable')[:k]
     gallery = []
     for index in order:
-        tile, overlay, _ = patch_view(state, int(index) + 1)
+        tile, _, _ = patch_view(state, int(index) + 1)
         weight = float(state['attention']['l1'][index])
-        gallery.extend([(tile, f'T{index + 1} · L1 weight {weight:.6f}'),
-                        (overlay, f'T{index + 1} · within-tile patch attention')])
+        gallery.append((tile, f'#{len(gallery)+1} · T{index + 1} · 权重 {weight*100:.2f}%'))
     return gallery
 
 
@@ -177,10 +198,9 @@ def head_view(state, selection):
         weights = state['attention']['l1_heads'][index]
         label = f'L1 aggregation head {index + 1}'
     return tile_overlay(state['path'], state['boxes'], weights), (
-        f'{label} · sum = {float(weights.sum()):.6f}. '
-        '蓝→黄表示本图内相对权重低→高；重叠区域取覆盖分块权重的平均值。'
-        ' / Blue→yellow: lower→higher within this image; overlap uses mean weight. '
-        '精确权重见表格 / Exact weights are in the table.')
+        f'{label} · 均匀参照 = {100/len(weights):.2f}%。'
+        '蓝色低于参照，灰色接近参照，橙红色高于参照；重叠区域取覆盖分块的平均权重。'
+        '分块权重不能直接解释为像素级伪造概率。')
 
 
 def parameter_rows(detector, branch, threshold, views):
@@ -195,6 +215,8 @@ def parameter_rows(detector, branch, threshold, views):
         ['Architecture', 'Local tile size', f'{int(detector.model.input_resolution)} × {int(detector.model.input_resolution)}'],
         ['Architecture', 'CLIP patch size', str(visual.conv1.kernel_size[0])],
         ['Architecture', 'Feature dimension', str(detector.model.embed_dim)],
+        ['Architecture', 'Feature extraction layer', str(detector.model.clip_mil_stop_after_block_1based
+              if detector.model.use_clip_intermediate_for_mil else len(visual.transformer.resblocks))],
         ['Architecture', 'L1 across-tile aggregation heads', str(core.level1_aggregate_attn.num_heads)],
         ['Architecture', 'L1 MIL pooling / hidden', f'{mil1.pooling} / {mil1.attn_V.out_features} ({mil1.attn_bag_mode})'],
         ['Architecture', 'L2 MIL pooling / hidden', f'{mil2.pooling} / {mil2.attn_V.out_features} ({mil2.attn_bag_mode})'],
@@ -214,7 +236,7 @@ def public_attention(state):
     weights = state['attention']
     return dict(
         meaning='Relative model attention, not a forgery probability or causal explanation.',
-        display='Each heatmap is min-max scaled independently; overlap uses mean tile weight.',
+        display='Fixed log2 scale relative to uniform 1/N attention: 0.25x to 4x; overlap uses mean tile weight.',
         local_tile_boxes=[list(box) for box in state['boxes']],
         l1_tile_weights=weights['l1'].tolist(),
         l1_aggregation_head_weights=weights['l1_heads'].tolist(),

presentation.py

@@ -0,0 +1,138 @@
+"""Readable presentation of model scores and quantitative attention weights."""
+from html import escape
+import math
+
+import numpy as np
+
+CARD_CSS = '''
+.ltf-card{font-family:ui-sans-serif,system-ui,sans-serif;color:#15243c;line-height:1.5}
+.ltf-card *{box-sizing:border-box}.ltf-eyebrow{font-size:12px;font-weight:750;letter-spacing:.11em;color:#60748c;text-transform:uppercase}
+.ltf-decision{border:1px solid #dce5ef;border-radius:20px;padding:25px;background:#fff;min-height:325px}
+.ltf-decision h2{font-size:25px;line-height:1.25;margin:10px 0 20px;letter-spacing:-.03em}
+.ltf-score{font-size:58px;line-height:1;font-weight:800;letter-spacing:-.06em;color:var(--accent,#087f85)}
+.ltf-score-label{font-size:13px;color:#60748c;margin:8px 0 18px}.ltf-chip{display:inline-block;padding:5px 10px;border-radius:8px;background:#eef3f8;color:#42566e;font-size:12px;font-weight:650;margin-right:5px}
+.ltf-mini{display:flex;align-items:center;gap:8px;margin:12px 0;font-size:13px}.ltf-mini b{width:57px}.ltf-mini>span{flex:1;background:#edf1f6;height:7px;border-radius:5px;overflow:hidden}.ltf-mini i{display:block;background:#14888e;height:100%;border-radius:5px}.ltf-mini em{width:45px;text-align:right;font-style:normal;font-variant-numeric:tabular-nums}
+.ltf-note{font-size:12px;color:#60748c;margin-top:18px}.ltf-wait{color:#405772;font-size:16px;margin:30px 0 10px}
+.ltf-stat-grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;margin:2px 0 20px}.ltf-stat{background:#fff;border:1px solid #dce5ef;padding:17px 20px;border-radius:13px}.ltf-stat strong{display:block;font-size:27px;letter-spacing:-.04em}.ltf-stat span{font-size:12px;color:#60748c}
+.ltf-chart{background:#fff;border:1px solid #dce5ef;border-radius:14px;padding:18px 16px}.ltf-chart h3{font-size:17px;margin:0 0 5px}.ltf-chart p{font-size:12px;color:#60748c;margin:0 0 12px}.ltf-scale{display:flex;justify-content:space-between;font-size:11px;color:#52687e;margin-top:5px}.ltf-colorbar{height:11px;border-radius:5px;background:linear-gradient(90deg,#23395d,#6886ab,#b4bfcb,#f7a342,#ee503c);margin-top:12px}
+.ltf-callout{padding:11px 13px;background:#edf5f8;border-left:3px solid #14888e;border-radius:6px;font-size:12px;color:#33506b;margin-top:12px}
+.ltf-hero{font-family:ui-sans-serif,system-ui,sans-serif;padding:29px 32px;border-radius:20px;background:linear-gradient(110deg,#10243e,#153c51);color:white;margin:0 0 24px}.ltf-card .ltf-hero h1{font-size:31px;margin:10px 0;letter-spacing:-.04em;color:#fff!important}.ltf-card .ltf-hero p{font-size:14px;color:#bed2e3!important;margin:7px 0}.ltf-hero .ltf-eyebrow{color:#75dcd2}.ltf-hero .ltf-chip{background:#ffffff12;color:#d9e9f1;border:1px solid #ffffff18;margin-top:12px}
+@media(max-width:650px){.ltf-stat-grid{grid-template-columns:repeat(2,1fr)}.ltf-hero{padding:22px}.ltf-hero h1{font-size:25px}.ltf-decision{min-height:250px}.ltf-score{font-size:47px}}
+@media(max-width:760px){
+ .gradio-container{padding:14px 12px 35px!important;min-width:0!important;width:100%!important;max-width:100vw!important}
+ .gradio-container .main{padding:0!important;min-width:0!important;width:100%!important}
+ .gradio-container .wrap,.gradio-container .contain{min-width:0!important;max-width:100%!important}
+ .gradio-container .row,.gradio-container .column,.gradio-container .block{min-width:0!important;max-width:100%!important}
+}
+'''
+
+
+def card(content):
+    return f'<style>{CARD_CSS}</style><div class="ltf-card">{content}</div>'
+
+
+HEADER = card('''<div class="ltf-hero"><div class="ltf-eyebrow">LTF / MODEL EXPLORER</div>
+<h1>图像检测与注意力分析</h1><p>上传原图，查看模型分数、分块权重与块内细节。</p>
+<span class="ltf-chip">CLIP ViT-L/14</span><span class="ltf-chip">第 24 层特征</span>
+<span class="ltf-chip">224 × 224 分块</span><span class="ltf-chip">研究演示</span></div>''')
+
+EMPTY_RESULT = card('''<div class="ltf-decision"><div class="ltf-eyebrow">ANALYSIS RESULT</div>
+<h2>等待分析</h2><div class="ltf-wait">上传图片后，点击「开始分析」。</div>
+<p class="ltf-note">这里将显示模型判定、生成分数和三个分支的对比。注意力分析会在下方展开。</p></div>''')
+
+
+def result_card(result):
+    score = float(result['score_fake'])
+    generated = result['label'] == 1
+    accent = '#d75536' if generated else '#087f85'
+    verdict = '生成图' if generated else '真实图'
+    branch = {'fusion': 'Fusion 融合', 'level1': 'L1 局部', 'level2': 'L2 视图'}[result['branch']]
+    bars = ''
+    for key, label in (('fusion', 'Fusion'), ('level1', 'L1'), ('level2', 'L2')):
+        value = result['probabilities'][key]['fake']
+        bars += (f'<div class="ltf-mini"><b>{label}</b><span><i style="width:{value*100:.3f}%"></i></span>'
+                 f'<em>{value:.3f}</em></div>')
+    return card(f'''<div class="ltf-decision" style="--accent:{accent};border-top:4px solid {accent}">
+<div class="ltf-eyebrow">模型判定 · {branch}</div><h2>{verdict}</h2>
+<div class="ltf-score">{score:.3f}</div><div class="ltf-score-label">生成分数 · 阈值 {result['threshold']:.2f}</div>
+{bars}<div class="ltf-note">{result['width']:,} × {result['height']:,} px · {result['views']-1} 个局部分块
+<br>分数是模型输出，未经概率校准；不代表图片来源的确定结论。</div></div>''')
+
+
+def stats_card(state):
+    if not state:
+        return ''
+    attention = state['attention']
+    layer = next((row[2] for row in state['parameters'] if row[1] == 'Feature extraction layer'), '24')
+    stats = [(str(len(state['boxes'])), '局部分块 · 另含 1 个全局视图'),
+             (str(attention['l1_heads'].shape[0]), 'L1 分块聚合 Heads'),
+             (f"{attention['patch'].shape[1]} × {attention['patch'].shape[2]}", '每块 Patch 网格'),
+             (str(layer), 'CLIP 特征层')]
+    return card('<div class="ltf-stat-grid">' + ''.join(
+        f'<div class="ltf-stat"><strong>{escape(value)}</strong><span>{label}</span></div>'
+        for value, label in stats) + '</div>')
+
+
+def scale_legend():
+    return ('<div class="ltf-colorbar"></div><div class="ltf-scale"><span>≤0.25×</span><span>0.5×</span>'
+            '<span>1× 均匀参照</span><span>2×</span><span>≥4×</span></div>')
+
+
+def weight_chart(state, selection='mean', level='l1'):
+    if not state:
+        return ''
+    attention = state['attention']
+    if level == 'l2':
+        weights = attention['l2']
+        labels = ['Global'] + [f'T{i+1}' for i in range(len(weights)-1)]
+        title = 'L2 视图权重'
+    else:
+        weights = attention['l1'] if selection == 'mean' else attention['l1_heads'][int(selection.split('_')[-1])-1]
+        labels = [f'T{i+1}' for i in range(len(weights))]
+        title = 'L1 分块权重 · ' + ('8 Heads 平均' if selection == 'mean' else selection.replace('_', ' '))
+    n = len(weights)
+    order = np.argsort(-weights, kind='stable')[:10]
+    maximum = max(float(weights.max()), 1 / n) * 1.12
+    width, left, track, row_height = 430, 63, 290, 32
+    height = 38 + row_height * len(order)
+    baseline = left + track * (1/n) / maximum
+    svg = [f'<svg viewBox="0 0 {width} {height}" role="img" aria-label="{escape(title)}" style="width:100%;font-family:system-ui,sans-serif">',
+           f'<line x1="{baseline:.2f}" y1="8" x2="{baseline:.2f}" y2="{height-22}" stroke="#8394a8" stroke-dasharray="3 4"/>']
+    for rank, index in enumerate(order):
+        y, value = 12 + rank * row_height, float(weights[index])
+        fill = '#102e4b' if labels[index] == 'Global' else ('#078b93' if rank == 0 else '#66aab1')
+        svg.extend([f'<text x="0" y="{y+15}" fill="#30465e" font-size="13" font-weight="650">{labels[index]}</text>',
+                    f'<rect x="{left}" y="{y}" width="{track}" height="21" rx="4" fill="#edf2f7"/>',
+                    f'<rect x="{left}" y="{y}" width="{track*value/maximum:.3f}" height="21" rx="4" fill="{fill}">'
+                    f'<title>{labels[index]}: {value:.8f} · {value*n:.4f}× uniform</title></rect>',
+                    f'<text x="{left+track+8}" y="{y+15}" fill="#30465e" font-size="12">{value*100:.2f}%</text>'])
+    svg.append(f'<text x="{left}" y="{height-4}" fill="#60748c" font-size="10">虚线 = 均匀分配 {100/n:.2f}% · 最多显示前 10 项</text></svg>')
+    ratio = float(weights.max()) * n
+    message = ('权重接近均匀，当前没有明显的集中区域。热图不会放大微小差异。'
+               if float(np.ptp(weights)) * n < 0.10 else
+               f'最高权重为均匀参照的 {ratio:.2f}×。排名表示注意力权重，不等同于伪造证据。')
+    if level == 'l2':
+        message = f'Global 全局视图占 {float(weights[0])*100:.2f}%；原图叠图仅展示局部分块。' + message
+    return card(f'<div class="ltf-chart"><h3>{title}</h3><p>数值是归一化注意力权重，所有项目之和为 100%。</p>'
+                + ''.join(svg) + scale_legend() + f'<div class="ltf-callout">{message}</div></div>')
+
+
+def patch_matrix(state, tile_number):
+    if not state:
+        return ''
+    from attention import attention_levels, colors
+    index = int(tile_number)-1
+    weights = state['attention']['patch'][index]
+    palette = colors(attention_levels(weights, weights.size))
+    h, w = weights.shape
+    cells = []
+    for y in range(h):
+        for x in range(w):
+            color = '#%02x%02x%02x' % tuple(palette[y, x])
+            value = float(weights[y, x])
+            cells.append(f'<rect x="{x*20}" y="{y*20}" width="20" height="20" fill="{color}" stroke="#ffffff40" stroke-width=".6">'
+                         f'<title>行 {y+1}，列 {x+1} · {value*100:.5f}% · {value*weights.size:.3f}× uniform</title></rect>')
+    return card(f'<div class="ltf-chart"><h3>T{index+1} · Patch 权重矩阵</h3><p>悬停查看原始权重；每格对应 14 × 14 输入像素。</p>'
+                f'<svg viewBox="0 0 {w*20} {h*20}" role="img" aria-label="Patch attention matrix" style="width:100%;max-height:420px">'
+                + ''.join(cells) + '</svg>' + scale_legend()
+                + '<div class="ltf-callout">统一使用「相对均匀权重」色标。灰色接近均匀，蓝色偏低，橙红色偏高。</div></div>')

styles.css

@@ -0,0 +1,38 @@
+:root{color-scheme:light}
+.gradio-container{max-width:1440px!important;margin:auto!important;padding:30px 28px 60px!important;background:#f4f7fb!important;color:#16263d!important;font-family:ui-sans-serif,system-ui,-apple-system,"Segoe UI","Microsoft YaHei",sans-serif!important}
+.block{border-color:#dce5ef!important;border-radius:13px!important;box-shadow:none!important}
+.form{border-color:#dce5ef!important}
+label,.label-wrap{font-weight:650!important}
+#upload-panel{background:#fff;border:1px solid #dce5ef;border-radius:18px;padding:21px;gap:14px;min-width:260px}
+#upload-panel h3{font-size:18px;margin-bottom:6px;color:#18314c}
+#upload-panel .prose p{color:#60748c;font-size:13px}
+#run-button{min-height:51px!important;border-radius:11px!important;font-size:16px!important;font-weight:750!important;background:#087f85!important;color:white!important;border-color:#087f85!important;box-shadow:0 4px 12px #087f8520!important}
+#run-button:hover{background:#06666b!important}
+#original-preview{background:#e9eff5!important}
+#original-preview img,.attention-image img{width:100%!important;height:100%!important;object-fit:contain!important}
+#analysis-section{margin-top:28px;gap:18px}
+#analysis-tabs{background:#fff;border:1px solid #dce5ef;border-radius:16px;padding:16px;overflow:hidden}
+#analysis-tabs .tab-nav{gap:5px;border-bottom:1px solid #e4ebf3;padding-bottom:12px;margin-bottom:18px}
+#analysis-tabs .tab-nav button{padding:12px 18px;border-radius:9px;font-weight:650;color:#4c627b;border:0}
+#analysis-tabs .tab-nav button[aria-selected="true"]{background:#e1f3f2;color:#006d73;box-shadow:inset 0 0 0 1px #b5dcda}
+#analysis-tabs [role="tablist"]{gap:5px;border-bottom:1px solid #e4ebf3;padding-bottom:12px;margin-bottom:18px;flex-wrap:wrap}
+#analysis-tabs [role="tab"]{padding:12px 18px!important;border-radius:9px!important;font-weight:650!important;color:#4c627b!important;border:0!important}
+#analysis-tabs [role="tab"][aria-selected="true"]{background:#e1f3f2!important;color:#006d73!important;box-shadow:inset 0 0 0 1px #b5dcda}
+#analysis-section .prose p{font-size:13px;color:#52687e;line-height:1.65}
+#analysis-section .prose h2{font-size:23px;color:#18314c;margin-top:5px}
+.section-kicker{font-size:13px;color:#13868a;font-weight:750;letter-spacing:.04em;margin-bottom:3px}
+.attention-image{background:#e9eff5!important}
+#top-crops{background:#fff!important}
+#top-crops .caption{font-weight:650!important;font-size:13px!important;background:#fff!important;color:#17334e!important}
+#technical-details{margin-top:22px}
+#footer-note{margin-top:18px;text-align:center;color:#6b7f93;font-size:12px}
+.setting-help{font-size:12px;color:#60748c}
+@media(max-width:760px){.gradio-container{padding:14px 12px 35px!important}#upload-panel{padding:16px}#analysis-tabs{padding:9px}#analysis-tabs .tab-nav button{padding:10px;font-size:12px}#analysis-section{margin-top:18px}}
+@media(max-width:760px){
+ .gradio-container{width:100%!important;min-width:0!important;max-width:100vw!important}
+ .gradio-container .main{min-width:0!important;padding:0!important;width:100%!important}
+ .row,.column,.block{min-width:0!important;max-width:100%!important}
+ #analysis-tabs [role="tablist"]{flex-wrap:wrap!important;min-width:0!important;width:100%}
+ #analysis-tabs [role="tab"]{white-space:normal!important;padding:9px!important;font-size:12px!important}
+ #top-crops [style*="grid-template-columns"]{grid-template-columns:repeat(2,minmax(0,1fr))!important}
+}