clairic / clairic_model.py
areneau's picture
Clarify base model and System One extraction usage
2c161be verified
Raw History Blame Contribute Delete
4.76 kB
"""Clairic's Transformers loader and System One extraction interface."""
from __future__ import annotations
import asyncio
import base64
import io
import json
from pathlib import Path
from typing import Any, Mapping
from clairic_runtime.api import PredictRequest, serialize_response
from clairic_runtime.backend import ClairicFlashModel
from clairic_runtime.errors import ClairRequestError
from clairic_runtime.large import Clairic27BModel
from clairic_runtime.settings import RuntimeSettings
def _request(value: Mapping[str, Any] | PredictRequest) -> PredictRequest:
if isinstance(value, PredictRequest):
return value
from PIL import Image, ImageOps
request = dict(value)
if "state" in request and not isinstance(request["state"], str):
request["state"] = json.dumps(request["state"], ensure_ascii=False)
images = request.get("images")
if isinstance(images, (list, tuple)):
images = list(images)
for index, image in enumerate(images):
if isinstance(image, Image.Image):
buffer = io.BytesIO()
ImageOps.exif_transpose(image).convert("RGBA").save(
buffer, format="PNG"
)
images[index] = "data:image/png;base64," + base64.b64encode(
buffer.getvalue()
).decode("ascii")
request["images"] = images
return PredictRequest.model_validate(request)
class ClairicModel:
"""A model and its typed extraction head, with synchronous and async APIs."""
def __init__(self, runtime: ClairicFlashModel, public_name: str) -> None:
self.runtime = runtime
self.model_id = public_name
names = {public_name, runtime.model_id}
self._model_selectors = names | {"@cf/cloudflare/" + name for name in names}
self.processor = runtime.processor
self.backbone = runtime.engine.backbone
self.head = runtime.engine.head
self.device = runtime.engine.device
async def predict_async(
self, request: Mapping[str, Any] | PredictRequest
) -> dict[str, Any]:
validated = _request(request)
if validated.model is not None and validated.model not in self._model_selectors:
raise ClairRequestError(
f"Unsupported model '{validated.model}'. Use '{self.model_id}'."
)
output = await self.runtime.predict_async(validated)
return serialize_response(validated, output, self.model_id)
def predict(self, request: Mapping[str, Any] | PredictRequest) -> dict[str, Any]:
"""Return structured values and scores for a System One: Extract request."""
try:
asyncio.get_running_loop()
except RuntimeError:
return asyncio.run(self.predict_async(request))
raise RuntimeError(
"Use await model.predict_async(request) inside an active event loop"
)
def eval(self) -> ClairicModel:
self.backbone.eval()
self.head.eval()
return self
def close(self) -> None:
self.runtime.shutdown()
def load_release_model(
model_path: str | Path,
device: Any = "cuda",
dtype: Any = None,
max_length: int = 65_273,
**from_pretrained_kwargs: Any,
) -> tuple[ClairicModel, Any]:
"""Load a local snapshot or a Hugging Face repository with Transformers."""
path = Path(model_path)
if not path.is_dir():
from huggingface_hub import snapshot_download
path = Path(snapshot_download(str(model_path)))
configuration = json.loads((path / "clair_head_config.json").read_text())
large = int(configuration["hidden_size"]) == 5120
model_id = "clairic-27b" if large else "clairic-flash"
settings = RuntimeSettings(
model_path=str(path),
version="1",
model_id=model_id,
max_length=max_length,
max_concurrency=1,
)
implementation = Clairic27BModel if large else ClairicFlashModel
runtime = implementation.load(
settings, device=str(device), dtype=dtype, **from_pretrained_kwargs
)
return ClairicModel(
runtime, "clairic" if large else "clairic-flash"
), runtime.processor
def systemone(
model: ClairicModel,
processor: Any,
request: Mapping[str, Any] | PredictRequest,
max_length: int | None = None,
) -> dict[str, Any]:
"""Answer a System One: Extract request with typed fields and confidence."""
if processor is not model.processor:
raise ValueError("Use the processor returned with this model")
if max_length is not None and max_length != model.runtime.settings.max_length:
raise ValueError("Set max_length when calling load_release_model")
return model.predict(request)