app

.dockerignore

@@ -0,0 +1,56 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Docker
+Dockerfile*
+docker-compose*
+.dockerignore
+
+# Logs
+*.log
+
+# Temporary files
+*.tmp
+*.temp
+
+# Documentation
+README.md
+docs/

.env.example

@@ -0,0 +1,12 @@
+# Environment Variables for SVM Classifier
+# Copy this file to .env and set your values
+
+# API Key for authentication
+API_KEY=my-super-secret-api-key-2024
+
+# Path to the model file
+MODEL_PATH=fake_news_model.joblib
+
+# Server configuration
+HOST=0.0.0.0
+PORT=8000

.gitattributes

@@ -33,3 +33,5 @@ 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
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.env

Dockerfile

@@ -0,0 +1,34 @@
+# Use Python 3.10 slim image
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create non-root user
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,13 +1,84 @@
----
-title: Svm Model
-emoji: 🔥
-colorFrom: purple
-colorTo: gray
-sdk: gradio
-sdk_version: 5.42.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SVM Fake News Classifier
+
+FastAPI application for classifying news articles as real or fake using Support Vector Machine with TF-IDF features.
+
+## Features
+
+- FastAPI REST API
+- SVM model with TF-IDF vectorization
+- Calibrated probability predictions
+- API key authentication
+- Health check endpoint
+- Docker support
+
+## API Endpoints
+
+- `GET /` - API information
+- `GET /health` - Health check
+- `POST /predict` - Single prediction
+- `POST /predict_batch` - Batch predictions
+- `GET /docs` - Interactive API documentation
+
+## Quick Start
+
+### Using Docker
+
+```bash
+# Build and run with docker-compose
+docker-compose up --build
+
+# Or build and run manually
+docker build -t svm-classifier .
+docker run -p 8000:8000 svm-classifier
+```
+
+### Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+# or
+python start.py
+# or
+uvicorn app:app --host 0.0.0.0 --port 8000
+```
+
+## Usage
+
+### Single Prediction
+
+```bash
+curl -X POST "http://localhost:8000/predict" \
+     -H "Content-Type: application/json" \
+     -H "x-api-key: super-secret-key" \
+     -d '{
+       "title": "Breaking News",
+       "text": "This is a news article text..."
+     }'
+```
+
+### Batch Prediction
+
+```bash
+curl -X POST "http://localhost:8000/predict_batch" \
+     -H "Content-Type: application/json" \
+     -H "x-api-key: super-secret-key" \
+     -d '{
+       "items": [
+         {"title": "News 1", "text": "Text 1"},
+         {"title": "News 2", "text": "Text 2"}
+       ]
+     }'
+```
+
+## Environment Variables
+
+- `MODEL_PATH`: Path to the model file (default: `fake_news_model.joblib`)
+- `API_KEY`: API key for authentication (default: `super-secret-key`)
+
+## License
+
+Apache 2.0

README_HF.md

@@ -0,0 +1,10 @@
+---
+title: SVM Fake News Classifier
+emoji: 📰
+colorFrom: red
+colorTo: blue
+sdk: docker
+app_port: 7860
+pinned: false
+license: apache-2.0
+---

README_gradio.md

@@ -0,0 +1,47 @@
+---
+title: SVM Fake News Classifier
+emoji: 📰
+colorFrom: red
+colorTo: blue
+sdk: gradio
+sdk_version: "4.44.0"
+app_file: gradio_app.py
+pinned: false
+license: apache-2.0
+---
+
+# SVM Fake News Classifier
+
+An interactive web application for classifying news articles as real or fake using Support Vector Machine with TF-IDF features.
+
+## Features
+
+- 🤖 **SVM Model**: Support Vector Machine with TF-IDF vectorization
+- 📊 **Calibrated Probabilities**: Reliable confidence scores using CalibratedClassifierCV
+- 🎯 **Interactive Interface**: User-friendly Gradio web interface
+- 📚 **Example Articles**: Pre-loaded examples to test the model
+- 📈 **Confidence Levels**: High/Medium/Low confidence indicators
+
+## How to Use
+
+1. **Enter Article Details**: Input the news title and content
+2. **Get Prediction**: Click "Classify News" to analyze the article
+3. **Review Results**: Check the prediction, probabilities, and confidence level
+
+## Model Information
+
+- **Algorithm**: Support Vector Machine (SVM)
+- **Features**: TF-IDF text vectorization
+- **Calibration**: CalibratedClassifierCV for probability estimates
+- **Output**: Binary classification (Real/Fake) with confidence scores
+
+## API Version
+
+For programmatic access, a FastAPI version is also available with the following endpoints:
+- `POST /predict` - Single article prediction
+- `POST /predict_batch` - Batch predictions
+- `GET /health` - Health check
+
+## Disclaimer
+
+This is a machine learning model for educational and research purposes. Always verify important information through multiple reliable sources.

__init__.py

@@ -0,0 +1 @@
+# SVM Fake News Classifier Package

app.py

@@ -0,0 +1,128 @@
+# app.py
+from __future__ import annotations
+
+import warnings
+from typing import List, Literal, Optional, Tuple
+from config import MODEL_PATH, REAL_LABEL, API_KEY
+import joblib
+from fastapi import FastAPI, Header, HTTPException
+from helper import _combine
+from schemas import PredictOut, PredictBatchIn, PredictIn, PredictBatchOut
+
+# Suppress sklearn version warnings
+warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")
+warnings.filterwarnings("ignore", message=".*InconsistentVersionWarning.*")
+# =========================
+# Load calibrated model
+# (Pipeline: TF-IDF -> CalibratedClassifierCV(LinearSVC))
+# =========================
+# Additional specific suppression for sklearn version warnings
+try:
+    from sklearn.exceptions import InconsistentVersionWarning
+    warnings.filterwarnings("ignore", category=InconsistentVersionWarning)
+except ImportError:
+    # Fallback for older sklearn versions
+    pass
+
+# Guard against double loading
+if 'PIPE' not in globals():
+    try:
+        print("Loading model from:", MODEL_PATH)
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            PIPE = joblib.load(MODEL_PATH)
+        print("Model loaded successfully")
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        raise
+        
+    # Lấy thứ tự class từ estimator cuối để map xác suất cho chắc
+    try:
+        classes = list(PIPE.named_steps["clf"].classes_)
+    except Exception:
+        classes = list(getattr(PIPE, "classes_", [0, 1]))  # fallback
+        
+    print(f"Model classes: {classes}")
+    IDX_REAL = classes.index(REAL_LABEL)
+    IDX_FAKE = classes.index(0)
+    print(f"Real index: {IDX_REAL}, Fake index: {IDX_FAKE}")
+else:
+    print("Model already loaded, skipping reload...")
+
+# =========================
+# Core inference
+# =========================
+def infer_one(inp: PredictIn) -> PredictOut:
+    text_all = inp.text_all.strip().lower() if inp.text_all else _combine(inp.title, inp.text)
+
+    # Suppress warnings during prediction
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        probs = PIPE.predict_proba([text_all])[0]
+    
+    prob_real = float(probs[IDX_REAL])
+    prob_fake = float(probs[IDX_FAKE])
+
+    label = "real" if prob_real >= 0.5 else "fake"
+
+    return PredictOut(
+        label=label,
+        prob_real=prob_real,
+        prob_fake=prob_fake,
+    )
+
+
+def infer_batch(items: List[PredictIn]) -> List[PredictOut]:
+    return [infer_one(x) for x in items]
+
+
+# =========================
+# FastAPI endpoints
+# =========================
+app = FastAPI(
+    title="SVM Fake/Real News Classifier",
+    description="API for classifying news as real or fake using SVM with TF-IDF features",
+    version="1.0.0"
+)
+
+@app.get("/")
+def root():
+    return {
+        "message": "SVM Fake/Real News Classifier API",
+        "endpoints": {
+            "predict": "/predict",
+            "predict_batch": "/predict_batch",
+            "health": "/health"
+        },
+        "model_info": {
+            "classes": ["fake", "real"],
+            "model_path": MODEL_PATH,
+            "calibrated": True
+        }
+    }
+
+@app.get("/health")
+def health_check():
+    return {"status": "healthy", "model_loaded": 'PIPE' in globals()}
+
+@app.post("/predict", response_model=PredictOut)
+def predict(payload: PredictIn, x_api_key: str = Header(default="")):
+    if x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    return infer_one(payload)
+
+@app.post("/predict_batch", response_model=PredictBatchOut)
+def predict_batch(payload: PredictBatchIn, x_api_key: str = Header(default="")):
+    if x_api_key != API_KEY:
+        raise HTTPException(status_code=401, detail="Unauthorized")
+    return PredictBatchOut(results=infer_batch(payload.items))
+
+
+if __name__ == "__main__":
+    import uvicorn
+    print("===== Application Ready =====")
+    print("FastAPI app initialized successfully")
+    print("API endpoints available at /predict and /predict_batch")
+    print("API documentation at /docs")
+    print("================================")
+    uvicorn.run(app, host="0.0.0.0", port=6778)

config.py

@@ -0,0 +1,14 @@
+import os
+
+# Model configuration
+MODEL_PATH = os.getenv("MODEL_PATH", "fake_news_model.joblib")
+
+# API Key configuration - có thể set qua nhiều cách:
+# 1. Environment variable: export API_KEY="your-secret-key"
+# 2. Docker: -e API_KEY="your-secret-key"
+# 3. docker-compose.yml: environment section
+# 4. Thay đổi default value dưới đây
+API_KEY = os.getenv("API_KEY", "my-super-secret-api-key-2024")
+
+# Model labels
+REAL_LABEL = 1  

docker-compose.yml

@@ -0,0 +1,19 @@
+version: '3.8'
+
+services:
+  svm-classifier:
+    build: .
+    ports:
+      - "8000:8000"
+    environment:
+      - MODEL_PATH=fake_news_model.joblib
+      - API_KEY=my-super-secret-api-key-2024  # THAY ĐỔI NÀY!
+    volumes:
+      - ./fake_news_model.joblib:/app/fake_news_model.joblib:ro
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s

fake_news_model.joblib

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

gradio_app.py

@@ -0,0 +1,188 @@
+import gradio as gr
+import warnings
+from typing import Tuple
+from config import MODEL_PATH, REAL_LABEL
+import joblib
+from helper import _combine
+from schemas import PredictIn
+
+# Suppress sklearn version warnings
+warnings.filterwarnings("ignore", category=UserWarning, module="sklearn")
+warnings.filterwarnings("ignore", message=".*InconsistentVersionWarning.*")
+
+try:
+    from sklearn.exceptions import InconsistentVersionWarning
+    warnings.filterwarnings("ignore", category=InconsistentVersionWarning)
+except ImportError:
+    pass
+
+# Load model
+print("Loading model from:", MODEL_PATH)
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    PIPE = joblib.load(MODEL_PATH)
+print("Model loaded successfully")
+
+# Get class indices
+try:
+    classes = list(PIPE.named_steps["clf"].classes_)
+except Exception:
+    classes = list(getattr(PIPE, "classes_", [0, 1]))
+
+print(f"Model classes: {classes}")
+IDX_REAL = classes.index(REAL_LABEL)
+IDX_FAKE = classes.index(0)
+
+def predict_news(title: str, text: str) -> Tuple[str, float, float, str]:
+    """
+    Predict if news is real or fake
+    
+    Args:
+        title: News article title
+        text: News article content
+        
+    Returns:
+        Tuple of (prediction, real_probability, fake_probability, confidence_level)
+    """
+    # Combine title and text
+    text_all = _combine(title, text)
+    
+    # Get prediction probabilities
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        probs = PIPE.predict_proba([text_all])[0]
+    
+    prob_real = float(probs[IDX_REAL])
+    prob_fake = float(probs[IDX_FAKE])
+    
+    # Determine prediction and confidence
+    if prob_real >= 0.5:
+        prediction = "REAL"
+        confidence = prob_real
+    else:
+        prediction = "FAKE" 
+        confidence = prob_fake
+    
+    # Determine confidence level
+    if confidence >= 0.8:
+        confidence_level = "High"
+    elif confidence >= 0.6:
+        confidence_level = "Medium"
+    else:
+        confidence_level = "Low"
+    
+    return prediction, prob_real, prob_fake, confidence_level
+
+# Example articles for demonstration
+examples = [
+    [
+        "Scientists Discover Breakthrough in Cancer Treatment",
+        "Researchers at leading medical institutions have announced a significant breakthrough in cancer treatment methodology. The new approach shows promising results in early clinical trials, offering hope for millions of patients worldwide. The research, published in a peer-reviewed journal, demonstrates improved survival rates and reduced side effects compared to traditional treatments."
+    ],
+    [
+        "SHOCKING: Aliens Found Living Among Us, Government Confirms",
+        "In a stunning revelation that changes everything we know about humanity, government officials have finally confirmed that extraterrestrial beings have been living among humans for decades. Sources close to the matter reveal that these aliens have been secretly controlling world governments and manipulating global events from the shadows."
+    ],
+    [
+        "Local Community Garden Helps Reduce Food Insecurity",
+        "A grassroots initiative in downtown Springfield has transformed an abandoned lot into a thriving community garden that provides fresh produce to local food banks. The project, started by neighborhood volunteers, has grown to include educational programs and has become a model for similar initiatives in other cities."
+    ]
+]
+
+# Create Gradio interface
+with gr.Blocks(title="SVM Fake News Classifier", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 📰 SVM Fake News Classifier
+        
+        This application uses a Support Vector Machine (SVM) with TF-IDF features to classify news articles as **real** or **fake**.
+        The model has been trained on a large dataset and uses calibrated probabilities for more reliable predictions.
+        
+        ### How to use:
+        1. Enter a news article title
+        2. Enter the article content/text
+        3. Click "Classify News" to get the prediction
+        
+        The model will return:
+        - **Prediction**: Whether the article is classified as REAL or FAKE
+        - **Probabilities**: Confidence scores for both real and fake classifications
+        - **Confidence Level**: Overall confidence in the prediction (High/Medium/Low)
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            title_input = gr.Textbox(
+                label="📰 News Title",
+                placeholder="Enter the news article title...",
+                lines=2
+            )
+            text_input = gr.Textbox(
+                label="📄 News Content", 
+                placeholder="Enter the news article content...",
+                lines=8
+            )
+            classify_btn = gr.Button("🔍 Classify News", variant="primary", size="lg")
+        
+        with gr.Column():
+            with gr.Group():
+                prediction_output = gr.Textbox(
+                    label="🎯 Prediction",
+                    interactive=False
+                )
+                confidence_output = gr.Textbox(
+                    label="📊 Confidence Level",
+                    interactive=False
+                )
+            
+            with gr.Row():
+                real_prob = gr.Number(
+                    label="✅ Real Probability",
+                    interactive=False
+                )
+                fake_prob = gr.Number(
+                    label="❌ Fake Probability", 
+                    interactive=False
+                )
+    
+    # Examples section
+    gr.Markdown("### 📚 Try these examples:")
+    gr.Examples(
+        examples=examples,
+        inputs=[title_input, text_input],
+        label="Example Articles"
+    )
+    
+    # Information section
+    with gr.Accordion("ℹ️ Model Information", open=False):
+        gr.Markdown(
+            """
+            **Model Details:**
+            - **Algorithm**: Support Vector Machine (SVM) with TF-IDF vectorization
+            - **Calibration**: Uses CalibratedClassifierCV for probability estimates
+            - **Features**: Text preprocessing, TF-IDF feature extraction
+            - **Training**: Trained on labeled real/fake news dataset
+            
+            **Interpretation:**
+            - **Real Probability > 0.5**: Article classified as REAL news
+            - **Fake Probability > 0.5**: Article classified as FAKE news
+            - **Confidence Level**: Based on the highest probability score
+              - High: ≥ 80% confidence
+              - Medium: 60-79% confidence  
+              - Low: < 60% confidence
+            
+            **Note**: This is a machine learning model and may not be 100% accurate. 
+            Always verify important information through multiple reliable sources.
+            """
+        )
+    
+    # Set up the prediction function
+    classify_btn.click(
+        fn=predict_news,
+        inputs=[title_input, text_input],
+        outputs=[prediction_output, real_prob, fake_prob, confidence_output]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

helper.py

@@ -0,0 +1,8 @@
+from typing import Optional
+# =========================
+# Helpers
+# =========================
+def _combine(title: Optional[str], text: Optional[str]) -> str:
+    title = title or ""
+    text = text or ""
+    return f"{title} {text}".strip().lower()

requirements.txt

@@ -0,0 +1,6 @@
+fastapi==0.111.0
+uvicorn[standard]==0.30.1
+scikit-learn==1.6.1
+joblib==1.3.2
+pydantic==2.8.2
+numpy==1.26.4

requirements_gradio.txt

@@ -0,0 +1,7 @@
+fastapi==0.111.0
+uvicorn[standard]==0.30.1
+scikit-learn==1.6.1
+joblib==1.3.2
+pydantic==2.8.2
+numpy==1.26.4
+gradio==4.44.0

schemas.py

@@ -0,0 +1,31 @@
+from typing import Optional, Literal, List
+from pydantic import BaseModel, Field
+from config import MODEL_PATH
+
+# =========================
+# Schemas
+# =========================
+class PredictIn(BaseModel):
+    title: Optional[str] = Field(default=None, description="Tiêu đề bài báo")
+    text: Optional[str] = Field(default=None, description="Nội dung bài báo")
+    text_all: Optional[str] = Field(default=None, description="title + text đã gộp sẵn")
+
+
+class PredictOut(BaseModel):
+    label: Literal["real", "fake"]
+    prob_real: float
+    prob_fake: float
+    calibrated: bool = Field(
+        default=True,
+        description="True vì đã dùng CalibratedClassifierCV(method='sigmoid').",
+    )
+    model_path: str = Field(default=MODEL_PATH)
+
+
+class PredictBatchIn(BaseModel):
+    items: List[PredictIn]
+
+
+class PredictBatchOut(BaseModel):
+    results: List[PredictOut]
+

start.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python3
+"""
+Start script for the SVM Fake News Classifier
+"""
+import uvicorn
+from app import app
+
+if __name__ == "__main__":
+    print("Starting SVM Fake News Classifier...")
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=8000,
+        log_level="info",
+        reload=False
+    )