chore: import upstream snapshot with attribution

vllm/entrypoints/pooling/classify/api_router.py

@@ -0,0 +1,33 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import Response
+
+from vllm.entrypoints.serve.utils.api_utils import (
+    load_aware_call,
+    validate_json_request,
+    with_cancellation,
+)
+
+from .protocol import ClassificationRequest
+from .serving import ServingClassification
+
+router = APIRouter()
+
+
+def classify(request: Request) -> ServingClassification | None:
+    return request.app.state.serving_classification
+
+
+@router.post("/classify", dependencies=[Depends(validate_json_request)])
+@with_cancellation
+@load_aware_call
+async def create_classify(
+    request: ClassificationRequest, raw_request: Request
+) -> Response:
+    handler = classify(raw_request)
+    if handler is None:
+        raise NotImplementedError("The model does not support Classification API")
+
+    return await handler(request, raw_request)

vllm/entrypoints/pooling/classify/io_processor.py

@@ -0,0 +1,12 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from ..base.io_processor import PoolingIOProcessor
+
+
+class ClassifyIOProcessor(PoolingIOProcessor):
+    name = "classify"
+
+
+class TokenClassifyIOProcessor(PoolingIOProcessor):
+    name = "token_classify"

vllm/entrypoints/pooling/classify/protocol.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+import time
+from typing import TypeAlias
+
+from pydantic import Field
+
+from vllm import PoolingParams
+from vllm.entrypoints.openai.engine.protocol import OpenAIBaseModel, UsageInfo
+from vllm.logger import init_logger
+from vllm.utils import random_uuid
+
+from ..base.protocol import (
+    ChatRequestMixin,
+    ClassifyRequestMixin,
+    CompletionRequestMixin,
+    FixedMaxLenTokenizeParamsMixin,
+    PoolingBasicRequestMixin,
+)
+
+logger = init_logger(__name__)
+
+
+class ClassificationCompletionRequest(
+    PoolingBasicRequestMixin,
+    CompletionRequestMixin,
+    ClassifyRequestMixin,
+    FixedMaxLenTokenizeParamsMixin,
+):
+    def to_pooling_params(self):
+        return PoolingParams(
+            task="classify",
+            use_activation=self.use_activation,
+        )
+
+
+class ClassificationChatRequest(
+    PoolingBasicRequestMixin,
+    ChatRequestMixin,
+    ClassifyRequestMixin,
+    FixedMaxLenTokenizeParamsMixin,
+):
+    def to_pooling_params(self):
+        return PoolingParams(
+            task="classify",
+            use_activation=self.use_activation,
+        )
+
+
+ClassificationRequest: TypeAlias = (
+    ClassificationCompletionRequest | ClassificationChatRequest
+)
+
+
+class ClassificationData(OpenAIBaseModel):
+    index: int
+    label: str | None
+    probs: list[float]
+    num_classes: int
+
+
+class ClassificationResponse(OpenAIBaseModel):
+    id: str = Field(default_factory=lambda: f"classify-{random_uuid()}")
+    object: str = "list"
+    created: int = Field(default_factory=lambda: int(time.time()))
+    model: str
+    data: list[ClassificationData]
+    usage: UsageInfo

vllm/entrypoints/pooling/classify/serving.py

@@ -0,0 +1,72 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
+
+from typing import TypeAlias
+
+import numpy as np
+from fastapi.responses import JSONResponse
+
+from vllm.entrypoints.openai.engine.protocol import UsageInfo
+from vllm.logger import init_logger
+from vllm.outputs import ClassificationOutput
+
+from ..base.serving import PoolingServing
+from ..typing import PoolingServeContext
+from .io_processor import ClassifyIOProcessor
+from .protocol import (
+    ClassificationData,
+    ClassificationRequest,
+    ClassificationResponse,
+)
+
+logger = init_logger(__name__)
+
+
+ClassificationServeContext: TypeAlias = PoolingServeContext[ClassificationRequest]
+
+
+class ServingClassification(PoolingServing):
+    request_id_prefix = "classify"
+
+    def init_io_processor(self, *args, **kwargs) -> ClassifyIOProcessor:
+        return ClassifyIOProcessor(*args, **kwargs)
+
+    def _build_response(
+        self,
+        ctx: ClassificationServeContext,
+    ) -> JSONResponse:
+        id2label = getattr(self.model_config.hf_config, "id2label", {})
+        num_prompt_tokens = 0
+        items: list[ClassificationData] = []
+        for idx, final_res in enumerate(ctx.final_res_batch):
+            classify_res = ClassificationOutput.from_base(final_res.outputs)
+
+            probs = classify_res.probs
+            predicted_index = int(np.argmax(probs))
+            label = id2label.get(predicted_index)
+
+            item = ClassificationData(
+                index=idx,
+                label=label,
+                probs=probs,
+                num_classes=len(probs),
+            )
+
+            items.append(item)
+            prompt_token_ids = final_res.prompt_token_ids
+            num_prompt_tokens += len(prompt_token_ids)
+
+        usage = UsageInfo(
+            prompt_tokens=num_prompt_tokens,
+            total_tokens=num_prompt_tokens,
+        )
+
+        response = ClassificationResponse(
+            id=ctx.request_id,
+            created=ctx.created_time,
+            model=ctx.model_name,
+            data=items,
+            usage=usage,
+        )
+
+        return JSONResponse(content=response.model_dump())