Upload serve_ministral.py with huggingface_hub

serve_ministral.py

@@ -1,17 +1,20 @@
 #!/usr/bin/env python3
 """
-Simple OpenAI-compatible API server for Ministral 14B using transformers
-Usage: python serve_ministral.py
+OpenAI-compatible API server for Ministral 14B with streaming support
 """
 
 import torch
-from transformers import AutoProcessor, AutoModelForImageTextToText
+from transformers import AutoProcessor, AutoModelForImageTextToText, TextIteratorStreamer
 from fastapi import FastAPI
+from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 from typing import List, Optional
 import uvicorn
 import time
 import traceback
+import json
+import asyncio
+from threading import Thread
 
 app = FastAPI()
 
@@ -43,14 +46,7 @@ class ChatRequest(BaseModel):
     max_tokens: Optional[int] = 2048
     temperature: Optional[float] = 0.7
     top_p: Optional[float] = 0.9
-
-class ChatResponse(BaseModel):
-    id: str
-    object: str = "chat.completion"
-    created: int
-    model: str
-    choices: List[dict]
-    usage: dict
+    stream: Optional[bool] = False
 
 @app.on_event("startup")
 async def load_model():
@@ -77,7 +73,7 @@ async def chat_completions(request: ChatRequest):
     try:
         # Format messages
         messages = [{"role": m.role, "content": m.content} for m in request.messages]
-        print(f"Processing {len(messages)} messages...")
+        print(f"Processing {len(messages)} messages, stream={request.stream}")
 
         # Try to apply chat template
         try:
@@ -88,7 +84,6 @@ async def chat_completions(request: ChatRequest):
             )
         except Exception as e:
             print(f"Chat template error: {e}")
-            # Fallback: ShareGPT format with [INST] tags
             chat_text = "<s>"
             for m in messages:
                 if m["role"] == "system":
@@ -98,49 +93,111 @@ async def chat_completions(request: ChatRequest):
                 elif m["role"] == "assistant":
                     chat_text += f"{m['content']}</s>"
 
-        print(f"Input length: {len(chat_text)} chars")
-
         # Tokenize
         inputs = processor.tokenizer(chat_text, return_tensors="pt").to(model.device)
         input_len = inputs["input_ids"].shape[1]
         print(f"Input tokens: {input_len}")
 
-        # Generate
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_new_tokens=request.max_tokens,
-                temperature=request.temperature if request.temperature and request.temperature > 0 else 1.0,
-                top_p=request.top_p if request.top_p else 0.9,
-                do_sample=request.temperature is not None and request.temperature > 0,
-                pad_token_id=processor.tokenizer.eos_token_id,
+        if request.stream:
+            # Streaming response
+            async def generate_stream():
+                streamer = TextIteratorStreamer(
+                    processor.tokenizer,
+                    skip_prompt=True,
+                    skip_special_tokens=True
+                )
+
+                generation_kwargs = {
+                    **inputs,
+                    "max_new_tokens": request.max_tokens,
+                    "temperature": request.temperature if request.temperature and request.temperature > 0 else 1.0,
+                    "top_p": request.top_p if request.top_p else 0.9,
+                    "do_sample": request.temperature is not None and request.temperature > 0,
+                    "pad_token_id": processor.tokenizer.eos_token_id,
+                    "streamer": streamer,
+                }
+
+                thread = Thread(target=model.generate, kwargs=generation_kwargs)
+                thread.start()
+
+                response_id = f"chatcmpl-{int(time.time())}"
+
+                for text in streamer:
+                    if text:
+                        text = fix_bpe_tokens(text)
+                        chunk = {
+                            "id": response_id,
+                            "object": "chat.completion.chunk",
+                            "created": int(time.time()),
+                            "model": request.model,
+                            "choices": [{
+                                "index": 0,
+                                "delta": {"content": text},
+                                "finish_reason": None
+                            }]
+                        }
+                        yield f"data: {json.dumps(chunk)}\n\n"
+                        await asyncio.sleep(0)
+
+                # Send final chunk
+                final_chunk = {
+                    "id": response_id,
+                    "object": "chat.completion.chunk",
+                    "created": int(time.time()),
+                    "model": request.model,
+                    "choices": [{
+                        "index": 0,
+                        "delta": {},
+                        "finish_reason": "stop"
+                    }]
+                }
+                yield f"data: {json.dumps(final_chunk)}\n\n"
+                yield "data: [DONE]\n\n"
+
+                thread.join()
+
+            return StreamingResponse(
+                generate_stream(),
+                media_type="text/event-stream",
+                headers={"Cache-Control": "no-cache", "Connection": "keep-alive"}
             )
-
-        # Decode only the new tokens
-        new_tokens = outputs[0][input_len:]
-        response_text = processor.tokenizer.decode(
-            new_tokens,
-            skip_special_tokens=True,
-            clean_up_tokenization_spaces=True
-        )
-        response_text = fix_bpe_tokens(response_text)
-        print(f"Generated {len(new_tokens)} tokens")
-
-        return ChatResponse(
-            id=f"chatcmpl-{int(time.time())}",
-            created=int(time.time()),
-            model=request.model,
-            choices=[{
-                "index": 0,
-                "message": {"role": "assistant", "content": response_text},
-                "finish_reason": "stop"
-            }],
-            usage={
-                "prompt_tokens": input_len,
-                "completion_tokens": len(new_tokens),
-                "total_tokens": input_len + len(new_tokens)
+        else:
+            # Non-streaming response
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_new_tokens=request.max_tokens,
+                    temperature=request.temperature if request.temperature and request.temperature > 0 else 1.0,
+                    top_p=request.top_p if request.top_p else 0.9,
+                    do_sample=request.temperature is not None and request.temperature > 0,
+                    pad_token_id=processor.tokenizer.eos_token_id,
+                )
+
+            new_tokens = outputs[0][input_len:]
+            response_text = processor.tokenizer.decode(
+                new_tokens,
+                skip_special_tokens=True,
+                clean_up_tokenization_spaces=True
+            )
+            response_text = fix_bpe_tokens(response_text)
+            print(f"Generated {len(new_tokens)} tokens")
+
+            return {
+                "id": f"chatcmpl-{int(time.time())}",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": request.model,
+                "choices": [{
+                    "index": 0,
+                    "message": {"role": "assistant", "content": response_text},
+                    "finish_reason": "stop"
+                }],
+                "usage": {
+                    "prompt_tokens": input_len,
+                    "completion_tokens": len(new_tokens),
+                    "total_tokens": input_len + len(new_tokens)
+                }
             }
-        )
     except Exception as e:
         print(f"Error: {e}")
         traceback.print_exc()