init

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

app.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional
+
+from fastapi import FastAPI
+from pydantic import BaseModel, Field
+
+try:
+    import torch
+    from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
+except Exception:  # pragma: no cover
+    torch = None
+    AutoModelForSeq2SeqLM = None
+    AutoTokenizer = None
+
+
+@dataclass
+class SummaryOutput:
+    summary: str
+    backend: str
+    used_target_length: Optional[int]
+
+
+class SummarizationConfig:
+    model_name: str = "google/mt5-small"
+    max_source_length: int = 1024
+    max_target_length: int = 160
+    num_beams: int = 4
+    no_repeat_ngram_size: int = 3
+    length_penalty: float = 1.0
+    fallback_sentences: int = 3
+
+
+def normalize_text(text: str) -> str:
+    return " ".join(text.replace("\u3000", " ").split())
+
+
+def split_sentences(text: str) -> List[str]:
+    import re
+
+    parts = re.split(r"(?<=[。！？!?；;])\s*", text)
+    return [p.strip() for p in parts if p.strip()]
+
+
+def tokenize(text: str) -> List[str]:
+    import re
+
+    return re.findall(r"[\u4e00-\u9fff]+|[A-Za-z0-9]+", text.lower())
+
+
+class SimpleExtractiveSummarizer:
+    def __init__(self, max_sentences: int = 3):
+        self.max_sentences = max_sentences
+
+    def summarize(self, text: str, target_length: int | None = None) -> str:
+        sentences = split_sentences(text)
+        if not sentences:
+            return ""
+        if len(sentences) == 1:
+            return sentences[0]
+
+        freq = {}
+        for sentence in sentences:
+            for token in tokenize(sentence):
+                freq[token] = freq.get(token, 0) + 1
+
+        scored = []
+        for idx, sentence in enumerate(sentences):
+            tokens = tokenize(sentence)
+            score = sum(freq.get(token, 0) for token in tokens) / max(1, len(tokens))
+            scored.append((score, idx, sentence))
+
+        scored.sort(key=lambda item: (-item[0], item[1]))
+        selected = sorted(scored[: self.max_sentences], key=lambda item: item[1])
+        kept: List[str] = []
+        total = 0
+        for _, _, sentence in selected:
+            if target_length is not None and kept and total + len(sentence) > target_length:
+                break
+            kept.append(sentence)
+            total += len(sentence)
+        return "".join(kept or [selected[0][2]])
+
+
+class HybridSummarizer:
+    def __init__(self, model_name: str = "google/mt5-small"):
+        self.model_name = model_name
+        self.backend_name = "fallback"
+        self.tokenizer = None
+        self.model = None
+        self.fallback = SimpleExtractiveSummarizer()
+        self.device = "cpu"
+        self._try_load_transformer()
+
+    def _try_load_transformer(self) -> None:
+        if AutoTokenizer is None or AutoModelForSeq2SeqLM is None or torch is None:
+            return
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name)
+            self.device = "cuda" if torch.cuda.is_available() else "cpu"
+            self.model.to(self.device)
+            self.backend_name = "transformer"
+        except Exception:
+            self.tokenizer = None
+            self.model = None
+            self.backend_name = "fallback"
+
+    def summarize(self, text: str, target_length: int | None = None) -> SummaryOutput:
+        text = normalize_text(text)
+        if not text:
+            return SummaryOutput(summary="", backend=self.backend_name, used_target_length=target_length)
+        if self.backend_name == "transformer" and self.tokenizer and self.model:
+            try:
+                return SummaryOutput(
+                    summary=self._summarize_with_transformer(text, target_length),
+                    backend="transformer",
+                    used_target_length=target_length,
+                )
+            except Exception:
+                pass
+        return SummaryOutput(
+            summary=self.fallback.summarize(text, target_length=target_length),
+            backend="fallback",
+            used_target_length=target_length,
+        )
+
+    def _summarize_with_transformer(self, text: str, target_length: int | None) -> str:
+        prompt = f"请根据目标长度 {target_length or 120} 字生成摘要：{text}"
+        inputs = self.tokenizer(
+            prompt,
+            return_tensors="pt",
+            truncation=True,
+            max_length=SummarizationConfig.max_source_length,
+        )
+        inputs = {k: v.to(self.device) for k, v in inputs.items()}
+        max_new_tokens = max(32, min(256, int((target_length or 120) * 1.2)))
+        min_new_tokens = max(16, int(max_new_tokens * 0.4))
+        generated = self.model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            min_new_tokens=min_new_tokens,
+            num_beams=SummarizationConfig.num_beams,
+            no_repeat_ngram_size=SummarizationConfig.no_repeat_ngram_size,
+            length_penalty=SummarizationConfig.length_penalty,
+            early_stopping=True,
+        )
+        return self.tokenizer.decode(generated[0], skip_special_tokens=True).strip()
+
+
+app = FastAPI(title="Transformer Summarizer Demo", version="1.0.0")
+engine = HybridSummarizer()
+
+
+class SummarizeRequest(BaseModel):
+    text: str
+    target_length: int | None = Field(default=120, ge=1, description="目标摘要长度")
+
+
+class SummarizeResponse(BaseModel):
+    summary: str
+    backend: str
+    target_length: int | None
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "backend": engine.backend_name}
+
+
+@app.post("/summarize", response_model=SummarizeResponse)
+def summarize(req: SummarizeRequest):
+    result = engine.summarize(req.text, target_length=req.target_length)
+    return SummarizeResponse(
+        summary=result.summary,
+        backend=result.backend,
+        target_length=result.used_target_length,
+    )
+
+
+@app.get("/")
+def root():
+    return {
+        "message": "Transformer Summarizer Demo is running",
+        "docs": "/docs",
+        "health": "/health",
+    }
+

requirements.txt

@@ -0,0 +1,7 @@
+fastapi>=0.110.0
+uvicorn>=0.29.0
+pydantic>=2.7.0
+transformers>=4.41.0
+sentencepiece>=0.2.0
+torch>=2.1.0
+