Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.9
+
+#COPY requirements.txt /app/
+WORKDIR /app
+# # Set up a new user named "user" with user ID 1000
+# RUN useradd -m -u 1000 user
+# # Switch to the "user" user
+# USER user
+# # Set home to the user's home directory
+# ENV HOME=/home/user \
+# 	PATH=/home/user/.local/bin:$PATH
+
+# # Set the working directory to the user's home directory
+# WORKDIR $HOME/app
+
+# # Copy the current directory contents into the container at $HOME/app setting the owner to the user
+# COPY --chown=user . $HOME/app
+
+RUN --mount=type=secret,id=LICENSE_KEY,mode=0444,required=true \
+    pip install --upgrade pip \
+    && pip install typing_extensions==4.5.0 \
+    && pip install --quiet prodigy -f https://$(cat /run/secrets/LICENSE_KEY)@download.prodi.gy
+
+RUN chmod 777 .
+
+COPY prodigy.json .
+COPY data ./data/
+COPY recipe.py .
+COPY prodigy.sh .
+
+ENV PRODIGY_HOME /app
+ENV PRODIGY_LOGGING "verbose"
+ENV MAX_SESSIONS 50
+
+EXPOSE 7860
+
+CMD ["bash","prodigy.sh"]

data/known_answers_cooking.jsonl

@@ -0,0 +1,5 @@
+{"text":"Cauliflower leaves. Good in a curry, stew, stir fry. Only found out about it recently..","meta":{"explanation_label":"Cauliflower leaves is an ingredient since in the context it's used in the dishes. Curry, stew, and stir fry are dishes as they are the final product of the ingredients like cauliflower leaves.","explanation_boundaries":null},"_input_hash":-1856281439,"_task_hash":-1652827864,"tokens":[{"text":"Cauliflower","start":0,"end":11,"id":0,"ws":true},{"text":"leaves","start":12,"end":18,"id":1,"ws":false},{"text":".","start":18,"end":19,"id":2,"ws":true},{"text":"Good","start":20,"end":24,"id":3,"ws":true},{"text":"in","start":25,"end":27,"id":4,"ws":true},{"text":"a","start":28,"end":29,"id":5,"ws":true},{"text":"curry","start":30,"end":35,"id":6,"ws":false},{"text":",","start":35,"end":36,"id":7,"ws":true},{"text":"stew","start":37,"end":41,"id":8,"ws":false},{"text":",","start":41,"end":42,"id":9,"ws":true},{"text":"stir","start":43,"end":47,"id":10,"ws":true},{"text":"fry","start":48,"end":51,"id":11,"ws":false},{"text":".","start":51,"end":52,"id":12,"ws":true},{"text":"Only","start":53,"end":57,"id":13,"ws":true},{"text":"found","start":58,"end":63,"id":14,"ws":true},{"text":"out","start":64,"end":67,"id":15,"ws":true},{"text":"about","start":68,"end":73,"id":16,"ws":true},{"text":"it","start":74,"end":76,"id":17,"ws":true},{"text":"recently","start":77,"end":85,"id":18,"ws":false},{"text":"..","start":85,"end":87,"id":19,"ws":false}],"spans":[{"token_start":0,"token_end":1,"start":0,"end":18,"text":"Cauliflower leaves","label":"INGREDIENT"},{"token_start":6,"token_end":6,"start":30,"end":35,"text":"curry","label":"DISH"},{"token_start":8,"token_end":8,"start":37,"end":41,"text":"stew","label":"DISH"},{"token_start":10,"token_end":11,"start":43,"end":51,"text":"stir fry","label":"DISH"}],"llm":{"prompt":"You are an expert Named Entity Recognition (NER) system. Your task is to accept Text as input and extract named entities for the set of predefined entity labels.\nFrom the Text input provided, extract named entities for each label in the following format:\n\nDISH: <comma delimited list of strings>\nEQUIPMENT: <comma delimited list of strings>\nINGREDIENT: <comma delimited list of strings>\n\nBelow are definitions of each label to help aid you in what kinds of named entities to extract for each label.\nAssume these definitions are written by an expert and follow them closely.\n\nDISH: Extract the name of a known dish.\nINGREDIENT: Extract the name of a cooking ingredient, including herbs and spices.\nEQUIPMENT: Extract any mention of cooking equipment. e.g. oven, cooking pot, grill\n\n\nBelow are some examples (only use these as a guide):\n\nText:\n'''\nYou can probably sand-blast it if it's an anodized aluminum pan.\n'''\n\nEQUIPMENT: anodized aluminum pan\n\n\nHere is the text that needs labeling:\n\nText:\n'''\nCauliflower leaves. Good in a curry, stew, stir fry. Only found out about it recently..\n'''","response":"DISH: curry, stew, stir fry\nINGREDIENT: Cauliflower leaves\nEQUIPMENT:"},"_view_id":"ner_manual","_is_binary":false,"answer":"accept","_timestamp":1698173684,"_annotator_id":"2023-10-24_14-36-43","_session_id":"2023-10-24_14-36-43"}
+{"text":"My Pro 500 is going on 18 years old. Thing is a tank. Just don't drop it on your toe","meta":{"explanation_label":"Pro 500 is a popular blender by KitchenAid.","explanation_boundaries":"Incorrect boundaries as it included 'My'."},"_input_hash":664573206,"_task_hash":-2138876470,"tokens":[{"text":"My","start":0,"end":2,"id":0,"ws":true},{"text":"Pro","start":3,"end":6,"id":1,"ws":true},{"text":"500","start":7,"end":10,"id":2,"ws":true},{"text":"is","start":11,"end":13,"id":3,"ws":true},{"text":"going","start":14,"end":19,"id":4,"ws":true},{"text":"on","start":20,"end":22,"id":5,"ws":true},{"text":"18","start":23,"end":25,"id":6,"ws":true},{"text":"years","start":26,"end":31,"id":7,"ws":true},{"text":"old","start":32,"end":35,"id":8,"ws":false},{"text":".","start":35,"end":36,"id":9,"ws":true},{"text":"Thing","start":37,"end":42,"id":10,"ws":true},{"text":"is","start":43,"end":45,"id":11,"ws":true},{"text":"a","start":46,"end":47,"id":12,"ws":true},{"text":"tank","start":48,"end":52,"id":13,"ws":false},{"text":".","start":52,"end":53,"id":14,"ws":true},{"text":"Just","start":54,"end":58,"id":15,"ws":true},{"text":"do","start":59,"end":61,"id":16,"ws":false},{"text":"n't","start":61,"end":64,"id":17,"ws":true},{"text":"drop","start":65,"end":69,"id":18,"ws":true},{"text":"it","start":70,"end":72,"id":19,"ws":true},{"text":"on","start":73,"end":75,"id":20,"ws":true},{"text":"your","start":76,"end":80,"id":21,"ws":true},{"text":"toe","start":81,"end":84,"id":22,"ws":false}],"spans":[{"token_start":1,"token_end":2,"start":3,"end":10,"text":"Pro 500","label":"EQUIPMENT"}],"llm":{"prompt":"You are an expert Named Entity Recognition (NER) system. Your task is to accept Text as input and extract named entities for the set of predefined entity labels.\nFrom the Text input provided, extract named entities for each label in the following format:\n\nDISH: <comma delimited list of strings>\nEQUIPMENT: <comma delimited list of strings>\nINGREDIENT: <comma delimited list of strings>\n\nBelow are definitions of each label to help aid you in what kinds of named entities to extract for each label.\nAssume these definitions are written by an expert and follow them closely.\n\nDISH: Extract the name of a known dish.\nINGREDIENT: Extract the name of a cooking ingredient, including herbs and spices.\nEQUIPMENT: Extract any mention of cooking equipment. e.g. oven, cooking pot, grill\n\n\nBelow are some examples (only use these as a guide):\n\nText:\n'''\nYou can probably sand-blast it if it's an anodized aluminum pan.\n'''\n\nEQUIPMENT: anodized aluminum pan\n\n\nHere is the text that needs labeling:\n\nText:\n'''\nMy Pro 500 is going on 18 years old. Thing is a tank. Just don't drop it on your toe\n'''","response":"EQUIPMENT: Pro 500"},"_view_id":"ner_manual","_is_binary":false,"answer":"accept","_timestamp":1698173153,"_annotator_id":"2023-10-24_14-36-43","_session_id":"2023-10-24_14-36-43"}
+{"text":"1/2 cup butter, 1 cup parm, and 1/2 cup heavy cream. Optionally put a half clove of minced garlic in the butter.","meta":{"explanation_label":"All of the entities are used and described as ingredients (inputs to dishes).","explanation_boundaries":"Measurements like cups or cloves are not to be included. Adjectives like 'minced' or 'heavy' should be included to better describe the ingredients."},"_input_hash":-2038609053,"_task_hash":481198127,"tokens":[{"text":"1/2","start":0,"end":3,"id":0,"ws":true},{"text":"cup","start":4,"end":7,"id":1,"ws":true},{"text":"butter","start":8,"end":14,"id":2,"ws":false},{"text":",","start":14,"end":15,"id":3,"ws":true},{"text":"1","start":16,"end":17,"id":4,"ws":true},{"text":"cup","start":18,"end":21,"id":5,"ws":true},{"text":"parm","start":22,"end":26,"id":6,"ws":false},{"text":",","start":26,"end":27,"id":7,"ws":true},{"text":"and","start":28,"end":31,"id":8,"ws":true},{"text":"1/2","start":32,"end":35,"id":9,"ws":true},{"text":"cup","start":36,"end":39,"id":10,"ws":true},{"text":"heavy","start":40,"end":45,"id":11,"ws":true},{"text":"cream","start":46,"end":51,"id":12,"ws":false},{"text":".","start":51,"end":52,"id":13,"ws":true},{"text":"Optionally","start":53,"end":63,"id":14,"ws":true},{"text":"put","start":64,"end":67,"id":15,"ws":true},{"text":"a","start":68,"end":69,"id":16,"ws":true},{"text":"half","start":70,"end":74,"id":17,"ws":true},{"text":"clove","start":75,"end":80,"id":18,"ws":true},{"text":"of","start":81,"end":83,"id":19,"ws":true},{"text":"minced","start":84,"end":90,"id":20,"ws":true},{"text":"garlic","start":91,"end":97,"id":21,"ws":true},{"text":"in","start":98,"end":100,"id":22,"ws":true},{"text":"the","start":101,"end":104,"id":23,"ws":true},{"text":"butter","start":105,"end":111,"id":24,"ws":false},{"text":".","start":111,"end":112,"id":25,"ws":false}],"spans":[{"token_start":2,"token_end":2,"start":8,"end":14,"text":"butter","label":"INGREDIENT"},{"token_start":6,"token_end":6,"start":22,"end":26,"text":"parm","label":"INGREDIENT"},{"token_start":11,"token_end":12,"start":40,"end":51,"text":"heavy cream","label":"INGREDIENT"},{"token_start":20,"token_end":21,"start":84,"end":97,"text":"minced garlic","label":"INGREDIENT"},{"token_start":24,"token_end":24,"start":105,"end":111,"text":"butter","label":"INGREDIENT"}],"llm":{"prompt":"You are an expert Named Entity Recognition (NER) system. Your task is to accept Text as input and extract named entities for the set of predefined entity labels.\nFrom the Text input provided, extract named entities for each label in the following format:\n\nDISH: <comma delimited list of strings>\nEQUIPMENT: <comma delimited list of strings>\nINGREDIENT: <comma delimited list of strings>\n\nBelow are definitions of each label to help aid you in what kinds of named entities to extract for each label.\nAssume these definitions are written by an expert and follow them closely.\n\nDISH: Extract the name of a known dish.\nINGREDIENT: Extract the name of a cooking ingredient, including herbs and spices.\nEQUIPMENT: Extract any mention of cooking equipment. e.g. oven, cooking pot, grill\n\n\nBelow are some examples (only use these as a guide):\n\nText:\n'''\nYou can probably sand-blast it if it's an anodized aluminum pan.\n'''\n\nEQUIPMENT: anodized aluminum pan\n\n\nHere is the text that needs labeling:\n\nText:\n'''\n1/2 cup butter, 1 cup parm, and 1/2 cup heavy cream. Optionally put a half clove of minced garlic in the butter.\n'''","response":"EQUIPMENT: None\nINGREDIENT: butter, parm, heavy cream, minced garlic"},"_view_id":"ner_manual","_is_binary":false,"answer":"accept","_timestamp":1698172783,"_annotator_id":"2023-10-24_14-36-43","_session_id":"2023-10-24_14-36-43"}
+{"text":"The timing would be about right for the turkey, but what are you doing for sides? May just need to adjust your dinner time a bit.","meta":{"explanation_label":"Turkey could be a dish or ingredient; when in doubt, infer from the context. In this example, it'll be a dish since it's the final cooking output.","explanation_boundaries":null},"_input_hash":974804537,"_task_hash":-1041528534,"tokens":[{"text":"The","start":0,"end":3,"id":0,"ws":true},{"text":"timing","start":4,"end":10,"id":1,"ws":true},{"text":"would","start":11,"end":16,"id":2,"ws":true},{"text":"be","start":17,"end":19,"id":3,"ws":true},{"text":"about","start":20,"end":25,"id":4,"ws":true},{"text":"right","start":26,"end":31,"id":5,"ws":true},{"text":"for","start":32,"end":35,"id":6,"ws":true},{"text":"the","start":36,"end":39,"id":7,"ws":true},{"text":"turkey","start":40,"end":46,"id":8,"ws":false},{"text":",","start":46,"end":47,"id":9,"ws":true},{"text":"but","start":48,"end":51,"id":10,"ws":true},{"text":"what","start":52,"end":56,"id":11,"ws":true},{"text":"are","start":57,"end":60,"id":12,"ws":true},{"text":"you","start":61,"end":64,"id":13,"ws":true},{"text":"doing","start":65,"end":70,"id":14,"ws":true},{"text":"for","start":71,"end":74,"id":15,"ws":true},{"text":"sides","start":75,"end":80,"id":16,"ws":false},{"text":"?","start":80,"end":81,"id":17,"ws":true},{"text":"May","start":82,"end":85,"id":18,"ws":true},{"text":"just","start":86,"end":90,"id":19,"ws":true},{"text":"need","start":91,"end":95,"id":20,"ws":true},{"text":"to","start":96,"end":98,"id":21,"ws":true},{"text":"adjust","start":99,"end":105,"id":22,"ws":true},{"text":"your","start":106,"end":110,"id":23,"ws":true},{"text":"dinner","start":111,"end":117,"id":24,"ws":true},{"text":"time","start":118,"end":122,"id":25,"ws":true},{"text":"a","start":123,"end":124,"id":26,"ws":true},{"text":"bit","start":125,"end":128,"id":27,"ws":false},{"text":".","start":128,"end":129,"id":28,"ws":false}],"spans":[{"start":40,"end":46,"text":"turkey","token_start":8,"token_end":8,"label":"DISH"}],"llm":{"prompt":"You are an expert Named Entity Recognition (NER) system. Your task is to accept Text as input and extract named entities for the set of predefined entity labels.\nFrom the Text input provided, extract named entities for each label in the following format:\n\nDISH: <comma delimited list of strings>\nEQUIPMENT: <comma delimited list of strings>\nINGREDIENT: <comma delimited list of strings>\n\nBelow are definitions of each label to help aid you in what kinds of named entities to extract for each label.\nAssume these definitions are written by an expert and follow them closely.\n\nDISH: Extract the name of a known dish.\nINGREDIENT: Extract the name of a cooking ingredient, including herbs and spices.\nEQUIPMENT: Extract any mention of cooking equipment. e.g. oven, cooking pot, grill\n\n\nBelow are some examples (only use these as a guide):\n\nText:\n'''\nYou can probably sand-blast it if it's an anodized aluminum pan.\n'''\n\nEQUIPMENT: anodized aluminum pan\n\n\nHere is the text that needs labeling:\n\nText:\n'''\nThe timing would be about right for the turkey, but what are you doing for sides? May just need to adjust your dinner time a bit.\n'''","response":"DISH: turkey\nEQUIPMENT: None\nINGREDIENT: sides"},"_view_id":"ner_manual","_is_binary":false,"answer":"accept","_timestamp":1698174298,"_annotator_id":"2023-10-24_14-36-43","_session_id":"2023-10-24_14-36-43"}
+{"text":"If you're into Italian/Sicilian try Lidia's Italy (PBS or YouTube).","meta":{"explanation_label":"Lidia's Italy is the title of a show, not a dish.","explanation_boundaries":null},"_input_hash":-929486735,"_task_hash":-815730362,"tokens":[{"text":"If","start":0,"end":2,"id":0,"ws":true},{"text":"you","start":3,"end":6,"id":1,"ws":false},{"text":"'re","start":6,"end":9,"id":2,"ws":true},{"text":"into","start":10,"end":14,"id":3,"ws":true},{"text":"Italian","start":15,"end":22,"id":4,"ws":false},{"text":"/","start":22,"end":23,"id":5,"ws":false},{"text":"Sicilian","start":23,"end":31,"id":6,"ws":true},{"text":"try","start":32,"end":35,"id":7,"ws":true},{"text":"Lidia","start":36,"end":41,"id":8,"ws":false},{"text":"'s","start":41,"end":43,"id":9,"ws":true},{"text":"Italy","start":44,"end":49,"id":10,"ws":true},{"text":"(","start":50,"end":51,"id":11,"ws":false},{"text":"PBS","start":51,"end":54,"id":12,"ws":true},{"text":"or","start":55,"end":57,"id":13,"ws":true},{"text":"YouTube","start":58,"end":65,"id":14,"ws":false},{"text":")","start":65,"end":66,"id":15,"ws":false},{"text":".","start":66,"end":67,"id":16,"ws":false}],"spans":[],"llm":{"prompt":"You are an expert Named Entity Recognition (NER) system. Your task is to accept Text as input and extract named entities for the set of predefined entity labels.\nFrom the Text input provided, extract named entities for each label in the following format:\n\nDISH: <comma delimited list of strings>\nEQUIPMENT: <comma delimited list of strings>\nINGREDIENT: <comma delimited list of strings>\n\nBelow are definitions of each label to help aid you in what kinds of named entities to extract for each label.\nAssume these definitions are written by an expert and follow them closely.\n\nDISH: Extract the name of a known dish.\nINGREDIENT: Extract the name of a cooking ingredient, including herbs and spices.\nEQUIPMENT: Extract any mention of cooking equipment. e.g. oven, cooking pot, grill\n\n\nBelow are some examples (only use these as a guide):\n\nText:\n'''\nYou can probably sand-blast it if it's an anodized aluminum pan.\n'''\n\nEQUIPMENT: anodized aluminum pan\n\n\nHere is the text that needs labeling:\n\nText:\n'''\nIf you're into Italian/Sicilian try Lidia's Italy (PBS or YouTube).\n'''","response":"DISH: Lidia's Italy\nEQUIPMENT: None\nINGREDIENT: None"},"_view_id":"ner_manual","_is_binary":false,"answer":"accept","_timestamp":1698173755,"_annotator_id":"2023-10-24_14-36-43","_session_id":"2023-10-24_14-36-43"}

prodigy.json

@@ -0,0 +1,14 @@
+{
+    "port": 7860,
+    "host": "0.0.0.0",
+    "db": "sqlite",
+    "db_settings": {
+      "sqlite": {
+        "name": "prodigy.db",
+        "path": "/app"
+      }
+    },
+    "max_sessions": 50,
+    "show_stats": true,
+    "hide_meta": true
+}

prodigy.sh

@@ -0,0 +1 @@
+python -m prodigy ner.qa.manual qa-ex blank:en data/known_answers_cooking.jsonl --label DISH,INGREDIENT,EQUIPMENT -F recipe.py

recipe.py

@@ -0,0 +1,281 @@
+import copy
+from functools import partial
+from typing import Callable, Iterable, List, Optional, Tuple, Union, Dict, Any
+
+import murmurhash
+from spacy.language import Language
+from spacy.tokens.doc import SetEntsDefault  # type: ignore
+from spacy.training import Example
+from spacy.util import filter_spans
+
+from prodigy.components.db import connect
+from prodigy.components.decorators import support_both_streams
+from prodigy.components.filters import filter_seen_before
+from prodigy.components.preprocess import (
+    add_annot_name,
+    add_tokens,
+    add_view_id,
+    make_ner_suggestions,
+    make_raw_doc,
+    resolve_labels,
+    split_sentences,
+)
+from prodigy.components.sorters import prefer_uncertain
+from prodigy.components.source import GeneratorSource
+from prodigy.components.stream import Stream, get_stream, load_noop
+from prodigy.core import Arg, recipe
+from prodigy.errors import RecipeError
+from prodigy.models.matcher import PatternMatcher
+from prodigy.models.ner import EntityRecognizerModel, ensure_sentencizer
+from prodigy.protocols import ControllerComponentsDict
+from prodigy.types import (
+    ExistingFilePath,
+    LabelsType,
+    SourceType,
+    StreamType,
+    TaskType,
+)
+from prodigy.util import (
+    ANNOTATOR_ID_ATTR,
+    BINARY_ATTR,
+    INPUT_HASH_ATTR,
+    TASK_HASH_ATTR,
+    combine_models,
+    copy_nlp,
+    get_pipe_labels,
+    log,
+    msg,
+    set_hashes,
+)
+
+
+
+def modify_spans(document):
+    # Modify the 'spans' key to be an empty list
+    document['spans'] = []
+    return document
+
+def spans_equal(s1: Dict[str, Any], s2: Dict[str, Any]) -> bool:
+    """Checks if two spans are equal"""
+    return s1["start"] == s2["start"] and s1["end"] == s2["end"]
+
+
+def labels_equal(s1: Dict[str, Any], s2: Dict[str, Any]) -> bool:
+    """Checks if two spans have the same label"""
+    return s1["label"] == s2["label"]
+
+
+def ensure_span_text(eg: TaskType) -> TaskType:
+    """Ensure that all spans have a text attribute"""
+    for span in eg.get("spans", []):
+        if "text" not in span:
+            span["text"] = eg["text"][span["start"] : span["end"]]
+    return eg
+
+
+def validate_answer(answer: TaskType, *, known_answers_map: Dict[int, TaskType]):
+    """Validate the answer against the known answers"""
+
+    known_answer = known_answers_map.get(answer[INPUT_HASH_ATTR])
+    if known_answer is None:
+        print(f"Skipping validation for answer {answer[INPUT_HASH_ATTR]}, no known answer found to validate against.")
+        return
+
+    known_answer = ensure_span_text(known_answer)
+    errors = []
+    known_spans = known_answer.get("spans", [])
+    answer_spans = answer.get("spans", [])
+    explanation_label = known_answer.get("meta", {}).get("explanation_label")
+    explanation_boundaries = known_answer.get("meta", {}).get(
+        "explanation_boundaries"
+    )
+    if not explanation_boundaries:
+        explanation_boundaries = (
+            "No explanation boundaries"
+        )
+
+    if len(known_spans) > len(answer_spans):
+        errors.append(
+            "You noted fewer entities than expected for this answer. All mentions must be annotated"
+        )
+    elif len(known_spans) < len(answer_spans):
+        errors.append(
+            "You noted more entities than expected for this answer."
+        )
+        if not known_spans:
+            # For cases where no annotations are expected
+            errors.append(explanation_label)
+    for known_span, span in zip(known_spans, answer_spans):
+        if not labels_equal(known_span, span):
+            # label error
+            errors.append(explanation_label)
+            continue
+        if not spans_equal(known_span, span):
+            # boundary error
+            errors.append(explanation_boundaries)
+            continue
+
+    if len(errors) > 0:
+        error_msg = "\n".join(errors)
+        error_msg += "\n\nExpected annotations:"
+        if known_spans:
+            expected_spans = [
+                f'[{s["text"]}]: {s["label"]}' for s in known_spans
+            ]
+            if expected_spans:
+                error_msg += "\n"
+                for span_msg in expected_spans:
+                    error_msg += span_msg + "\n"
+        else:
+            error_msg += "\n\nNone."
+        raise ValueError(error_msg)
+
+@recipe(
+    "ner.qa.manual",
+    # fmt: off
+    dataset=Arg(help="Dataset to save annotations to"),
+    nlp=Arg(help="Loadable spaCy pipeline for tokenization or blank:lang (e.g. blank:en)"),
+    source=Arg(help="Data to annotate (file path or '-' to read from standard input)"),
+    loader=Arg("--loader", "-lo", help="Loader (guessed from file extension if not set)"),
+    label=Arg("--label", "-l", help="Comma-separated label(s) to annotate or text file with one label per line"),
+    patterns=Arg("--patterns", "-pt", help="Path to match patterns file"),
+    exclude=Arg("--exclude", "-e", help="Comma-separated list of dataset IDs whose annotations to exclude"),
+    highlight_chars=Arg("--highlight-chars", "-C", help="Allow highlighting individual characters instead of tokens"),
+    # fmt: on
+)
+def manual(
+    dataset: str,
+    nlp: Language,
+    source: SourceType,
+    loader: Optional[str] = None,
+    label: Optional[LabelsType] = None,
+    patterns: Optional[ExistingFilePath] = None,
+    exclude: List[str] = [],
+    highlight_chars: bool = False,
+) -> ControllerComponentsDict:
+    """
+    Mark spans by token. Requires only a tokenizer and no entity recognizer,
+    and doesn't do any active learning. If patterns are provided, their matches
+    are highlighted in the example, if available. The recipe will present
+    all examples in order, so even examples without matches are shown. If
+    character highlighting is enabled, no "tokens" are saved to the database.
+    """
+    log("RECIPE: Starting recipe ner.manual", locals())
+    labels = get_pipe_labels(label, nlp.pipe_labels.get("ner", []))
+    stream = get_stream(
+        source,
+        loader=loader,
+        rehash=True,
+        dedup=True,
+        input_key="text",
+        is_binary=False,
+    )
+    if patterns is not None:
+        pattern_matcher = PatternMatcher(nlp, combine_matches=True, all_examples=True)
+        pattern_matcher = pattern_matcher.from_disk(patterns)
+        stream.apply(lambda examples: (eg for _, eg in pattern_matcher(examples)))
+    # Add "tokens" key to the tasks, either with words or characters
+    stream.apply(lambda examples: (modify_spans(eg) for eg in examples))
+    exclude_names = [ds.name for ds in exclude] if exclude is not None else None
+
+    known_answers = get_stream(
+        source,
+        loader=loader,
+        rehash=True,
+        dedup=True,
+        input_key="text",
+        is_binary=False,
+    )
+    known_answers_map = {eg[INPUT_HASH_ATTR]: eg for eg in known_answers}
+
+    return {
+        "view_id": "ner_manual",
+        "dataset": dataset,
+        "stream": [_ for _ in stream],
+        "exclude": exclude_names,
+        "validate_answer": partial(validate_answer, known_answers_map=known_answers_map),
+        "config": {
+            "lang": nlp.lang,
+            "labels": labels,
+            "exclude_by": "input",
+            "ner_manual_highlight_chars": highlight_chars,
+        },
+    }
+
+
+@support_both_streams(stream_arg="stream")
+def preprocess_stream(
+    stream: StreamType,
+    nlp: Language,
+    *,
+    labels: Optional[List[str]],
+    unsegmented: bool,
+    set_annotations: bool = True,
+) -> StreamType:
+    if not unsegmented:
+        stream = split_sentences(nlp, stream)  # type: ignore
+    stream = add_tokens(nlp, stream)  # type: ignore
+    if set_annotations:
+        spacy_model = f"{nlp.meta['lang']}_{nlp.meta['name']}"
+        # Add a 'spans' key to each example, with predicted entities
+        texts = ((eg["text"], eg) for eg in stream)
+        for doc, eg in nlp.pipe(texts, as_tuples=True, batch_size=10):
+            task = copy.deepcopy(eg)
+            spans = []
+            for ent in doc.ents:
+                if labels and ent.label_ not in labels:
+                    continue
+                spans.append(ent)
+            for span in eg.get("spans", []):
+                spans.append(doc.char_span(span["start"], span["end"], span["label"]))
+            spans = filter_spans(spans)
+            span_dicts = []
+            for ent in spans:
+                span_dicts.append(
+                    {
+                        "token_start": ent.start,
+                        "token_end": ent.end - 1,
+                        "start": ent.start_char,
+                        "end": ent.end_char,
+                        "text": ent.text,
+                        "label": ent.label_,
+                        "source": spacy_model,
+                        "input_hash": eg[INPUT_HASH_ATTR],
+                    }
+                )
+            task["spans"] = span_dicts
+            task[BINARY_ATTR] = False
+            task = set_hashes(task)
+            yield task
+    else:
+        yield from stream
+
+
+def get_ner_labels(
+    nlp: Language, *, label: Optional[List[str]], component: str = "ner"
+) -> Tuple[List[str], bool]:
+    model_labels = nlp.pipe_labels.get(component, [])
+    labels = get_pipe_labels(label, model_labels)
+    # Check if we're annotating all labels present in the model or a subset
+    no_missing = len(set(labels).intersection(set(model_labels))) == len(model_labels)
+    return labels, no_missing
+
+
+def get_update(nlp: Language, *, no_missing: bool) -> Callable[[List[TaskType]], None]:
+    def update(answers: List[TaskType]) -> None:
+        log(f"RECIPE: Updating model with {len(answers)} answers")
+        examples = []
+        for eg in answers:
+            if eg["answer"] == "accept":
+                doc = make_raw_doc(nlp, eg)
+                ref = make_raw_doc(nlp, eg)
+                spans = [
+                    doc.char_span(span["start"], span["end"], label=span["label"])
+                    for span in eg.get("spans", [])
+                ]
+                value = SetEntsDefault.outside if no_missing else SetEntsDefault.missing
+                ref.set_ents(spans, default=value)
+                examples.append(Example(doc, ref))
+        nlp.update(examples)
+
+    return update