Duplicate from MatrixYao/how_many_data_points_zh

Co-authored-by: Matrix Yao <[email protected]>

.gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+*$py.class
+
+
+.env/

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.7
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+CMD ["bokeh", "serve", "naacl_demo", "--allow-websocket-origin=*"]

README.md

@@ -0,0 +1,12 @@
+---
+title: How Many Data Points
+emoji: 🦀
+colorFrom: red
+colorTo: yellow
+sdk: docker
+pinned: false
+app_port: 5006
+duplicated_from: MatrixYao/how_many_data_points_zh
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

naacl_demo/demo_utils.py

@@ -0,0 +1,514 @@
+import math
+
+import pandas as pd
+import numpy as np
+from itertools import product
+import shapely
+from bokeh.models import Span, Label, ColumnDataSource, Whisker
+from bokeh.plotting import figure, show
+from shapely.geometry import Polygon
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+import seaborn
+
+task_patterns = {
+    "CB": [0, 3],
+    "RTE": [0, 3],
+    "BoolQ": [0, 3, 5],
+    "MNLI": [0, 3],
+    "COPA": [0, 1],
+    "WSC": [0, 1, 2],
+    "WiC": [0, 1],
+    "MultiRC": [0, 1, 2],
+}
+task_reps = {"CB": 4, "RTE": 4, "BoolQ": 4, "MNLI": 4, "COPA": 4, "WSC": 4, "WiC": 4, "MultiRC": 4}
+task_best_pattern = {"CB": 0, "RTE": 0, "BoolQ": 0, "MNLI": 0, "COPA": 1, "WSC": 0, "WiC": 0, "MultiRC": 1}
+task_metric_short = {
+    "CB": "f1-macro",
+    "RTE": "acc",
+    "BoolQ": "acc",
+    "MNLI": "acc",
+    "COPA": "acc",
+    "WSC": "acc",
+    "WiC": "acc",
+    "MultiRC": "f1",
+}
+task_metrics = {
+    "CB": "F1-macro",
+    "RTE": "accuracy",
+    "BoolQ": "accuracy",
+    "MNLI": "accuracy",
+    "COPA": "accuracy",
+    "WSC": "accuracy",
+    "WiC": "accuracy",
+    "MultiRC": "F1",
+}
+task_neutral = {
+    "CB": True,
+    "RTE": True,
+    "BoolQ": True,
+    "MNLI": True,
+    "COPA": False,
+    "WSC": False,
+    "multirc": True,
+    "WiC": True,
+    "MultiRC": True,
+}
+neutral_tasks = [
+    "BoolQ",
+    "CB",
+    "MNLI",
+    "MultiRC",
+    "RTE",
+    "WiC",
+]
+tasks = sorted(task_patterns.keys())
+
+pvp_colors = ["goldenrod", "blanchedalmond", "floralwhite"]
+ctl_colors = ["crimson", "salmon", "mistyrose"]
+clf_colors = ["indigo", "plum", "thistle"]
+
+
+def prompt_boolq(passage, question, pattern):
+    if pattern == 0:
+        return f"""<span style="color: #0c593d">{passage}</span> <span style="color: #910713"><b>Based on the previous passage,</b></span> <span style="color: #031154">{question}</span> <span style="color: #ba9004"><b>[YES/NO]</b></span>"""
+    if pattern == 1:
+        return f"""<span style="color: #0c593d">{passage}</span><span style="color: #910713"><b> Question:</b></span> <span style="color: #031154">{question}</span><span style="color: #910713"><b> Answer: </b></span><span style="color: #ba9004"><b>[YES/NO]</b></span>"""
+    if pattern == 2:
+        return f"""<span style="color: #910713"><b>Based on the following passage,</b></span> <span style="color: #031154">{question}</span><span style="color: #ba9004"><b> [YES/NO]</b></span> <span style="color: #0c593d">{passage}</span>"""
+
+
+def advantage_text(advantage):
+    model_type = (
+        """<span style="color: #4B0082">分类头法</span>"""
+        if advantage < 0
+        else """<span style="color: #daa520">提示法</span>"""
+    )
+    return f"""<b>{model_type}</b> 优势: <b>{abs(advantage):.2f}</b> 条样本"""
+
+
+def average_advantage_text(advantage):
+    model_type = (
+        """<span style="color: #4B0082">分类头法</span>"""
+        if advantage < 0
+        else """<span style="color: #daa520">提示法</span>"""
+    )
+    return f"""<b>Average {model_type}</b> 优势: <b>{abs(advantage):.2f}</b> 条样本"""
+
+
+def naming_convention(task, seed, pvp_index=None, neutral=False):
+    method = f"PVP {pvp_index}" if pvp_index is not None else "CLF"
+    model = "roberta"
+    if neutral:
+        verbalizer = "neutral"
+    else:
+        verbalizer = None
+    return (
+            f"{method} {model}"
+            + (f" {verbalizer} verbalizer" if verbalizer is not None else "")
+            + f" seed {seed} - test-{task_metric_short[task]}-all-p"
+    )
+
+
+def get_data(task):
+    url = f"https://raw.githubusercontent.com/TevenLeScao/pet/master/exported_results/{task.lower()}/wandb_export.csv"
+    df = pd.read_csv(url)
+    training_points = df["training_points"]
+
+    head_performances = np.transpose(np.array([df[naming_convention(task, i)] for i in range(task_reps[task])]))
+    pattern_performances = {}
+    for pattern in task_patterns[task]:
+        pattern_performances[pattern] = {
+            "normal": np.transpose(np.array([df[naming_convention(task, i, pattern)] for i in range(task_reps[task])]))
+        }
+        if task_neutral[task]:
+            pattern_performances[pattern]["neutral"] = np.transpose(
+                np.array([df[naming_convention(task, i, pattern, True)] for i in range(task_reps[task])])
+            )
+
+    return training_points, head_performances, pattern_performances
+
+
+def reduct(performances, reduction="accmax", final_pattern=0, verbalizer="normal", exclude=None):
+    # Combining the different runs for each experimental set-up
+    reducted = None
+
+    if isinstance(performances, dict):
+        performances = performances[final_pattern][verbalizer]
+    if exclude is not None:
+        performances = np.delete(performances, exclude, axis=1)
+
+    if reduction == "avg":
+        # Average
+        reducted = np.nanmean(performances, axis=1)
+
+    if reduction == "std":
+        # Standard deviation
+        reducted = np.nanstd(performances, axis=1)
+
+    if reduction == "max":
+        # Maximum
+        reducted = np.nanmax(performances, axis=1)
+
+    if reduction == "accmax":
+        # This makes the maximum curve monotonic
+        max_performance = np.nanmax(performances, axis=1)
+        reducted = np.maximum.accumulate(max_performance)
+
+    assert reducted is not None, "unrecognized reduction method"
+    return reducted
+
+
+def find_surrounding_points(perf, clf_results, pvp_results):
+    for i, clf_result in enumerate(clf_results):
+        if i - 1 > 0 and clf_result == clf_results[i - 1]:
+            continue
+        if clf_result > perf:
+            if i == 0:
+                raise ValueError(f"value {perf} too small")
+            else:
+                break
+    for j, pvp_result in enumerate(pvp_results):
+        if j - 1 > 0 and pvp_result == pvp_results[j - 1]:
+            continue
+        if pvp_result > perf:
+            if j == 0:
+                raise ValueError(f"value {perf} too small")
+            else:
+                break
+    return i - 1, j - 1
+
+
+def interpolate(perf, x1, x2, y1, y2):
+    return x1 + (perf - y1) * (x2 - x1) / (y2 - y1)
+
+
+def interpolate_from_idx(perf, idx, results, training_points):
+    return interpolate(perf, training_points[idx], training_points[idx + 1], results[idx], results[idx + 1])
+
+
+def interpolate_from_perf(perf, overlapping_range, training_points, clf_results, pvp_results):
+    if not overlapping_range[0] <= perf <= overlapping_range[1]:
+        raise ValueError(f"perf {perf} not in acceptable bounds {overlapping_range}")
+    clf_idx, pvp_idx = find_surrounding_points(perf, clf_results, pvp_results)
+    return interpolate_from_idx(perf, clf_idx, clf_results, training_points), interpolate_from_idx(
+        perf, pvp_idx, pvp_results, training_points
+    )
+
+
+def data_difference(perf, overlapping_range, training_points, clf_results, pvp_results):
+    x1, x2 = interpolate_from_perf(perf, overlapping_range, training_points, clf_results, pvp_results)
+    return x1 - x2
+
+
+def calculate_overlap(clf_results, pvp_results, full_range=False):
+    if full_range:
+        return (min(min(clf_results), min(pvp_results)), max(max(clf_results), max(pvp_results)))
+    else:
+        return (max(min(clf_results), min(pvp_results)), min(max(clf_results), max(pvp_results)))
+
+
+def calculate_range(overlapping_range, number_of_points):
+    integral_range = (
+        overlapping_range[0] + i / (number_of_points + 1) * (overlapping_range[1] - overlapping_range[0])
+        for i in range(1, number_of_points + 1)
+    )
+    return integral_range
+
+
+def calculate_differences(integral_range, overlapping_range, training_points, clf_results, pvp_results):
+    differences = [
+        data_difference(y, overlapping_range, training_points, clf_results, pvp_results) for y in integral_range
+    ]
+    return differences
+
+
+def calculate_offset(training_points, clf_results, pvp_results, number_of_points=1000):
+    overlapping_range = calculate_overlap(clf_results, pvp_results)
+    integral_range = calculate_range(overlapping_range, number_of_points)
+    differences = calculate_differences(integral_range, overlapping_range, training_points, clf_results, pvp_results)
+    offset = sum(differences) / number_of_points
+    return offset
+
+
+def intersection_with_range(training_points, results, band):
+    result_polygon = Polygon(
+        [(training_points[i], results[i]) for i in range(len(training_points))]
+        + [(training_points[-1], 0), (training_points[0], 0)]
+    )
+    return result_polygon.intersection(band)
+
+
+def fill_polygon(fig, polygon, color, label=None, alpha=1.0):
+    if polygon.is_empty or isinstance(polygon, shapely.geometry.LineString):
+        return
+    if isinstance(polygon, Polygon):
+        xs, ys = polygon.exterior.xy
+        fig.patch(xs, ys, color=color, alpha=alpha)
+    else:
+        for geom in polygon.geoms:
+            if isinstance(geom, shapely.geometry.LineString):
+                continue
+            xs, ys = geom.exterior.xy
+            fig.patch(xs, ys, color=color, alpha=alpha)
+            label = None
+
+
+label_order = {
+    "head run": 0,
+    "head advantage": 1,
+    "control run": 2,
+    "optimization advantage": 3,
+    "prompting run": 4,
+    "semantics advantage": 5,
+    "region of comparison": 6,
+}
+
+
+def metric_tap(
+        event, overlapping_range, training_points, clf_results, pvp_results, advantage_box, advantage_plot
+):
+    _, metric_value = event.x, event.y
+    try:
+        advantage_value = data_difference(metric_value, overlapping_range, training_points, clf_results, pvp_results)
+        advantage_box.text = advantage_text(advantage_value)
+        if not isinstance(advantage_plot.renderers[-1], Span):
+            metric_line = Span(
+                location=metric_value,
+                line_alpha=0.7,
+                dimension="width",
+                line_color=clf_colors[0] if advantage_value < 0 else pvp_colors[0],
+                line_dash="dashed",
+                line_width=1,
+            )
+            advantage_plot.renderers.extend([metric_line])
+        else:
+            advantage_plot.renderers[-1].location = metric_value
+            advantage_plot.renderers[-1].line_color = clf_colors[0] if advantage_value < 0 else pvp_colors[0]
+    # clicking outside the region
+    except ValueError:
+        pass
+
+
+def plot_polygons_bokeh(task, training_points, clf_results, pvp_results, clf_colors, pvp_colors, x_log_scale=False):
+    overlapping_range = calculate_overlap(clf_results, pvp_results, False)
+    full_range = calculate_overlap(clf_results, pvp_results, True)
+    middle_y = (full_range[0] + full_range[1]) / 2
+
+    fig = figure(plot_height=400, plot_width=800, max_height=400, max_width=800,
+                 x_axis_type="log" if x_log_scale else "linear", title="分类头法及提示法在各规模的训练子集上的性能")
+
+    fig.circle(training_points, clf_results, color=clf_colors[0], legend="分类头法")
+    fig.circle(training_points, pvp_results, color=pvp_colors[0], legend="提示法")
+    fig.line(training_points, clf_results, color=clf_colors[0], alpha=1)
+    fig.line(training_points, pvp_results, color=pvp_colors[0], alpha=1)
+    fig.xaxis.axis_label = "训练子集规模"
+    fig.yaxis.axis_label = task_metrics[task]
+    fig.patch(
+        [training_points[0], training_points[0], training_points[-1], training_points[-1]],
+        [overlapping_range[0], overlapping_range[1], overlapping_range[1], overlapping_range[0]],
+        color="black",
+        fill_alpha=0,
+        line_width=0,
+        legend="比较区域",
+        hatch_alpha=0.14,
+        hatch_scale=40,
+        hatch_pattern="/",
+    )
+
+    band = Polygon(
+        [
+            (training_points[0], overlapping_range[0]),
+            (training_points[0], overlapping_range[1]),
+            (training_points[-1], overlapping_range[1]),
+            (training_points[-1], overlapping_range[0]),
+        ]
+    )
+    full_band = Polygon(
+        [
+            (training_points[0], full_range[0]),
+            (training_points[0], full_range[1]),
+            (training_points[-1], full_range[1]),
+            (training_points[-1], full_range[0]),
+        ]
+    )
+    clf_polygon = intersection_with_range(training_points, clf_results, band)
+    pvp_polygon = intersection_with_range(training_points, pvp_results, band)
+    full_clf_polygon = intersection_with_range(training_points, clf_results, full_band)
+    full_pvp_polygon = intersection_with_range(training_points, pvp_results, full_band)
+
+    clf_inside_area = clf_polygon.difference(pvp_polygon)
+    pvp_inside_area = pvp_polygon.difference(clf_polygon)
+    clf_outside_area = (full_clf_polygon.difference(full_pvp_polygon)).difference(clf_inside_area)
+    pvp_outside_area = (full_pvp_polygon.difference(full_clf_polygon)).difference(pvp_inside_area)
+
+    fill_polygon(fig, clf_outside_area, clf_colors[1], alpha=0.13)
+    fill_polygon(fig, pvp_outside_area, pvp_colors[1], alpha=0.18)
+    fill_polygon(
+        fig, clf_inside_area, clf_colors[1], alpha=0.4, label="head advantage" if task == "WiC" else None
+    )
+    fill_polygon(fig, pvp_inside_area, pvp_colors[1], alpha=0.4, label="prompting advantage")
+
+    fig.line([training_points[0], training_points[-1]], [overlapping_range[0], overlapping_range[0]], color="dimgrey")
+    fig.line([training_points[0], training_points[-1]], [overlapping_range[1], overlapping_range[1]], color="dimgrey")
+
+    vline = Span(
+        location=training_points[-1], dimension="height", line_color="black", line_width=2.5, line_dash="dashed"
+    )
+    end_label = Label(
+        x=training_points[-1], y=middle_y, text="数据集总大小", angle=90, angle_units="deg", text_align="center"
+    )
+    fig.renderers.extend([vline, end_label])
+
+    fig.legend.location = "bottom_right"
+
+    return fig
+
+
+def plot_three_polygons_bokeh(
+        task, training_points, clf_results, pvp_results, ctl_results, clf_colors, pvp_colors, ctl_colors,
+        x_log_scale=False
+):
+    overlapping_range = calculate_overlap(clf_results, pvp_results, False)
+    full_range = calculate_overlap(clf_results, pvp_results, True)
+    middle_y = (full_range[0] + full_range[1]) / 2
+
+    fig = figure(plot_height=400, plot_width=800, max_height=400, max_width=800,
+                 x_axis_type="log" if x_log_scale else "linear", title="分类头法、提示法以及空言语器提示法在各规模的训练子集上的性能")
+    fig.xaxis.axis_label = "训练子集规模"
+    fig.yaxis.axis_label = task_metrics[task]
+    fig.circle(training_points, clf_results, color=clf_colors[0], legend="分类头法")
+    fig.circle(training_points, pvp_results, color=pvp_colors[0], legend="提示法")
+    fig.circle(training_points, ctl_results, color=ctl_colors[0], legend="空言语器提示法")
+    fig.line(training_points, clf_results, color=clf_colors[0], alpha=1)
+    fig.line(training_points, pvp_results, color=pvp_colors[0], alpha=1)
+    fig.line(training_points, ctl_results, color=ctl_colors[0], alpha=1)
+
+    fig.patch(
+        [training_points[0], training_points[0], training_points[-1], training_points[-1]],
+        [overlapping_range[0], overlapping_range[1], overlapping_range[1], overlapping_range[0]],
+        color="black",
+        fill_alpha=0,
+        line_width=0,
+        legend="比较区域",
+        hatch_alpha=0.14,
+        hatch_scale=40,
+        hatch_pattern="/",
+    )
+
+    band = Polygon(
+        [
+            (training_points[0], overlapping_range[0]),
+            (training_points[0], overlapping_range[1]),
+            (training_points[-1], overlapping_range[1]),
+            (training_points[-1], overlapping_range[0]),
+        ]
+    )
+    full_band = Polygon(
+        [
+            (training_points[0], full_range[0]),
+            (training_points[0], full_range[1]),
+            (training_points[-1], full_range[1]),
+            (training_points[-1], full_range[0]),
+        ]
+    )
+
+    clf_polygon = intersection_with_range(training_points, clf_results, band)
+    pvp_polygon = intersection_with_range(training_points, pvp_results, band)
+    ctl_polygon = intersection_with_range(training_points, ctl_results, band)
+
+    full_clf_polygon = intersection_with_range(training_points, clf_results, full_band)
+    full_pvp_polygon = intersection_with_range(training_points, pvp_results, full_band)
+    full_ctl_polygon = intersection_with_range(training_points, ctl_results, full_band)
+
+    clf_inside_area = clf_polygon.difference(ctl_polygon)
+    pvp_inside_area = pvp_polygon.difference(clf_polygon).difference(ctl_polygon)
+    ctl_inside_area = ctl_polygon.difference(clf_polygon)
+
+    clf_outside_area = (full_clf_polygon.difference(full_ctl_polygon)).difference(clf_inside_area)
+    pvp_outside_area = (full_pvp_polygon.difference(full_clf_polygon).difference(ctl_polygon)).difference(
+        pvp_inside_area
+    )
+    ctl_outside_area = (full_ctl_polygon.difference(full_clf_polygon)).difference(pvp_inside_area)
+
+    fill_polygon(
+        fig, clf_inside_area, clf_colors[1], alpha=0.4, label="head advantage" if task == "WiC" else None
+    )
+    fill_polygon(fig, pvp_inside_area, pvp_colors[1], alpha=0.4, label="prompting advantage")
+    fill_polygon(fig, ctl_inside_area, ctl_colors[1], alpha=0.4, label="null verbalizer advantage")
+    fill_polygon(fig, clf_outside_area, clf_colors[1], alpha=0.13)
+    fill_polygon(fig, pvp_outside_area, pvp_colors[1], alpha=0.18)
+    fill_polygon(fig, ctl_outside_area, ctl_colors[1], alpha=0.13)
+
+    fig.line([training_points[0], training_points[-1]], [overlapping_range[0], overlapping_range[0]], color="dimgrey")
+    fig.line([training_points[0], training_points[-1]], [overlapping_range[1], overlapping_range[1]], color="dimgrey")
+
+    vline = Span(
+        location=training_points[-1], dimension="height", line_color="black", line_width=2.5, line_dash="dashed"
+    )
+    end_label = Label(
+        x=training_points[-1], y=middle_y, text="数据集总大小", angle=90, angle_units="deg", text_align="center"
+    )
+    fig.renderers.extend([vline, end_label])
+
+    fig.legend.location = "bottom_right"
+
+    return fig
+
+
+def pattern_graph(task):
+    fig = figure(plot_height=400, plot_width=800, max_height=400, max_width=800, x_axis_type="log", title="Performance over training subset sizes of different prompt patterns")
+    fig.xaxis.axis_label = "训练子集规模"
+    fig.yaxis.axis_label = task_metrics[task]
+    url = f"https://raw.githubusercontent.com/TevenLeScao/pet/master/exported_results/{task.lower()}/wandb_export.csv"
+    df = pd.read_csv(url)
+    expanded_training_points = np.array(list(df["training_points"]) * task_reps[task] * len(task_patterns[task]))
+    data = np.array(df[[naming_convention(task, seed, pattern) for pattern in task_patterns[task] for seed in
+                        range(task_reps[task])]])
+    data = data.reshape(-1, task_reps[task])
+    col_med = np.nanmean(data, axis=1)
+    # Find indices that you need to replace
+    inds = np.where(np.isnan(data))
+    # Place column means in the indices. Align the arrays using take
+    data[inds] = np.take(col_med, inds[0])
+    data = data.reshape(len(df["training_points"]), -1)
+    data = data.transpose().reshape(-1)
+    data = data + np.random.normal(0, 0.01, len(data))
+    pattern = np.array([i // (len(data) // len(task_patterns[task])) for i in range(len(data))])
+    seed = np.array([0, 1, 2, 3] * (len(data) // task_reps[task]))
+    long_df = pd.DataFrame(np.stack((expanded_training_points, pattern, seed, data), axis=1),
+                           columns=["training_points", "pattern", "seed", task_metrics[task]])
+    long_df['pattern'] = long_df['pattern'].astype(int).astype(str)
+    gby_pattern = long_df.groupby('pattern')
+    pattern_colors = ["royalblue", "darkturquoise", "darkviolet"]
+
+    for i, (pattern, pattern_df) in enumerate(gby_pattern):
+        gby_training_points = pattern_df.groupby('training_points')
+        x = [training_point for training_point, training_point_df in gby_training_points]
+        y_max = list([np.max(training_point_df[task_metrics[task]]) for training_point, training_point_df in gby_training_points])
+        y_min = list([np.min(training_point_df[task_metrics[task]]) for training_point, training_point_df in gby_training_points])
+        y = list([np.median(training_point_df[task_metrics[task]]) for training_point, training_point_df in gby_training_points])
+        fig.circle(x, y, color=pattern_colors[i], alpha=1, legend=f"模式 {i}")
+        fig.line(x, y, color=pattern_colors[i], alpha=1)
+        fig.varea(x=x, y1=y_max, y2=y_min, color=pattern_colors[i], alpha=0.11)
+        # source = ColumnDataSource(data=dict(base=x, lower=y_min, upper=y_max))
+        # w = Whisker(source=source, base="base", upper="upper", lower="lower", line_color=pattern_colors[i], line_alpha=0.3)
+        # w.upper_head.line_color = pattern_colors[i]
+        # w.lower_head.line_color = pattern_colors[i]
+        # fig.add_layout(w)
+
+    return fig
+
+
+
+def cubic_easing(t):
+    if t < 0.5:
+        return 4 * t * t * t
+    p = 2 * t - 2
+    return 0.5 * p * p * p + 1
+
+
+def circ_easing(t):
+    if t < 0.5:
+        return 0.5 * (1 - math.sqrt(1 - 4 * (t * t)))
+    return 0.5 * (math.sqrt(-((2 * t) - 3) * ((2 * t) - 1)) + 1)

naacl_demo/main.py

@@ -0,0 +1,293 @@
+from bokeh.events import Tap
+from bokeh.io import curdoc
+from bokeh.layouts import column
+from bokeh.models import Div, TextInput, RadioButtonGroup, TextAreaInput, Span, Button, Panel, Tabs
+from bokeh.models.tools import CrosshairTool
+
+from demo_utils import (
+    get_data,
+    prompt_boolq,
+    pvp_colors,
+    ctl_colors,
+    clf_colors,
+    reduct,
+    task_best_pattern,
+    plot_polygons_bokeh,
+    advantage_text,
+    data_difference,
+    calculate_overlap,
+    circ_easing,
+    average_advantage_text,
+    plot_three_polygons_bokeh,
+    tasks,
+    metric_tap,
+    neutral_tasks, pattern_graph,
+)
+from text import text1, text2, text3, text4, initial_passage, initial_question, text5
+
+########################################################################################################################
+# Basic dimensions
+########################################################################################################################
+
+plot_width = 1200
+plot_height = 400
+sidebar_width = 400
+in_text_plot_height = 300
+text_width = 800
+widget_size = 400
+
+########################################################################################################################
+# Patternification widget
+########################################################################################################################
+
+passage = TextAreaInput(title="篇章", rows=3, value=initial_passage, max_width=text_width)
+passage.align = "center"
+question = TextInput(title="问题", value=initial_question, max_width=text_width)
+question.align = "center"
+radio_button_group = RadioButtonGroup(labels=["模板 1", "模板 2", "模板 3"], active=0, max_width=text_width)
+radio_button_group.align = "center"
+
+box_style = {
+    "display": "block",
+    "margin": "0 auto",
+    "width": f"{text_width}px",
+    "text-align": "center",
+    "white-space": "pre-wrap",
+    "background": "#f4f4f4",
+    "border": "1px solid #ddd",
+    # "border-left": "3px solid #4d4945",
+    "color": "#666",
+    "page-break-inside": "avoid",
+    # "font-family": "monospace",
+    "font-size": "15px",
+    "line-height": "1.6",
+    "max-width": "100%",
+    "overflow": "hidden",
+    "min-height": "30px",
+    "word-wrap": "break-word",
+}
+
+prompt_box = Div(
+    text=prompt_boolq(passage.value, question.value, radio_button_group.active),
+    width=text_width,
+    style=box_style,
+    sizing_mode="scale_width",
+)
+prompt_box.align = "center"
+
+
+def update_prompt(attrname, old, new):
+    prompt_box.text = prompt_boolq(passage.value, question.value, radio_button_group.active)
+
+
+passage.on_change("value", update_prompt)
+question.on_change("value", update_prompt)
+radio_button_group.on_change("active", update_prompt)
+
+patternification = column(passage, question, radio_button_group, prompt_box, sizing_mode="scale_width")
+patternification.align = "center"
+
+########################################################################################################################
+# Advantage diagram
+########################################################################################################################
+
+advantage_plots_per_task = []
+overlapping_range_per_task = []
+training_points_per_task = []
+clf_results_per_task = []
+pvp_results_per_task = []
+advantage_tabs = []
+advantage_all_figures = Tabs(tabs=advantage_tabs)
+
+advantage_box = Div(
+    text="在比较区域内点击某点以计算该点对应的性能点上的数据优势",
+    width=text_width,
+    style=box_style,
+    sizing_mode="scale_width",
+)
+advantage_box.align = "center"
+
+for task in tasks:
+    training_points, classifier_performances, pattern_performances = get_data(task)
+    training_points_per_task.append(list(training_points))
+    clf_results_per_task.append(reduct(classifier_performances, "accmax"))
+    pvp_results_per_task.append(reduct(pattern_performances, "accmax", task_best_pattern[task], "normal"))
+    advantage_plots_per_task.append(plot_polygons_bokeh(
+        task, training_points_per_task[-1], clf_results_per_task[-1], pvp_results_per_task[-1], clf_colors,
+        pvp_colors
+    ))
+    advantage_plots_per_task[-1].align = "center"
+    advantage_plots_per_task[-1].add_tools(CrosshairTool(dimensions="width", line_alpha=0.2))
+    overlapping_range_per_task.append(calculate_overlap(clf_results_per_task[-1], pvp_results_per_task[-1]))
+    advantage_tabs.append(Panel(child=advantage_plots_per_task[-1], title=task))
+
+    advantage_plots_per_task[-1].on_event(
+        Tap,
+        lambda event: metric_tap(
+            event,
+            overlapping_range_per_task[advantage_all_figures.active],
+            training_points_per_task[advantage_all_figures.active],
+            clf_results_per_task[advantage_all_figures.active],
+            pvp_results_per_task[advantage_all_figures.active],
+            advantage_box,
+            advantage_plots_per_task[advantage_all_figures.active],
+        ),
+    )
+
+    if task == "MNLI":
+        training_points_per_task.append(list(training_points))
+        clf_results_per_task.append(reduct(classifier_performances, "accmax"))
+        pvp_results_per_task.append(reduct(pattern_performances, "accmax", task_best_pattern[task], "normal"))
+        advantage_plots_per_task.append(plot_polygons_bokeh(
+            task, training_points_per_task[-1], clf_results_per_task[-1], pvp_results_per_task[-1], clf_colors,
+            pvp_colors, x_log_scale=True
+        ))
+        advantage_plots_per_task[-1].align = "center"
+        advantage_plots_per_task[-1].add_tools(CrosshairTool(dimensions="width", line_alpha=0.2))
+        overlapping_range_per_task.append(calculate_overlap(clf_results_per_task[-1], pvp_results_per_task[-1]))
+        advantage_tabs.append(Panel(child=advantage_plots_per_task[-1], title="MNLI (log scale)"))
+
+        advantage_plots_per_task[-1].on_event(
+            Tap,
+            lambda event: metric_tap(
+                event,
+                overlapping_range_per_task[advantage_all_figures.active],
+                training_points_per_task[advantage_all_figures.active],
+                clf_results_per_task[advantage_all_figures.active],
+                pvp_results_per_task[advantage_all_figures.active],
+                advantage_box,
+                advantage_plots_per_task[advantage_all_figures.active],
+            ),
+        )
+
+advantage_all_figures = Tabs(tabs=advantage_tabs)
+advantage_all_figures.align = "center"
+
+
+def on_integrate_click():
+    frames = 200
+    initial_placement = overlapping_range_per_task[advantage_all_figures.active][0]
+
+    if not isinstance(advantage_plots_per_task[advantage_all_figures.active].renderers[-1], Span):
+        metric_line = Span(
+            location=initial_placement,
+            line_alpha=0.7,
+            dimension="width",
+            line_color=clf_colors[0] if initial_placement < 0 else pvp_colors[0],
+            line_dash="dashed",
+            line_width=1,
+        )
+        advantage_plots_per_task[advantage_all_figures.active].renderers.extend([metric_line])
+    else:
+        advantage_plots_per_task[advantage_all_figures.active].renderers[-1].location = initial_placement
+        advantage_plots_per_task[advantage_all_figures.active].renderers[-1].line_color = clf_colors[
+            0] if initial_placement < 0 else pvp_colors[0]
+
+    average_advantage = 0
+    for i in range(1, frames):
+        metric_value = overlapping_range_per_task[advantage_all_figures.active][0] + (
+                overlapping_range_per_task[advantage_all_figures.active][1] -
+                overlapping_range_per_task[advantage_all_figures.active][0]) * (i / frames)
+        advantage_value = data_difference(metric_value, overlapping_range_per_task[advantage_all_figures.active],
+                                          training_points_per_task[advantage_all_figures.active],
+                                          clf_results_per_task[advantage_all_figures.active],
+                                          pvp_results_per_task[advantage_all_figures.active])
+        average_advantage = ((i - 1) * average_advantage + advantage_value) / i
+
+        advantage_plots_per_task[advantage_all_figures.active].renderers[-1].location = metric_value
+        advantage_plots_per_task[advantage_all_figures.active].renderers[-1].line_color = clf_colors[
+            0] if advantage_value < 0 else pvp_colors[0]
+        advantage_box.text = average_advantage_text(average_advantage)
+
+
+integrate = Button(width=175, max_width=175, label="对整个区域进行积分！")
+integrate.align = "center"
+integrate.on_click(on_integrate_click)
+
+
+def on_tab_change(attr, old, new):
+    advantage_box.text = "在比较区域内点击某点以计算该点对应的性能点上的数据优势"
+
+
+advantage_all_figures.on_change('active', on_tab_change)
+
+advantage_column = column(advantage_all_figures, advantage_box, integrate, sizing_mode="scale_width")
+
+########################################################################################################################
+# Null verbalizer diagram
+########################################################################################################################
+
+null_tabs = []
+null_all_figures = Tabs(tabs=null_tabs)
+
+for task in neutral_tasks:
+    training_points, classifier_performances, pattern_performances = get_data(task)
+    training_points = list(training_points)
+    clf_results = reduct(classifier_performances, "accmax")
+    pvp_results = reduct(pattern_performances, "accmax", task_best_pattern[task], "normal")
+    ctl_results = reduct(pattern_performances, "accmax", task_best_pattern[task], "neutral")
+    null_plot = plot_three_polygons_bokeh(task, training_points, clf_results, pvp_results, ctl_results, clf_colors,
+                                          pvp_colors, ctl_colors)
+    null_plot.align = "center"
+    null_plot.add_tools(CrosshairTool(dimensions="width", line_alpha=0.2))
+    null_tabs.append(Panel(child=null_plot, title=task))
+
+    if task == "MNLI":
+        null_plot = plot_three_polygons_bokeh(task, training_points, clf_results, pvp_results, ctl_results, clf_colors,
+                                              pvp_colors, ctl_colors, x_log_scale=True)
+        null_plot.align = "center"
+        null_plot.add_tools(CrosshairTool(dimensions="width", line_alpha=0.2))
+        null_tabs.append(Panel(child=null_plot, title="MNLI (log scale)"))
+
+null_all_figures = Tabs(tabs=null_tabs)
+null_all_figures.align = "center"
+
+########################################################################################################################
+# Patterns diagram
+########################################################################################################################
+
+pattern_tabs = []
+pattern_all_figures = Tabs(tabs=pattern_tabs)
+
+for task in tasks:
+    pattern_plot = pattern_graph(task)
+    pattern_plot.align = "center"
+    pattern_plot.add_tools(CrosshairTool(dimensions="width", line_alpha=0.2))
+    pattern_tabs.append(Panel(child=pattern_plot, title=task))
+
+pattern_all_figures = Tabs(tabs=pattern_tabs)
+pattern_all_figures.align = "center"
+
+########################################################################################################################
+# Add write-up text
+########################################################################################################################
+
+main_text_style = {
+    "min-height": "100px",
+    "overflow": "hidden",
+    "display": "block",
+    "margin": "auto",
+    "width": f"{text_width}px",
+    "font-size": "18px",
+}
+
+textbox1 = Div(text=text1, style=main_text_style)
+textbox2 = Div(text=text2, style=main_text_style)
+textbox3 = Div(text=text3, style=main_text_style)
+textbox4 = Div(text=text4, style=main_text_style)
+textbox5 = Div(text=text5, style=main_text_style)
+textbox1.align = "center"
+textbox2.align = "center"
+textbox3.align = "center"
+textbox4.align = "center"
+textbox5.align = "center"
+
+########################################################################################################################
+# Set up layouts and add to document
+########################################################################################################################
+
+main_body = column(textbox1, patternification, textbox2, advantage_column, textbox3, null_all_figures, textbox4, pattern_all_figures, textbox5, sizing_mode="scale_width")
+main_body.align = "center"
+
+curdoc().add_root(main_body)
+curdoc().title = "一条提示抵得上多少样本数据？"

naacl_demo/text.md

@@ -0,0 +1,90 @@
+# 一条提示抵得上多少条数据？
+
+当前 NLP 应用的主流方法是针对各式各样的特定任务，分别对预训练语言模型的分类头进行微调。随着语言模型变得越来越大，各种替代方法相继涌现，开始叫板在 [BERT](https://arxiv.org/abs/1810.04805)、[UniLM](https://arxiv.org/abs/1905.03197) 以及 [GPT](https://openai.com/research/language-unsupervised) 中广泛使用的分类头法。特别地，GPT-3 向大家普及了提示法，该方法通过自然语言输入来引导预训练语言模型依靠自身解决任务，而不再需要额外的分类头。
+
+提示很有意思，用户可以通过它向模型提供信息，这与传统的 ML 监督学习有很大不同。在与 [Alexader Rush](http://rush-nlp.com/) 合作的 [NAACL 2021 论文](https://arxiv.org/abs/2103.08493)中，我们研究了基于提示的微调，该方法可用于替代当前标准的有监督微调法，我们的实验表明提示通常比标准方法更有优势，因此该方法很有前途。在分析这种优势时，我们认为提示为模型带来了额外的信息，这促使我们想用数据点这个指标来量化这种优势，也就是说：**提示可以抵多少个数据点？**
+
+## 提示法
+
+为了使预训练语言模型能够完成特定任务，当前的主流方法是用随机初始化的线性分类头替换原模型的最后一层：词预测层。然后使用有监督的任务数据通过反向传播来训练修改后的模型，主要学习这个新分类头的权重，同时也可以更新模型其他层的权重。我们将这种方法称为*分类头*法。
+
+一种与之相竞争的方法是*提示法*：这类方法主要尝试使用原语言模型来预测目标类相应的单词来“回答”分类问题，而不是像传统方法那样“预测”类标签。这使得我们可以直接使用语言模型本身来执行分类任务。在这里，*提示*就是精心设计的、用于生成所需的答案文本的输入文本。
+
+这听起来可能很抽象，但这其实恰恰就是人类在实际生活中进行文本推理时所使用的非常自然的方法：例如，学校练习往往以一个文本输入（例如，一篇关于火星的文章）加上一个问题（“火星上有生命吗？”）的形式呈现，并期望你提供一个自然语言的答案（“否”<sup>1</sup>），该答案其实就可以映射到分类任务的某个类别（这里，“否”对应假，“是”对应真，本例就是个二分类问题）。在这种范式中，就像做语法练习一样，我们把特定于任务的数据输入给模型，而模型就像学生一样，需要以固定的方式进行填空。提示法希望能显式利用语言模型中包含的预训练信息，而不是仅以将其隐含表征馈送给线性分类头的方式隐式利用这些信息。
+
+以下是 [SuperGLUE](https://arxiv.org/abs/1905.00537) 中的 [BoolQ](https://arxiv.org/abs/1905.10044) 任务的示例，其题型为判断题，每条数据包括一个文本 <span style="color: #0c593d">passage</span> 及其对应的问题 <span style="color: #031154">question</span> ，其答案为布尔值，要么为真，要么为假。每条数据可以和 <span style="color: #910713">**模板（pattern）**</span> 一起组装成一个文本序列，该序列只有一个需预测的 <span style="color: #ba9004">**掩码词**</span>。预测出该掩码词后，预测词会被一个预设的 *言语器（verbalizer）* 转换为类，也就是说*言语器*负责输出词与类别之间的映射：比较该词被映射为*真*和*假*的概率，如果*真*的概率高，则最终预测为真，反之则为假。
+
+![image](mockups/boolqpatterns.png)
+
+## 微调
+
+这样，我们就把通用语言模型转变成了针对特定任务的分类器。这种基于提示的语言模型分类器的用法很多：
+ 
+- 预训练模型中保留的语言建模功能允许它们在没有额外数据的情况下执行，这与**以随机初始化开始因此初始性能也随机**的*线性分类头*模型相反。因此，许多论文将其用于[零样本分类](https://arxiv.org/abs/1912.10165)。 
+
+- 为了将有监督的任务数据引入模型，我们可以使用反向传播及语言建模中的交叉熵损失目标来微调：将与正确类别相关联的言语器词作为正确预测。 [PET](https://arxiv.org/abs/2001.07676) 使用了这个方法，[T5](https://arxiv.org/abs/1910.10683) 也使用了这个目标函数 - 尽管 T5 使用任务前缀来指示任务，而未使用自然语言提示来描述它。
+
+- 还有一种方法是使用*潜觉（priming）*，此时，我们需要为当前问题找到若干正确的示例，将其作为原输入文本的前缀一起输入给模型。它没有反向传播，所以永远不会修改语言模型的权重永远；相反，它主要靠在推理时使用注意力机制去利用正确的示例。[GPT3](https://arxiv.org/abs/2005.14165) 使用了该方法。
+
+- 最后，PET 的方法是使用提示模型���测未标注数据的软标签（或称为伪标签），然后将其作为标签去训练线性分类头。
+
+在本文中，我们想在提示法和分类头法之间进行一个公平的比较，因此我们统一采用基于反向传播的微调方法。
+
+## 一个提示可以抵多少条数据？
+
+正如我们所看到的，分类头法和提示法都可以用于针对下游任务进行有监督微调。二者的核心区别在于，除了带标注的原始样本外，提示法还给了模型一个用于对特定任务进行粗略描述的句子。从某种意义上说，这句话也是一种监督数据，因为它告诉模型任务的信息，但它在本质上与机器学习中标准的监督数据又截然不同。我们应该如何看待这种新的监督数据？又该如何量化这种方法的“零样本”程度？
+
+我们通过在 SuperGLUE 任务和 MNLI 上比较*分类头法*和*提示法*来尝试回答上面的问题。我们使用的具体方法是：对每个任务，我们通过从数据集中选取样本数不断增加的子集，然后在每个子集上使用这两种方法对 [`RoBERTa-large`](https://arxiv.org/abs/1907.11692) 进行微调，同时其他所有配置保持不变，最后对评估各自的微调模型的性能。为了公平起见，我们先调整基线分类头模型的超参，并使它们的性能达到 SuperGLUE 排行榜中 BERT++ 的性能水平，然后在对应的*提示法*模型中采用相同的超参。
+
+下图绘制了每个任务 <sup>2</sup> 的最终性能（指标随任务而不同）随数据集大小的变化曲线。有了这个图，我们就能够对两种方法在给定任务上达到一定性能水平所需的数据量进行对比。我们将这种差异称为在该性能水平上其中一个方法相对于其他方法的*数据优势*。我们将两种方法都能达到的性能的范围称为*比较窗口*。通过在该范围内进行积分，我们可以获得在某任务上一种方法相对于另一种方法的“平均数据优势”。从图上看，这即是两条曲线所夹区域的的面积除以比较窗口的高度。<sup>3</sup>
+
+![image](mockups/advantage.png)
+
+下表总结了在每个任务上提示法相对于分类头法的平均数据优势，其误差范围由自助采样法（bootstrapping）获得，具体做法是对每个数据规模，我们运行 4 次分类头法和 4 次提示法（即每个数据规模共 16 种组合），然后计算这些结果的标准差。不同任务的结果有很大不同；甚至对于同一任务的不同数据集，结果也会有所不同，例如 MNLI 和 RTE，这俩数据集虽然同属蕴涵任务，但结果就很不同。然而，总的趋势也很明显，即：除 WiC <sup>4</sup> 之外，提示方法在其他任务中都具有显著的优势。 **提示提供的附加信息始终大致相当于数百个数据点**。
+
+|                | MNLI     | BoolQ  | CB   | COPA    | MultiRC<sup>5</sup> | RTE    | WiC     | WSC     |
+|----------------|----------|--------|------|---------|----------|--------|---------|---------|
+| 提示法 vs 分类头法 | 3506±536 | 752±46 | 90±2 | 288±242 | 384±378  | 282±34 | -424±74 | 281±137 |
+
+
+## 模板与言语器
+
+#### 对言语器进行控制
+
+当前，提示主要被用作零样本分类的工具，这是一个很自然的用法。然而，真正操作起来，零样本一般会很棘手，因为需要对提示和言语器进行完美对齐。在上文中，我们已经表明，提示可以应用到更广泛的场景中，包括在全数据场景中。为了对比提示法的零样本性和自适应性，我们考虑一个*空言语器（null verbalizer）*，该言语器与任务完全无关。对于只需要填写一个词的任务（因此 COPA 和 WSC 数据集不在此列），我们把其言语映射（例如“是”、“否”、“也许”、“对”或“错”）替换成随机的。这样的话，提示模型就会像分类头模型一样，在没有训练数据的情况下无法使用。我们对空言语器配置进行与上文相同的优势分析，并绘制出相应的曲线，如下：
+
+![image](mockups/nullverbalizer.png)
+
+|                | MNLI     | BoolQ  | CB   | MultiRC<sup>5</sup> | RTE    | WiC     |
+|----------------|----------|--------|------|----------|--------|---------|
+| 提示法 vs 分类头法 | 3506±536 | 752±46 | 90±2 | 384±378  | 282±34 | -424±74 |
+| 提示法 vs 空言语器 | 150±252  | 299±81 | 78±2 | 74±56    | 404±68 | -354±166 |
+| 空言语器 vs 分类头法 | 3355±612 | 453±90 | 12±1 | 309±320  | -122±62 | -70±160 |
+
+从结果来看，其数据优势噪声比直接提示法与分类头法的数据优势的噪声更大。然而，我们也发现，即使仅使用空言语器，语言模型也能够适应任务，即使只有几个数据点，其也能凭借恰当的提示取得与分类头模型相当或更好的性能。因此，我们可以认为，即使没有信息丰富的言语器，提示法带来的归纳偏差也是有益的。
+
+#### ��板选择带来的影响
+
+另一个可能影响提示法在零样本分类场景下的成败的因素是：提示模板的选择。这里，我们看一下该因素对我们的影响。我们复用了 PET 中的模板（每个任务有两到三个完全不同的模板），并对每个任务的每种模板进行了实验，结果如下。我们可以看到提示的选择对结果没有显著影响，其方差小于随机种子带来的方差。
+
+![image](mockups/prompts.png)
+
+## 最后的话
+
+通过这项工作，我们研究了一种新的、基于自然语言提示的微调方法，其目的是通过单词预测显式地利用预训练模型的语言建模能力，而不是通过基于模型中间表征的线性分类器隐式地利用它。为了公平比较，我们把问题建模为用反向传播来微调基于提示的分类器语言模型，我们发现提示法通常优于标准的微调线性分类头的方法。我们用数据点来估计这种优势，以衡量人类通过提示提供的附加信息，并发现**编写提示始终抵得上数百个数据点**。此外，即使没有言语器带来的信息量（即使用空言语器），这种优势仍然存在，并且这种方法对于提示的选择相当鲁棒。
+
+对于从业人员而言，我们相信基于提示的微调应当而且会成为一种标准工​​具：特别是对于中小型的特定任务数据集，自己设计提示只需付出很小的努力即可获得相当大的数据优势。而对于研究人员而言，我们认为这个领域还有很多问题尚待探索：为什么相同的提示在 MNLI 数据集上抵得上 3500 个样本，而在 RTE 数据集上却只抵得上 282 个样本？提示与标准 ML 监督有何关系？由于它们具有一些零样本特性，因此它们对对抗样本或领域外样本的反应是否有所不同？
+
+<sup>1</sup>：或者严格点说，至少据我们所知为否。
+
+<sup>2</sup>：眼尖的读者会注意到所有这些曲线都是单调的。我们为每个实验执行了 4 次运行（即对每个任务的每个数据规模，分别各运行分类头法和提示法 4 次，并用得到的模型测试）。为了清楚起见，并且由于两种方法的微调有时都会失败，从而导致负异常值，因此针对每个数据规模我们报告在此数据规模或更小的数据规模下获得的最大性能，我们将其称为*累积最大*聚合。除了减少方差之外，这不会对报告的数据优势产生太大影响，且即使对于非单调曲线，对图形的解读仍然成立。
+
+<sup>3</sup>：在计算每个指标的数据优势时，我们为每个数据赋予相同的权重；我们还可以针对每个任务重新参数化 y 轴。这种做法到底是会对提示法相对于分类头法的数据优势起促进作用还是阻碍作用不好说，与数据集相关。举个例子，强调接近收敛时的增益会增加 CB 和 MNLI 上的提示法的数据优势，但会降低 COPA 或 BoolQ 上的优势。
+
+<sup>4</sup>：有趣的是，PET 已经发现提示对该数据集无效。
+
+<sup>5</sup>：MultiRC 的比较窗口太小，因为分类头基线模型无法学习到多数类之外知识；我们使用整个区域来获得实际结果的下界。
+
+> 英文原文: <url> https://huggingface.co/spaces/teven-projects/how_many_data_points </url>
+> 原文作者：Teven Le Scao
+> 译者: Matrix Yao (姚伟峰)，英特尔深度学习工程师，工作方向为 transformer-family 模型在各模态数据上的应用及大规模模型的训练推理。

naacl_demo/text.py

@@ -0,0 +1,171 @@
+text1 = """<h1 id="how-many-data-points-is-a-prompt-worth">一条提示抵得上多少条数据？</h1>
+<img class='center' style='height: 5em; float: right;' src='https://raw.githubusercontent.com/TevenLeScao/transformer-xl/master/pytorch/assets/avatar_logo_joint.png' alt='avatar'>
+<h4>发表于 2021 年 4 月 6 日</h4> 
+<h4>Teven Le Scao, Hugging Face 研究员 • <a href="https://twitter.com/Fluke_Ellington">@Fluke_Ellington</a> </h4> 
+<p>当前 NLP 应用的主流方法是针对各式各样的特定任务，分别对预训练语言模型的分类头进行微调。随着语言模型变得越来越大，各种替代方法相继涌现，开始叫板在 <a href="https://arxiv.org/abs/1810.04805">BERT</a>、<a href="https://arxiv.org/abs/1905.03197">UniLM</a> 以及 <a href="https://openai.com/research/language-unsupervised">GPT</a> 中广泛使用的分类头法。特别地，GPT-3 向大家普及了提示法，该方法通过自然语言输入来引导预训练语言模型依靠自身解决任务，而不再需要额外的分类头。</p>
+<p>提示很有意思，用户可以通过它向模型提供信息，这与传统的 ML 监督学习有很大不同。在与 <a href="http://rush-nlp.com/">Sasha Rush</a> 合作的 NAACL 2021 <a href="https://arxiv.org/abs/2103.08493">论文</a>中，我们研究了基于提示的微调，该方法可用于替代当前标准的有监督微调法，我们的实验表明提示通常比标准方法更有优势，因此该方法很有前途。在分析这种优势时，我们认为提示为模型带来了额外的信息，这促使我们想用数据点这个指标来量化这种优势，也就是说：<strong>一个提示可以抵多少条数据？</strong> </p>
+
+<h2 id="prompting">提示法</h2>
+<p>为了使预训练语言模型能够完成特定任务，当前的主流方法是用随机初始化的线性分类头替换原模型的最后一层：词预测层。然后使用有监督的任务数据通过反向传播来训练修改后的模型，主要学习这个新分类头的权重，同时也可以更新模型其他层的权重。我们将这种方法称为<em>分类头</em>法。</p>
+<p>一种与之相竞争的方法是<em>提示法</em>：这类方法主要尝试使用原语言模型来预测目标类相应的单词来“回答”分类问题，而不是像传统方法那样“预测”类标签。这使得我们可以直接使用语言模型本身来执行分类任务。在这里，<em>提示</em>就是精心设计的、用于生成所需的答案文本的输入文本。</p>
+<p id="footnote1back">这听起来可能很抽象，但这其实恰恰就是人类在实际生活中进行文本推理时所使用的非常自然的方法：例如，学校练习往往以一个文本输入（例如，一篇关于火星的文章）加上一个问题（&quot;火星上有生命吗？&quot;）的形式呈现，并期望你提供一个自然语言的答案（&quot;否&quot;<a href="#footnote1"><sup>1</sup></a>），该答案其实就可以映射到分类任务的某个类别（这里，&quot;否&quot;对应<code>假</code>，&quot;是&quot;对应<code>真</code>，本例就是个二分类问题）。在这种范式中，就像做语法练习一样，我们把特定于任务的数据输入给模型，而模型就像学生一样，需要以固定的方式进行填空。提示法希望能显式利用语言模型中包含的预训练信息，而不是仅以将其隐含表征馈送给线性分类头的方式隐式利用这些信息。</p>
+<p>以下是 <a href="https://arxiv.org/abs/1905.00537">SuperGLUE</a> 中的 <a href="https://arxiv.org/abs/1905.10044">BoolQ</a> 任务的示例，其题型为判断题，每条数据包括一个文本 <span style="color: #0c593d">passage</span> 及其对应的问题 <span style="color: #031154">question</span> ，其答案为布尔值，要么为真，要么为假。每条数据可以和 <span style="color: #910713"><strong>模板（pattern）</strong></span> 一起组装成一个文本序列，该序列只有一个需预测的 <span style="color: #ba9004"><strong>掩码词</strong></span>。预测出该掩码词后，预测词会被一个预设的 <em>言语器（verbalizer）</em> 转换为类，也就是说<em>言语器</em>负责输出词与类别之间的映射：比较该词被映射为<em>是</em>和<em>否</em>的概率，如果<em>是</em>的概率高，则最终预测为<code>真</code>，反之则为<code>假</code>。
+</p>
+"""
+
+text2 = """<h2 id="fine-tuning">微调</h2>
+<p>这样，我们就把通用语言模型转变成了针对特定任务的分类器。这种基于提示的语言模型分类器的用法很多： </p>
+<ul>
+<li>预训练模型中保留的语言建模功能允许它们在没有额外数据的情况下执行，这与<strong>以随机初始化开始因此初始性能也随机</strong>的<em>线性分类头</em>模型相反。因此，许多论文将其用于 <a href="https://arxiv.org/abs/1912.10165">零样本分类</a>。</li>
+<li>为了将有监督的任务数据引入模型，我们可以使用反向传��及语言建模中的交叉熵损失目标来微调：将与正确类别相关联的言语器词作为正确预测。 <a href="https://arxiv.org/abs/2001.07676">PET</a> 使用了这个方法，<a href="https://arxiv.org/abs/1910.10683">T5</a> 也使用了这个目标函数 - 尽管 T5 使用任务前缀来指示任务，而未使用自然语言提示来描述它。</li>
+<li>还有一种方法是使用<em>潜觉（priming）</em>，此时，我们需要为当前问题找到若干正确的示例，将其作为原输入文本的前缀一起输入给模型。它没有反向传播，所以永远不会修改语言模型的权重永远；相反，它主要靠在推理时使用注意力机制去利用正确的示例。<a href="https://arxiv.org/abs/2005.14165">GPT-3</a> 使用了该方法。</li>
+<li>最后，PET 的方法是使用提示模型预测未标注数据的软标签（或称为伪标签），然后将其作为标签去训练线性分类头。</li>
+</ul>
+<p>在本文中，我们想在提示法和分类头法之间进行一个公平的比较，因此我们统一采用基于反向传播的微调方法。</p>
+<h2 id="how-many-data-points-is-a-prompt-worth-">一个提示可以抵多少条数据？</h2>
+<p>正如我们所看到的，分类头法和提示法都可以用于针对下游任务进行有监督微调。二者的核心区别在于，除了带标注的原始样本外，提示法还给了模型一个用于对特定任务进行粗略描述的句子。从某种意义上说，这句话也是一种监督数据，因为它告诉模型任务的信息，但它在本质上与机器学习中标准的监督数据又截然不同。我们应该如何看待这种新的监督数据？又该如何量化这种方法的“零样本”程度？</p>
+<p>我们通过在 SuperGLUE 任务和 MNLI 上比较<em>分类头法</em>和<em>提示法</em>来尝试回答上面的问题。我们使用的具体方法是：对每个任务，我们通过从数据集中选取样本数不断增加的子集，然后在每个子集上使用这两种方法对 <a href="https://arxiv.org/abs/1907.11692"><code>RoBERTa-large</code></a> 进行微调，同时其他所有配置保持不变，最后对评估各自的微调模型的性能。为了公平起见，我们先调整基线分类头模型的超参，并使它们的性能达到 SuperGLUE 排行榜中 BERT++ 的性能水平，然后在对应的<em>提示法</em>模型中采用相同的超参。</p>
+<p id="footnote2back">下图绘制了每个任务 <a href="#footnote2"><sup>2</sup></a> 的最终性能（指标随任务而不同）随数据集大小的变化曲线。有了这个图，我们就能够对两种方法在给定任务上达到一定性能水平所需的数据量进行对比。我们将这种差异称为在该性能水平上其中一个方法相对于其他方法的<em>数据优势</em>。我们将两种方法都能达到的性能的范围称为<em>比较窗口</em>。通过在该范围内进行积分，我们可以获得在某任务上一种方法相对于另一种方法的<em>平均数据优势</em>。从图上看，这即是两条曲线所夹区域的的面积除以比较窗口的高度。<a href="#footnote3"><sup>3</sup></a> </p>
+"""
+
+text3 = """<html>
+<head>
+<style>
+table, th, td {
+  border: 1px solid black;
+  border-collapse: collapse;
+}
+.styled-table {
+  margin-left: auto; 
+  margin-right: auto;
+}
+.styled-table {
+    border-collapse: collapse;
+    font-size: 1em;
+    font-family: sans-serif;
+    min-width: 400px;
+    box-shadow: 0 0 20px rgba(0, 0, 0, 0.15);
+}
+.styled-table thead tr {
+    background-color: #ffebcd;
+    color: #000000;
+    text-align: left;
+}
+.styled-table th,
+.styled-table td {
+    padding: 6px 8px;
+    font-size: 13px;
+}
+.styled-table tbody tr {
+    border-bottom: 1px solid #dddddd;
+}
+
+.styled-table tbody tr:nth-of-type(even) {
+    background-color: #f3f3f3;
+}
+
+.styled-table tbody tr:last-of-type {
+    border-bottom: 2px solid #29004a;
+}
+}
+
+
+</style>
+</head>
+<body>
+<p id="footnote4back">下表总结了在每个任务上提示法相对于分类头法的平均数据优势，其误差范围由自助采样法（bootstrapping）获得，具体做法是对每个数据规模，我们运行 4 次分类头法和 4 次提示法（即每个数据规模共 16 种组合），然后计算这些结果的标准差。不同任务的结果有很大不同；甚至对于同一任务的不同数据集，结果也会有所不同，例如 MNLI 和 RTE，这俩数据集虽然同属蕴涵任务，但结果就很不同。然而，总的趋势也很明显，即：除 WiC <a href="#footnote4"><sup>4</sup></a> 之外，提示方法在其他任务中都具有显著的优势。 <strong>提示提供的附加信息始终大致相当于数百个数据点</strong>。</p>
+<table id="footnote5back" class="styled-table">
+<thead>
+<tr>
+<th></th>
+<th><a href="https://arxiv.org/abs/1704.05426">MNLI</a></th>
+<th><a href="https://arxiv.org/abs/1905.10044">BoolQ</a></th>
+<th><a href="https://ojs.ub.uni-konstanz.de/sub/index.php/sub/article/view/601">CB</a></th>
+<th><a href="https://people.ict.usc.edu/~gordon/publications/AAAI-SPRING11A.PDF">COPA</a></th>
+<th><a href="https://www.aclweb.org/anthology/N18-1023/">MultiRC</a><sup><a href="#footnote5">5</a></sup></th>
+<th><a href="https://link.springer.com/chapter/10.1007/978-94-024-0881-2_42">RTE</a></th>
+<th><a href="https://arxiv.org/abs/1808.09121">WiC</a></th>
+<th><a href="https://arxiv.org/abs/1808.09121">WSC</a></th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>提示法 vs 分类头法</td>
+<td>3506±536</td>
+<td>752±46</td>
+<td>90±2</td>
+<td>288±242</td>
+<td>384±378</td>
+<td>282±34</td>
+<td>-424±74</td>
+<td>281±137</td>
+</tr>
+</tbody>
+</table>
+<h2 id="patterns-and-verbalizers">模板与言语器</h2>
+<h4 id="control-verbalizers">对言语器进行控制</h4>
+<p>当前，提示主要被用作零样本分类的工具，这是一个很自然的用法。然而，真正操作起来，零样本一般会很棘手，因为需要对提示和言语器进行完美对齐。在上文中，我们已经表明，提示可以应用到更广泛的场景中，包括在全数据场景中。为了对比提示法的零样本性和自适应性，我们考虑一个<em>空言语器（null verbalizer）</em>，该言语器与任务完全无关。对于只需要填写一个词的任务（因此 COPA 和 WSC 数据集不在此列），我们把其言语映射（例如&quot;是&quot;、&quot;否&quot;、&quot;也许&quot;、&quot;对&quot;或&quot;错&quot;）替换成随机的。这样的话，提示模型就会像分类头模型一样，在没有训练数据的情况下无法使用。我们对空言语器配置进行与上文相同的优势分析，并绘制出相应的曲线，如下：</p>
+</body>
+</html>
+"""
+
+text4 = """<table id="footnote6back" class="styled-table">
+<thead>
+<tr>
+<th></th>
+<th>MNLI</th>
+<th>BoolQ</th>
+<th>CB</th>
+<th>MultiRC<a href="#footnote5"><sup>6</sup></a></th>
+<th>RTE</th>
+<th>WiC</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>提示法 vs 分类头法</td>
+<td>3506±536</td>
+<td>752±46</td>
+<td>90±2</td>
+<td>384±378</td>
+<td>282±34</td>
+<td>-424±74</td>
+</tr>
+<tr>
+<td>提示法 vs 空言语器</td>
+<td>150±252</td>
+<td>299±81</td>
+<td>78±2</td>
+<td>74±56</td>
+<td>404±68</td>
+<td>-354±166</td>
+</tr>
+<tr>
+<td>空言语器 vs 分类头法</td>
+<td>3355±612</td>
+<td>453±90</td>
+<td>12±1</td>
+<td>309±320</td>
+<td>-122±62</td>
+<td>-70±160</td>
+</tr>
+</tbody>
+</table>
+<p>从结果来看，其数据优势噪声比直接提示法与分类头法的数据优势的噪声更大。然而，我们也发现，即使仅使用空言语器，语言模型也能够适应任务，即使只有几个数据点，其也能凭借恰当的提示取得与分类头模型相当或更好的性能。因此，我们可以认为，即使没有信息丰富的言语器，提示法带来的归纳偏差也是有益的。</p>
+<h4 id="influence-of-the-pattern-choice">模板选择带来的影响</h4>
+<p>另一个可能影响提示法在零样本分类场景下的成败的因素是：提示模板的选择。这里，我们看一下该因素对我们的影响。我们复用了 PET 中的模板（每个任务有两到三个完全不同的模板），并对每个任务的每种模板进行了实验，结果如下。我们可以看到提示的选择对结果没有显著影响，其方差小于随机种子带来的方差。</p>
+"""
+
+text5 = """<h2 id="mot-de-la-fin">最后的话</h2>
+<p>通过这项工作，我们研究了一种新的、基于自然语言提示的微调方法，其目的是通过单词预测显式地利用预训练模型的语言建模能力，而不是通过基于模型中间表征的线性分类器隐式地利用它。为了公平比较，我们把问题建模为用反向传播来微调基于提示的分类器语言模型，我们发现提示法通常优于标准的微调线性分类头的方法。我们用数据点来估计这种优势，以衡量人类通过提示提供的附加信息，并发现<strong>编写提示始终抵得上数百个数据点</strong>。此外，即使没有言语器带来的信息量（即使用空言语器），这种优势仍然存在，并且这种方法对于提示的选择相当鲁棒。</p>
+<p>对于从业人员而言，我们相信基于提示的微调应当而且会成为一种标准工​​具：特别是对于中小型的特定任务数据集，自己设计提示只需付出很小的努力即可获得相当大的数据优势。而对于研究人员而言，我们认为这个领域还有很多问题尚待探索：为什么相同的提示在 MNLI 数据集上抵得上 3500 个样本，而在 RTE 数据集上却只抵得上 282 个样本？提示与标准 ML 监督有何关系？由于它们具有一些零样本特性，因此它们对对抗样本或领域外样本的反应是否有所不同？</p>
+<p id="footnote1"><sup><a href="#footnote1back">1</a></sup>: 或者严格点说，至少据我们所知为否。</p>
+<p id="footnote2"><sup><a href="#footnote2back">2</a></sup>: 眼尖的读者会注意到所有这些曲线都是单调的。我们为每个实验执行了 4 次运行（即对每个任务的每个数据规模，分别各运行分类头法和提示法 4 次，并用得到的模型测试）。为了清楚起见，并且由于两种方法的微调有时都会失败，从而导致负异常值，因此针对每个数据规模我们报告在此数据规模或更小的数据规模下获得的最大性能，我们将其称为*累积最大*聚合。除了减少方差之外，这不会对报告的数据优势产生太大影响，且即使对于非单调曲线，对图形的解读仍然成立。 </p>
+<p id="footnote3"><sup><a href="#footnote2back">3</a></sup>: 在计算每个指标的数据优势时，我们为每个数据赋予相同的权重；我们还可以针对每个任务重新参数化 y 轴。这种做法到底是会对提示法相对于分类头法的数据优势起促进作用还是阻碍作用不好说，与数据集相关。举个例子，强调接近收敛时的增益会增加 CB 和 MNLI 上的提示法的数据优势，但会降低 COPA 或 BoolQ 上的优势。 </p>
+<p id="footnote4"><sup><a href="#footnote4back">4</a></sup>: 有趣的是，PET 已经发现提示对该数据集无效。</p>
+<p id="footnote5"><sup><a href="#footnote5back">5</a> <a href="#footnote6back">6</a></sup>: MultiRC 的比较窗口太小，因为分类头基线模型无法学习到多数类之外知识；我们使用整个区域来获得实际结果的下界。</p>
+"""
+
+initial_passage = "In informal games, it is customary to announce 'check' when making a move that puts the opponent's king in check. In formal competitions, however, check is rarely announced."
+
+initial_question = "do you always have to say check in chess?"

requirements.txt

@@ -0,0 +1,22 @@
+bokeh==2.3.0
+cycler==0.10.0
+Jinja2==2.11.2
+kiwisolver==1.3.1
+MarkupSafe==1.1.1
+matplotlib==3.4.1
+numpy==1.18.4
+packaging==20.4
+pandas==1.0.3
+Pillow==7.1.2
+pyparsing==2.4.7
+python-dateutil==2.8.1
+pytz==2020.1
+PyYAML==5.3.1
+randomcolor==0.4.4.5
+scipy==1.4.1
+seaborn==0.11.1
+Shapely==1.7.1
+six==1.15.0
+tornado==6.0.4
+typing-extensions==3.7.4.2
+virtualenv-clone==0.5.4