Skip to content

Práctica con imágenes: leer documentos escaneados y verificar resultados de OCR ​

💡 Resumen en una frase: usar el reconocimiento de imágenes de Jev para construir dos líneas de procesamiento de documentos en papel — para documentos escaneados, «Noul busca si está, Box busca dónde, Choice lee el valor»; para resultados de OCR, «verificar la página completa una vez y examinar el recorte otra vez», con puntuaciones bajas pasando a revisión humana.

En el curso previo Box e imágenes aprendiste a enviar solicitudes con imágenes y a leer los cuatro bordes. Esta lección lo ensambla en un proyecto completo. La documentación oficial ofrece tres cookbooks de imágenes: Reading a scanned vaccination record (leer un registro de vacunación escaneado), OCR confidence and bounding boxes (verificar los valores del OCR de facturas) y Feeder-cam visit log (registro de especies de una cámara de comedero de aves). Esta lección recorre los dos primeros; el tercero se explica junto con las técnicas avanzadas.

Los números oficiales primero, para ver el efecto real de este método: 16 vacunas candidatas clasificadas correctamente todas en una sola solicitud — las 6 presentes en el registro con probabilidad 0.97 o más, y la «vacuna combinada contra hepatitis A y B», muy parecida, con solo 0.02; la fecha cubierta por una pegatina, el modelo responde «no se distingue» en vez de adivinar; las tres lecturas erróneas del OCR de dos facturas (AN400074, INV03070, 16/09/2028) todas fueron detectadas por las dos pasadas. Esta lección dura unos 20 minutos; el ejemplo oficial incluye la caché de respuestas json_cache.json — según la nota oficial, con la caché en el directorio de ejecución el script reproduce la caché en lugar de hacer solicitudes reales, así que sin Key también se obtienen los mismos números que esta página.

Qué podrás hacer al terminar ​

  • Escribir una línea de procesamiento de lectura de documentos escaneados: Noul + Box encuentra cada fila que necesitas en la tabla, Choice lee el valor, y cuando no se distingue obtienes unreadable en vez de un año inventado
  • Separar «leer la imagen» y «juzgar según lo leído» en dos solicitudes — medición oficial: la versión combinada en una sola pregunta dejó pasar ambas incidencias por debajo del umbral de revisión
  • Verificar los valores extraídos por OCR: por cada campo, una pasada sobre la página completa y otra de detalle sobre imagen recortada, por debajo de 0.25 pasa a revisión humana, con el recuadro de revisión dibujado sobre la imagen original
  • Usar el mismo juego de preguntas para fotogramas de vídeo consecutivos: la cámara del comedero de aves clasifica correctamente si hay ave en los 101 fotogramas (101/101), y acierta la especie en 132/133

Por qué usar el reconocimiento de imágenes de Jev en lugar de dejar que un LLM multimodal mire la imagen directamente ​

«Enviar el escaneo a GPT para que lo lea por mí» es la primera reacción de muchos — funciona, pero obtienes un párrafo de texto, no un juicio que pueda entrar en el código.

CapacidadLLM multimodal mirando la imagen directamenteJev reconocimiento de imágenes
Contenido ilegible❌ Tiende a dar igualmente una respuesta — la fecha bajo la pegatina se «lee» de todos modos✅ Con la opción unreadable en la Choice, en el ejemplo oficial el modelo realmente la eligió, y la Noul de legibilidad al lado dio solo 0.05
Información de posición❌ Descripción en prosa del tipo «una fila algo arriba en la tabla»✅ Box devuelve los cuatro bordes como proporciones, y se recorta directamente esa fila para que la vea quien revisa
Grado de certeza❌ Cada vez que preguntas «¿estás seguro?» la respuesta cambia✅ Cada pregunta trae probabilidad: la vacuna presente en la página 0.97+, la ausente 0.02, y el umbral escrito en tu código
Juicio y lectura de imagen❌ Un solo prompt lo abarca todo, y al fallar no se sabe si leyó mal o juzgó mal✅ Leer la imagen en una solicitud y juzgar según lo leído en otra — el paso que falla se ve por separado
Forma de la respuesta❌ Texto libre, y aguas abajo hay que escribir un parser✅ Respuesta tipada + distribución de probabilidades, if se usa directamente

En una frase: el LLM te «describe» la imagen, Jev te la «juzga» — solo el juicio trae probabilidad, y con la probabilidad se puede fijar un umbral de revisión.

Tu situación actual ​

  • «Montañas de documentos en papel escaneados por ingresar al sistema, el OCR ya corrió, pero nadie sabe qué campos leyó mal — verificar uno por uno tarda más que teclearlo a mano»
  • «Al pedirle a un modelo multimodal que lea un escaneo, hasta la fecha tapada por una mancha me da un año, y si está mal no avisa en absoluto»
  • «Quiero que el modelo me diga en qué posición de la imagen está el objetivo, y me responde con una prosa de “algo a la izquierda de la escena”, imposible de usar para escribir código de recorte»

Cuándo usar esta técnica ​

Cuando necesitas:

  • Leer información estructurada de documentos escaneados o fotografías de recibos: filas de tablas, fechas, números, importes
  • El OCR ya extrajo los valores, pero necesitas algo que verifique campo por campo: si el valor es correcto, si está en la página, si se leyó mal
  • Obtener juicio y posición a la vez: qué dice esta fila y en qué posición de la imagen está (para recortarla y que alguien la revise)

Y además no quieres:

  • Entrenar o desplegar un modelo de visión dedicado
  • Parsear respuestas en lenguaje natural que un modelo multimodal improvisa libremente
  • Adivinar qué paso falló dentro de una respuesta donde «leer la imagen» y «juzgar» van mezclados

🎒 Preparativos antes de empezar ​

  • Completaste Box e imágenes: sabes enviar imágenes con el Image del SDK de Python, conoces el encabezado TypeSafe-Danger-Zone-Images: true y sabes leer las proporciones de los cuatro bordes
  • Se recomienda haber leído Noul preguntas de sí/no y Choice preguntas de opción múltiple: cada paso de esta lección es una combinación de estos dos tipos de pregunta más Box
  • Lograste ejecutarInstalación y primera solicitud: .venv está disponible. La primera mitad de esta lección se puede ejecutar sin Key (reproducción de caché oficial); si quieres enviar solicitudes reales, configura TYPESAFE_API_KEY
  • Un vaso de agua ☕—— esta lección es la obra final de la ruta C: tres cookbook oficiales, leer documentos escaneados, verificar facturas y observar aves, todos con el mismo esquema de «filtro de entrada + localización + lectura de valores»

Hazlo conmigo ​

Crea image_docs.py y pega los bloques de código de cada paso siguiente en orden en el mismo archivo. Los pasos 1–5 tratan del documento escaneado del registro de vacunación (ejemplo oficial), y el paso 6 cambia a la verificación OCR de una factura (otro ejemplo oficial, cambios: cambiar la imagen y la tabla de campos). ¿No tienes Key por ahora? Aun así puedes ejecutar — el json_cache.json oficial guarda las respuestas originales de todos los números de esta página; el script detecta la caché y la reproduce, sin enviar solicitudes reales (si quieres ejecutar de verdad, borra el archivo de caché).

Paso 1: instalar el entorno, descargar el ejemplo oficial de documento escaneado y la caché ​

Por qué: el cookbook oficial grabó cada respuesta de la API en json_cache.json—— palabras textuales oficiales: si la caché existe, el script reproduce esas respuestas en lugar de llamar a la API, así obtienes los mismos números que los oficiales. Prepara primero los materiales para que cada paso posterior tenga números oficiales con los que comparar.

Instala las dependencias (comando de instalación del cookbook oficial del registro de vacunación, se añadió pillow—— el recorte del paso 5 lo necesita):

bash
pip install ipython matplotlib pillow 'typesafe-sdk>=0.7.5,<0.8.0' \
    'cooksafe>=0.2.0,<0.3.0'

Descarga el documento escaneado y la caché del repositorio oficial de ejemplos (typesafe-public-examples, colócalos en el mismo directorio que el script):

bash
curl -sL -o vaccination_record.jpg https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/reading_scanned_documents/vaccination_record.jpg
curl -sL -o json_cache.json https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/reading_scanned_documents/json_cache.json

Pega el encabezado del archivo—— cliente, constantes de umbral, función de solicitud con caché:

python
import hashlib
import json
import os
from datetime import date
from pathlib import Path
from time import perf_counter

from cooksafe import JsonCache
from typesafe_sdk import Image, TypeSafeClient

TYPESAFE_MODEL = "jev-1.14.0"  # Box questions need Jev 1.14
IMAGES_ON = {"TypeSafe-Danger-Zone-Images": "true"}  # opt in to the image preview
READ_CUTOFF = 0.90  # below this, a person checks the reading against the paper
LEGIBLE_CUTOFF = 0.50  # the legibility Noul gets its own, lower cutoff
IN_DATE_CUTOFF = 0.50  # below this, a nurse checks whether the dose still covers the trip

client = TypeSafeClient(
    api_key=os.environ.get("TYPESAFE_API_KEY", "cache-only"),  # keyless kernels replay
    timeout=120.0,
)
json_cache = JsonCache(Path("json_cache.json"))

PAGE = Path("vaccination_record.jpg")
PAGE_SHA = hashlib.sha256(PAGE.read_bytes()).hexdigest()[:16]  # cache key for the scan


@json_cache
def ask(model: str, page_sha: str, questions_json: str) -> dict:
    """One request: the scan as the state, plus a set of questions about it."""
    started = perf_counter()
    response = client.system_one(
        state={"page": Image(PAGE)},
        questions=json.loads(questions_json),
        model=model,
        extra_headers=IMAGES_ON,
    )
    return {
        "answers": {k: a.model_dump(mode="json") for k, a in response.answers.items()},
        "seconds": round(perf_counter() - started, 2),
    }


def ask_page(questions: dict) -> dict:
    if not questions:  # nothing to ask, such as a page with no rows found
        return {"answers": {}}
    return ask(TYPESAFE_MODEL, PAGE_SHA, json.dumps(questions, sort_keys=True))


print("setup ok")

Ejecuta python image_docs.py.

Deberías ver: setup ok—— este paso solo es montaje, todavía no se envían solicitudes.

⚠️ Característica experimental, las palabras textuales oficiales hay que pegarlas en la pared

Images y Box están en vista previa temprana (oficialmente llamados dreamer-ready, sin estándar de producción): las solicitudes con imagen o con Box deben incluir el encabezado TypeSafe-Danger-Zone-Images: true, y el formato de solicitud puede cambiar entre versiones. Las preguntas Box requieren Jev 1.14—— jev-latest ya apunta a jev-1.14.0. En la fase de prototipo juega tranquilo, para producción evalúa por tu cuenta. Las imágenes también tienen limitaciones: PNG/JPEG, 280–1568 píxeles por lado, un solo archivo ≤ 16 MiB; los documentos escaneados de alta resolución primero se reducen y luego se envían, ver la tabla de limitaciones de la lección Box e imágenes.

  • setup ok se imprimió, vaccination_record.jpg y json_cache.json están en el directorio de ejecución

Paso 2: Jev primera pregunta de reconocimiento de imágenes—— ¿está Noul presente y en qué fila está el Box? ​

Por qué: Jev no hace «extraer la imagen en una lista de datos»—— responde preguntas sobre la imagen. Así que el enfoque oficial es: tienes una lista (los 16 tipos de vacunas que puso esta clínica) y haces dos preguntas por cada candidato. Esta es exactamente la solución de Box siempre devuelve un cuadro: Noul se encarga de «está o no está», Box de «dónde está»; si Noul dice que no está, se ignora ese cuadro.

Una solicitud envía 33 preguntas: 16 vacunas × (Noul + Box) + 1 pregunta Noul para comprobar «¿hay vacunas fuera de la lista en la tabla?»—— esa última la añadió específicamente lo oficial: las otras 32 preguntas no detectan el caso de «la lista omitió algo». El mecanismo de preguntas mixtas en paralelo se explica en Preguntas en paralelo y fan-out especulativo.

python
VACCINES = [
    "Hepatitis A", "Hepatitis B", "Hepatitis A and B combined", "Typhoid",
    "Hepatitis A and typhoid combined", "Yellow fever", "Rabies", "Japanese encephalitis",
    "Tick-borne encephalitis", "Cholera", "MenACWY", "MenB",
    "Tetanus, diphtheria and polio (Td/IPV)", "MMR", "Varicella", "Influenza",
]
PRESENT_CUTOFF = 0.5  # P(recorded) at or above this counts the vaccine as on the page


def find_questions() -> dict:
    questions = {"unlisted": {
        "type": "noul",
        "instructions": {
            "question": "Does the vaccines table in `page` record any vaccine that is not "
                        "in this list?",
            "list": VACCINES,
        },
    }}
    for i, vaccine in enumerate(VACCINES):
        questions[f"vac_{i:02d}"] = {
            "type": "noul",
            "instructions": f"Is {vaccine} recorded in the vaccines table in `page`, with "
                            "exactly this name?",
        }
        questions[f"vac_{i:02d}|box"] = {
            "type": "box",
            "instructions": f"the whole {vaccine} row of the vaccines table in `page`",
        }
    return questions


found = ask_page(find_questions())
F = found["answers"]
present = []
for i, vaccine in enumerate(VACCINES):
    p, box = F[f"vac_{i:02d}"]["noul"], F[f"vac_{i:02d}|box"]
    print(f"{vaccine:<40}recorded {p:.2f}  box top {box['box']['top']:.2f}")
    if p >= PRESENT_CUTOFF:
        present.append({"vaccine": vaccine, "present": p, "box": box["box"],
                        "box_confidence": box["confidence"]})
print(f"\nanother vaccine on the page: {F['unlisted']['noul']:.2f}")

rows = sorted(present, key=lambda r: r["box"]["top"])  # box tops give the page order
for n, row in enumerate(rows, 1):
    row["id"], row["position"] = f"row-{n}", n

Ejecuta python image_docs.py.

Deberías ver (números grabados del jev-1.14.0 oficial):

text
Hepatitis A                             recorded 0.98  box top 0.33
Hepatitis B                             recorded 0.98  box top 0.40
Hepatitis A and B combined              recorded 0.02  box top 0.36
Typhoid                                 recorded 0.98  box top 0.48
Hepatitis A and typhoid combined        recorded 0.01  box top 0.34
Yellow fever                            recorded 0.98  box top 0.55
Rabies                                  recorded 0.97  box top 0.69
Japanese encephalitis                   recorded 0.01  box top 0.35
Tick-borne encephalitis                 recorded 0.01  box top 0.34
Cholera                                 recorded 0.01  box top 0.34
MenACWY                                 recorded 0.00  box top 0.34
MenB                                    recorded 0.01  box top 0.35
Tetanus, diphtheria and polio (Td/IPV)  recorded 0.98  box top 0.62
MMR                                     recorded 0.01  box top 0.33
Varicella                               recorded 0.01  box top 0.34
Influenza                               recorded 0.01  box top 0.34

another vaccine on the page: 0.02

Tres formas de leerlo:

  • Los nombres parecidos no lo engañan: la lista incluye a propósito parientes cercanos como «vacuna combinada contra hepatitis A y B» y «vacuna combinada contra hepatitis A y fiebre tifoidea»—— los 6 tipos realmente presentes en la página están todos por encima de 0.97, los parientes cercanos todos por debajo de 0.02, un margen claro de separación
  • box top es el número de fila gratis: las 6 filas se ordenan por el borde top, que es exactamente su orden en la página—— el recorte del paso 5 y mostrárselo a quien revisa dependen de este orden
  • Tampoco se escaparon las vacunas fuera de la lista: ese «Noul de entrada» respondió 0.02—— no hay vacunas fuera de la lista en la tabla. Si estuviera por encima de 0.5, habría que marcar toda la página para revisión humana (paso 5)

Lo oficial también advierte algo: 16 tipos de vacuna con 33 preguntas no hay problema, pero cuando la lista tiene miles de elementos, las preguntas pueden no caber en una sola solicitud (límite de contexto)—— primero agrupa por categoría con un Noul por grupo para reducir el alcance, y luego pregunta en detalle cada elemento de los grupos que coincidan.

💡 Este es el valor único del reconocimiento de imágenes con Jev

Una probabilidad por candidato te permite convertir «está o no está» en una cuestión de umbral: entre 0.97 y 0.02 no hay zona gris, PRESENT_CUTOFF = 0.5 corta limpiamente de un tajo. El «veo registros de hepatitis A y B» que te da un LLM multimodal no contiene estos números; solo puedes elegir creerlo o no.

  • 16 probabilidades de fila impresas: 6 tipos ≥ 0.97, parientes cercanos ≤ 0.02, unlisted 0.02; puedo explicar por qué ese último Noul no se puede omitir

Paso 3: Choice lee el año, si no se ve claramente responde unreadable ​

Por qué: encontrar la fila es solo la primera mitad; hay que leer el año de vacunación para saber si la dosis sigue siendo válida. La trampa clave: Choice siempre elige una opción—— cuando la fecha está cubierta por una pegatina, sin una vía de escape elige a la fuerza el año que más se parece. La solución oficial: poner other y unreadable al final de la lista de opciones, para que el modelo pueda decir explícitamente «no se puede leer»; y añadir un Noul independiente que pregunte «¿la fecha es totalmente legible?», como segunda señal.

python
YEAR = {
    **{f"y{n}": str(n) for n in range(2016, 2027)},
    "other": "A year before 2016 or after 2026",
    "unreadable": "The year is covered, stained, smudged or damaged and can't be read",
}


def read_questions(row: dict) -> dict:
    where = f"the DATE GIVEN cell of the {row['vaccine']} row of the vaccines table in `page`"
    i = row["id"]
    return {
        f"{i}|year": {
            "type": "choice", "criteria": YEAR,
            "instructions": "Dates on this record are written day/month/year, so the year "
                            f"is the last part. What year is written in {where}?",
        },
        f"{i}|legible": {
            "type": "noul",
            "instructions": f"Is the date in {where} fully legible, with nothing covering, "
                            "staining, smudging or blurring any of it?",
        },
    }


read = ask_page({k: q for row in rows for k, q in read_questions(row).items()})
A = read["answers"]
for row in rows:
    i = row["id"]
    row["year"], row["year_confidence"] = A[f"{i}|year"]["choice"], A[f"{i}|year"]["confidence"]
    row["legible"] = A[f"{i}|legible"]["noul"]

UNRESOLVED = ("other", "unreadable")  # picks that leave the row without a year


def year_given(row: dict) -> int | None:
    return None if row["year"] in UNRESOLVED else int(row["year"][1:])


def as_text(row: dict) -> str:
    year = year_given(row)
    return str(year) if year else row["year"]


print(f"{'vaccine':<40}{'year':<12}legible")
for row in rows:
    print(f"{row['vaccine']:<40}{as_text(row):<12}{row['legible']:.2f}")

Ejecuta.

Deberías ver (números grabados del jev-1.14.0 oficial):

text
vaccine                                 year        legible
Hepatitis A                             2026        0.96
Hepatitis B                             2026        0.86
Typhoid                                 2021        0.96
Yellow fever                            2025        0.96
Tetanus, diphtheria and polio (Td/IPV)  2024        0.96
Rabies                                  unreadable  0.05

Dos detalles merecen que te detengas a mirarlos:

  • En la fila de la rabia, el modelo respondió unreadable—— su fecha está cubierta por una pegatina de lote. El Noul de legibilidad dio simultáneamente 0.05, las dos señales se confirman mutuamente. Este es el sentido de la vía de escape: lo que no se puede leer se informa, en lugar de adivinarse

  • Con fechas legibles, el Noul de legibilidad solo da 0.86–0.96 (una de ellas, la de 0.86, fue marcada con resaltador)—— más bajo que la confianza de Choice, así que lo oficial fijó para la legibilidad una línea de revisión propia más baja, 0.50, en lugar de reutilizar 0.90. Cada pregunta tiene su propia escala de puntuación, no apliques el mismo umbral a todo

  • Se imprimieron los años de las seis filas; puedo explicar qué filtra cada uno de other y unreadable (años fuera de la lista vs. fechas que no se pueden leer en absoluto)

Paso 4: solicitud en texto plano para verificar la validez — separar la lectura de la imagen y el juicio ​

Por qué: este paso es uno de los diseños más valiosos que aprender del cookbook. Leer bien la fecha no basta — la vacuna contra la fiebre tifoidea se puso en 2021, la letra es clara, pero el período de protección es de unos tres años, y al salir en el mes 11 de 2026 ya había caducado hacía tiempo. Para ese juicio, lo oficial no deja que el modelo lo haga mirando la imagen, sino que envía el año leído como texto plano en una tercera solicitud: la imagen ya no se adjunta, y el juicio trata únicamente de «¿esta dosis sigue siendo válida en la fecha de salida?», totalmente desacoplado de la lectura de la imagen.

La aritmética de fechas (cuántos años han pasado) la calcula el código y la coloca en el state — la comparación de fechas es una debilidad conocida de Jev, la aritmética siempre va en el código.

python
DEPARTURE = date(2026, 11, 12)  # from the traveller's booking


def before_departure(year: int) -> str:
    years = DEPARTURE.year - year
    return "less than a year" if years == 0 else f"about {years} year{'s' * (years != 1)}"


CHECK_CONTEXT = (
    "Each entry is one line of an adult traveller's vaccination record, as read from a "
    f"scan. The traveller leaves on {DEPARTURE.day} November {DEPARTURE.year}. Judge "
    "only whether the dose will still protect the traveller on that date, by usual "
    "travel-health guidance for adults."
)
IN_DATE_QUESTION = "Will this dose still protect the traveller on the departure date?"
IN_DATE_CRITERIA = {
    "true": "The dose is within the usual protection period for this vaccine on the "
            "departure date.",
    "false": "The dose is past the usual protection period for this vaccine by the "
             "departure date.",
}


def check_questions(readable: list[dict]) -> dict:
    return {
        row["id"]: {
            "type": "noul",
            "instructions": {"question": IN_DATE_QUESTION, "entry": row["id"]},
            "criteria": IN_DATE_CRITERIA,
        }
        for row in readable
    }


def check_state(readable: list[dict]) -> dict:
    return {
        "context": CHECK_CONTEXT,
        "entries": [{"id": r["id"], "vaccine": r["vaccine"], "year_given": as_text(r),
                     "given_before_departure": before_departure(year_given(r))}
                    for r in readable],
    }

La tercera solicitud no lleva imagen ni añade el encabezado de images — el juicio trata solo del texto del año leído, y se envuelve igualmente con el decorador de caché:

python
@json_cache
def check(model: str, state_json: str, questions_json: str) -> dict:
    started = perf_counter()
    response = client.system_one(
        state=json.loads(state_json), questions=json.loads(questions_json), model=model
    )
    return {
        "answers": {k: a.noul for k, a in response.answers.items()},
        "seconds": round(perf_counter() - started, 2),
    }


readable = [r for r in rows if year_given(r) is not None]
checked = check(TYPESAFE_MODEL, json.dumps(check_state(readable)),
                json.dumps(check_questions(readable))) if readable else {"answers": {}}
for row in rows:
    row["in_date"] = checked["answers"].get(row["id"])
    year = year_given(row)
    ago = before_departure(year) if year else "-"
    shown = "  -" if row["in_date"] is None else f"{row['in_date']:.2f}"
    print(f"{row['vaccine']:<40}{as_text(row):<12}{ago:<20}{shown}")

Ejecuta.

Deberías ver (números grabados del jev-1.14.0 oficial):

text
Hepatitis A                             2026        less than a year    0.94
Hepatitis B                             2026        less than a year    0.83
Typhoid                                 2021        about 5 years       0.38
Yellow fever                            2025        about 1 year        0.95
Tetanus, diphtheria and polio (Td/IPV)  2024        about 2 years       0.93
Rabies                                  unreadable  -                     -

La vacuna tifoidea 0.38 — quedó destacada. La rabia no tiene puntuación, porque el año no se leyó (en el paso 3 se respondió unreadable), así que el código directamente no la envía a esta solicitud.

¿Por qué hay que dividirlo en dos solicitudes? Lo oficial hizo un experimento contraejemplo en el apéndice — preguntando directamente sobre la imagen el tema de la validez (la fecha de salida está escrita en el encabezado de la página):

text
vaccine                                  from the image  from the readings
Hepatitis A                                        0.88               0.94
Hepatitis B                                        0.85               0.83
Typhoid                                            0.50               0.38
Yellow fever                                       0.96               0.95
Tetanus, diphtheria and polio (Td/IPV)             0.84               0.93
Rabies                                             0.88                  -

Preguntando sobre la imagen: la rabia 0.88 pasó (cuando la fecha estaba claramente tapada por una pegatina); la tifoidea 0.50, justo en el límite, también pasó. Lo oficial señala la causa: una sola respuesta cubría dos pasos — no puedes distinguir si el modelo no leyó bien la fecha o si el juicio en sí estaba mal. Al separarlos (el flujo principal de esta página), la rabia se detiene en el paso de lectura, y el juicio de la tifoidea, con 0.38, también se envía a revisión humana.

💡 Este es el valor único del reconocimiento de imágenes con Jev

Cada estación de la cadena tiene su propia probabilidad y su propia línea de revisión; qué estación falló y quién debe revisarlo queda escrito con claridad en la respuesta. Fusionarlo en una sola pregunta equivale a soldar dos alarmas en una — y ambas fallan.

  • La tifoidea 0.38 y la rabia - coinciden; puedo explicar, con el contraejemplo del apéndice, los dos beneficios de «separar la lectura de la imagen y el juicio»

Paso 5: marcar puntuaciones bajas y recortar por Box para enviar a revisión humana ​

Por qué: tres pasos de lectura + un paso de juicio; ahora se reúnen todas las puntuaciones bajas en una sola lista de revisión. Las reglas son todo código puro — Jev solo da probabilidades, a quién se envía a revisión humana lo decide tu umbral.

python
def reading_score(row: dict) -> float:
    """The weakest of the answers that say the row was found and read."""
    return min(row["present"], row["year_confidence"])


def review_reasons(row: dict) -> list[str]:
    reasons = []
    if (row["year"] in UNRESOLVED or reading_score(row) < READ_CUTOFF
            or row["legible"] < LEGIBLE_CUTOFF):
        reasons.append("Check the reading")
    if row["in_date"] is not None and row["in_date"] < IN_DATE_CUTOFF:
        reasons.append("Check the dose")
    return reasons


def page_reasons() -> list[str]:
    """Flags that belong to the whole page rather than to one row."""
    if F["unlisted"]["noul"] >= PRESENT_CUTOFF:
        return ["Check the page: it may record a vaccine outside the list"]
    return []


for row in rows:
    in_date = "–" if row["in_date"] is None else f"{row['in_date']:.2f}"
    flags = ", ".join(review_reasons(row)) or "–"
    print(f"| {row['vaccine']} | {as_text(row)} | {reading_score(row):.2f} | "
          f"{row['legible']:.2f} | {in_date} | {flags} |")
print(f"page: {', '.join(page_reasons()) or 'not flagged'}")

Ejecuta.

Deberías ver (números grabados del jev-1.14.0 oficial):

text
| Hepatitis A | 2026 | 0.98 | 0.96 | 0.94 | – |
| Hepatitis B | 2026 | 0.98 | 0.86 | 0.83 | – |
| Typhoid | 2021 | 0.98 | 0.96 | 0.38 | Check the dose |
| Yellow fever | 2025 | 0.98 | 0.96 | 0.95 | – |
| Tetanus, diphtheria and polio (Td/IPV) | 2024 | 0.98 | 0.96 | 0.93 | – |
| Rabies | unreadable | 0.97 | 0.05 | – | Check the reading |
page: not flagged (another vaccine on the page: 0.02)

Dos reglas de marcado a nivel de fila y una a nivel de página:

  • «Verificar lectura»: el año cae en other/unreadable, la puntuación de lectura (el más débil entre present y year_confidence) está por debajo de 0.90, o la legibilidad está por debajo de 0.50 — si se cumple cualquiera
  • «Verificar dosis»: la puntuación de validez está por debajo de 0.50. Nótese que una puntuación alta de lectura de la tifoidea no salva una puntuación baja de juicio — palabras oficiales: el juicio se basa en un año que pudo leerse mal, y los dos marcados no se compensan entre sí
  • Marcado a nivel de página: si el Noul de unlisted es ≥ 0.5, se envía la página entera a revisión — esa vacuna no tiene su propia fila, así que las reglas de fila no la detectan

Por último, la parte para humanos: recortar por Box la fila completa marcada (el código oficial usa matplotlib para dibujar; aquí se da el núcleo del recorte — el box guardado en el paso 2 ahora sirve):

python
PAD = 0.02  # fraction of the page added around each box before cropping
LOW_BOX_CONFIDENCE, LOW_PAD = 0.6, 0.05  # a less certain box gets a wider margin


def crop(box: dict, confidence: float):
    from PIL import Image
    page = Image.open(PAGE)
    w, h = page.size
    pad = LOW_PAD if confidence < LOW_BOX_CONFIDENCE else PAD
    top, bottom = max(0.0, box["top"] - pad), min(1.0, box["bottom"] + pad)
    left, right = max(0.0, box["left"] - pad), min(1.0, box["right"] + pad)
    return page.crop((int(left * w), int(top * h), int(right * w), int(bottom * h)))


for row in rows:
    if review_reasons(row):
        crop(row["box"], row["box_confidence"]).save(f"review-{row['id']}.jpg")
        print(f"saved review-{row['id']}.jpg  ({', '.join(review_reasons(row))})")

Tras ejecutarlo, review-row-3.jpg (tifoidea, verificar dosis) y review-row-6.jpg (rabia, verificar lectura) quedan en el directorio de ejecución — quien revisa no tiene que buscar en el escaneo de la página completa, sino que mira directamente la fila recortada.

Al final, lo oficial da consejos de ajuste: estos umbrales (0.90 / 0.50 / 0.50) son un punto de partida, no un dogma — usa registros verificados por humanos para calibrar tu propia línea. El principio detrás de la lógica de umbrales se explica en Confianza (Confidence).

  • Los dos marcados no se compensan: la tifoidea solo marcó la dosis, la rabia solo la lectura; mis review-*.jpg quedaron recortados

Paso 6: verificación de OCR de facturas — dos comprobaciones detectan tres lecturas erróneas ​

Por qué: ya se leyeron los escaneos, ¿y al revés? El OCR extrae valores de fotos de facturas — la mayoría son correctos, pero verificarlos uno por uno tarda lo mismo que teclearlos a mano. El enfoque oficial: Jev verifica cada valor extraído dos veces — una comprobación contra la página completa (verificación de página) y otra contra la imagen recortada (verificación de recorte); si cualquiera está por debajo de 0.25, pasa a revisión humana. Quien revisa solo mira los pocos marcados.

El escenario es muy realista: una es una factura de papel carbón con pliegues muy marcados (Milkwood, 1393×1080) y otra tiene una sombra en medio (Siyakhula, 899×1599) — el OCR leyó 8 campos (proveedor, número de factura, fecha, importe a pagar, cuatro datos bancarios), de los cuales tres se leyeron mal:

FacturaCampoLo que extrajo el OCRLo impreso en el papel
Milkwoodnúmero de facturaAN400074IN400074
Siyakhulanúmero de facturaINV03070INV03079
Siyakhulafecha16/09/202816/09/2026

Los números oficiales provienen de jev-1.14.0 (grabación de 2026-10-15). Esta parte requiere instalar aparte la extensión typesafe-sdk[pil] y descargar un segundo conjunto de ejemplos; dependencias y descarga:

bash
pip install ipython pillow 'typesafe-sdk[pil]>=0.7.5' 'cooksafe>=0.2.0,<0.3.0'

Las fotos de facturas, extractions.json (los valores extraídos por OCR) y el segundo conjunto de json_cache.json se descargan del directorio ocr_confidence_bounding_boxes del repositorio oficial de ejemplos; las fotos van en la carpeta inputs/. Ojo: esta caché tiene el mismo nombre que el json_cache.json del paso 1; si se ponen en el mismo directorio se sobrescriben entre sí — abre una carpeta aparte para el ejemplo de facturas, o termina de ejecutar los cinco pasos anteriores antes de descargar. Lo oficial lo dice claramente: los dos pasos de OCR y LLM (ellos usan Apple Vision más un LLM) no están en el código — cualquier extractor sirve, porque la verificación solo necesita las fotos y los valores extraídos.

Tres solicitudes, una ronda por cada factura. La primera solicitud: foto de la página completa + dos preguntas por campo (Box para localizar la posición, Noul para comprobar «¿es el valor extraído el de este campo?»):

python
FIELDS = {
    # field: what it is, in the words every question uses
    "supplier_name": "the supplier's (seller's) business name",
    "invoice_number": "the invoice or document number",
    "invoice_date": "the invoice date",
    "amount_due": "the final total amount payable",
    "bank_name": "the name of the supplier's bank in the payment details",
    "account_holder": "the account holder name in the supplier's bank details",
    "account_number": "the supplier's bank account number",
    "branch_code": "the supplier's bank branch code",
}
SAME_VALUE = "Ignore differences in spacing, punctuation, currency symbols and letter case."

# request 1: the whole photo, a Box + a Noul per field
def page_questions(values: dict) -> dict:
    from typesafe_sdk import Box, Noul
    questions = {}
    for field, value in sorted(values.items()):
        questions[f"box_{field}"] = Box(
            instructions=f"{FIELDS[field]}, printed as “{value}” in `page`"
        )
        questions[f"fits_{field}"] = Noul(
            instructions=f"Is “{value}” {FIELDS[field]} on `page`? {SAME_VALUE}"
        )
    return questions

La segunda solicitud recorta la zona alrededor del marco de cada campo y vuelve a preguntar el Box ampliado (la zona ocupa al menos el 30 % del ancho de la página y el 15 % de la altura; aunque el primer marco estuviera desviado, no sale de la zona); la tercera solicitud recorta cada marco nuevo (con margen en los cuatro lados) y hace una pregunta Noul: «¿Este valor está claramente impreso en esta imagen recortada? Si está cortado, ilegible o es distinto, responde no» — Ignore differences in spacing, punctuation... hace que las diferencias de espacios, puntuación, mayúsculas y símbolos monetarios no cuenten como error. La imagen recortada de cada campo se incrusta en las instructions de su propia pregunta y se client.attach_assets() envía de una vez (el mecanismo para referenciar imágenes dentro del texto se explica en la técnica avanzada de la lección de Box e imágenes).

Todo cae en una función de decisión: si cualquier comprobación está por debajo de BAR = 0.25, entonces review. El marcador oficial tras la ejecución:

text
photo          #  field           extracted                  fits page   crop  verdict
milkwood.jpg   1  supplier_name   MILKWOOD mushrooms              0.98   0.95  ok
milkwood.jpg   2  invoice_number  AN400074                        0.88   0.18  REVIEW
milkwood.jpg   3  invoice_date    01/09/2026                      0.53   0.82  ok
milkwood.jpg   4  amount_due      504.70                          0.95   0.80  ok
milkwood.jpg   5  bank_name       Standard Bank                   0.98   0.53  ok
milkwood.jpg   6  account_holder  MILKWOOD                        0.90   0.57  ok
milkwood.jpg   7  account_number  080 11 4941                     0.35   0.92  ok
siyakhula.jpg  1  supplier_name   Siyakhula Trading Services      0.96   0.31  ok
siyakhula.jpg  2  invoice_number  INV03070                        0.02   0.04  REVIEW
siyakhula.jpg  3  invoice_date    16/09/2028                      0.17   0.66  REVIEW
siyakhula.jpg  4  amount_due      R1,305.65                       0.97   0.84  ok
siyakhula.jpg  5  bank_name       Standard Bank                   0.97   0.98  ok
siyakhula.jpg  6  account_holder  Siyakhula Trading               0.93   0.96  ok
siyakhula.jpg  7  account_number  10 13 205 260 5                 0.96   0.78  ok
siyakhula.jpg  8  branch_code     051001                          0.97   0.94  ok

Mira las puntuaciones de las tres lecturas erróneas — esta es la tabla más importante de toda la lección:

  • AN400074 (en el papel está impreso IN400074; la I inicial se reconoció como A): la verificación de página 0.88 lo dejó pasar (en la foto de la página completa la letra pequeña es demasiado pequeña), la verificación de recorte 0.18 lo atrapó
  • 16/09/2028 (en el papel está impreso 16/09/2026, el último dígito 6 fue reconocido como 8): la verificación del recorte 0.66 lo dejó pasar, la verificación de página 0.17 lo detectó
  • INV03070 (en el papel está impreso INV03079, el último dígito 9 fue reconocido como 0): ambas puntuaciones bajas (0.02 / 0.04), doble captura

Palabras textuales oficiales: ninguna de las dos comprobaciones por sí sola detecta las tres. Las dos comprobaciones tienen perspectivas complementarias: la página completa mira «¿este valor parece plausible en este formato?», el recorte mira «¿estos caracteres son exactamente estos?». Y los valores totalmente correctos pasaron ambas comprobaciones (mínimo 0.35 / 0.31).

  • Puedo explicar cuál de las dos comprobaciones detectó y cuál dejó pasar cada una de las tres lecturas erróneas; BAR = 0.25 se evalúa con «o» y no con «y»

📋 Prompt mágico ​

El «Prompt» de esta página son plantillas de preguntas y código: cópialas, sustituye los marcadores 【】 y podrás aplicarlas a tus propios documentos escaneados. El trío: el dúo buscador de filas, la escotilla de escape para leer valores, y la doble comprobación de OCR.

📝 Dúo buscador de filas (versión Noul + Box) ​

Efecto esperado: para cualquier necesidad del tipo «algo de una lista podría estar en el documento, hay que encontrarlo y localizarlo» (vacunas, firmas, sellos, filas de entradas), basta con cambiar la lista usando la misma plantilla.

python
# 必填项:【清单】换你要找的东西列表;instructions 里的 `page` 换你的图在 state 里的字段名
questions = {
    "unlisted": Noul(instructions={
        "question": "Does the table in `page` record any 【东西类型】 that is not in this list?",
        "list": 【清单】,
    }),
}
for i, item in enumerate(【清单】):
    questions[f"item_{i:02d}"] = Noul(
        instructions=f"Is 【东西】 recorded in the table in `page`, with exactly this name?")
    questions[f"item_{i:02d}|box"] = Box(
        instructions=f"the whole 【东西】 row of the table in `page`")
# 选填项:近亲名称故意放进清单里测区分度(官方放了 Hepatitis A and B combined)?
# 输出规范:P(yes) ≥ 0.5 视为在页上;按 box["box"]["top"] 排序得到页面顺序
# 约束条件:
# ✅ Noul 说不在页上,就不理会它那个 Box——Box 永远返回一个框
# ✅ unlisted 那道守门题保留:行级规则抓不到「列表漏了」
# ❌ 清单几千项别硬塞一个请求——先按组 Noul 预筛,再对命中组细问

✅ Escotilla de escape para leer valores (versión Choice) ​

Efecto esperado: leer de una imagen cualquier valor de un conjunto cerrado (año, mes, denominación, número de edición), y cuando no se puede leer, obtener un unreadable explícito en lugar de una suposición a ciegas.

python
# 必填项:【选项集】+ 两个逃生舱;【值在原文里的写法】写进 instructions 帮模型定位
VALUE = {
    **{【你的选项集】},
    "other": "【选项集之外的值】",
    "unreadable": "The value is covered, stained, smudged or damaged and can't be read",
}
question = Choice(
    instructions="【值在原文里怎么写的(如 day/month/year,年份是最后一部分)】"
                 "What 【值】 is written in 【位置描述,如 the DATE GIVEN cell of the X row】?",
    criteria=VALUE,
)
# 选填项:旁边加一道 Noul 问「这段完全可读吗」做第二信号(官方:可读性的分数尺度更低,阈值单独设)?
# 输出规范:answer.choice + answer.confidence;other/unreadable 让该行无值可判,直接送人工
# 约束条件:
# ✅ Choice 永远挑一个——没有逃生舱它就硬猜,这是本模板存在的理由
# ❌ 不要把「读值」和「按值判断」合并成一道题对着图问(见第 4 步附录反例)

🔧 Flujo de doble comprobación de OCR (versión código) ​

Efecto esperado: verificar dos veces cada campo extraído por OCR, derivar a revisión humana los que estén por debajo del umbral y dibujar recuadros de revisión.

python
BAR = 0.25  # a check scoring below this flags the field

def check_invoice(photo, values) -> dict:
    first = find_fields(photo, values)      # 请求 1:整页 Box + Noul 页面核对
    tight = zoom_fields(photo, values, first["boxes"])  # 请求 2:放大重框
    shown = check_crops(photo, values, tight["boxes"])  # 请求 3:裁剪 Noul 细看
    return {
        field: {
            "value": values[field],
            "box": tight["boxes"][field],
            "fits": first["fits"][field],          # 页面核对分
            "shows": shown["shows"][field],         # 裁剪核对分
            "review": first["fits"][field] < BAR or shown["shows"][field] < BAR,
        }
        for field in sorted(values)
    }
# 必填项:【照片】【values:OCR 抽出的字段 map】;阈值 BAR 按你的容错调
# 选填项:复核框画在原图上——review 橙色、通过蓝色,复核的人对着位置看?
# 输出规范:每字段 {value, box, fits, shows, review};review=True 进人工队列
# 约束条件:
# ✅ 任一检查低于阈值就转人工——「或」不是「且」(单次检查抓不全)
# ✅ SAME_VALUE 句式保留:空格、标点、大小写、货币符号差异不算错
# ❌ 别指望整页一次看全:小字要靠裁剪放大,两次检查视角互补

Puntos de control ✅ ​

  • Completé el flujo completo con el documento escaneado de vacunas: 33 preguntas para buscar filas → Choice lee el año (unreadable escotilla de escape) → solicitud de texto puro para verificar la validez → marcar puntuaciones bajas + recortar
  • Puedo explicar por qué leer la imagen y juzgar deben separarse en dos solicitudes, y qué se pierde en la versión combinada (rabia 0.88 pasa, tifoidea 0.50 pasa por los pelos)
  • Puedo mirar el marcador y explicar cuál comprobación detectó cada una de las tres lecturas erróneas de OCR: AN400074 el recorte, 16/09/2028 la página completa, INV03070 doble captura
  • Todos mis umbrales tienen su origen marcado: lectura 0.90, legibilidad 0.50, validez 0.50, OCR 0.25, y sé que hay que ajustarlos con muestras verificadas manualmente
  • Sé que ambas solicitudes llevan TypeSafe-Danger-Zone-Images: true, y que la tercera solicitud de texto puro no lo necesita

Advertencias de errores comunes ​

❌ Sin escotilla de escape, Choice hace suposiciones a ciegas ​

Una fecha cubierta por una pegatina, un número borroso por una mancha: Choice siempre elige una opción; sin una salida de «no se puede leer», te dará el año que más se parece, y además con una confidence nada baja. La solución oficial es doble: al final de la lista de opciones se pone other (fuera de lista) y unreadable (ilegible), y al lado se añade un Noul independiente de legibilidad. En el ejemplo oficial, la fila de la rabia: Choice responde unreadable, el Noul de legibilidad 0.05, ambas señales correctas.

❌ Combinar la lectura de la imagen y el juicio en una sola pregunta ​

«¿Esta vacuna sigue siendo válida en la fecha de salida? La fecha de salida está en el encabezado»: preguntado directamente sobre la imagen, la prueba oficial dio rabia con 0.88 pasando (la fecha estaba claramente cubierta) y tifoidea 0.50 pasando por los pelos. Motivo: una sola respuesta cubre dos pasos, no puedes distinguir si no leyó bien o si juzgó mal. La forma correcta de dividirlo: la solicitud de lectura de imagen produce lecturas estructuradas, y la solicitud de juicio solo recibe texto: la rabia se detiene en el paso de lectura, el juicio de tifoidea 0.38 va a revisión humana.

❌ Tomarse al pie de la letra el recuadro de Box ​

Box siempre devuelve un recuadro: para lo que no está en la imagen, igualmente da cuatro bordes. En el registro de vacunas, 10 vacunas que no están en la página, cada una con un recuadro como box top 0.33. La forma correcta es el dúo del paso 2: usar el recuadro solo si el Noul dice que está (≥ 0.5); cuando el Noul de fuera de lista da ≥ 0.5, enviar la página entera a revisión. Ojo también: el confidence de BoxAnswer, según el esquema de la API, puede ser null (cuando el modelo no lo proporciona); verifica si es nulo antes de comparar con el umbral, no dejes que el código lance directamente TypeError.

❌ Enviar imágenes pequeñas tal cual y no reducir las grandes ​

Si se superan los límites de imagen de la API, la solicitud se rechaza directamente y no hay escalado automático: imágenes estáticas PNG/JPEG, 280–1568 píxeles por lado, 78,400–2,458,624 píxeles totales, ≤ 16 MiB por archivo. Los escaneos de alta resolución: primero comprime el lado más largo a 1568; a la inversa, los recortes pequeños con un lado menor que 280 hay que ampliarlos (en el ejemplo oficial, la imagen de la región reencuadrada tras ampliar se agrandó a 1200 y la imagen de la verificación del recorte se amplió a 800 antes de enviarla; si es realmente demasiado pequeña, se pega en el centro de un lienzo blanco y la posición en el lienzo se registra para convertir de vuelta las coordenadas). Y otra trampa: la API recodifica al procesar, y la imagen procesada puede ser más grande que el archivo original; enviar un montón de imágenes pequeñas también puede chocar con el límite de «todas las imágenes de la solicitud suman 32 MiB».

Técnicas avanzadas (opcional) ​

El mismo enfoque aplicado a fotogramas de vídeo continuo: registro de especies de una cámara de comedero para aves. El tercer cookbook oficial de imágenes (Feeder-cam visit log): un vídeo de 101 segundos de una cámara de comedero, se extrae un fotograma por segundo y se envían 5 preguntas por fotograma: si hay aves (Noul), cuántas (Choice: none/one/several), dónde está el ave más visible (Box), y qué especies son las aves más a la izquierda y más a la derecha (dos Choice, 10 especies de aves más other; cada opción describe «cómo se ve este tipo de ave en la imagen de la cámara» y no una descripción estilo guía de campo). Resultado oficial: bird_present y la anotación manual 101/101 totalmente correctos, especies reconocidas correctamente 132/133; tiempo mediano por fotograma 0.54 segundos, 4 hilos en paralelo.

Tres diseños que vale la pena copiar: uno, Box devuelve un solo recuadro por pregunta; cuando hay dos aves en el mismo fotograma, la segunda solicitud pide un recuadro por nombre de especie («the male northern cardinal (the bright red bird)»); si dos recuadros se solapan (intersección sobre unión) ≥ 0.6, se considera que es el mismo ave contada dos veces y solo se conserva la de confidence más alta. Dos, visits() convierte las respuestas de los fotogramas en un «registro de visitas», con tres parámetros (probabilidad de especie ≥ 0.6, hueco ≤ 2 fotogramas, al menos 2 fotogramas para contar una visita) que son asunto puramente del código, Jev no los ve: reajustar los parámetros no requiere reenviar solicitudes. Tres, cuando aves de la misma especie van en bandada no se pueden separar: la recomendación oficial es usar un detector zero-shot (como el SAM 3 de Meta) para encontrar primero todos los recuadros por «bird», y luego Jev reconoce la especie de cada recorte de ave.

**Con documentos escaneados en chino, prueba antes de desplegar. ** La documentación oficial indica que Jev se entrenó principalmente en inglés, otros idiomas (incluido el chino) funcionan pero con menor precisión: antes de poner en producción documentos en chino, ejecuta un lote con tus propios escaneos y fíjate sobre todo en la distribución de probabilidades y la confidence (la explicación sobre soporte de idiomas está en modelos y precios).

Ten claro el costo. Las imágenes no se cobran por separado: cada imagen se factura por tokens de entrada, al mismo precio que el texto; usage.input_tokens incluye los tokens de todas las imágenes. Las imágenes también ocupan contexto (64k por solicitud / 32k por pregunta), y meter demasiadas imágenes de una vez provoca max_tokens_exceeded. El mecanismo de caché del ejemplo oficial te ahorra dinero en la fase de desarrollo: las respuestas se cachean según el contenido de la solicitud, así que reejecutar no vuelve a enviar todo.

Conecta tus propios documentos. La documentación oficial dice claramente que este enfoque sirve para cualquier documento cuyo «conjunto de respuestas ya se conozca»: VACCINES cámbialo por tu lista, YEAR por tu rango de valores, la pregunta de vigencia por tu criterio de negocio; se conservan los dos escapes other y unreadable. Para la versión en texto puro de la extracción de valores (fechas, correos, teléfonos, importes), ver extracción de valores; sobre cómo repartir extracción y verificación entre varios modelos para ahorrar, ver extracción en cascada.

Resumen de esta lección ​

✅ Jev Reconocimiento de imágenes para leer documentos escaneados: Noul averigua si está, Box en qué fila está (top ordenar por bordes da el orden en la página), Choice lee el valor con los escapes other/unreadable: lo que no se puede leer se reporta, no se adivina.

✅ Separar lectura de imagen y juicio: la solicitud de lectura lleva imagen, la de juicio es texto puro. Contraejemplo oficial: fusionarlo en una sola pregunta, rabia 0.88 pasa por error y tifoidea 0.50 pasa justo al límite; una sola respuesta cubre dos pasos y todas las alarmas fallan.

✅ Doble comprobación de OCR: verificación de página completa + verificación de recortes; si cualquiera baja de 0.25, se pasa a revisión humana. Las tres lecturas erróneas fueron detectadas; cualquiera de las dos comprobaciones por separado habría dejado escapar alguna. Los recuadros de revisión se dibujan sobre la imagen original y el humano solo mira lo marcado.

✅ Fotogramas de vídeo con la misma receta: Noul como guardián + Box + Choice con la pregunta de especie, 101/101 acierta si hay aves o no; los umbrales del registro de visitas están todos en el código, ajustarlos no requiere reenviar solicitudes.

Repaso de los campos de configuración clave:

CampoValor en esta páginaExplicación
TYPESAFE_MODELjev-1.14.0Las preguntas Box necesitan Jev 1.14; fija el ID de versión, no uses el jev-latest que cambia
IMAGES_ON{"TypeSafe-Danger-Zone-Images": "true"}Obligatorio en cada solicitud con imagen/Box; las solicitudes de texto puro no lo necesitan
PRESENT_CUTOFF0.5Solo se usa ese Box si P(en la página) ≥ 0.5
READ_CUTOFF / LEGIBLE_CUTOFF0.90 / 0.50La puntuación de lectura y la de legibilidad tienen escalas distintas, define umbrales por separado
IN_DATE_CUTOFF0.50Si el juicio de vigencia queda por debajo, se envía a humano; no se compensa con la marca de lectura
BAR0.25Línea de revisión de la doble comprobación de OCR; si cualquiera de las dos baja de este valor, se marca review
unreadable / otherEscapesel primero cubre «no se puede leer», el segundo cubre «fuera del rango de valores»
Límites de imagen280–1568 píxeles por lado, ≤ 16 MiB por archivoSi se excede, se rechaza sin reescalar; los recortes pequeños deben ampliarse antes de enviarlos

Tutoriales relacionados:

  • Box e imágenes: los cimientos de esta página: cómo cargar Image, conversión de los cuatro bordes, Noul como portero
  • Extracción de valores: extracción en texto puro de fechas, correos, teléfonos e importes: preguntas por componentes + candidatos con regex
  • Confidence (confianza): tres niveles de uso (alto: ejecutar automáticamente / medio: marcar / bajo: pasar a humano) y ajuste de umbrales según el riesgo

Avance de la próxima lección ​

Aquí se cierra la ruta C: ya tienes el juicio de texto, la extracción de valores y el reconocimiento de imágenes. Lo siguiente es el manual avanzado: otra forma de Jev: el Agente de navegador. Próxima lección: Manual avanzado: Jev Ultrafast, Agente de navegador y guía de trampas a evitar.

Aprenderás:

  • Qué es Jev Ultrafast: le das un objetivo, Jev elige la acción y el elemento, y el LLM pequeño solo escribe la cadena de texto al teclear
  • Espacio de acciones con índice dinámico: en cada observación se genera una nueva tabla de elementos, y un solo viaje de ida y vuelta decide a la vez la acción y el objetivo
  • Principios e instalación para ejecutar en 7 segundos una búsqueda real en Google Flights
  • Los 9 modos de fallo conocidos de Jev 1.13 — la otra cara de la idea de «descomponer el problema» de esta página
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.