Deploy humanizer backend

.gitignore

@@ -0,0 +1,5 @@
+.env
+__pycache__/
+*.pyc
+*.pyo
+.DS_Store

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for layer caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all backend files
+COPY main.py .
+COPY humanizer.py .
+COPY detector.py .
+COPY evaluator.py .
+
+# Expose port 7860 (HuggingFace Spaces default port)
+EXPOSE 7860
+
+# Start the server on port 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,44 @@
+---
+title: Humanizer API
+emoji: 🧠
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+# Humanizer API
+
+FastAPI backend for the AI text humanizer.
+
+## Endpoints
+
+- `POST /humanize` — Humanize AI-generated text
+
+## Request
+
+```json
+{
+  "text": "Your AI-generated text here",
+  "mode": "standard"
+}
+```
+
+## Response
+
+```json
+{
+  "humanized": "Rewritten text here",
+  "mode": "standard",
+  "score_before": 0.94,
+  "score_after": 0.21,
+  "similarity_score": 0.91,
+  "meaning_preserved": true
+}
+```
+
+## Modes
+
+- `simple` — Light cleanup only
+- `standard` — Full restructuring
+- `enhanced` — Maximum humanization

detector.py

@@ -0,0 +1,28 @@
+from transformers import pipeline
+
+# Cache the classifier pipeline globally after first load
+_classifier = None
+
+def get_ai_score(text: str) -> float:
+    global _classifier
+    if _classifier is None:
+        # Load the pipeline using the specified model
+        _classifier = pipeline(
+            "text-classification",
+            model="openai-community/roberta-base-openai-detector"
+        )
+    
+    # Truncate input text to 512 tokens max before scoring to respect model limits
+    results = _classifier(text, truncation=True, max_length=512)
+    result = results[0]
+    
+    label = result["label"]
+    score = float(result["score"])
+    
+    # Map labels:
+    # "Fake" score represents AI probability.
+    # "Real" score represents human probability, so AI probability = 1 - score.
+    if label == "Fake":
+        return score
+    else:
+        return 1.0 - score

evaluator.py

@@ -0,0 +1,22 @@
+from sentence_transformers import SentenceTransformer, util
+
+# Cache the SentenceTransformer model globally after first load
+_model = None
+
+def get_similarity(text_a: str, text_b: str) -> float:
+    global _model
+    if _model is None:
+        _model = SentenceTransformer('all-MiniLM-L6-v2')
+    
+    # Encode both inputs into embeddings
+    embedding_a = _model.encode(text_a, convert_to_tensor=True)
+    embedding_b = _model.encode(text_b, convert_to_tensor=True)
+    
+    # Compute cosine similarity
+    similarity = util.cos_sim(embedding_a, embedding_b)
+    
+    return float(similarity[0][0])
+
+def meaning_preserved(text_a: str, text_b: str, threshold: float = 0.85) -> bool:
+    similarity = get_similarity(text_a, text_b)
+    return similarity >= threshold

humanizer.py

@@ -0,0 +1,87 @@
+import os
+import requests
+
+HF_API_URL = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
+
+SIMPLE_PROMPT = """You are a light text editor. Rewrite the text the user sends with these rules only:
+1. Remove any of these phrases entirely: "It is important to note", "In today's fast-paced world", "Furthermore", "Moreover", "In conclusion", "When it comes to", "It is worth noting", "Needless to say", "In the realm of", "It goes without saying".
+2. Replace obvious synonym swaps where words feel robotic or overly formal.
+3. Do NOT change sentence structure, length, or order.
+4. Do NOT change the meaning, facts, or argument.
+5. Output ONLY the rewritten text. No preamble. No explanation."""
+
+STANDARD_PROMPT = """You are a text restructuring engine. Rewrite the text the user sends with these rules:
+1. Vary sentence lengths. Mix short sentences (under 8 words) with longer ones (over 25 words). Never have 3 sentences of similar length in a row.
+2. Remove any of these phrases entirely: "It is important to note", "In today's fast-paced world", "Furthermore", "Moreover", "In conclusion", "When it comes to", "It is worth noting", "Needless to say", "In the realm of", "It goes without saying".
+3. Flip at least 2 passive voice constructions to active voice.
+4. Move a subordinate clause from the end of a sentence to the beginning in at least 2 places.
+5. Add 1 or 2 contractions where formal phrasing sits (e.g. "it is" -> "it's").
+6. Do NOT change the meaning, facts, or argument.
+7. Output ONLY the rewritten text. No preamble. No explanation."""
+
+ENHANCED_PROMPT = """You are an aggressive text humanizer. Rewrite the text the user sends to sound completely natural and human. Follow all of these rules:
+1. Vary sentence lengths dramatically. Short punchy sentences (3-6 words) must appear. Long flowing sentences (30+ words) must appear. No rhythm should feel uniform.
+2. Remove any of these phrases entirely: "It is important to note", "In today's fast-paced world", "Furthermore", "Moreover", "In conclusion", "When it comes to", "It is worth noting", "Needless to say", "In the realm of", "It goes without saying".
+3. Flip all passive voice constructions to active voice.
+4. Move subordinate clauses to unexpected positions.
+5. Add contractions naturally throughout (aim for 30% of sentences).
+6. Add one parenthetical aside somewhere in the text that feels natural.
+7. Replace at least one transition word per paragraph with a casual connector or none at all.
+8. Introduce one slightly informal word choice per paragraph.
+9. Do NOT change the meaning, facts, or argument. All information must be preserved.
+10. Output ONLY the rewritten text. No preamble. No explanation."""
+
+PROMPTS = {
+    "simple": SIMPLE_PROMPT,
+    "standard": STANDARD_PROMPT,
+    "enhanced": ENHANCED_PROMPT,
+}
+
+
+def _build_prompt(system: str, text: str) -> str:
+    """Format prompt in Mistral instruct format."""
+    return f"<s>[INST] {system}\n\nText to rewrite:\n{text} [/INST]"
+
+
+async def humanize_text(text: str, mode: str = "standard") -> str:
+    hf_token = os.getenv("HF_TOKEN")
+    if not hf_token:
+        raise ValueError("HF_TOKEN not set in environment variables.")
+
+    system_prompt = PROMPTS.get(mode, STANDARD_PROMPT)
+    prompt = _build_prompt(system_prompt, text)
+
+    headers = {"Authorization": f"Bearer {hf_token}"}
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": 2000,
+            "temperature": 0.7,
+            "top_p": 0.95,
+            "do_sample": True,
+            "return_full_text": False,
+        }
+    }
+
+    response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=60)
+
+    if response.status_code == 503:
+        # Model is loading — wait and retry once
+        import time
+        time.sleep(20)
+        response = requests.post(HF_API_URL, headers=headers, json=payload, timeout=60)
+
+    if response.status_code != 200:
+        raise ValueError(f"HuggingFace API error {response.status_code}: {response.text}")
+
+    result = response.json()
+
+    # HF returns a list with one dict: [{"generated_text": "..."}]
+    if isinstance(result, list) and len(result) > 0:
+        generated = result[0].get("generated_text", "")
+        # Strip any accidental prompt echo if return_full_text was ignored
+        if "[/INST]" in generated:
+            generated = generated.split("[/INST]")[-1].strip()
+        return generated.strip()
+
+    raise ValueError(f"Unexpected response format from HuggingFace: {result}")

main.py

@@ -0,0 +1,57 @@
+import os
+import traceback
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+from humanizer import humanize_text
+from detector import get_ai_score
+from evaluator import get_similarity, meaning_preserved
+
+app = FastAPI(title="AI Humanizer API")
+
+class HumanizeRequest(BaseModel):
+    text: str
+    mode: str = "standard"
+
+class HumanizeResponse(BaseModel):
+    humanized: str
+    mode: str
+    score_before: float
+    score_after: float
+    similarity_score: float
+    meaning_preserved: bool
+
+@app.post("/humanize", response_model=HumanizeResponse)
+async def humanize(request: HumanizeRequest):
+    if request.mode not in ("simple", "standard", "enhanced"):
+        raise HTTPException(status_code=400, detail="mode must be one of: simple, standard, enhanced")
+        
+    try:
+        score_before = get_ai_score(request.text)
+        humanized_text = await humanize_text(request.text, mode=request.mode)
+        
+        if not meaning_preserved(request.text, humanized_text):
+            humanized_text = await humanize_text(request.text, mode=request.mode)
+            
+        score_after = get_ai_score(humanized_text)
+        similarity_score = get_similarity(request.text, humanized_text)
+        preserved = meaning_preserved(request.text, humanized_text)
+        
+        return HumanizeResponse(
+            humanized=humanized_text,
+            mode=request.mode,
+            score_before=score_before,
+            score_after=score_after,
+            similarity_score=similarity_score,
+            meaning_preserved=preserved
+        )
+    except Exception as e:
+        import traceback
+        raise HTTPException(status_code=500, detail=traceback.format_exc())
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+uvicorn
+python-dotenv
+requests
+
+# Large installs: pip install may take a few minutes
+transformers
+torch
+sentence-transformers