Upload 7 files

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.12-slim
+
+# Thiết lập thư mục làm việc trong container
+WORKDIR /app
+
+# Cài đặt các thư viện hệ thống cần thiết cho thư viện 'psycopg2' (nếu dùng PostgreSQL)
+RUN apt-get update && apt-get install -y libpq-dev gcc && rm -rf /var/lib/apt/lists/*
+
+# Copy file requirements.txt vào trước để tận dụng cache của Docker
+COPY requirements.txt .
+
+# Cài đặt các thư viện Python
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy toàn bộ mã nguồn vào container
+COPY . .
+
+# HuggingFace Spaces mặc định chạy trên cổng 7860
+ENV PORT=7860
+
+# Lệnh khởi chạy server (Lưu ý: cổng phải là 7860)
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port 7860"]

database.py

@@ -0,0 +1,46 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, DeclarativeBase, Session
+from typing import Generator
+import os
+from dotenv import load_dotenv
+
+# 1. Xác định chính xác vị trí thư mục backend/
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+env_path = os.path.join(CURRENT_DIR, ".env")
+
+# 2. Ép nạp biến môi trường từ ĐÚNG tệp .env đó
+load_dotenv(dotenv_path=env_path)
+
+# 3. Lấy biến từ môi trường
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+# 4. Chốt chặn an toàn
+if not DATABASE_URL:
+    raise ValueError("⛔ CẢNH BÁO: Không tìm thấy DATABASE_URL. Hãy kiểm tra lại file .env hoặc biến môi trường trên server deploy!")
+
+# 3. Tạo engine thuần túy cho PostgreSQL (hoặc MySQL)
+# Chú ý: Đã xóa hoàn toàn logic của SQLite
+engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+
+SessionLocal = sessionmaker(
+    bind=engine,
+    autocommit=False,
+    autoflush=False,
+)
+
+class Base(DeclarativeBase):
+    pass
+
+def get_db() -> Generator[Session, None, None]:
+    """FastAPI dependency that provides a database session per request."""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def init_db() -> None:
+    """Create all tables defined via Base metadata."""
+    from backend import models  # noqa: F401 — ensure models are registered
+
+    Base.metadata.create_all(bind=engine)

inference.py

@@ -0,0 +1,126 @@
+"""
+inference.py - Xử lý Aspect-Based Sentiment Analysis (ABSA)
+"""
+
+import time
+import torch
+import torch.nn as nn
+from transformers import AutoModel, AutoTokenizer
+import os
+from safetensors.torch import load_file
+import re
+
+# ---------------------------------------------------------------------------   
+# KHỞI TẠO MODEL THẬT (Load 1 lần khi server start)
+# ---------------------------------------------------------------------------   
+
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+# Trỏ đến thư mục ml_models/visobert_absa nằm ngay trong backend
+MODEL_DIR = os.path.join(CURRENT_DIR, "ml_models/visobert_absa")
+
+def clean_text(text: str) -> str:
+    """
+    Hàm làm sạch văn bản (Dọn dẹp noise, lower case) giống hệt với lúc train
+    được quy định trong file EDA_Preprocess.ipynb.
+    """
+    if not text: 
+        return ""
+    text = str(text).lower() 
+    text = re.sub(r'[^\w\s]', ' ', text) 
+    text = re.sub(r'\s+', ' ', text).strip() 
+    return text
+
+print("[INFO] Đang cấu hình và load mô hình HuggingFace ABSA...")
+
+class VisoBertMultiTask(nn.Module):
+    def __init__(self, model_name: str, n_aspects: int):
+        super().__init__()
+        self.n_aspects = n_aspects
+        self.num_classes = 4
+        self.encoder = AutoModel.from_pretrained(model_name)
+        hidden_size = self.encoder.config.hidden_size
+        self.head = nn.Linear(hidden_size, n_aspects * self.num_classes)
+        # Khai báo buffer rỗng để khớp với trọng số loss_weights lưu trong safetensors
+        self.register_buffer("loss_weights", torch.ones(4, dtype=torch.float32))
+
+    def forward(self, input_ids=None, attention_mask=None, labels=None):
+        enc = self.encoder(input_ids=input_ids, attention_mask=attention_mask)
+        cls = enc.last_hidden_state[:, 0, :]
+        logits = self.head(cls).view(-1, self.n_aspects, self.num_classes)
+        return logits
+
+# Dựa vào dữ liệu từ bạn, model Deep Learning này được retrain đầy đủ với 38 aspect
+ASPECTS_LIST = [
+    'AMBIENCE#GENERAL', 'FACILITIES#CLEANLINESS', 'FACILITIES#COMFORT', 'FACILITIES#DESIGN&FEATURES', 'FACILITIES#GENERAL', 
+    'FACILITIES#MISCELLANEOUS', 'FACILITIES#PRICES', 'FACILITIES#QUALITY', 'FOOD&DRINKS#MISCELLANEOUS', 'FOOD&DRINKS#PRICES', 
+    'FOOD&DRINKS#QUALITY', 'FOOD&DRINKS#STYLE&OPTIONS', 'HOTEL#CLEANLINESS', 'HOTEL#COMFORT', 'HOTEL#DESIGN&FEATURES', 
+    'HOTEL#GENERAL', 'HOTEL#MISCELLANEOUS', 'HOTEL#PRICES', 'HOTEL#QUALITY', 'LOCATION#GENERAL', 'RESTAURANT#GENERAL', 
+    'RESTAURANT#MISCELLANEOUS', 'RESTAURANT#PRICES', 'ROOMS#CLEANLINESS', 'ROOMS#COMFORT', 'ROOMS#DESIGN&FEATURES', 
+    'ROOMS#GENERAL', 'ROOMS#MISCELLANEOUS', 'ROOMS#PRICES', 'ROOMS#QUALITY', 'ROOM_AMENITIES#CLEANLINESS', 
+    'ROOM_AMENITIES#COMFORT', 'ROOM_AMENITIES#DESIGN&FEATURES', 'ROOM_AMENITIES#GENERAL', 'ROOM_AMENITIES#MISCELLANEOUS', 
+    'ROOM_AMENITIES#PRICES', 'ROOM_AMENITIES#QUALITY', 'SERVICE#GENERAL'
+]
+
+# Map 4 nhãn sentiment thành tên chữ theo notebook deep_learning
+# 0 = None, 1 = Negative, 2 = Neutral, 3 = Positive
+SENTIMENT_MAP = {
+    1: "negative",
+    2: "neutral",
+    3: "positive"
+}
+
+try:
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_DIR)
+    # uitnlp/visobert là backbone bạn đã dùng để train
+    model = VisoBertMultiTask(model_name="uitnlp/visobert", n_aspects=len(ASPECTS_LIST))
+    
+    # Load trọng số từ safetensors
+    weights_path = os.path.join(MODEL_DIR, "model.safetensors")
+    if os.path.exists(weights_path):
+        state_dict = load_file(weights_path)
+        model.load_state_dict(state_dict, strict=False)
+        print("[INFO] Đã load state_dict thành công!")
+    
+    model.eval()
+    print("[INFO] Mô hình đã sẵn sàng!")
+except Exception as e:
+    print(f"[WARN] Không thể load model HuggingFace, kiểm tra lại thư mục deep_learning_model. Lỗi: {e}")
+    model = None
+    tokenizer = None
+
+
+def process_review(text: str) -> list[dict[str, str]]:
+    """
+    Hàm nhận vào câu review và trả về nhiều Aspect (Khía cạnh) cùng Sentiment (Cảm xúc).
+    Đầu ra bắt buộc phải có format: [{"aspect": str, "sentiment": str}, ...]
+    """
+    if model is None or tokenizer is None:
+        raise RuntimeError("Mô hình Deep Learning hiện không khả dụng. Vui lòng liên hệ quản trị viên hoặc kiểm tra lại cấu hình AI.")
+
+    # Tiền xử lý văn bản như đã làm ở file EDA_Preprocess.ipynb
+    cleaned = clean_text(text)
+
+    # 1. Tiền xử lý bằng Tokenizer sử dụng đoạn văn bản đã dọn dẹp
+    inputs = tokenizer(cleaned, return_tensors="pt", truncation=True, padding=True, max_length=256)
+    
+    with torch.no_grad():
+        # Đầu ra có shape (1, N_Aspects, 4)
+        logits = model(input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"])
+        
+    predictions = torch.argmax(logits, dim=-1) # Lấy nhãn có xác suất cao nhất của từng aspect
+    preds_flat = predictions[0].tolist() # Vì batch_size=1, lấy list của phần tử đầu tiên
+    
+    results = []
+    # 2. Ánh xạ về Aspect & Sentiment
+    for idx, pred_label in enumerate(preds_flat):
+        # 0 = None (review không đề cập đến khía cạnh này) nên ta bỏ qua
+        if pred_label != 0 and pred_label in SENTIMENT_MAP:
+            aspect_name = ASPECTS_LIST[idx]
+            sentiment_name = SENTIMENT_MAP[pred_label]
+            results.append({
+                "aspect": aspect_name,
+                "sentiment": sentiment_name
+            })
+
+    return results
+

main.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import os
+from collections import defaultdict
+from datetime import datetime, timedelta, timezone
+from typing import Annotated
+
+from fastapi import Depends, FastAPI, HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from passlib.context import CryptContext
+from sqlalchemy import desc
+from sqlalchemy.orm import Session
+
+from backend.database import get_db, init_db
+from backend.inference import process_review
+from backend.models import Review, ReviewAspect, User
+from backend.schemas import ReviewCreate, ReviewResponse, Token, UserCreate, UserResponse
+
+from dotenv import load_dotenv
+
+# ---------------------------------------------------------------------------
+# Security configuration
+# ---------------------------------------------------------------------------
+load_dotenv()
+
+SECRET_KEY: str = os.getenv("SECRET_KEY", "change-me-in-production-use-a-long-random-string")
+ALGORITHM = os.getenv("ALGORITHM", "HS256")
+ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", 1440))
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/login")
+
+# ---------------------------------------------------------------------------
+# App initialisation
+# ---------------------------------------------------------------------------
+
+app = FastAPI(
+    title="ABSA Tourism API",
+    description="Aspect-Based Sentiment Analysis for hotel & restaurant reviews.",
+    version="1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.on_event("startup")
+def on_startup() -> None:
+    init_db()
+
+
+# ---------------------------------------------------------------------------
+# Auth helpers
+# ---------------------------------------------------------------------------
+
+_BCRYPT_MAX_BYTES = 72
+
+
+def _validate_password_bytes(password: str) -> str:
+    """Strip surrounding whitespace and guard against bcrypt 72-byte limit."""
+    password = password.strip()
+    if len(password.encode("utf-8")) > _BCRYPT_MAX_BYTES:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=f"Password must not exceed {_BCRYPT_MAX_BYTES} bytes.",
+        )
+    return password
+
+
+def _hash_password(plain: str) -> str:
+    return pwd_context.hash(plain)
+
+
+def _verify_password(plain: str, hashed: str) -> bool:
+    return pwd_context.verify(plain, hashed)
+
+
+def _create_access_token(subject: str) -> str:
+    expire = datetime.now(timezone.utc) + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+    payload = {"sub": subject, "exp": expire}
+    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
+
+
+# ---------------------------------------------------------------------------
+# Dependencies
+# ---------------------------------------------------------------------------
+
+def get_current_user(
+    token: Annotated[str, Depends(oauth2_scheme)],
+    db: Annotated[Session, Depends(get_db)],
+) -> User:
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials.",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        username: str | None = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+
+    user = db.query(User).filter(User.username == username).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+
+# Convenience type alias for annotated dependency injection
+CurrentUser = Annotated[User, Depends(get_current_user)]
+DBSession = Annotated[Session, Depends(get_db)]
+
+
+# ---------------------------------------------------------------------------
+# Auth routes
+# ---------------------------------------------------------------------------
+
+@app.post(
+    "/register",
+    response_model=UserResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Register a new user",
+    tags=["Auth"],
+)
+def register(payload: UserCreate, db: DBSession) -> User:
+    password = _validate_password_bytes(payload.password)
+
+    if db.query(User).filter(User.username == payload.username).first():
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="Username already taken.",
+        )
+
+    user = User(
+        username=payload.username,
+        hashed_password=_hash_password(password),
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+    return user
+
+
+@app.post(
+    "/login",
+    response_model=Token,
+    summary="Obtain a JWT bearer token",
+    tags=["Auth"],
+)
+def login(
+    form: Annotated[OAuth2PasswordRequestForm, Depends()],
+    db: DBSession,
+) -> Token:
+    password = _validate_password_bytes(form.password)
+
+    user = db.query(User).filter(User.username == form.username).first()
+    if not user or not _verify_password(password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password.",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+    return Token(access_token=_create_access_token(user.username))
+
+
+# ---------------------------------------------------------------------------
+# ABSA routes
+# ---------------------------------------------------------------------------
+
+@app.post(
+    "/predict",
+    response_model=ReviewResponse,
+    status_code=status.HTTP_201_CREATED,
+    summary="Run ABSA inference and persist the result",
+    tags=["ABSA"],
+)
+def predict(
+    payload: ReviewCreate,
+    current_user: CurrentUser,
+    db: DBSession,
+) -> Review:
+    try:
+        results: list[dict[str, str]] = process_review(payload.review_text)
+    except Exception as exc:
+        raise HTTPException(
+            status_code=status.HTTP_502_BAD_GATEWAY,
+            detail=f"Inference error: {exc}",
+        )
+
+    review = Review(
+        user_id=current_user.id,
+        review_text=payload.review_text,
+    )
+    db.add(review)
+    db.commit()
+    db.refresh(review)
+
+    for res in results:
+        aspect = ReviewAspect(
+            review_id=review.id,
+            aspect=res.get("aspect"),
+            sentiment=res.get("sentiment"),
+        )
+        db.add(aspect)
+    
+    db.commit()
+    db.refresh(review)
+    return review
+
+
+@app.get(
+    "/reviews",
+    response_model=list[ReviewResponse],
+    summary="List all reviews for the current user",
+    tags=["ABSA"],
+)
+def list_reviews(current_user: CurrentUser, db: DBSession) -> list[Review]:
+    return (
+        db.query(Review)
+        .filter(Review.user_id == current_user.id)
+        .order_by(desc(Review.created_at))
+        .all()
+    )
+
+
+@app.get(
+    "/analytics",
+    summary="Sentiment counts grouped by aspect for the current user",
+    tags=["ABSA"],
+)
+def analytics(
+    current_user: CurrentUser,
+    db: DBSession,
+) -> dict[str, dict[str, int]]:
+    rows = (
+        db.query(ReviewAspect.aspect, ReviewAspect.sentiment)
+        .join(Review)
+        .filter(
+            Review.user_id == current_user.id,
+            ReviewAspect.aspect.isnot(None),
+            ReviewAspect.sentiment.isnot(None),
+        )
+        .all()
+    )
+
+    # Build: { "SERVICE#GENERAL": {"positive": N, "negative": M} }
+    result: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    for aspect, sentiment in rows:
+        result[aspect][sentiment] += 1
+
+    # Convert inner defaultdicts to plain dicts for JSON serialisation
+    return {aspect: dict(counts) for aspect, counts in result.items()}
+
+@app.delete(
+    "/reviews",
+    status_code=status.HTTP_204_NO_CONTENT,
+    summary="Xóa toàn bộ review của user hiện tại",
+    tags=["ABSA"],
+)
+def clear_all_reviews(current_user: CurrentUser, db: DBSession):
+    # Tìm tất cả review của user này và xóa sạch
+    db.query(Review).filter(Review.user_id == current_user.id).delete()
+    db.commit()
+    return

models.py

@@ -0,0 +1,76 @@
+from datetime import datetime, timezone
+from typing import List, Optional
+
+from sqlalchemy import DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from backend.database import Base
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    username: Mapped[str] = mapped_column(String(150), unique=True, index=True, nullable=False)
+    hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
+
+    # Relationships
+    reviews: Mapped[List["Review"]] = relationship(
+        "Review",
+        back_populates="user",
+        cascade="all, delete-orphan",
+        passive_deletes=True,
+    )
+
+    def __repr__(self) -> str:
+        return f"<User id={self.id} username={self.username!r}>"
+
+
+class ReviewAspect(Base):
+    __tablename__ = "review_aspects"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    review_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("reviews.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    aspect: Mapped[str] = mapped_column(String(100), nullable=False)
+    sentiment: Mapped[str] = mapped_column(String(50), nullable=False)
+
+    # Relationships
+    review: Mapped["Review"] = relationship("Review", back_populates="aspects")
+
+    def __repr__(self) -> str:
+        return f"<ReviewAspect id={self.id} review_id={self.review_id} aspect={self.aspect!r} sentiment={self.sentiment!r}>"
+
+
+class Review(Base):
+    __tablename__ = "reviews"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, index=True)
+    user_id: Mapped[int] = mapped_column(
+        Integer,
+        ForeignKey("users.id", ondelete="CASCADE"),
+        nullable=False,
+        index=True,
+    )
+    review_text: Mapped[str] = mapped_column(Text, nullable=False)
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True),
+        default=lambda: datetime.now(timezone.utc),
+        nullable=False,
+    )
+
+    # Relationships
+    user: Mapped["User"] = relationship("User", back_populates="reviews")
+    aspects: Mapped[List["ReviewAspect"]] = relationship(
+        "ReviewAspect",
+        back_populates="review",
+        cascade="all, delete-orphan",
+        passive_deletes=True,
+    )
+
+    def __repr__(self) -> str:
+        return f"<Review id={self.id}>"

requirements.txt

@@ -0,0 +1,65 @@
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.13.0
+bcrypt==5.0.0
+certifi==2026.2.25
+cffi==2.0.0
+click==8.3.2
+colorama==0.4.6
+cryptography==46.0.7
+ecdsa==0.19.2
+fastapi==0.135.3
+filelock==3.25.2
+fsspec==2026.3.0
+greenlet==3.4.0
+h11==0.16.0
+hf-xet==1.4.3
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.10.1
+idna==3.11
+Jinja2==3.1.6
+joblib==1.5.3
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+mpmath==1.3.0
+networkx==3.6.1
+numpy==2.4.4
+packaging==26.0
+pandas==3.0.2
+passlib==1.7.4
+pyasn1==0.6.3
+pycparser==3.0
+pydantic==2.13.0
+pydantic-settings==2.13.1
+pydantic_core==2.46.0
+Pygments==2.20.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+python-jose==3.5.0
+python-multipart==0.0.26
+PyYAML==6.0.3
+psycopg2-binary==2.9.11
+regex==2026.4.4
+rich==15.0.0
+rsa==4.9.1
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.17.1
+setuptools==81.0.0
+shellingham==1.5.4
+six==1.17.0
+SQLAlchemy==2.0.49
+starlette==1.0.0
+sympy==1.14.0
+threadpoolctl==3.6.0
+tokenizers==0.22.2
+torch==2.11.0
+tqdm==4.67.3
+transformers==5.5.4
+typer==0.24.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2026.1
+uvicorn==0.44.0

schemas.py

@@ -0,0 +1,54 @@
+from datetime import datetime
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+# ---------------------------------------------------------------------------
+# User schemas
+# ---------------------------------------------------------------------------
+
+class UserCreate(BaseModel):
+    username: str = Field(..., min_length=3, max_length=150)
+    password: str = Field(..., min_length=6, max_length=72)
+
+
+class UserResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    username: str
+
+
+# ---------------------------------------------------------------------------
+# Auth schemas
+# ---------------------------------------------------------------------------
+
+class Token(BaseModel):
+    access_token: str
+    token_type: Literal["bearer"] = "bearer"
+
+
+# ---------------------------------------------------------------------------
+# Review schemas
+# ---------------------------------------------------------------------------
+
+class ReviewCreate(BaseModel):
+    review_text: str = Field(..., min_length=1)
+
+
+class AspectResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    aspect: str
+    sentiment: str
+
+
+class ReviewResponse(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: int
+    review_text: str
+    created_at: datetime
+    aspects: list[AspectResponse] = []