@brainpilot/skills 0.0.6

package/skills/13_Visualization/nature-figure/assets/figures4papers/figure_RNAGenScape/plot_manifold.py

@@ -0,0 +1,61 @@
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def function(x, y):
+    z = 0.6 * np.exp(-((x - 1)**2 + (y + 1)**2))
+    z += 0.5 * np.exp(-((x - 1)**2 + (y - 4)**2))
+    z += 0.3 * np.exp(-((x - 2)**2 + (y - 2)**2))
+    z += 0.2 * np.exp(-((x + 3)**2 + (y + 1)**2))
+    z += 0.3 * np.exp(-((x + 1)**2 + (y + 1)**2))
+    z -= 0.1 * np.exp(-((x + 1)**2 + (y - 2)**2))
+    z += 0.3 * np.exp(-((x + 2)**2 + (y - 2)**2))
+    z += 0.3 * np.exp(-((x + 2)**2 + (y - 1)**2))
+    return z
+
+if __name__ == '__main__':
+    # Generate coordinates
+    x = np.linspace(-3, 3, 200)
+    y = np.linspace(-3, 3, 200)
+    x, y = np.meshgrid(x, y)
+
+    # Define a multi-well "energy" function (inverted to form valleys)
+    z = function(x, y)
+
+    # Set up plot
+    fig = plt.figure(figsize=(10, 7))
+    ax = fig.add_subplot(1, 1, 1, projection='3d')
+
+    # Plot the surface with smooth shading
+    ax.plot_surface(
+        x, y, z,
+        cmap='coolwarm',
+        edgecolor='none',
+        linewidth=0,
+        antialiased=True,
+        alpha=0.95,
+    )
+
+    # # Plot descent path
+    # path_x = np.linspace(-2.5, 1, 100)
+    # path_y = np.linspace(2.5, -1, 100)
+    # path_z = function(path_x, path_y)
+    # ax.plot(path_x, path_y, path_z, color='red', linestyle='--', linewidth=3)
+
+    # Aesthetics
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_zticks([])
+    ax.xaxis.pane.set_visible(False)
+    ax.yaxis.pane.set_visible(False)
+    ax.zaxis.pane.set_visible(False)
+    ax.xaxis.line.set_color((0.0, 0.0, 0.0, 0.0))
+    ax.yaxis.line.set_color((0.0, 0.0, 0.0, 0.0))
+    ax.zaxis.line.set_color((0.0, 0.0, 0.0, 0.0))
+    ax.set_box_aspect([1, 1, 0.5])
+    ax.view_init(elev=20, azim=50)
+
+    fig.tight_layout(pad=2)
+    os.makedirs('./figures', exist_ok=True)
+    fig.savefig('./figures/manifold.png')

package/skills/13_Visualization/nature-figure/assets/figures4papers/figure_RNAGenScape/plot_sweep.py

@@ -0,0 +1,77 @@
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.ticker import MaxNLocator
+
+
+# results_increase = {
+#     r'Median property change': [0.1125, 0.44046, 0.46006, 0.45625, 0.46510],
+#     r'Percentage improved $\uparrow$': [55.15, 70.11, 71.02, 71.46, 71.52],
+#     r'Latent space distance $\downarrow$': [0.11868, 0.11877, 0.11961, 0.11964, 0.11999],
+# }
+# results_decrease = {
+#     r'Median property change': [-1.1246, -1.5761, -1.62873, -1.65457, -1.65872],
+#     r'Percentage improved $\uparrow$': [79.39, 86.31, 87.08, 87.24, 87.01],
+#     r'Latent space distance $\downarrow$': [0.16017, 0.12758, 0.12141, 0.12024, 0.12015],
+# }
+results_increase = {
+  r'Median change in property': [0.292, 0.5047563, 0.57401, 0.55921, 0.5471513271],
+  r'Success rate $\uparrow$': [67.6, 77.3, 79.9, 79.4, 79.6],
+}
+results_decrease = {
+  r'Median change in property': [-0.90106, -1.27954, -1.3083, -1.2785, -1.29],
+  r'Success rate $\uparrow$': [75.9, 84.7, 84.9, 84.7, 85.1],
+}
+
+
+if __name__ == '__main__':
+    plt.rcParams['text.usetex'] = True
+    plt.rcParams['font.family'] = 'helvetica'
+    plt.rcParams['font.size'] = 15
+    plt.rcParams['axes.spines.right'] = False
+    plt.rcParams['axes.spines.top'] = False
+    plt.rcParams['axes.linewidth'] = 2
+
+    x_label = 'Optimization step'
+    x_values = [1, 5, 10, 20, 40]
+
+    keys = ['Median change in property', 'Success rate']
+    fig = plt.figure(figsize=(4.5 * len(keys), 4))
+    for fig_idx, y_key in enumerate(keys):
+        ax = fig.add_subplot(1, len(keys), fig_idx + 1)
+        for key in results_increase.keys():
+            if y_key in key:
+                y_values_increase = results_increase[key]
+                y_label_increase = key
+        for key in results_decrease.keys():
+            if y_key in key:
+                y_values_decrease = results_decrease[key]
+                y_label_decrease = key
+
+        #0F4D92
+        ax.plot(x_values,
+                y_values_increase,
+                linestyle='-', linewidth=3,
+                marker='o', markersize=8,
+                label='increase property',
+                alpha=0.8,
+                color="#ea84dd")
+        ax.plot(x_values,
+                y_values_decrease,
+                linestyle='-', linewidth=3,
+                marker='o', markersize=8,
+                label='decrease property',
+                alpha=0.8,
+                color="#0f4d92")
+        if fig_idx == 1:
+            ax.set_ylim([0, 100])
+        ax.set_xticks(x_values)
+        ax.set_xlabel(x_label, fontsize=16)
+        ax.set_ylabel(y_label_increase, fontsize=16)
+        ax.yaxis.set_major_locator(MaxNLocator(nbins=5))
+        if fig_idx == len(keys) - 1:
+            ax.legend(loc='lower right', frameon=False)
+
+    fig.tight_layout(pad=1)
+    os.makedirs('./figures', exist_ok=True)
+    fig.savefig('./figures/results_sweep.png', dpi=300)

package/skills/13_Visualization/nature-figure/assets/figures4papers/figure_VIGIL/plot_comparison_radar.py

@@ -0,0 +1,173 @@
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+
+
+data_comparison = {
+    'methods': [
+        r'DPO',
+        r'DA-DPO',
+        r'VIGIL (Ours)',
+    ],
+    'colors': [
+        "#D88F8A",
+        "#8BCF8B",
+        "#0F4D92"
+    ],
+    'results': {
+        'Qwen2.5-VL-7B\nPOPE$_{Adv}$': np.array([82.8, 84.2, 86.9]),
+        'LLaVA-OneVision-7B\nPOPE$_{Adv}$': np.array([82.8, 84.2, 86.9]),
+        'InternVL2.5-26B\nPOPE$_{Adv}$': np.array([85.5, 86.8, 89.4]),
+        'Qwen2.5-VL-72B\nPOPE$_{Adv}$': np.array([84.5, 87.4, 89.8]),
+        'Qwen2.5-VL-7B\nMathVista': np.array([48.0, 48.8, 49.5]),
+        'LLaVA-OneVision-7B\nMathVista': np.array([50.8, 51.5, 52.8]),
+        'InternVL2.5-26B\nMathVista': np.array([57.9, 58.8, 60.1]),
+        'Qwen2.5-VL-72B\nMathVista': np.array([54.1, 55.4, 56.6]),
+        'Qwen2.5-VL-7B\nMMBench': np.array([71.2, 72.0, 72.5]),
+        'LLaVA-OneVision-7B\nMMBench': np.array([72.5, 73.0, 73.8]),
+        'InternVL2.5-26B\nMMBench': np.array([79.5, 80.1, 81.3]),
+        'Qwen2.5-VL-72B\nMMBench': np.array([77.2, 77.8, 78.5]),
+    },
+}
+
+
+def _task_suffix(subtask_name):
+    """Benchmark = part after the first newline (e.g. 'Qwen2.5-VL-7B\\nMathVista' -> 'MathVista')."""
+    return subtask_name.split('\n', 1)[-1] if '\n' in subtask_name else subtask_name
+
+
+def plot_radar(data_comparison):
+    """
+    Single radar chart. Each axis = one subtask; one curve per method.
+    Each benchmark (task suffix after \\n) has its own radii list: values are normalized
+    to display range 45-90 using that benchmark's min/max from its radii list, and
+    radius labels on each spoke show that benchmark's tick values.
+    """
+    methods = data_comparison['methods']
+    colors = data_comparison['colors']
+    n_methods = len(methods)
+    benchmark_radii = {
+        'POPE$_{Adv}$': [75, 80, 85, 91],
+        'MathVista': [30, 40, 50, 61],
+        'MMBench': [40, 55, 70, 85],
+    }
+
+    # results is directly subtask_name -> value array
+    task_dict = data_comparison['results']
+    subtask_names = list(task_dict.keys())
+    value_arrays = list(task_dict.values())
+
+    fig = plt.figure(figsize=(12, 10))
+    ax = fig.add_subplot(111, projection='polar')
+    n_subtasks = len(subtask_names)
+    subtask_benchmarks = [_task_suffix(st) for st in subtask_names]
+
+    # Per-benchmark (r_min, r_max) from that benchmark's radii list
+    def limits_for_benchmark(bench):
+        radii = benchmark_radii.get(bench, [0, 100])
+        return (min(radii), max(radii))
+
+    # One polygon per method: normalize each spoke by its benchmark's radii range, then map to 45-90
+    angles = np.linspace(2 * np.pi, 0, n_subtasks, endpoint=False)
+    angles_closed = np.append(angles, angles[0])
+
+    for m in range(n_methods):
+        vals = np.array([v[m] for v in value_arrays], dtype=float)
+        mask = np.isnan(vals)
+        if np.any(mask):
+            vals = vals.copy()
+            fill = 0.0 if np.all(mask) else np.nanmean(vals)
+            vals[mask] = fill
+        # Normalize per spoke: benchmark's (r_min, r_max) -> display 45-90. One vertex per subtask (no interpolation).
+        normalized = np.zeros_like(vals)
+        for i, (v, bench) in enumerate(zip(vals, subtask_benchmarks)):
+            r_lo, r_hi = limits_for_benchmark(bench)
+            span = r_hi - r_lo
+            if span <= 0:
+                normalized[i] = 45 + 45 * 0.5
+            else:
+                n = np.clip((v - r_lo) / span, 0.0, 1.0)
+                normalized[i] = 45 + 45 * n
+        # Closed polygon: exact data at each angle, then back to first (no extra interpolation)
+        vals_closed = np.append(normalized, normalized[0])
+        ax.plot(angles_closed, vals_closed, color=colors[m], linewidth=2, label=methods[m])
+        ax.fill(angles_closed, vals_closed, color=colors[m], alpha=0.05)
+        # Mark actual vertices so it's clear each point is a real data value
+        ax.scatter(angles, normalized, color=colors[m], s=18, zorder=5, edgecolors='none')
+
+    ax.set_ylim(45, 90)
+    ax.set_theta_zero_location('N')
+    for spine in ax.spines.values():
+        spine.set_visible(False)
+    r_min_disp, r_max_disp = ax.get_ylim()
+    ax.grid(False)
+    # Outer boundary
+    ax.plot(angles_closed, np.full_like(angles_closed, r_max_disp), color='k', linewidth=0.8, zorder=4)
+    # Radial spokes: one per angle
+    for a in angles:
+        ax.plot([a, a], [r_min_disp, r_max_disp], color='gray', linewidth=0.5, zorder=4)
+    # Benchmark-specific contour polygons: one polygon per level index k (innermost=0, ...).
+    max_levels = max(len(benchmark_radii.get(b, [])) for b in subtask_benchmarks)
+    for k in range(max_levels):
+        display_radii = np.zeros(n_subtasks)
+        for i, bench in enumerate(subtask_benchmarks):
+            radii_list = benchmark_radii.get(bench, [])
+            if not radii_list:
+                display_radii[i] = 45 + 22.5
+                continue
+            contour_val = radii_list[k] if k < len(radii_list) else radii_list[-1]
+            r_lo, r_hi = limits_for_benchmark(bench)
+            span = r_hi - r_lo
+            if span <= 0:
+                display_radii[i] = 45 + 22.5
+            else:
+                frac = (contour_val - r_lo) / span
+                display_radii[i] = 45 + 45 * np.clip(frac, 0.0, 1.0)
+        contour_closed = np.append(display_radii, display_radii[0])
+        ax.plot(angles_closed, contour_closed, color='k', linewidth=0.6, zorder=4, label='_nolegend_')
+    ax.set_yticks([r_max_disp])
+    ax.set_yticklabels([])
+    ax.set_rlabel_position(0)
+    ax.set_xticks(angles)
+    ax.set_xticklabels([])
+    # Per-spoke radius labels: skip innermost tick to avoid clutter
+    for angle, bench in zip(angles, subtask_benchmarks):
+        radii_list = benchmark_radii.get(bench, [])
+        if len(radii_list) <= 1:
+            continue
+        r_lo, r_hi = limits_for_benchmark(bench)
+        span = r_hi - r_lo
+        for tick_val in radii_list[1:]:  # skip innermost (smallest) number
+            if span <= 0:
+                display_r = 45 + 22.5
+            else:
+                frac = (tick_val - r_lo) / span
+                display_r = 45 + 45 * np.clip(frac, 0.0, 1.0)
+            lbl = f'{tick_val:.0f}' if tick_val == int(tick_val) else f'{tick_val:.1f}'
+            rot = np.degrees(angle)
+            ax.text(angle, display_r + 1, lbl, fontsize=12, ha='center', va='center',
+                    rotation=rot, rotation_mode='anchor',
+                    transform=ax.transData, clip_on=False)
+    # One label per subtask (angle)
+    for angle, label in zip(angles, subtask_names):
+        offset = 8 + 10 * np.abs(np.sin(angle))
+        label_r = r_max_disp + offset
+        ax.text(angle, label_r, label, fontsize=14, ha='center', va='center',
+                transform=ax.transData, clip_on=False, fontfamily='monospace')
+    ax.legend(loc='upper right', bbox_to_anchor=(1.40, 0.05), fontsize=15, frameon=False)
+
+    fig.tight_layout(pad=2)
+    os.makedirs('./figures/', exist_ok=True)
+    fig.savefig('./figures/comparison_radar.png', dpi=300, bbox_inches='tight')
+    plt.close(fig)
+    return
+
+
+if __name__ == '__main__':
+    plt.rcParams['font.family'] = 'helvetica'
+    plt.rcParams['font.size'] = 24
+    plt.rcParams['axes.spines.right'] = False
+    plt.rcParams['axes.spines.top'] = False
+    plt.rcParams['axes.linewidth'] = 3
+
+    plot_radar(data_comparison)

package/skills/13_Visualization/nature-figure/assets/figures4papers/figure_VIGIL/plot_posttraining.py

@@ -0,0 +1,82 @@
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib import gridspec as gridspec
+from matplotlib.collections import LineCollection
+from matplotlib.colors import to_rgba
+from matplotlib.lines import Line2D
+
+
+data_posttraining = {
+    'methods': [
+        'DPO',
+        'DA-DPO',
+        'VIGIL (Ours)',
+    ],
+    'colors': [
+        "#D88F8A",
+        "#8BCF8B",
+        "#0F4D92"
+    ],
+    'steps': [0, 200, 400, 600, 800],
+    'results': np.array([
+        [22.0, 25.5, 28.2, 29.5, 30.2],
+        [22.0, 33.5, 38.2, 39.8, 40.5],
+        [22.0, 52.5, 56.8, 57.9, 58.5],
+    ]),
+}
+
+
+def plot_curves(data_posttraining):
+    methods = data_posttraining['methods']
+    colors = data_posttraining['colors']
+
+    fig = plt.figure(figsize=(9, 8))
+    ax = fig.add_subplot(1, 1, 1)
+    y_ticks = [0, 20, 40, 60]
+    x = np.asarray(data_posttraining['steps'])
+    results = data_posttraining['results'] # shape (n_methods, n_steps)
+    x_pos = np.arange(len(x))
+    ax.axhline(y=results[0][0], color='black', alpha=0.3, linewidth=4, linestyle='--')
+    for m, (method, color) in enumerate(zip(methods, colors)):
+        y = results[m]
+        # Segments with alpha increasing left to right
+        pts = np.column_stack([x_pos, y])
+        segments = np.stack([pts[:-1], pts[1:]], axis=1)
+        n_seg = len(segments)
+        alphas = np.linspace(0.3, 0.9, n_seg)
+        rgb = np.array(to_rgba(color))
+        seg_colors = [(*rgb[:3], a) for a in alphas]
+        lc = LineCollection(segments, colors=seg_colors, linewidths=3, capstyle='round')
+        ax.add_collection(lc)
+        ax.plot(x_pos, y, color=color, linewidth=0, marker='o', markersize=10, label='_nolegend_')
+
+    # Legend with line + marker for each method
+    handles = [ Line2D([0], [0], color='black', linestyle='--', linewidth=4, alpha=0.3, label='SFT only')]
+    for method, color in zip(methods, colors):
+        handles.append(Line2D([0], [0], color=color, linewidth=3, marker='o', markersize=10, label=method))
+    ax.legend(handles=handles, fontsize=20, loc='lower right', ncols=2, frameon=False)
+
+    ax.set_xlabel('Post-training steps', fontsize=28, fontfamily='helvetica', labelpad=12)
+    ax.set_xticks(x_pos)
+    ax.set_xticklabels([str(b) for b in x])
+    ax.set_ylabel('Performance on highly\nvision-dependent tasks' + r'$\uparrow$', fontsize=28, fontfamily='helvetica', labelpad=12)
+    ax.set_yticks(y_ticks)
+    ax.set_yticklabels(y_ticks)
+    ax.tick_params(labelsize=20, length=8, width=1.5)
+
+    fig.tight_layout(pad=2)
+    os.makedirs('./figures/', exist_ok=True)
+    fig.savefig('./figures/comparison_posttraining.png', dpi=300)
+    plt.close(fig)
+    return
+
+
+if __name__ == '__main__':
+    plt.rcParams['font.family'] = 'helvetica'
+    plt.rcParams['font.size'] = 24
+    plt.rcParams['axes.spines.top'] = False
+    plt.rcParams['axes.spines.right'] = False
+    plt.rcParams['axes.linewidth'] = 3
+
+    plot_curves(data_posttraining)

package/skills/13_Visualization/nature-figure/assets/figures4papers/figure_brainteaser/plot_brute_force.py

@@ -0,0 +1,248 @@
+import os
+import numpy as np
+from matplotlib import pyplot as plt
+from matplotlib import gridspec as gridspec
+from matplotlib import patheffects as path_effects
+
+
+data_brute_force_math = {
+    'methods': [
+        r'DeepSeek R1 Distill Qwen 1.5B',
+        r'DeepSeek R1 Distill Qwen 14B',
+        r'DeepSeek R1 Distill Llama 70B',
+        r'deepseek-chat (Deepseek-V3)',
+        r'deepseek-reasoner (Deepseek-R1)',
+        r'gemini-2.5-flash-preview-04-17',
+        r'OpenAI o3'
+    ],
+    'colors': ['#DDF3DE', '#AADCA9', '#8BCF8B', '#F6CFCB', '#E9A6A1', '#FFF6CC', '#3775BA'],
+    'prompts': ['CoT Prompt', 'Math Prompt', 'Hint Prompt', 'Math + Hint'],
+    'subtypes': [r'$\bf{Only}$ $\bf{Model}$ brute force',
+                 r'$\bf{Only}$ $\bf{Human}$ brute force',
+                 r'$\bf{Neither}$ brute force',
+                 r'$\bf{Both}$ brute force'],
+    'hatch_styles': ['/', '\\', '', 'x'],
+    'result': {
+        'CoT Prompt': np.array([[26.8, 3.6, 60.0, 9.6],
+                                [27.6, 3.2, 59.2, 10.0],
+                                [24.4, 4.0, 62.4, 9.2],
+                                [31.2, 3.6, 55.6, 9.6],
+                                [14.0, 7.2, 72.8, 6.0],
+                                [16.9, 5.9, 70.0, 7.2],
+                                [9.5, 7.5, 79.4, 3.5]]) / 100,
+        'Math Prompt': np.array([[27.2, 4.8, 59.6, 8.4],
+                                 [25.6, 4.8, 61.2, 8.4],
+                                 [24.4, 4.8, 62.4, 8.4],
+                                 [28.4, 3.2, 58.4, 10.0],
+                                 [10.0, 5.6, 76.7, 7.6],
+                                 [12.6, 5.2, 74.8, 7.4],
+                                 [4.2, 7.9, 85.7, 2.1]]) / 100,
+        'Hint Prompt': np.array([[29.6, 4.4, 57.2, 8.8],
+                                 [27.6, 2.8, 59.2, 10.4],
+                                 [20.4, 5.2, 66.4, 8.0],
+                                 [28.0, 3.2, 58.8, 10.0],
+                                 [14.0, 6.0, 72.8, 7.2],
+                                 [12.4, 5.1, 74.4, 8.1],
+                                 [6.8, 6.8, 83.2, 3.1]]) / 100,
+        'Math + Hint': np.array([[26.4, 4.0, 60.4, 9.2],
+                                 [27.6, 3.2, 59.2, 10.0],
+                                 [24.0, 4.8, 62.8, 8.4],
+                                 [25.2, 2.8, 61.6, 10.4],
+                                 [8.0, 6.8, 78.8, 6.4],
+                                 [10.0, 6.1, 76.4, 7.4],
+                                 [3.7, 6.4, 86.7, 3.2]]) / 100,
+    },
+}
+
+data_brute_force_logic = {
+    'methods': [
+        r'DeepSeek R1 Distill Qwen 1.5B',
+        r'DeepSeek R1 Distill Qwen 14B',
+        r'DeepSeek R1 Distill Llama 70B',
+        r'deepseek-chat (Deepseek-V3)',
+        r'deepseek-reasoner (Deepseek-R1)',
+        r'gemini-2.5-flash-preview-04-17',
+        r'OpenAI o3'
+    ],
+    'colors': ['#DDF3DE', '#AADCA9', '#8BCF8B', '#F6CFCB', '#E9A6A1', '#FFF6CC', '#3775BA'],
+    'prompts': ['CoT Prompt', 'Math Prompt', 'Hint Prompt', 'Math + Hint'],
+    'subtypes': [r'$\bf{Only}$ $\bf{Model}$ brute force',
+                 r'$\bf{Only}$ $\bf{Human}$ brute force',
+                 r'$\bf{Neither}$ brute force',
+                 r'$\bf{Both}$ brute force'],
+    'hatch_styles': ['/', '\\', '', 'x'],
+    'result': {
+        'CoT Prompt': np.array([[18.0, 5.2, 72.0, 4.8],
+                                [30.8, 3.2, 59.2, 6.8],
+                                [23.2, 2.8, 66.8, 7.2],
+                                [32.4, 3.6, 57.6, 6.4],
+                                [13.7, 6.8, 76.7, 2.8],
+                                [15.7, 3.2, 75.6, 5.5],
+                                [15.9, 6.5, 75.6, 2.0]]) / 100,
+        'Math Prompt': np.array([[20.0, 4.4, 70.0, 5.6],
+                                 [31.2, 4.0, 58.8, 6.0],
+                                 [24.4, 4.0, 65.6, 6.0],
+                                 [33.6, 3.6, 56.4, 6.4],
+                                 [12.4, 7.6, 77.6, 2.4],
+                                 [15.2, 5.5, 75.7, 3.7],
+                                 [10.5, 6.2, 80.9, 2.4]]) / 100,
+        'Hint Prompt': np.array([[15.6, 4.8, 74.4, 5.2],
+                                 [30.4, 3.2, 59.6, 6.8],
+                                 [25.2, 2.8, 64.8, 7.2],
+                                 [27.6, 2.8, 62.4, 7.2],
+                                 [9.6, 6.0, 80.7, 3.6],
+                                 [14.3, 4.5, 75.8, 5.4],
+                                 [6.9, 5.9, 84.8, 2.5]]) / 100,
+        'Math + Hint': np.array([[20.0, 3.2, 70.0, 6.8],
+                                 [32.0, 4.8, 58.0, 5.2],
+                                 [19.6, 4.0, 70.4, 6.0],
+                                 [26.0, 4.0, 64.0, 6.0],
+                                 [8.8, 5.6, 81.5, 4.0],
+                                 [13.0, 5.3, 76.8, 4.8],
+                                 [5.1, 7.4, 86.5, 0.9]]) / 100,
+    },
+}
+
+if __name__ == '__main__':
+    plt.rcParams['font.family'] = 'helvetica'
+    plt.rcParams['font.size'] = 24
+    plt.rcParams['axes.spines.right'] = False
+    plt.rcParams['axes.spines.top'] = False
+    plt.rcParams['axes.linewidth'] = 3
+
+    fig = plt.figure(figsize=(52, 12))
+
+    gs = gridspec.GridSpec(2, 5)
+
+    for prompt_idx, prompt_name in enumerate(data_brute_force_math['prompts']):
+        ax = fig.add_subplot(gs[prompt_idx])
+        num_methods = len(data_brute_force_math['methods'])
+        bars = ax.bar(
+            np.arange(num_methods),
+            data_brute_force_math['result'][prompt_name][:, 0],
+            color=data_brute_force_math['colors'],
+            label=data_brute_force_math['methods'],
+            hatch=data_brute_force_math['hatch_styles'][0],
+            edgecolor='black',
+            linewidth=2,
+        )
+
+        for bar in bars:
+            height = bar.get_height()
+            text = ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                height / 2,
+                f'{height:.3f}',
+                ha='center',
+                va='center',
+                color='#FFD700',
+                fontsize=20,
+                path_effects=[
+                    path_effects.Stroke(linewidth=4, foreground='black'),
+                    path_effects.Normal()
+                ]
+            )
+
+        for subtype_idx in range(1, len(data_brute_force_math['subtypes'])):
+            ax.bar(
+                np.arange(num_methods),
+                data_brute_force_math['result'][prompt_name][:, subtype_idx],
+                color=data_brute_force_math['colors'],
+                label=data_brute_force_math['methods'],
+                hatch=data_brute_force_math['hatch_styles'][subtype_idx],
+                bottom=np.cumsum(data_brute_force_math['result'][prompt_name], axis=1)[:, subtype_idx - 1],
+                edgecolor='black',
+                linewidth=2,
+                alpha=0.8,
+            )
+
+        ax.set_title(data_brute_force_math['prompts'][prompt_idx], fontsize=36, pad=36)
+        ax.set_ylabel('Probability', fontsize=30, labelpad=12)
+        ax.set_ylim([0, 1.01])
+        ax.set_xticks([])
+
+    ax = fig.add_subplot(gs[4])
+    bar = ax.bar(
+        np.arange(num_methods),
+        np.ones_like(np.arange(num_methods)),
+        color=data_brute_force_math['colors'],
+        label=data_brute_force_math['methods'],
+        hatch='',
+        edgecolor='black',
+        linewidth=3,
+    )
+    handles, labels = ax.get_legend_handles_labels()
+    for b in bar:
+        b.remove()
+    ax.legend(handles, labels, fontsize=30, loc='center', frameon=False)
+    ax.set_axis_off()
+
+    for prompt_idx, prompt_name in enumerate(data_brute_force_logic['prompts']):
+        ax = fig.add_subplot(gs[prompt_idx + 5])
+        num_methods = len(data_brute_force_logic['methods'])
+        bars = ax.bar(
+            np.arange(num_methods),
+            data_brute_force_logic['result'][prompt_name][:, 0],
+            color=data_brute_force_logic['colors'],
+            label=data_brute_force_logic['methods'],
+            hatch=data_brute_force_logic['hatch_styles'][0],
+            edgecolor='black',
+            linewidth=2,
+        )
+
+        for bar in bars:
+            height = bar.get_height()
+            text = ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                height / 2,
+                f'{height:.3f}',
+                ha='center',
+                va='center',
+                color='#FFD700',
+                fontsize=20,
+                path_effects=[
+                    path_effects.Stroke(linewidth=4, foreground='black'),
+                    path_effects.Normal()
+                ]
+            )
+
+        for subtype_idx in range(1, len(data_brute_force_logic['subtypes'])):
+            ax.bar(
+                np.arange(num_methods),
+                data_brute_force_logic['result'][prompt_name][:, subtype_idx],
+                color=data_brute_force_logic['colors'],
+                label=data_brute_force_logic['methods'],
+                hatch=data_brute_force_logic['hatch_styles'][subtype_idx],
+                bottom=np.cumsum(data_brute_force_logic['result'][prompt_name], axis=1)[:, subtype_idx - 1],
+                edgecolor='black',
+                linewidth=2,
+                alpha=0.8,
+            )
+
+        ax.set_title(data_brute_force_logic['prompts'][prompt_idx], fontsize=36, pad=36)
+        ax.set_ylabel('Probability', fontsize=30, labelpad=12)
+        ax.set_ylim([0, 1.01])
+        ax.set_xticks([])
+
+    ax = fig.add_subplot(gs[9])
+    num_subtypes = len(data_brute_force_math['subtypes'])
+    bar = ax.bar(
+        np.arange(num_subtypes),
+        np.ones_like(np.arange(num_subtypes)),
+        color='white',
+        label=data_brute_force_math['subtypes'],
+        hatch=data_brute_force_math['hatch_styles'],
+        edgecolor='black',
+        linewidth=3,
+    )
+    handles, labels = ax.get_legend_handles_labels()
+    for b in bar:
+        b.remove()
+    ax.legend(handles, labels, fontsize=30, loc='center', frameon=False)
+    ax.set_axis_off()
+
+    fig.tight_layout(pad=2)
+
+    os.makedirs('./figures/', exist_ok=True)
+    fig.savefig('./figures/brute_force.png', dpi=300)
+    plt.close(fig)