Deploy document classifier app

app.py

@@ -0,0 +1,48 @@
+import joblib
+import numpy as np
+import gradio as gr
+
+
+MODEL_PATH = "models/best_model.pkl"
+
+model = joblib.load(MODEL_PATH)
+
+
+def classify_document(text):
+    if not text or len(text.strip()) < 5:
+        return "Please enter at least 5 characters.", 0.0
+
+    prediction = model.predict([text])[0]
+
+    decision_scores = model.decision_function([text])
+    confidence_score = float(np.max(decision_scores))
+
+    return prediction, round(confidence_score, 4)
+
+
+demo = gr.Interface(
+    fn=classify_document,
+    inputs=gr.Textbox(
+        lines=8,
+        placeholder="Paste news/document text here...",
+        label="Input Document Text"
+    ),
+    outputs=[
+        gr.Textbox(label="Predicted Category"),
+        gr.Number(label="Confidence Score")
+    ],
+    title="BBC News Document Classifier",
+    description=(
+        "Classifies document text into one of five categories: "
+        "business, entertainment, politics, sport, or tech."
+    ),
+    examples=[
+        ["The football team won the final match after scoring two goals."],
+        ["The company reported strong profits and growth in global markets."],
+        ["New software updates improve artificial intelligence performance."]
+    ]
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

models/baseline_model.pkl

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

models/best_model.pkl

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

requirements.txt

@@ -0,0 +1,216 @@
+accelerate==1.13.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.5
+aiohttp-retry==2.9.1
+aiosignal==1.4.0
+alembic==1.18.4
+amqp==5.3.1
+annotated-doc==0.0.4
+annotated-types==0.7.0
+antlr4-python3-runtime==4.9.3
+anyio==4.13.0
+appdirs==1.4.4
+asyncssh==2.23.0
+atpublic==7.0.0
+attrs==26.1.0
+billiard==4.2.4
+black==26.5.1
+blinker==1.9.0
+brotli==1.2.0
+cachetools==7.1.3
+celery==5.6.3
+certifi==2026.4.22
+cffi==2.0.0
+charset-normalizer==3.4.7
+click==8.4.0
+click-didyoumean==0.3.1
+click-plugins==1.1.1.2
+click-repl==0.3.0
+cloudpickle==3.1.2
+colorama==0.4.6
+configobj==5.0.9
+contourpy==1.3.3
+coverage==7.14.0
+cryptography==46.0.7
+cycler==0.12.1
+databricks-sdk==0.110.0
+datasets==4.8.5
+deprecation==2.1.0
+dictdiffer==0.9.0
+dill==0.4.1
+diskcache==5.6.3
+distro==1.9.0
+docker==7.1.0
+dpath==2.2.0
+dulwich==1.2.1
+dvc==3.67.1
+dvc-data==3.18.3
+dvc-http==2.32.0
+dvc-objects==5.2.0
+dvc-render==1.0.2
+dvc-studio-client==0.22.0
+dvc-task==0.40.2
+dynaconf==3.2.13
+entrypoints==0.4
+evidently==0.7.21
+Faker==40.18.0
+fastapi==0.136.1
+filelock==3.29.0
+flake8==7.3.0
+Flask==3.1.3
+flask-cors==6.0.2
+flatten-dict==0.5.0
+flufl.lock==9.1.0
+fonttools==4.63.0
+frozenlist==1.8.0
+fsspec==2026.2.0
+funcy==2.0
+gitdb==4.0.12
+GitPython==3.1.50
+google-auth==2.53.0
+gradio==6.14.0
+gradio_client==2.5.0
+grandalf==0.8
+graphene==3.4.3
+graphql-core==3.2.8
+graphql-relay==3.2.0
+greenlet==3.5.0
+groovy==0.1.2
+gto==1.9.0
+h11==0.16.0
+hf-gradio==0.4.1
+hf-xet==1.5.0
+httpcore==1.0.9
+httptools==0.7.1
+httpx==0.28.1
+huey==2.6.0
+huggingface_hub==1.15.0
+hydra-core==1.3.2
+idna==3.15
+importlib_metadata==9.0.0
+iniconfig==2.3.0
+iterative-telemetry==0.0.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.5.3
+kiwisolver==1.5.0
+kombu==5.6.2
+litestar==2.21.1
+litestar-htmx==0.5.0
+Mako==1.3.12
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+matplotlib==3.10.9
+mccabe==0.7.0
+mdurl==0.1.2
+mlflow==3.12.0
+mlflow-skinny==3.12.0
+mlflow-tracing==3.12.0
+mpmath==1.3.0
+msgspec==0.21.1
+multidict==6.7.1
+multipart==1.3.1
+multiprocess==0.70.19
+mypy_extensions==1.1.0
+networkx==3.6.1
+nltk==3.9.4
+numpy==2.4.6
+omegaconf==2.3.0
+opentelemetry-api==1.42.0
+opentelemetry-proto==1.42.0
+opentelemetry-sdk==1.42.0
+opentelemetry-semantic-conventions==0.63b0
+orjson==3.11.9
+packaging==26.2
+pandas==2.3.3
+pathspec==1.1.1
+patsy==1.0.2
+pillow==12.2.0
+platformdirs==4.9.6
+plotly==5.24.1
+pluggy==1.6.0
+polyfactory==3.3.0
+prettytable==3.17.0
+prompt_toolkit==3.0.52
+propcache==0.5.2
+protobuf==6.33.6
+psutil==7.2.2
+pyarrow==23.0.1
+pyasn1==0.6.3
+pyasn1_modules==0.4.2
+pycodestyle==2.14.0
+pycparser==3.0
+pydantic==2.13.4
+pydantic-settings==2.14.1
+pydantic_core==2.46.4
+pydot==4.0.1
+pydub==0.25.1
+pyflakes==3.4.0
+pygit2==1.19.2
+Pygments==2.20.0
+pygtrie==2.5.0
+pyparsing==3.3.2
+pytest==9.0.3
+pytest-cov==7.1.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+python-multipart==0.0.29
+pytokens==0.4.1
+pytz==2026.2
+pywin32==311
+PyYAML==6.0.3
+regex==2026.5.9
+requests==2.34.2
+rich==15.0.0
+rich-click==1.9.7
+ruamel.yaml==0.19.1
+safehttpx==0.1.7
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.17.1
+scmrepo==3.6.2
+seaborn==0.13.2
+semantic-version==2.10.0
+semver==3.0.4
+shellingham==1.5.4
+shortuuid==1.0.13
+shtab==1.8.0
+six==1.17.0
+skops==0.14.0
+smmap==5.0.3
+sniffio==1.3.1
+SQLAlchemy==2.0.49
+sqlparse==0.5.5
+sqltrie==0.11.2
+starlette==0.52.1
+statsmodels==0.14.6
+sympy==1.14.0
+tabulate==0.10.0
+tenacity==9.1.4
+threadpoolctl==3.6.0
+tokenizers==0.22.2
+tomlkit==0.14.0
+torch==2.12.0
+tqdm==4.67.3
+transformers==5.8.1
+typer==0.25.1
+typing-inspect==0.9.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2026.2
+tzlocal==5.3.1
+urllib3==2.7.0
+uuid6==2025.0.1
+uvicorn==0.47.0
+vine==5.1.0
+voluptuous==0.16.0
+waitress==3.0.2
+watchdog==6.0.0
+watchfiles==1.2.0
+wcwidth==0.7.0
+websockets==16.0
+Werkzeug==3.1.8
+xxhash==3.7.0
+yarl==1.23.0
+zc.lockfile==4.0
+zipp==4.1.0

src/api/main.py

@@ -0,0 +1,34 @@
+import joblib
+import numpy as np
+from fastapi import FastAPI
+from src.api.schemas import PredictionRequest, PredictionResponse
+
+app = FastAPI(
+    title="BBC Document Classification API",
+    version="1.0.0"
+)
+
+model = joblib.load("models/best_model.pkl")
+
+
+@app.get("/")
+def home():
+    return {"message": "BBC Document Classification API is running"}
+
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+
+@app.post("/predict", response_model=PredictionResponse)
+def predict(request: PredictionRequest):
+    prediction = model.predict([request.text])[0]
+
+    decision_scores = model.decision_function([request.text])
+    confidence_score = float(np.max(decision_scores))
+
+    return {
+        "predicted_class": prediction,
+        "confidence_score": round(confidence_score, 4)
+    }

src/api/schemas.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+
+class PredictionRequest(BaseModel):
+    text: str = Field(..., min_length=5)
+
+
+class PredictionResponse(BaseModel):
+    predicted_class: str
+    confidence_score: float

src/data/check_data.py

@@ -0,0 +1,18 @@
+import pandas as pd
+
+df = pd.read_csv("data/raw/bbc-text.csv")
+
+print("\nFirst 5 Rows:")
+print(df.head())
+
+print("\nDataset Shape:")
+print(df.shape)
+
+print("\nColumns:")
+print(df.columns)
+
+print("\nMissing Values:")
+print(df.isnull().sum())
+
+print("\nClass Distribution:")
+print(df["label_text"].value_counts())

src/data/load_data.py

@@ -0,0 +1,17 @@
+from datasets import load_dataset
+import pandas as pd
+import os
+
+dataset = load_dataset("SetFit/bbc-news")
+
+train_df = pd.DataFrame(dataset["train"])
+test_df = pd.DataFrame(dataset["test"])
+
+df = pd.concat([train_df, test_df], ignore_index=True)
+
+os.makedirs("data/raw", exist_ok=True)
+
+df.to_csv("data/raw/bbc-text.csv", index=False)
+
+print(df.shape)
+print(df.head())

src/data/preprocess.py

@@ -0,0 +1,30 @@
+import os
+import re
+import pandas as pd
+
+
+def clean_text(text):
+    text = str(text).lower()
+    text = re.sub(r"[^a-zA-Z0-9\s]", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def preprocess_data(
+    input_path="data/raw/bbc-text.csv",
+    output_path="data/processed/processed_bbc.csv"
+):
+    df = pd.read_csv(input_path)
+
+    df["clean_text"] = df["text"].apply(clean_text)
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+
+    df.to_csv(output_path, index=False)
+
+    print("Preprocessing completed!")
+    print(df.head())
+
+
+if __name__ == "__main__":
+    preprocess_data()

src/data/split_data.py

@@ -0,0 +1,35 @@
+import os
+import pandas as pd
+from sklearn.model_selection import train_test_split
+
+RANDOM_STATE = 42
+
+df = pd.read_csv("data/processed/processed_bbc.csv")
+
+train_df, temp_df = train_test_split(
+    df,
+    test_size=0.30,
+    random_state=RANDOM_STATE,
+    stratify=df["label_text"]
+)
+
+val_df, test_df = train_test_split(
+    temp_df,
+    test_size=0.50,
+    random_state=RANDOM_STATE,
+    stratify=temp_df["label_text"]
+)
+
+os.makedirs("data/splits", exist_ok=True)
+
+train_df.to_csv("data/splits/train.csv", index=False)
+val_df.to_csv("data/splits/val.csv", index=False)
+test_df.to_csv("data/splits/test.csv", index=False)
+
+print("Train/Validation/Test split completed.")
+print("Train shape:", train_df.shape)
+print("Validation shape:", val_df.shape)
+print("Test shape:", test_df.shape)
+
+print("\nTrain class distribution:")
+print(train_df["label_text"].value_counts())

src/models/train_baseline.py

@@ -0,0 +1,53 @@
+import os
+import mlflow
+import mlflow.sklearn
+import pandas as pd
+
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import accuracy_score, f1_score, classification_report
+import joblib
+
+
+train_df = pd.read_csv("data/splits/train.csv")
+val_df = pd.read_csv("data/splits/val.csv")
+
+X_train = train_df["clean_text"]
+y_train = train_df["label_text"]
+
+X_val = val_df["clean_text"]
+y_val = val_df["label_text"]
+
+os.makedirs("models", exist_ok=True)
+
+mlflow.set_experiment("bbc-document-classification")
+
+with mlflow.start_run(run_name="tfidf_logistic_regression"):
+
+    model = Pipeline([
+        ("tfidf", TfidfVectorizer(max_features=5000)),
+        ("classifier", LogisticRegression(max_iter=1000))
+    ])
+
+    model.fit(X_train, y_train)
+
+    y_pred = model.predict(X_val)
+
+    accuracy = accuracy_score(y_val, y_pred)
+    f1 = f1_score(y_val, y_pred, average="weighted")
+
+    print("Accuracy:", accuracy)
+    print("F1 Score:", f1)
+    print("\nClassification Report:")
+    print(classification_report(y_val, y_pred))
+
+    mlflow.log_param("model", "TF-IDF + Logistic Regression")
+    mlflow.log_param("max_features", 5000)
+    mlflow.log_metric("accuracy", accuracy)
+    mlflow.log_metric("f1_score", f1)
+
+    joblib.dump(model, "models/baseline_model.pkl")
+    mlflow.sklearn.log_model(model, "baseline_model")
+
+print("Baseline model training completed.")

src/models/train_compare_models.py

@@ -0,0 +1,76 @@
+import os
+import mlflow
+import mlflow.sklearn
+import pandas as pd
+import joblib
+
+from sklearn.pipeline import Pipeline
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import LinearSVC
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import accuracy_score, f1_score, classification_report
+
+
+train_df = pd.read_csv("data/splits/train.csv")
+val_df = pd.read_csv("data/splits/val.csv")
+
+X_train = train_df["clean_text"]
+y_train = train_df["label_text"]
+
+X_val = val_df["clean_text"]
+y_val = val_df["label_text"]
+
+os.makedirs("models", exist_ok=True)
+
+models = {
+    "logistic_regression": LogisticRegression(max_iter=1000),
+    "linear_svm": LinearSVC(),
+    "random_forest": RandomForestClassifier(n_estimators=100, random_state=42),
+}
+
+mlflow.set_experiment("bbc-document-classification")
+
+best_model = None
+best_model_name = None
+best_f1 = 0
+
+for model_name, classifier in models.items():
+    with mlflow.start_run(run_name=model_name):
+
+        pipeline = Pipeline([
+            ("tfidf", TfidfVectorizer(max_features=5000)),
+            ("classifier", classifier)
+        ])
+
+        pipeline.fit(X_train, y_train)
+
+        y_pred = pipeline.predict(X_val)
+
+        accuracy = accuracy_score(y_val, y_pred)
+        f1 = f1_score(y_val, y_pred, average="weighted")
+
+        print("\n==============================")
+        print(f"Model: {model_name}")
+        print("Accuracy:", accuracy)
+        print("F1 Score:", f1)
+        print(classification_report(y_val, y_pred))
+
+        mlflow.log_param("model_name", model_name)
+        mlflow.log_param("vectorizer", "TF-IDF")
+        mlflow.log_param("max_features", 5000)
+        mlflow.log_metric("accuracy", accuracy)
+        mlflow.log_metric("f1_score", f1)
+
+        mlflow.sklearn.log_model(pipeline, model_name)
+
+        if f1 > best_f1:
+            best_f1 = f1
+            best_model = pipeline
+            best_model_name = model_name
+
+joblib.dump(best_model, "models/best_model.pkl")
+
+print("\nBest model:", best_model_name)
+print("Best F1:", best_f1)
+print("Saved to models/best_model.pkl")

src/models/train_transformer.py

@@ -0,0 +1,141 @@
+import os
+import mlflow
+import mlflow.transformers
+import pandas as pd
+import numpy as np
+
+from datasets import Dataset
+from transformers import (
+    DistilBertTokenizerFast,
+    DistilBertForSequenceClassification,
+    TrainingArguments,
+    Trainer
+)
+
+from sklearn.metrics import accuracy_score, f1_score
+
+
+# Load datasets
+train_df = pd.read_csv("data/splits/train.csv")
+val_df = pd.read_csv("data/splits/val.csv")
+
+# Label mapping
+labels = sorted(train_df["label_text"].unique())
+
+label2id = {label: idx for idx, label in enumerate(labels)}
+id2label = {idx: label for label, idx in label2id.items()}
+
+train_df["label_id"] = train_df["label_text"].map(label2id)
+val_df["label_id"] = val_df["label_text"].map(label2id)
+
+# Convert to Hugging Face Dataset
+train_dataset = Dataset.from_pandas(
+    train_df[["clean_text", "label_id"]]
+)
+
+val_dataset = Dataset.from_pandas(
+    val_df[["clean_text", "label_id"]]
+)
+
+# Load tokenizer
+tokenizer = DistilBertTokenizerFast.from_pretrained(
+    "distilbert-base-uncased"
+)
+
+
+# Tokenization function
+def tokenize(batch):
+    return tokenizer(
+        batch["clean_text"],
+        padding="max_length",
+        truncation=True,
+        max_length=256
+    )
+
+
+train_dataset = train_dataset.map(tokenize, batched=True)
+val_dataset = val_dataset.map(tokenize, batched=True)
+
+# Model
+model = DistilBertForSequenceClassification.from_pretrained(
+    "distilbert-base-uncased",
+    num_labels=len(labels),
+    id2label=id2label,
+    label2id=label2id
+)
+
+
+# Metrics
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+
+    predictions = np.argmax(logits, axis=-1)
+
+    accuracy = accuracy_score(labels, predictions)
+
+    f1 = f1_score(
+        labels,
+        predictions,
+        average="weighted"
+    )
+
+    return {
+        "accuracy": accuracy,
+        "f1": f1
+    }
+
+
+# Training arguments
+training_args = TrainingArguments(
+    output_dir="models/distilbert_output",
+    evaluation_strategy="epoch",
+    save_strategy="epoch",
+    learning_rate=2e-5,
+    per_device_train_batch_size=8,
+    per_device_eval_batch_size=8,
+    num_train_epochs=2,
+    weight_decay=0.01,
+    logging_dir="./logs",
+    load_best_model_at_end=True
+)
+
+# Trainer
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=val_dataset,
+    compute_metrics=compute_metrics
+)
+
+# MLflow
+mlflow.set_experiment("bbc-document-classification")
+
+with mlflow.start_run(run_name="distilbert_classifier"):
+
+    trainer.train()
+
+    metrics = trainer.evaluate()
+
+    print(metrics)
+
+    mlflow.log_params({
+        "model": "DistilBERT",
+        "epochs": 2,
+        "batch_size": 8,
+        "learning_rate": 2e-5
+    })
+
+    mlflow.log_metrics(metrics)
+
+    trainer.save_model("models/distilbert_model")
+
+    mlflow.transformers.log_model(
+        transformers_model={
+            "model": model,
+            "tokenizer": tokenizer
+        },
+        artifact_path="distilbert_model"
+    )
+
+print("Transformer training completed!")

src/monitoring/drift_report.py

@@ -0,0 +1,44 @@
+import os
+import pandas as pd
+
+from evidently import Report
+from evidently.presets import DataDriftPreset
+
+
+REFERENCE_DATA_PATH = "data/splits/train.csv"
+CURRENT_DATA_PATH = "data/splits/test.csv"
+REPORT_OUTPUT_PATH = "reports/data_drift_report.html"
+
+
+def generate_drift_report():
+    reference_data = pd.read_csv(REFERENCE_DATA_PATH)
+    current_data = pd.read_csv(CURRENT_DATA_PATH)
+
+    # Use simple numerical features for drift monitoring
+    reference_data["text_length"] = reference_data["clean_text"].apply(len)
+    reference_data["word_count"] = reference_data["clean_text"].apply(lambda x: len(str(x).split()))
+
+    current_data["text_length"] = current_data["clean_text"].apply(len)
+    current_data["word_count"] = current_data["clean_text"].apply(lambda x: len(str(x).split()))
+
+    reference_features = reference_data[["text_length", "word_count"]]
+    current_features = current_data[["text_length", "word_count"]]
+
+    report = Report([
+        DataDriftPreset()
+    ])
+
+    result = report.run(
+        reference_data=reference_features,
+        current_data=current_features
+    )
+
+    os.makedirs("reports", exist_ok=True)
+    result.save_html(REPORT_OUTPUT_PATH)
+
+    print("Data drift report generated successfully.")
+    print(f"Report saved at: {REPORT_OUTPUT_PATH}")
+
+
+if __name__ == "__main__":
+    generate_drift_report()