Deploy with full python image

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.gguf filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,23 @@
+# Use FULL Python image (Not slim) to ensure pre-built wheels work
+FROM python:3.10
+
+WORKDIR /code
+
+# 1. Install Dependencies
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# 2. Install llama-cpp-python (Pre-built Binary)
+#    Because we are using the full python image, this should now work 
+#    without compiling gcc, saving 15 minutes.
+RUN pip install llama-cpp-python \
+    --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+
+# 3. Download NLTK Data
+RUN python -m nltk.downloader punkt punkt_tab vader_lexicon
+
+# 4. Copy App
+COPY ./app /code/app
+
+# 5. Start
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/final_model.gguf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:046cf2e43a39736a6cd25879dba9d04a9b9b20a6d6476ab1ce70c4d406f65a2f
+size 397807264

app/main.py

@@ -0,0 +1,174 @@
+import os
+import time
+import nltk
+from nltk.sentiment import SentimentIntensityAnalyzer
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+from llama_cpp import Llama
+
+# ==========================================
+# CONFIGURATION
+# ==========================================
+MODEL_PATH = "app/final_model.gguf" 
+SENTIMENT_THRESHOLD = 0.05
+
+ml_resources = {}
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("⚡ Loading NLP tools...")
+    
+    try:
+        nltk.data.find('tokenizers/punkt')
+    except LookupError:
+        nltk.download('punkt')
+        nltk.download('punkt_tab')
+        nltk.download('vader_lexicon')
+    
+    ml_resources["analyzer"] = SentimentIntensityAnalyzer()
+
+    print(f"⚡ Loading Llama Model from {MODEL_PATH}...")
+    if not os.path.exists(MODEL_PATH):
+        print(f"❌ CRITICAL ERROR: Model not found at {MODEL_PATH}")
+    else:
+        try:
+            ml_resources["llm"] = Llama(
+                model_path=MODEL_PATH,
+                n_ctx=2048,
+                n_gpu_layers=0, 
+                verbose=False
+            )
+            print("✅ Model loaded successfully!")
+        except Exception as e:
+            print(f"❌ Failed to load model: {e}")
+
+    yield
+    ml_resources.clear()
+
+app = FastAPI(lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ToneRequest(BaseModel):
+    text: str
+    style: str 
+
+class ToneResponse(BaseModel):
+    original: str
+    transformed: str
+    latency_ms: float
+    changes_made: int
+
+def should_rewrite(sentence):
+    toxic_keywords = [
+        "garbage", "trash", "stupid", "dumb", "idiot", "hate", "terrible",
+        "horrible", "awful", "suck", "useless", "incompetent", "mess", "disaster"
+    ]
+    for word in toxic_keywords:
+        if word in sentence.lower():
+            return True, f"Keyword: {word}"
+
+    sia = ml_resources["analyzer"]
+    scores = sia.polarity_scores(sentence)
+    if scores['compound'] < SENTIMENT_THRESHOLD:
+        return True, f"Sentiment: {scores['compound']}"
+
+    return False, "Neutral"
+
+@app.post("/transform", response_model=ToneResponse)
+async def transform_text(request: ToneRequest):
+    if "llm" not in ml_resources:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    llm = ml_resources["llm"]
+    start_time = time.time()
+    
+    # Split by newlines to preserve paragraphs
+    original_lines = request.text.split('\n')
+    final_text_blocks = []
+    changes_count = 0
+
+    print(f"\n--- Request ({request.style}) ---")
+
+    for line in original_lines:
+        if not line.strip():
+            final_text_blocks.append("")
+            continue
+
+        try:
+            sentences = nltk.sent_tokenize(line)
+        except:
+            sentences = [line]
+
+        line_rewrites = []
+
+        for sent in sentences:
+            clean_sent = sent.strip()
+            if not clean_sent: continue
+
+            needs_fix, reason = should_rewrite(clean_sent)
+
+            if needs_fix:
+                print(f"   ⚠️ REWRITING: '{clean_sent[:20]}...' -> {reason}")
+                
+                system_prompt = (
+                    "You are a professional editor. Rewrite the input text to be polite and corporate. "
+                    "Keep the exact same meaning and speaker perspective."
+                )
+
+                if request.style.lower() == "casual":
+                    examples = [
+                        {"role": "user", "content": "Rewrite: This is garbage."},
+                        {"role": "assistant", "content": "This isn't really working for me."},
+                        {"role": "user", "content": "Rewrite: You are so lazy."},
+                        {"role": "assistant", "content": "I feel like we could be moving faster."}
+                    ]
+                else:
+                    examples = [
+                        {"role": "user", "content": "Rewrite: This design is garbage."},
+                        {"role": "assistant", "content": "The current design does not meet the requirements."},
+                        {"role": "user", "content": "Rewrite: I don't know why I hired you."},
+                        {"role": "assistant", "content": "I am concerned about the value being delivered."}
+                    ]
+
+                messages = [{"role": "system", "content": system_prompt}]
+                messages.extend(examples)
+                messages.append({"role": "user", "content": f"Rewrite: {clean_sent}"})
+
+                output = llm.create_chat_completion(
+                    messages=messages,
+                    temperature=0.1, 
+                    max_tokens=128
+                )
+                
+                new_text = output['choices'][0]['message']['content'].strip()
+                if "Rewrite:" in new_text: new_text = new_text.replace("Rewrite:", "").strip()
+
+                print(f"      -> {new_text}")
+                line_rewrites.append(new_text)
+                changes_count += 1
+            else:
+                line_rewrites.append(clean_sent)
+
+        final_text_blocks.append(" ".join(line_rewrites))
+
+    final_output = "\n".join(final_text_blocks)
+
+    return ToneResponse(
+        original=request.text,
+        transformed=final_output,
+        latency_ms=round((time.time() - start_time) * 1000, 2),
+        changes_made=changes_count
+    )
+
+@app.get("/")
+def read_root():
+    return {"status": "online", "model": "Qwen-GGUF-Quantized"}

requirements.txt

@@ -0,0 +1,4 @@
+fastapi
+uvicorn
+pydantic
+nltk