@researai/deepscientist 1.5.16 → 1.6.0

package/src/skills/paper-plot/scripts/line_aime.py

@@ -0,0 +1,94 @@
+"""
+Reproduce: image6.png — AIME avg@32 training curve
+Two lines with vertical breakpoint markers + horizontal reference line.
+Style: sans-serif, 4-spine box, no grid, right-bottom legend.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.lines as mlines
+
+plt.rcParams.update({
+    'font.family': 'sans-serif',
+    'font.sans-serif': ['DejaVu Sans', 'Arial', 'Helvetica'],
+    'text.usetex': False,
+})
+
+rng = np.random.default_rng(42)
+
+# ---- Synthetic data ----
+# w/ Dynamic Sampling (purple): 0-2200 steps, rises fast, ends ~0.42
+steps_dyn_a = np.arange(0, 2300, 50)
+y_dyn_a = 0.43 * (1 - np.exp(-steps_dyn_a / 600))
+y_dyn_a += rng.normal(0, 0.012, len(steps_dyn_a))
+y_dyn_a = np.clip(y_dyn_a, 0, 0.45)
+y_dyn_a[:2] = [0.03, 0.03]   # cold start
+
+# w/o Dynamic Sampling (cyan): 0-9000, slower rise, peaks ~0.42 at step 6000, then drops
+steps_nodyn = np.arange(0, 9100, 100)
+y_nodyn = 0.38 * (1 - np.exp(-steps_nodyn / 1200))
+y_nodyn += rng.normal(0, 0.012, len(steps_nodyn))
+y_nodyn = np.clip(y_nodyn, 0, 0.44)
+y_nodyn[:2] = [0.01, 0.02]
+# After step 6000, add gradual decline
+mask = steps_nodyn > 6000
+y_nodyn[mask] -= 0.06 * (steps_nodyn[mask] - 6000) / 3000
+
+C_DYN   = '#5B0DAD'   # deeper purple, closer to the source figure
+C_NODYN = '#5BBCCA'   # soft teal
+C_REF   = '#3D78C2'   # separate blue for the horizontal reference line
+STEP_DYN  = 2200      # purple vertical marker
+STEP_NODYN = 6050     # teal vertical marker
+REF_Y = 0.43          # horizontal reference line
+
+fig, ax = plt.subplots(figsize=(9.0, 4.8))
+
+# ---- Main curves ----
+ax.plot(steps_dyn_a, y_dyn_a, color=C_DYN, lw=1.4, zorder=3, label='w/ Dynamic Sampling')
+ax.plot(steps_nodyn, y_nodyn, color=C_NODYN, lw=1.4, zorder=3, label='w/o Dynamic Sampling')
+
+# ---- Horizontal reference line ----
+ax.axhline(REF_Y, color=C_REF, lw=1.5, linestyle='--', zorder=2)
+
+# ---- Vertical dashed markers ----
+ax.axvline(STEP_DYN, color=C_DYN, lw=1.5, linestyle='--', alpha=0.85, zorder=2)
+ax.axvline(STEP_NODYN, color=C_NODYN, lw=1.5, linestyle='--', alpha=0.85, zorder=2)
+
+# ---- Axes styling ----
+ax.set_xlim(-100, 9200)
+ax.set_ylim(-0.01, 0.47)
+ax.set_xticks([0, 2000, 4000, 6000, 8000])
+ax.set_xticklabels(['0', '2000', '4000', '6000', '8000'], fontsize=10)
+ax.set_yticks([0.0, 0.1, 0.2, 0.3, 0.4])
+ax.tick_params(labelsize=10, direction='out', length=4, width=0.8)
+ax.set_xlabel('Step', fontsize=12)
+ax.set_ylabel('AIME avg@32', fontsize=12)
+
+# Full box frame (all spines visible)
+for sp in ax.spines.values():
+    sp.set_visible(True)
+    sp.set_linewidth(1.0)
+
+ax.grid(False)
+
+# ---- Legend ----
+leg = ax.legend(
+    loc='lower right',
+    fontsize=9.5,
+    frameon=True,
+    facecolor='white',
+    edgecolor='#AAAAAA',
+    framealpha=1.0,
+    borderpad=0.5,
+    labelspacing=0.3,
+    handlelength=2.0,
+    handletextpad=0.5,
+)
+
+fig.tight_layout(pad=0.8)
+fig.savefig(
+    '/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/line_aime_repro.png',
+    dpi=300, facecolor='white',
+)
+plt.close(fig)
+print('saved: line_aime_repro.png')

package/src/skills/paper-plot/scripts/line_loss_inset.py

@@ -0,0 +1,157 @@
+"""
+Reproduce: image10.png — Loss curve with zoom inset (SiameseNorm paper style)
+Main plot: L-shaped spine (left+bottom) + axis arrows, 3 lines.
+Inset: zoomed blue+green in right panel.
+Style: serif, tab10 colors, black dashed connection lines.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.patches as mpatches
+from matplotlib.patches import ConnectionPatch, FancyArrowPatch
+from mpl_toolkits.axes_grid1.inset_locator import mark_inset, inset_axes
+
+plt.rcParams.update({
+    'text.usetex': True,
+    'font.family': 'serif',
+    'font.serif': ['Computer Modern Roman', 'STIX Two Text', 'DejaVu Serif'],
+    'axes.unicode_minus': False,
+})
+
+rng = np.random.default_rng(7)
+
+# ---- Synthetic data ----
+steps = np.arange(0, 5600, 20)
+
+# HybridNorm (orange): exponential decay to ~8, spike at ~1900, then flat ~8
+y_hybrid = 7.5 * np.exp(-steps / 450) + 2.8
+y_hybrid += rng.normal(0, 0.06, len(steps))
+spike_idx = np.searchsorted(steps, 1880)
+spike_end = np.searchsorted(steps, 1940)
+y_hybrid[spike_idx:spike_end] = np.linspace(y_hybrid[spike_idx - 1], 15.5, spike_end - spike_idx)
+after_spike = np.searchsorted(steps, 1940)
+y_hybrid[after_spike:] = 7.8 + rng.normal(0, 0.07, len(steps[after_spike:]))
+
+# HybridNorm-ResiDual (blue): rapid decay + noisy with prominent spikes
+y_blue = 7.8 * np.exp(-steps / 380) + 2.3
+y_blue += rng.normal(0, 0.18, len(steps))
+mask_noisy = steps > 2300
+# Simulate a visible blue-line peak after roughly step 2300, matching the source figure
+noise_large = rng.normal(0, 1.5, mask_noisy.sum())
+# A few stronger spikes
+for idx_offset in rng.integers(10, mask_noisy.sum() - 10, size=8):
+    noise_large[idx_offset] += rng.uniform(4, 9)
+y_blue[mask_noisy] += noise_large
+y_blue = np.clip(y_blue, 1.8, 13.5)
+
+# SiameseNorm/Ours (green): smooth rapid decay
+y_green = 7.2 * np.exp(-steps / 360) + 2.1
+y_green += rng.normal(0, 0.05, len(steps))
+y_green = np.clip(y_green, 1.8, 9.0)
+
+# tab10 colors
+C_ORANGE = '#FF7F0E'
+C_BLUE   = '#1F77B4'
+C_GREEN  = '#2CA02C'
+
+# ---- Main panel ----
+# Source image size is about 952×368, so the target aspect ratio is roughly 2.59.
+fig = plt.figure(figsize=(10.5, 4.05))
+ax_main = fig.add_axes([0.08, 0.16, 0.50, 0.78])
+
+ax_main.plot(steps, y_hybrid, color=C_ORANGE, lw=1.3, label='HybridNorm', zorder=3)
+ax_main.plot(steps, y_blue,   color=C_BLUE,   lw=1.0, label='HybridNorm-ResiDual', zorder=3)
+ax_main.plot(steps, y_green,  color=C_GREEN,  lw=1.3, label='SiameseNorm (Ours)', zorder=4)
+
+ax_main.set_xlim(-50, 5600)
+ax_main.set_ylim(1.5, 14.5)   # align roughly with the source range of ~2 to 14
+ax_main.set_xlabel(r'Step', fontsize=10)
+ax_main.set_ylabel(r'Loss', fontsize=10)
+ax_main.set_xticks([0, 1000, 2000, 3000, 4000, 5000])
+ax_main.tick_params(labelsize=9.0, direction='out', length=3.5, width=0.8)
+
+# L-shaped spines: keep left and bottom, hide top and right
+ax_main.spines['top'].set_visible(False)
+ax_main.spines['right'].set_visible(False)
+ax_main.spines['left'].set_linewidth(1.0)
+ax_main.spines['bottom'].set_linewidth(1.0)
+
+# Axis-end arrowheads to mimic the source figure
+ax_main.plot(1, 0, '>k', transform=ax_main.get_yaxis_transform(),
+             clip_on=False, markersize=5)
+ax_main.plot(0, 1, '^k', transform=ax_main.get_xaxis_transform(),
+             clip_on=False, markersize=5)
+
+ax_main.grid(True, color='#E0E0E0', linewidth=0.5, linestyle=':')
+ax_main.set_axisbelow(True)
+
+leg = ax_main.legend(
+    loc='upper right',
+    fontsize=9.0,
+    frameon=True,
+    facecolor='white',
+    edgecolor='#DDDDDD',
+    borderpad=0.4,
+    labelspacing=0.25,
+    handlelength=1.8,
+    framealpha=1.0,
+)
+
+# ---- Zoom region (dashed rectangle) ----
+zoom_x1, zoom_x2 = 2400, 5500
+zoom_y1, zoom_y2 = 1.8, 4.5
+rect = mpatches.FancyBboxPatch(
+    (zoom_x1, zoom_y1),
+    zoom_x2 - zoom_x1, zoom_y2 - zoom_y1,
+    boxstyle='square,pad=0',
+    linewidth=1.0, edgecolor='#333333',
+    facecolor='none', linestyle='--',
+    zorder=5,
+)
+ax_main.add_patch(rect)
+
+# ---- Inset panel on the right (roughly 40% of the total width) ----
+ax_inset = fig.add_axes([0.61, 0.10, 0.36, 0.86])
+
+mask_z = (steps >= zoom_x1) & (steps <= zoom_x2)
+steps_z = steps[mask_z]
+
+ax_inset.plot(steps_z, y_blue[mask_z],  color=C_BLUE,  lw=1.0, zorder=3)
+ax_inset.plot(steps_z, y_green[mask_z], color=C_GREEN, lw=1.2, zorder=4)
+
+ax_inset.set_xlim(zoom_x1 - 50, zoom_x2 + 50)
+ax_inset.set_ylim(zoom_y1 - 0.1, zoom_y2 + 4.0)   # source inset y-range is roughly 1.8 to 8.5
+ax_inset.set_xticks([3000, 4000, 5000])
+ax_inset.tick_params(labelsize=8.5, direction='out', length=3.5, width=0.8)
+
+for sp in ax_inset.spines.values():
+    sp.set_visible(True)
+    sp.set_linewidth(1.5)
+    sp.set_color('#2A6073')   # deep blue-gray inset border
+
+ax_inset.grid(False)
+
+# ---- Black dashed connectors from the zoom box to the inset ----
+# upper-right zoom corner -> inset upper-left
+con1 = ConnectionPatch(
+    xyA=(zoom_x2, zoom_y2), coordsA=ax_main.transData,
+    xyB=(ax_inset.get_xlim()[0], ax_inset.get_ylim()[1]),
+    coordsB=ax_inset.transData,
+    color='#333333', lw=0.8, linestyle='--',
+)
+# lower-right zoom corner -> inset lower-left
+con2 = ConnectionPatch(
+    xyA=(zoom_x2, zoom_y1), coordsA=ax_main.transData,
+    xyB=(ax_inset.get_xlim()[0], ax_inset.get_ylim()[0]),
+    coordsB=ax_inset.transData,
+    color='#333333', lw=0.8, linestyle='--',
+)
+fig.add_artist(con1)
+fig.add_artist(con2)
+
+fig.savefig(
+    '/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/line_loss_inset_repro.png',
+    dpi=300, facecolor='white',
+)
+plt.close(fig)
+print('saved: line_loss_inset_repro.png')

package/src/skills/paper-plot/scripts/line_selfdistill.py

@@ -0,0 +1,168 @@
+"""
+Reproduce image2 and image3 from the self-distillation paper.
+image2: continuous training curves with confidence-band shading and a horizontal reference line
+image3: discrete scaling curves with confidence-band shading
+Source: Reinforcement learning via self-distillation
+"""
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import numpy as np
+
+# ── Style summary ─────────────────────────────────────────
+# Typeface: serif, close to LaTeX Computer Modern, with usetex enabled.
+# Weighting: title normal, SDPO legend entry bold, others normal.
+# Spines: keep only left and bottom.
+# Grid: none.
+# Colors: green for SDPO, blue for GRPO, gray for the base model.
+# Band: semi-transparent fill with alpha around 0.15.
+plt.rcParams.update({
+    'text.usetex': True,
+    'font.family': 'serif',
+    'font.serif': ['Computer Modern Roman', 'STIX Two Text', 'DejaVu Serif'],
+    'axes.unicode_minus': False,
+})
+
+C_SDPO  = '#2CA02C'   # matplotlib tab green
+C_GRPO  = '#1F77B4'   # matplotlib tab blue
+C_BASE  = '#BCBCBC'   # light gray for the base model
+
+# ══════════════════════════════════════════════════════════
+# Figure 2: continuous training curves (LiveCodeBench v6)
+# ══════════════════════════════════════════════════════════
+np.random.seed(42)
+
+steps = np.linspace(0, 20000, 400)   # more points for smoother EMA output
+
+def raw_curve(start, end, steps, noise=0.008):
+    t = steps / steps[-1]
+    curve = start + (end - start) * (1 - np.exp(-4 * t))
+    curve += np.random.normal(0, noise, len(steps)) * (1 - t * 0.7)
+    return curve
+
+def ema(arr, alpha=0.96):
+    """Exponential moving average used to mimic smoothed training logs."""
+    out = np.zeros_like(arr)
+    out[0] = arr[0]
+    for i in range(1, len(arr)):
+        out[i] = alpha * out[i - 1] + (1 - alpha) * arr[i]
+    return out
+
+# Generate noisy raw curves first, then smooth them with EMA
+sdpo_mean = ema(raw_curve(0.285, 0.490, steps, noise=0.006))
+sdpo_std  = 0.012 * np.exp(-2 * steps / steps[-1]) + 0.007
+grpo_mean = ema(raw_curve(0.285, 0.415, steps, noise=0.006))
+grpo_std  = 0.010 * np.exp(-2 * steps / steps[-1]) + 0.006
+
+fig2, ax2 = plt.subplots(figsize=(6.5, 4.4))
+
+ax2.fill_between(steps, sdpo_mean - sdpo_std, sdpo_mean + sdpo_std,
+                 color=C_SDPO, alpha=0.20)
+ax2.fill_between(steps, grpo_mean - grpo_std, grpo_mean + grpo_std,
+                 color=C_GRPO, alpha=0.20)
+ax2.plot(steps, sdpo_mean, color=C_SDPO, lw=2.5, label=r'\textbf{SDPO}')
+ax2.plot(steps, grpo_mean, color=C_GRPO, lw=2.5, label='GRPO')
+# The source figure uses a sparse dotted baseline line rather than a standard dash
+ax2.axhline(0.406, color='#AAAAAA', lw=1.8,
+            linestyle=(0, (1, 2)), label='Claude Sonnet 4')
+
+ax2.set_xlim(0, 20000)
+ax2.set_ylim(0.28, 0.52)
+ax2.set_xlabel('Number of Generations', fontsize=13)
+ax2.set_ylabel('Accuracy', fontsize=13)
+ax2.set_title('LiveCodeBench v6', fontsize=15, pad=7)
+
+ax2.xaxis.set_major_formatter(ticker.FuncFormatter(
+    lambda x, _: f'{int(x/1000)}k' if x > 0 else '0'))
+ax2.xaxis.set_major_locator(ticker.MultipleLocator(5000))
+ax2.yaxis.set_major_locator(ticker.MultipleLocator(0.05))
+
+leg2 = ax2.legend(fontsize=11, loc='lower right',
+                  framealpha=0, edgecolor='none',
+                  handlelength=2.2, borderaxespad=0.5, labelspacing=0.3)
+for text in leg2.get_texts():
+    if 'SDPO' in text.get_text():
+        text.set_fontweight('bold')
+
+# Four-sided frame with inward ticks, matching the source figure
+for sp in ax2.spines.values():
+    sp.set_visible(True)
+    sp.set_linewidth(1.5)
+ax2.tick_params(direction='in', length=5, width=1.2, labelsize=11)
+ax2.grid(False)
+
+fig2.tight_layout(pad=0.9)
+fig2.savefig('/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/line_selfdistill_v6_repro.png',
+             dpi=300, facecolor='white')
+plt.close(fig2)
+print('saved: line_selfdistill_v6_repro.png')
+
+# ══════════════════════════════════════════════════════════
+# Figure 3: model scaling curves (Qwen3)
+# ══════════════════════════════════════════════════════════
+param_labels = ['0.6', '1.7', '4', '8']
+param_x      = [0.6,   1.7,   4,   8]
+x_pos        = [0, 1, 2, 3]   # evenly spaced manual positions for the x-axis labels
+
+sdpo_pts = [0.215, 0.333, 0.450, 0.490]
+grpo_pts = [0.212, 0.295, 0.400, 0.414]
+base_pts = [0.095, 0.150, 0.233, 0.284]
+
+sdpo_std3 = [0.005, 0.006, 0.008, 0.006]
+grpo_std3 = [0.005, 0.006, 0.007, 0.006]
+
+fig3, ax3 = plt.subplots(figsize=(10, 5))   # 2:1 aspect ratio, matching the source
+
+ax3.fill_between(x_pos,
+                 [v - s for v, s in zip(sdpo_pts, sdpo_std3)],
+                 [v + s for v, s in zip(sdpo_pts, sdpo_std3)],
+                 color=C_SDPO, alpha=0.18)
+ax3.fill_between(x_pos,
+                 [v - s for v, s in zip(grpo_pts, grpo_std3)],
+                 [v + s for v, s in zip(grpo_pts, grpo_std3)],
+                 color=C_GRPO, alpha=0.18)
+
+MEC = 'black'   # the source figure uses black marker outlines
+ax3.plot(x_pos, sdpo_pts, color=C_SDPO, lw=2.5,
+         marker='o', ms=7, mfc=C_SDPO,
+         markeredgecolor=MEC, markeredgewidth=1.0,
+         label=r'\textbf{SDPO}')
+ax3.plot(x_pos, grpo_pts, color=C_GRPO, lw=2.5,
+         marker='o', ms=7, mfc=C_GRPO,
+         markeredgecolor=MEC, markeredgewidth=1.0,
+         label='GRPO')
+ax3.plot(x_pos, base_pts, color=C_BASE, lw=2.5,   # keep the base line as thick as the others
+         marker='o', ms=7, mfc=C_BASE,
+         markeredgecolor=MEC, markeredgewidth=1.0,
+         label='base model')
+
+ax3.set_xticks(x_pos)
+ax3.set_xticklabels(param_labels, fontsize=11)
+ax3.set_xlim(-0.35, 3.35)
+ax3.set_ylim(0.08, 0.51)   # align with the source 0.1-0.5 tick range
+ax3.set_xlabel('Model parameters (B)', fontsize=13)
+ax3.set_ylabel(r'\textit{Accuracy}', fontsize=13)
+ax3.set_title('Model scaling (Qwen3)', fontsize=15, pad=7)
+ax3.yaxis.set_major_locator(ticker.MultipleLocator(0.1))
+
+# Move the legend to the lower-right, matching the source placement
+leg3 = ax3.legend(fontsize=11, loc='lower right',
+                  bbox_to_anchor=(0.98, 0.02),
+                  framealpha=0, edgecolor='none',
+                  handlelength=2.2, borderaxespad=0.5, labelspacing=0.3)
+for text in leg3.get_texts():
+    if 'SDPO' in text.get_text():
+        text.set_fontweight('bold')
+
+# Four-sided frame + inward ticks
+for sp in ax3.spines.values():
+    sp.set_visible(True)
+    sp.set_linewidth(1.5)
+ax3.tick_params(direction='in', length=5, width=1.2, labelsize=11)
+ax3.grid(False)
+
+fig3.tight_layout(pad=0.9)
+fig3.savefig('/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/line_selfdistill_scaling_repro.png',
+             dpi=300, facecolor='white')
+plt.close(fig3)
+print('saved: line_selfdistill_scaling_repro.png')

package/src/skills/paper-plot/scripts/radar_dora.py

@@ -0,0 +1,151 @@
+"""
+Reproduce: image8.png — DoRA vs LoRA Radar Chart
+Style: sans-serif, dashed octagonal grid, white-bg value annotations,
+       semi-transparent fill, legend: black text + colored line segment.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.lines as mlines
+
+plt.rcParams.update({
+    'font.family': 'sans-serif',
+    'font.sans-serif': ['DejaVu Sans', 'Arial', 'Helvetica'],
+    'text.usetex': False,
+})
+
+# ---- Data (clockwise, starting from the top) ----
+CATEGORIES = [
+    'CommonSense\n(LLaMA)',
+    'MT-bench\n(LLaMA2)',
+    'MT-bench\n(LLaMA)',
+    'visual instruction\ntuning (LLaVA-1.5)',
+    'video-text\n(VL-BART)',
+    'image-text\n(VL-BART)',
+    'CommonSense\n(LLaMA3)',
+    'CommonSense\n(LLaMA2)',
+]
+
+DORA_raw = np.array([78.40, 6.00, 5.50, 67.60, 85.40, 77.40, 85.20, 79.70])
+LORA_raw = np.array([76.30, 5.70, 5.10, 66.90, 83.50, 76.50, 80.80, 77.60])
+
+N = len(CATEGORIES)
+
+RANGES = [
+    (74.0, 80.0),
+    (5.4,  6.2),
+    (4.8,  5.7),
+    (65.0, 70.0),
+    (81.0, 87.0),
+    (74.0, 79.0),
+    (78.0, 87.0),
+    (75.0, 81.0),
+]
+RMIN, RMAX = 0.35, 1.0
+
+def nrm(v, vmin, vmax):
+    return RMIN + (RMAX - RMIN) * (v - vmin) / (vmax - vmin)
+
+dora_r = np.array([nrm(v, r[0], r[1]) for v, r in zip(DORA_raw, RANGES)])
+lora_r = np.array([nrm(v, r[0], r[1]) for v, r in zip(LORA_raw, RANGES)])
+
+angles = np.linspace(0, 2 * np.pi, N, endpoint=False)
+
+def close(arr):
+    return np.concatenate([arr, [arr[0]]])
+
+# Source image size is about 1032×850, so the aspect ratio is roughly 1.21
+fig, ax = plt.subplots(figsize=(7.0, 5.8),
+                       subplot_kw=dict(projection='polar'))
+
+ax.set_theta_zero_location('N')
+ax.set_theta_direction(-1)
+ax.set_yticks([])
+ax.set_xticks([])
+
+# ---- Concentric octagonal dashed grids, not circular grids ----
+for r in [0.4, 0.55, 0.7, 0.85, 1.0]:
+    ax.plot(close(angles), close(np.full(N, r)),
+            color='#CCCCCC', lw=0.8, linestyle='--', zorder=1)
+
+# Radial guide lines
+for ang in angles:
+    ax.plot([ang, ang], [0, 1.0],
+            color='#CCCCCC', lw=0.8, linestyle='--', zorder=1)
+
+C_DORA = '#5A8A5A'   # deep green, close to the source figure
+C_LORA = '#4169E1'   # royal blue, matching the LoRA line
+
+# ---- Filled regions with a shared opacity ----
+ax.fill(close(angles), close(dora_r), color=C_DORA, alpha=0.18, zorder=3)
+ax.fill(close(angles), close(lora_r), color=C_LORA, alpha=0.18, zorder=3)
+
+# ---- Lines (DoRA visibly thicker than LoRA) ----
+ax.plot(close(angles), close(dora_r),
+        color=C_DORA, lw=3.0, solid_capstyle='round', zorder=4)
+ax.plot(close(angles), close(lora_r),
+        color=C_LORA, lw=1.5, solid_capstyle='round', zorder=4)
+
+# ---- Numeric labels with white boxes for readability ----
+def fmt(v):
+    # The source figure keeps two decimals
+    return f'{v:.2f}'
+
+for i, ang in enumerate(angles):
+    # DoRA values outside the polygon
+    r_d = dora_r[i] + 0.08
+    ax.text(ang, r_d, fmt(DORA_raw[i]),
+            ha='center', va='center',
+            fontsize=7.8, color=C_DORA, zorder=6,
+            bbox=dict(boxstyle='round,pad=0.12',
+                      facecolor='white', edgecolor='none', alpha=0.85))
+    # LoRA values inside the polygon
+    r_l = lora_r[i] - 0.09
+    ax.text(ang, r_l, fmt(LORA_raw[i]),
+            ha='center', va='center',
+            fontsize=7.8, color=C_LORA, zorder=6,
+            bbox=dict(boxstyle='round,pad=0.12',
+                      facecolor='white', edgecolor='none', alpha=0.85))
+
+# ---- Axis labels ----
+# In the source figure the labels sit close to the outer polygon ring
+label_r = 1.13
+for i, (ang, cat) in enumerate(zip(angles, CATEGORIES)):
+    if abs(np.sin(ang)) < 0.15:
+        ha = 'center'
+    elif np.sin(ang) > 0:
+        ha = 'left'
+    else:
+        ha = 'right'
+    ax.text(ang, label_r, cat,
+            ha=ha, va='center',
+            fontsize=8.5, color='#333333',
+            multialignment='center')
+
+# ---- Legend: black series names plus colored line samples ----
+# DoRA legend row (thicker green line + bold black text)
+fig.text(0.09, 0.91,
+         '────  ', color=C_DORA, fontsize=11,
+         fontweight='bold', va='center', ha='left')
+fig.text(0.155, 0.91,
+         'DoRA', color='black', fontsize=10,
+         fontweight='bold', va='center', ha='left')
+
+# LoRA legend row (thinner blue line + regular black text)
+fig.text(0.09, 0.875,
+         '─────', color=C_LORA, fontsize=8.5,
+         va='center', ha='left')
+fig.text(0.155, 0.875,
+         'LoRA', color='black', fontsize=10,
+         va='center', ha='left')
+
+ax.set_ylim(0, 1.32)   # reduce top and bottom whitespace so the polygon fills more of the canvas
+ax.set_frame_on(False)
+
+fig.subplots_adjust(left=0.10, right=0.90, top=0.86, bottom=0.06)
+fig.savefig(
+    '/Users/bytedance/gitcode/paper_experiment_plot_skills/repro/radar_dora_repro.png',
+    dpi=300, facecolor='white',
+)
+plt.close(fig)
+print('saved: radar_dora_repro.png')